Ticket #9154: templates_optimizations_r9285.diff

django/template/loader_tags.py

@@ +1 @@
+import copy
+
 from django.template import TemplateSyntaxError, TemplateDoesNotExist, Variable
 from django.template import Library, Node, TextNode
-from django.template.loader import get_template, get_template_from_string, find_template_source
+from django.template.loader import get_template
 from django.conf import settings
 from django.utils.safestring import mark_safe
 
@@ -43 +45 @@
         self.nodelist = nodelist
         self.parent_name, self.parent_name_expr = parent_name, parent_name_expr
         self.template_dirs = template_dirs
+        if self.parent_name_expr is None:
+            self.compiled_parent = copy.deepcopy(self.get_parent(context=None))
+        else:
+            self.compiled_parent = None
 
     def __repr__(self):
         if self.parent_name_expr:
@@ -61 +67 @@
         if hasattr(parent, 'render'):
             return parent # parent is a Template object
         try:
-            source, origin = find_template_source(parent, self.template_dirs)
+            return get_template(parent, self.template_dirs)
         except TemplateDoesNotExist:
             raise TemplateSyntaxError, "Template %r cannot be extended, because it doesn't exist" % parent
-        else:
-            return get_template_from_string(source, origin, parent)
 
     def render(self, context):
-        compiled_parent = self.get_parent(context)
+        if self.compiled_parent is not None:
+            compiled_parent = self.compiled_parent
+        else:
+            compiled_parent = self.get_parent(context)
         parent_blocks = dict([(n.name, n) for n in compiled_parent.nodelist.get_nodes_by_type(BlockNode)])
+        old_parent_nodelists = dict()
         for block_node in self.nodelist.get_nodes_by_type(BlockNode):
             # Check for a BlockNode with this node's name, and replace it if found.
             try:
@@ -93 +101 @@
                 # Keep any existing parents and add a new one. Used by BlockNode.
                 parent_block.parent = block_node.parent
                 parent_block.add_parent(parent_block.nodelist)
+                old_parent_nodelists[block_node.name] = parent_block.nodelist
                 parent_block.nodelist = block_node.nodelist
-        return compiled_parent.render(context)
+        rendered_string = compiled_parent.render(context)
+        # Restore every original parent nodelist
+        for node_name, nodelist in old_parent_nodelists.items():
+            parent_blocks[node_name].nodelist = nodelist
+        return rendered_string
 
 class ConstantIncludeNode(Node):
     def __init__(self, template_path):
@@ -156 +169 @@
     uses the literal value "base" as the name of the parent template to extend,
     or ``{% extends variable %}`` uses the value of ``variable`` as either the
     name of the parent template to extend (if it evaluates to a string) or as
-    the parent tempate itelf (if it evaluates to a Template object).
+    the parent template itself (if it evaluates to a Template object).
     """
     bits = token.contents.split()
     if len(bits) != 2:

django/template/loader.py

@@ -26 +26 @@
 
 template_source_loaders = None
 
+_template_cache = {}
+
 class LoaderOrigin(Origin):
     def __init__(self, display_name, loader, name, dirs):
         super(LoaderOrigin, self).__init__(display_name)
@@ -72 +74 @@
             pass
     raise TemplateDoesNotExist, name
 
-def get_template(template_name):
+def get_template(template_name, dirs=None):
     """
     Returns a compiled Template object for the given template name,
     handling template inheritance recursively.
     """
-    source, origin = find_template_source(template_name)
-    template = get_template_from_string(source, origin, template_name)
+    if not settings.TEMPLATE_DEBUG and template_name in _template_cache:
+        template = _template_cache[template_name]
+    else:
+        source, origin = find_template_source(template_name, dirs)
+        template = get_template_from_string(source, origin, template_name)
+        _template_cache[template_name] = template
     return template
 
 def get_template_from_string(source, origin=None, name=None):