Ticket #15053: patch.15426.diff

template/base.py

@@ -195 +195 @@
                 token = Token(TOKEN_COMMENT, content)
         else:
             token = Token(TOKEN_TEXT, token_string)
+        token.source = self.origin, (-1, -1)
         token.lineno = self.lineno
         self.lineno += token_string.count('\n')
         return token
@@ -268 +269 @@
                 raise TemplateSyntaxError("%r must be the first tag in the template." % node)
         if isinstance(nodelist, NodeList) and not isinstance(node, TextNode):
             nodelist.contains_nontext = True
+        node.source = token.source
         nodelist.append(node)
 
     def enter_command(self, command, token):

template/loader_tags.py

@@ -2 +2 @@
 from django.template.base import Library, Node, TextNode
 from django.template.context import Context
 from django.template.defaulttags import token_kwargs
-from django.template.loader import get_template
+from django.template.loader import find_template, get_template
 from django.conf import settings
 from django.utils.safestring import mark_safe
 
@@ -99 +99 @@
             raise TemplateSyntaxError(error_msg)
         if hasattr(parent, 'render'):
             return parent # parent is a Template object
-        return get_template(parent)
+        origin, source = self.source
+        return get_template(parent, skip_template=origin.name)
 
     def render(self, context):
+        origin, source = self.source
+        if origin and origin.loadname == self.parent_name:
+            template = find_template(self.parent_name, skip_template=origin.name)
+            template_source = template[0]
+            extends_tags = template_source.nodelist[0]
+            parent_origin, parent_source = extends_tags.source
+            self.parent_name = getattr(parent_origin, 'name', None)
         compiled_parent = self.get_parent(context)
 
         if BLOCK_CONTEXT_KEY not in context.render_context:

template/debug.py

@@ -54 +54 @@
     def create_variable_node(self, contents):
         return DebugVariableNode(contents)
 
-    def extend_nodelist(self, nodelist, node, token):
-        node.source = token.source
-        super(DebugParser, self).extend_nodelist(nodelist, node, token)
-
     def unclosed_block_tag(self, parse_until):
         command, source = self.command_stack.pop()
         msg = "Unclosed tag '%s'. Looking for one of: %s " % (command, ', '.join(parse_until))

template/loader.py

@@ -78 +78 @@
     def reload(self):
         return self.loader(self.loadname, self.dirs)[0]
 
+
+class LoaderOriginLite(object):
+
+    def __init__(self, display_name, loader, name, dirs):
+        self.name = display_name
+        self.loader, self.loadname, self.dirs = loader, name, dirs
+
+
 def make_origin(display_name, loader, name, dirs):
     if settings.TEMPLATE_DEBUG and display_name:
         return LoaderOrigin(display_name, loader, name, dirs)
     else:
-        return None
+        return LoaderOriginLite(display_name, loader, name, dirs)
 
 def find_template_loader(loader):
     if isinstance(loader, (tuple, list)):
@@ -117 +125 @@
     else:
         raise ImproperlyConfigured('Loader does not define a "load_template" callable template source loader')
 
-def find_template(name, dirs=None):
+
+def find_template(name, dirs=None, skip_template=None):
     # Calculate template_source_loaders the first time the function is executed
     # because putting this logic in the module-level namespace may cause
     # circular import errors. See Django ticket #1292.
@@ -129 +138 @@
             if loader is not None:
                 loaders.append(loader)
         template_source_loaders = tuple(loaders)
+    template_candidate = None
     for loader in template_source_loaders:
         try:
             source, display_name = loader(name, dirs)
-            return (source, make_origin(display_name, loader, name, dirs))
+            if skip_template:
+                extends_tags = source.nodelist[0]
+                extends_tags_origin, extends_tags_source = extends_tags.source
+                if extends_tags_origin.name == skip_template:
+                    template_candidate = None
+                    continue
+                if not template_candidate:
+                    template_candidate = (source, make_origin(display_name, loader, name, dirs))
+            else:
+                return (source, make_origin(display_name, loader, name, dirs))
         except TemplateDoesNotExist:
             pass
-    raise TemplateDoesNotExist(name)
+    if not template_candidate:
+        raise TemplateDoesNotExist(name)
+    return template_candidate
 
 def find_template_source(name, dirs=None):
     # For backward compatibility
@@ -149 +170 @@
         raise Exception("Found a compiled template that is incompatible with the deprecated `django.template.loaders.find_template_source` function.")
     return template, origin
 
-def get_template(template_name):
+def get_template(template_name, skip_template=None):
     """
     Returns a compiled Template object for the given template name,
     handling template inheritance recursively.
     """
-    template, origin = find_template(template_name)
+    template, origin = find_template(template_name, skip_template=skip_template)
     if not hasattr(template, 'render'):
         # template needs to be compiled
         template = get_template_from_string(template, origin, template_name)