binding: Updates Jinja2 from 2.7.1 to 2.8.

third_party/jinja2/loaders.py

 # -*- coding: utf-8 -*-
 """
     jinja2.loaders
     ~~~~~~~~~~~~~~
 
     Jinja loader classes.
 
     :copyright: (c) 2010 by the Jinja Team.
     :license: BSD, see LICENSE for more details.
 """
@@ skipping 123 matching lines @@
         return environment.template_class.from_code(environment, code,
                                                     globals, uptodate)
 
 
 class FileSystemLoader(BaseLoader):
     """Loads templates from the file system.  This loader can find templates
     in folders on the file system and is the preferred way to load them.
 
     The loader takes the path to the templates as string, or if multiple
     locations are wanted a list of them which is then looked up in the
-    given order:
+    given order::
 
     >>> loader = FileSystemLoader('/path/to/templates')
     >>> loader = FileSystemLoader(['/path/to/templates', '/other/path'])
 
     Per default the template encoding is ``'utf-8'`` which can be changed
     by setting the `encoding` parameter to something else.
+
+    To follow symbolic links, set the *followlinks* parameter to ``True``::
+
+    >>> loader = FileSystemLoader('/path/to/templates', followlinks=True)
+
+    .. versionchanged:: 2.8+
+       The *followlinks* parameter was added.
     """
 
-    def __init__(self, searchpath, encoding='utf-8'):
+    def __init__(self, searchpath, encoding='utf-8', followlinks=False):
         if isinstance(searchpath, string_types):
             searchpath = [searchpath]
         self.searchpath = list(searchpath)
         self.encoding = encoding
+        self.followlinks = followlinks
 
     def get_source(self, environment, template):
         pieces = split_template_path(template)
         for searchpath in self.searchpath:
             filename = path.join(searchpath, *pieces)
             f = open_if_exists(filename)
             if f is None:
                 continue
             try:
                 contents = f.read().decode(self.encoding)
             finally:
                 f.close()
 
             mtime = path.getmtime(filename)
+
             def uptodate():
                 try:
                     return path.getmtime(filename) == mtime
                 except OSError:
                     return False
             return contents, filename, uptodate
         raise TemplateNotFound(template)
 
     def list_templates(self):
         found = set()
         for searchpath in self.searchpath:
-            for dirpath, dirnames, filenames in os.walk(searchpath):
+            walk_dir = os.walk(searchpath, followlinks=self.followlinks)
+            for dirpath, dirnames, filenames in walk_dir:
                 for filename in filenames:
                     template = os.path.join(dirpath, filename) \
                         [len(searchpath):].strip(os.path.sep) \
                                           .replace(os.path.sep, '/')
                     if template[:2] == './':
                         template = template[2:]
                     if template not in found:
                         found.add(template)
         return sorted(found)
 
@@ skipping 80 matching lines @@
             source = self.mapping[template]
             return source, None, lambda: source == self.mapping.get(template)
         raise TemplateNotFound(template)
 
     def list_templates(self):
         return sorted(self.mapping)
 
 
 class FunctionLoader(BaseLoader):
     """A loader that is passed a function which does the loading.  The
-    function becomes the name of the template passed and has to return either
+    function receives the name of the template and has to return either
     an unicode string with the template source, a tuple in the form ``(source,
     filename, uptodatefunc)`` or `None` if the template does not exist.
 
     >>> def load_template(name):
     ...     if name == 'index.html':
     ...         return '...'
     ...
     >>> loader = FunctionLoader(load_template)
 
     The `uptodatefunc` is a function that is called if autoreload is enabled
@@ skipping 47 matching lines @@
             return loader.get_source(environment, name)
         except TemplateNotFound:
             # re-raise the exception with the correct fileame here.
             # (the one that includes the prefix)
             raise TemplateNotFound(template)
 
     @internalcode
     def load(self, environment, name, globals=None):
         loader, local_name = self.get_loader(name)
         try:
-            return loader.load(environment, local_name)
+            return loader.load(environment, local_name, globals)
         except TemplateNotFound:
             # re-raise the exception with the correct fileame here.
             # (the one that includes the prefix)
             raise TemplateNotFound(name)
 
     def list_templates(self):
         result = []
         for prefix, loader in iteritems(self.mapping):
             for template in loader.list_templates():
                 result.append(prefix + self.delimiter + template)
@@ skipping 99 matching lines @@
                 mod = __import__(module, None, None, ['root'])
             except ImportError:
                 raise TemplateNotFound(name)
 
             # remove the entry from sys.modules, we only want the attribute
             # on the module object we have stored on the loader.
             sys.modules.pop(module, None)
 
         return environment.template_class.from_module_dict(
             environment, mod.__dict__, globals)