Changeset 1293:28eed5438061

Timestamp:

01/14/08 01:29:05 (3 years ago)

Author:

Ben Bangert <ben@…>

Branch:

trunk

Message:

* Added mimetype function and MIMETypes class for registering mimetypes.

Files:

• CHANGELOG (modified) (1 diff)
• pylons/configuration.py (modified) (2 diffs)
• pylons/controllers/util.py (modified) (3 diffs)

CHANGELOG

@@ -3 +3 @@
 
 0.9.7 (**tip**)
+* Added mimetype function and MIMETypes class for registering mimetypes.
 * WARNING: Removed pylons.Response, so do not attempt to import it or use it
   as it's no longer there. If you must return a new Response object, import

pylons/configuration.py

@@ -16 +16 @@
 import pylons.legacy
 import pylons.templating
+from pylons.controllers.util import MIMETypes
 
 
@@ -287 +288 @@
         conf = self.current_conf()
         
+        # Load the MIMETypes with its default types
+        MIMETypes.load_defaults()
+        
         # Ensure all the keys from defaults are present, load them if not
         for key, val in copy.deepcopy(PylonsConfig.defaults).iteritems():

pylons/controllers/util.py

@@ -4 +4 @@
 """
 import logging
+import mimetypes
 import warnings
 
@@ -13 +14 @@
 
 import pylons
-import pylons.legacy
 
 __all__ = ['abort', 'etag_cache', 'redirect_to', 'Request', 'Response']
@@ -69 +69 @@
         return self.status, self.headers, self.body
 
-    
+
+class MIMETypes(object):
+    """MIMETypes registration mapping
+    
+    The MIMETypes object class provides a single point to hold onto all
+    the registered mimetypes, and their association extensions. It's
+    used by the mimetypes function to determine the appropriat content
+    type to return to a client.
+    
+    """
+    extension_mapping = {}
+    type_mapping = {}
+    
+    def load_defaults(cls):
+        """Loads a default mapping of extensions and mimetypes
+        
+        These are suitable for most web applications by default. 
+        Additional types can be added with the MIMETypes.register 
+        method.
+        
+        """
+        extension_mapping = {}
+        type_mapping = {}
+        mimetypes.init()
+        for ext, mimetype in mimetypes.types_map.iteritems():
+            type_mapping[mimetype] = ext[1:]
+            extension_mapping[ext[1:]] = mimetype
+        cls.extension_mapping.update(extension_mapping)
+        cls.type_mapping.update(type_mapping)
+        
+        # Add some common defaults and aliases
+        MIMETypes.register('*/*', 'all')
+        MIMETypes.register('text/plain', 'text', ext_aliases=('txt',))
+        MIMETypes.register('text/html', 'html', 
+                           type_aliases=('application/xhtml+xml',), 
+                           ext_aliases=('xhtml',))
+        MIMETypes.register('text/javascript', 'js',
+                           type_aliases=('application/javascript', 
+                                         'application/x-javascript'))
+        MIMETypes.register('text/css', 'css')
+        MIMETypes.register('text/calendar', 'ics')
+        MIMETypes.register('text/csv', 'csv')
+        MIMETypes.register('application/xml', 'xml',
+                           type_aliases=('text/xml', 'application/x-xml'))
+        MIMETypes.register('application/rss+xml', 'rss')
+        MIMETypes.register('application/atom+xml', 'atom')
+        MIMETypes.register('application/x-yaml', 'yaml',
+                           type_aliases=('text/yaml',))
+        MIMETypes.register('multipart/form-data', 'multipart_form')
+        MIMETypes.register('application/x-www-form-urlencoded', 'url_encoded_form')
+        MIMETypes.register('application/json', 'json', 
+                           type_aliases=('text/x-json',))
+    load_defaults = classmethod(load_defaults)
+    
+    def register(cls, mimetype, extension, type_aliases=None, ext_aliases=None):
+        """Register additional MIMETypes
+        
+        Additional mimetypes that a user wants to recognize and handle
+        should be registered using this method. Extension aliases that
+        should be treated as equivilant to the desired extension, along
+        with alias mimetypes can also be registered.
+        
+        Example:
+            # Register text/plain as the text extension, or txt
+            MIMETypes.register('text/plain', 'text', ext_aliases=('txt',))
+        
+        """
+        cls.type_mapping[mimetype] = extension
+        if type_aliases:
+            for alias in type_aliases:
+                cls.type_mapping[alias] = extension
+        
+        cls.extension_mapping[extension] = mimetype
+        if ext_aliases:
+            for alias in ext_aliases:
+                cls.extension_mapping[alias] = mimetype
+    register = classmethod(register)
+
+
+def mimetype(extension):
+    """Check the Routes match and client HTTP Accept to attempt to use
+    the appropriate mime-type
+    
+    This works best with Routes ``map.resource`` which sets up routes
+    that can accept matches with a specific extension.
+    
+    Example:
+        def somaction(self):
+            # prepare a bunch of data
+            # ......
+            
+            if mimetype('html'):
+                return render('/some/template.html')
+            elif mimetype('atom'):
+                return render('/some/xml_template.xml')
+            elif mimetype('csv'):
+                # write the data to a csv file
+                return csvfile
+            else:
+                abort(404)
+    
+    """
+    request = pylons.request._current_obj()
+    # Pull out the possible return content-type
+    return_type = MIMETypes.extension_mapping.get(extension)
+    if not return_type:
+        raise Exception("Can't check for extensions that haven't been "
+                        "registered")
+    
+    # Check for a format in Route args first
+    route_format = request.environ['pylons.routes_dict'].get('format')
+    if route_format:
+        mime_type = MIMETypes.extension_mapping[route_format]
+        resolved_extension = MIMETypes.type_mapping[mime_type]
+        if resolved_extension == extension:
+            pylons.response.headers['Content-Type'] = mime_type
+            return True
+    
+    # Check to see if this matches in the Request accept
+    if return_type in request.accept_language:
+        pylons.response.headers['Content-Type'] = return_type
+        return True
+    
+    # Didn't match the route format or the Request accept, don't match
+    return False
+
+
 def etag_cache(key=None):
     """Use the HTTP Entity Tag cache for Browser side caching