Ticket #16147: 16147.r17335.diff

django/template/loader_tags.py

@@ -125 +125 @@
         # the same.
         return compiled_parent._render(context)
 
-class BaseIncludeNode(Node):
-    def __init__(self, *args, **kwargs):
-        self.extra_context = kwargs.pop('extra_context', {})
-        self.isolated_context = kwargs.pop('isolated_context', False)
-        super(BaseIncludeNode, self).__init__(*args, **kwargs)
-
-    def render_template(self, template, context):
-        values = dict([(name, var.resolve(context)) for name, var
-                       in self.extra_context.iteritems()])
-        if self.isolated_context:
-            return template.render(context.new(values))
-        context.update(values)
-        output = template.render(context)
-        context.pop()
-        return output
-
-class ConstantIncludeNode(BaseIncludeNode):
-    def __init__(self, template_path, *args, **kwargs):
-        super(ConstantIncludeNode, self).__init__(*args, **kwargs)
-        try:
-            t = get_template(template_path)
-            self.template = t
-        except:
-            if settings.TEMPLATE_DEBUG:
-                raise
-            self.template = None
-
-    def render(self, context):
-        if not self.template:
-            return ''
-        return self.render_template(self.template, context)
-
-class IncludeNode(BaseIncludeNode):
-    def __init__(self, template_name, *args, **kwargs):
-        super(IncludeNode, self).__init__(*args, **kwargs)
+class IncludeNode(Node):
+    def __init__(self, template_name, resolve=False, *args, **kwargs):
         self.template_name = template_name
+        self.resolve = resolve
+        self.extra_context = kwargs.pop('with', {})
+        self.isolated_context = kwargs.pop('only', False)
+        super(IncludeNode, self).__init__(*args, **kwargs)
 
     def render(self, context):
+        template_name = self.template_name
+
         try:
-            template_name = self.template_name.resolve(context)
+            if self.resolve:
+                template_name = template_name.resolve(context)
+
             template = get_template(template_name)
+
             return self.render_template(template, context)
         except:
             if settings.TEMPLATE_DEBUG:
                 raise
             return ''
 
