Update Jinja2 (Python template library) to 2.7.1

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.
 """
 import os
 import sys
 import weakref
 from types import ModuleType
 from os import path
-try:
-    from hashlib import sha1
-except ImportError:
-    from sha import new as sha1
+from hashlib import sha1
 from jinja2.exceptions import TemplateNotFound
-from jinja2.utils import LRUCache, open_if_exists, internalcode
+from jinja2.utils import open_if_exists, internalcode
+from jinja2._compat import string_types, iteritems
 
 
 def split_template_path(template):
     """Split a path into segments and perform a sanity check.  If it detects
     '..' in the path it will raise a `TemplateNotFound` error.
     """
     pieces = []
     for piece in template.split('/'):
         if path.sep in piece \
            or (path.altsep and path.altsep in piece) or \
@@ skipping 114 matching lines @@
     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.
     """
 
     def __init__(self, searchpath, encoding='utf-8'):
-        if isinstance(searchpath, basestring):
+        if isinstance(searchpath, string_types):
             searchpath = [searchpath]
         self.searchpath = list(searchpath)
         self.encoding = encoding
 
     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:
@@ skipping 100 matching lines @@
 
     Because auto reloading is rarely useful this is disabled per default.
     """
 
     def __init__(self, mapping):
         self.mapping = mapping
 
     def get_source(self, environment, template):
         if template in self.mapping:
             source = self.mapping[template]
-            return source, None, lambda: source != self.mapping.get(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
     an unicode string with the template source, a tuple in the form ``(source,
@@ skipping 11 matching lines @@
     return value.
     """
 
     def __init__(self, load_func):
         self.load_func = load_func
 
     def get_source(self, environment, template):
         rv = self.load_func(template)
         if rv is None:
             raise TemplateNotFound(template)
-        elif isinstance(rv, basestring):
+        elif isinstance(rv, string_types):
             return rv, None, None
         return rv
 
 
 class PrefixLoader(BaseLoader):
     """A loader that is passed a dict of loaders where each loader is bound
     to a prefix.  The prefix is delimited from the template by a slash per
     default, which can be changed by setting the `delimiter` argument to
     something else::
 
         loader = PrefixLoader({
             'app1':     PackageLoader('mypackage.app1'),
             'app2':     PackageLoader('mypackage.app2')
         })
 
     By loading ``'app1/index.html'`` the file from the app1 package is loaded,
     by loading ``'app2/index.html'`` the file from the second.
     """
 
     def __init__(self, mapping, delimiter='/'):
         self.mapping = mapping
         self.delimiter = delimiter
 
-    def get_source(self, environment, template):
+    def get_loader(self, template):
         try:
             prefix, name = template.split(self.delimiter, 1)
             loader = self.mapping[prefix]
         except (ValueError, KeyError):
             raise TemplateNotFound(template)
+        return loader, name
+
+    def get_source(self, environment, template):
+        loader, name = self.get_loader(template)
         try:
             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)
+        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 self.mapping.iteritems():
+        for prefix, loader in iteritems(self.mapping):
             for template in loader.list_templates():
                 result.append(prefix + self.delimiter + template)
         return result
 
 
 class ChoiceLoader(BaseLoader):
     """This loader works like the `PrefixLoader` just that no prefix is
     specified.  If a template could not be found by one loader the next one
     is tried.
 
@@ skipping 10 matching lines @@
         self.loaders = loaders
 
     def get_source(self, environment, template):
         for loader in self.loaders:
             try:
                 return loader.get_source(environment, template)
             except TemplateNotFound:
                 pass
         raise TemplateNotFound(template)
 
+    @internalcode
+    def load(self, environment, name, globals=None):
+        for loader in self.loaders:
+            try:
+                return loader.load(environment, name, globals)
+            except TemplateNotFound:
+                pass
+        raise TemplateNotFound(name)
+
     def list_templates(self):
         found = set()
         for loader in self.loaders:
             found.update(loader.list_templates())
         return sorted(found)
 
 
 class _TemplateModule(ModuleType):
     """Like a normal module but with support for weak references"""
 
@@ skipping 12 matching lines @@
     """
 
     has_source_access = False
 
     def __init__(self, path):
         package_name = '_jinja2_module_templates_%x' % id(self)
 
         # create a fake module that looks for the templates in the
         # path given.
         mod = _TemplateModule(package_name)
-        if isinstance(path, basestring):
+        if isinstance(path, string_types):
             path = [path]
         else:
             path = list(path)
         mod.__path__ = path
 
         sys.modules[package_name] = weakref.proxy(mod,
             lambda x: sys.modules.pop(package_name, None))
 
         # the only strong reference, the sys.modules entry is weak
         # so that the garbage collector can remove it once the
@@ skipping 19 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)