Ticket #412: loader.patch

genshi/template/loader.py

@@ -14 +14 @@
 """Template loading and caching."""
 
 import os
+import sys
 try:
     import threading
 except ImportError:
@@ -32 +33 @@
 
     def __init__(self, name, search_path):
         """Create the exception.
-        
+
         :param name: the filename of the template
         :param search_path: the search path used to lookup the template
         """
@@ -43 +44 @@
 class TemplateLoader(object):
     """Responsible for loading templates from files on the specified search
     path.
-    
+
     >>> import tempfile
     >>> fd, path = tempfile.mkstemp(suffix='.html', prefix='template')
     >>> os.write(fd, '<p>$var</p>')
     11
     >>> os.close(fd)
-    
+
     The template loader accepts a list of directory paths that are then used
     when searching for template files, in the given order:
-    
+
     >>> loader = TemplateLoader([os.path.dirname(path)])
-    
+
     The `load()` method first checks the template cache whether the requested
     template has already been loaded. If not, it attempts to locate the
     template file, and returns the corresponding `Template` object:
-    
+
     >>> from genshi.template import MarkupTemplate
     >>> template = loader.load(os.path.basename(path))
     >>> isinstance(template, MarkupTemplate)
     True
-    
+
     Template instances are cached: requesting a template with the same name
     results in the same instance being returned:
-    
+
     >>> loader.load(os.path.basename(path)) is template
     True
-    
+
     The `auto_reload` option can be used to control whether a template should
     be automatically reloaded when the file it was loaded from has been
     changed. Disable this automatic reloading to improve performance.
-    
+
     >>> os.remove(path)
     """
     def __init__(self, search_path=None, auto_reload=False,
                  default_encoding=None, max_cache_size=25, default_class=None,
                  variable_lookup='strict', allow_exec=True, callback=None):
         """Create the template laoder.
-        
+
         :param search_path: a list of absolute path names that should be
                             searched for template files, or a string containing
                             a single absolute path; alternatively, any item on
@@ -105 +106 @@
                          callback can be used for example to add any desired
                          filters to the template
         :see: `LenientLookup`, `StrictLookup`
-        
+
         :note: Changed in 0.5: Added the `allow_exec` argument
         """
         from genshi.template.markup import MarkupTemplate
@@ -142 +143 @@
 
     def load(self, filename, relative_to=None, cls=None, encoding=None):
         """Load the template with the given name.
-        
+
         If the `filename` parameter is relative, this method searches the
         search path trying to locate a template matching the given name. If the
         file name is an absolute path, the search path is ignored.
-        
+
         If the requested template is not found, a `TemplateNotFound` exception
         is raised. Otherwise, a `Template` object is returned that represents
         the parsed template.
-        
+
         Template instances are cached to avoid having to parse the same
         template file more than once. Thus, subsequent calls of this method
         with the same template file name will return the same `Template`
         object (unless the ``auto_reload`` option is enabled and the file was
         changed since the last parse.)
-        
+
         If the `relative_to` parameter is provided, the `filename` is
         interpreted as being relative to that path.
-        
+
         :param filename: the relative path of the template file to load
         :param relative_to: the filename of the template from which the new
                             template is being loaded, or ``None`` if the
@@ -226 +227 @@
                 else:
                     try:
                         if isabs:
-                            # If the filename of either the included or the 
+                            # If the filename of either the included or the
                             # including template is absolute, make sure the
                             # included template gets an absolute path, too,
                             # so that nested includes work properly without a
@@ -251 +252 @@
     def _instantiate(self, cls, fileobj, filepath, filename, encoding=None):
         """Instantiate and return the `Template` object based on the given
         class and parameters.
-        
+
         This function is intended for subclasses to override if they need to
         implement special template instantiation logic. Code that just uses
         the `TemplateLoader` should use the `load` method instead.
-        
+
         :param cls: the class of the template object to instantiate
         :param fileobj: a readable file-like object containing the template
                         source
@@ -276 +277 @@
     @staticmethod
     def directory(path):
         """Loader factory for loading templates from a local directory.
-        
+
         :param path: the path to the local directory containing the templates
         :return: the loader function to load templates from the given directory
         :rtype: ``function``
         """
+        if os.path.supports_unicode_filenames and not isinstance(path, unicode):
+            encoding = sys.getfilesystemencoding()
+            if encoding:
+                path = unicode(path, encoding)
+            else:
+                path = unicode(path)
         def _load_from_directory(filename):
             filepath = os.path.join(path, filename)
             fileobj = open(filepath, 'U')
@@ -293 +300 @@
     @staticmethod
     def package(name, path):
         """Loader factory for loading templates from egg package data.
-        
+
         :param name: the name of the package containing the resources
         :param path: the path inside the package data
         :return: the loader function to load templates from the given package
@@ -309 +316 @@
     def prefixed(**delegates):
         """Factory for a load function that delegates to other loaders
         depending on the prefix of the requested template path.
-        
+
         The prefix is stripped from the filename when passing on the load
         request to the delegate.
-        
+
         >>> load = prefixed(
         ...     app1 = lambda filename: ('app1', filename, None, None),
         ...     app2 = lambda filename: ('app2', filename, None, None)
@@ -321 +328 @@
         ('app1', 'app1/foo.html', None, None)
         >>> print(load('app2/bar.html'))
         ('app2', 'app2/bar.html', None, None)
-        
+
         :param delegates: mapping of path prefixes to loader functions
         :return: the loader function
         :rtype: ``function``