+    def render_template(self, template, context):
+        values = dict([(name, var.resolve(context)) for name, var
+                       in self.extra_context.iteritems()])
+        if self.isolated_context:
+            return template.render(context.new(values))
+        context.update(values)
+        output = template.render(context)
+        context.pop()
+        return output
+
 @register.tag('block')
 def do_block(parser, token):
     """
@@ -243 +229 @@
     bits = token.split_contents()
     if len(bits) < 2:
         raise TemplateSyntaxError("%r tag takes at least one argument: the name of the template to be included." % bits[0])
+
     options = {}
     remaining_bits = bits[2:]
     while remaining_bits:
@@ -260 +247 @@
         else:
             raise TemplateSyntaxError('Unknown argument for %r tag: %r.' %
                                       (bits[0], option))
-        options[option] = value
-    isolated_context = options.get('only', False)
-    namemap = options.get('with', {})
-    path = bits[1]
-    if path[0] in ('"', "'") and path[-1] == path[0]:
-        return ConstantIncludeNode(path[1:-1], extra_context=namemap,
-                                   isolated_context=isolated_context)
-    return IncludeNode(parser.compile_filter(bits[1]), extra_context=namemap,
-                       isolated_context=isolated_context)
+        options[str(option)] = value
+
+    options.setdefault("only", False)
+    options.setdefault("with", {})
+
+    template_name = bits[1]
+    if template_name[0] in ('"', "'") and template_name[-1] == template_name[0]:
+        resolve = False
+        template_name = template_name[1:-1]
+    else:
+        resolve = True
+        template_name = parser.compile_filter(template_name)
+
+    return IncludeNode(
+        template_name,
+        resolve=resolve,
+        **options
+    )

tests/regressiontests/templates/tests.py

@@ -21 +21 @@
 from django.core import urlresolvers
 from django.template import loader
 from django.template.loaders import app_directories, filesystem, cached
-from django.test import RequestFactory
+from django.test import RequestFactory, TestCase
 from django.test.utils import (get_warnings_state, restore_warnings_state,
     setup_test_template_loader, restore_template_loaders, override_settings)
 from django.utils import unittest
@@ -1728 +1728 @@
             template.Template('{% include "child" only %}').render(ctx),
             'none'
         )
+
+
+class IncludeTagTest(TestCase):
+
+    def setUp(self):
+        setup_test_template_loader({
+            "basic.html": "Basic",
+            "headline.html": "{{ headline }}",
+            "has space.html": "Spaced",
+            "onetwo.html": "{{ first }}-{{ second }}",
+            "recursive.html": "{% for item in items %}{{ item.label }}{% if not item.children|length_is:0 %}{% with item.children as items %}({% include 'recursive.html' %}){% endwith %}{% endif %}{% endfor %}",
+        })
+
+    def tearDown(self):
+        restore_template_loaders()
+
+    def test_include(self):
+        t = Template("{% include 'basic.html' %}")
+        c = Context()
+        output = t.render(c)
+        self.assertEqual(output, "Basic")
+
+    def test_context(self):
+        t = Template("{% include 'headline.html' %}")
+        c = Context(dict(headline="Headline"))
+        output = t.render(c)
+        self.assertEqual(output, "Headline")
+
+    def test_include_variable(self):
+        t = Template("{% include template_name %}")
+        c = Context(dict(template_name="basic.html"))
+        output = t.render(c)
+        self.assertEqual(output, "Basic")
+
+    def test_does_not_exist(self):
+        t = Template("{% include 'chuck-testa.html' %}")
+        c = Context()
+        self.assertEqual(t.render(c), "")
+        with self.settings(TEMPLATE_DEBUG=True):
+            with self.assertRaises(template.TemplateDoesNotExist):
+                t.render(c)
+
+        t = Template("{% include template_name %}")
+        c = Context(dict(template_name="nope.html"))
+        self.assertEqual(t.render(c), "")
+        with self.settings(TEMPLATE_DEBUG=True):
+            with self.assertRaises(template.TemplateDoesNotExist):
+                t.render(c)
+
+        t = Template("{% if false %}{% include 'chuck-testa.html' %}{% endif %}")
+        c = Context(dict(false=False))
+        self.assertEqual(t.render(c), "")
+        with self.settings(TEMPLATE_DEBUG=True):
+            self.assertEqual(t.render(c), "")
+
+    def test_recursive_include(self):
+        t = loader.get_template("recursive.html")
+        c = Context({
+            'items': [ 
+                {'label': 1, 'children': [ 
+                    {'label': 2, 'children': [ 
+                        {'label': 3, 'children': []}, 
+                        {'label': 4, 'children': []}, 
+                    ]}, 
+                ]},
+            ]}
+        )
+        self.assertEqual(t.render(c), "1(2(34))")
+
+    def test_with_space(self):
+        t = Template("{% include 'has space.html' %}")
+        c = Context()
+        output = t.render(c)
+        self.assertEqual(output, "Spaced")
+
+    def test_inline_context(self):
+        t = Template("{% include 'headline.html' with headline='Inline' %}")
+        c = Context()
+        output = t.render(c)
+        self.assertEqual(output, "Inline")
+
+        t = Template("{% include headline with headline='Dynamic' %}")
+        c = Context(dict(headline="headline.html"))
+        output = t.render(c)
+        self.assertEqual(output, "Dynamic")
+
+        t = Template("{{ headline }} {% include 'headline.html' with headline=headline|upper %}")
+        c = Context(dict(headline="Headline"))
+        output = t.render(c)
+        self.assertEqual(output, "Headline HEADLINE")
+
+    def test_isolated_context(self):
+        t = Template("{% include 'headline.html' only %}")
+        c = Context(dict(headline="Headline"))
+        output = t.render(c)
+        self.assertEqual(output, "")
+
+        t = Template("{% include 'onetwo.html' only with first='Inline' %}")
+        c = Context(dict(
+            first="First",
+            second="Second",
+        ))
+        output = t.render(c)
+        self.assertEqual(output, "Inline-")
+
+        t = Template("{% include 'onetwo.html' with first='Inline' only %}")
+        c = Context(dict(
+            first="First",
+            second="Second",
+        ))
+        output = t.render(c)
+        self.assertEqual(output, "Inline-")
+
+    def test_autoescape_context(self):
+        t = Template("{% autoescape off %}{% include 'onetwo.html' %}{% endautoescape %}")
+        c = Context(dict(
+            first="&",
+        ))
+        output = t.render(c)
+        self.assertEqual(output, "&-")
+
+        t = Template("{% autoescape off %}{% include 'onetwo.html' with first=var1 only %}{% endautoescape %}")
+        c = Context(dict(var1="&"))
+        output = t.render(c)
+        self.assertEqual(output, "&-")
+
+    def test_errors(self):
+        with self.assertRaises(template.TemplateSyntaxError):
+            t = Template("{% include 'onetwo.html' with %}")
+
+        with self.assertRaises(template.TemplateSyntaxError):
+            t = Template("{% include 'onetwo.html' with 'no key' %}")
+
+        with self.assertRaises(template.TemplateSyntaxError):
+            t = Template("{% include 'onetwo.html' with dotted.arg='error' %}")
+
+        with self.assertRaises(template.TemplateSyntaxError):
+            t = Template("{% include 'onetwo.html' with something_random %}")
+
+        with self.assertRaises(template.TemplateSyntaxError):
+            t = Template("{% include 'onetwo.html' with only only %}")