Ticket #7817: 7817.diff

django/template/loader_tags.py

@@ -1 +1 @@
 from django.template import TemplateSyntaxError, TemplateDoesNotExist, Variable
 from django.template import Library, Node, TextNode
+from django.template.defaulttags import kwarg_re
 from django.template.loader import get_template
 from django.conf import settings
 from django.utils.safestring import mark_safe
@@ -124 +125 @@
         # the same.
         return compiled_parent._render(context)
 
-class ConstantIncludeNode(Node):
-    def __init__(self, template_path):
+class BaseIncludeNode(Node):
+    def __init__(self, *args, **kwargs):
+        self.extra_context = kwargs.pop('extra_context', {})
+        super(BaseIncludeNode, self).__init__(*args, **kwargs)
+
+    def render_template(self, template, context):
+        values = [(name, var.resolve(context)) for name, var
+                  in self.extra_context.iteritems()]
+        context.update(dict(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
@@ -135 +150 @@
             self.template = None
 
     def render(self, context):
-        if self.template:
-            return self.template.render(context)
-        else:
+        if not self.template:
             return ''
+        return self.render_template(self.template, context)
 
-class IncludeNode(Node):
-    def __init__(self, template_name):
-        self.template_name = Variable(template_name)
+class IncludeNode(BaseIncludeNode):
+    def __init__(self, template_name, extra_context={}):
+        self.template_name = template_name
+        self.extra_context = extra_context
 
     def render(self, context):
         try:
             template_name = self.template_name.resolve(context)
-            t = get_template(template_name)
-            return t.render(context)
-        except TemplateSyntaxError, e:
+            template = get_template(template_name)
+            return self.render_template(template, context)
+        except TemplateSyntaxError:
             if settings.TEMPLATE_DEBUG:
                 raise
             return ''
@@ -201 +216 @@
 
 def do_include(parser, token):
     """
-    Loads a template and renders it with the current context.
+    Loads a template and renders it with the current context. You can pass
+    additional context using keyword arguments.
 
     Example::
 
         {% include "foo/some_include" %}
+        {% include "foo/some_include" with bar="BAZZ!" baz="BING!" %}
+
     """
     bits = token.split_contents()
-    if len(bits) != 2:
-        raise TemplateSyntaxError("%r tag takes one argument: the name of the template to be included" % bits[0])
+    if len(bits) < 2:
+        raise TemplateSyntaxError("%r tag takes at least one argument: the name of the template to be included." % bits[0])
+    namemap = {}
+    if len(bits) > 2:
+        if bits[2] != 'with':
+            raise TemplateSyntaxError('''Invalid option %r for %r tag.''' % (bits[2], bits[0]))
+        for bit in bits[3:]:
+            match = kwarg_re.match(bit)
+            if not match:
+                raise TemplateSyntaxError("Malformed arguments to %r tag." % bits[0])
+            name, value = match.groups()
+            if not name:
+                raise TemplateSyntaxError('''"with" part of %r tag accepts only keyword arguments.''' % bits[0])
+            if name in namemap:
+                raise TemplateSyntaxError("Tried to bind value to name %r more than once." % name)
+            namemap[name] = parser.compile_filter(value)
+        if not namemap:
+            raise TemplateSyntaxError('''"with" in %r tag needs at least one keyword argument.''' % bits[0])
     path = bits[1]
     if path[0] in ('"', "'") and path[-1] == path[0]:
-        return ConstantIncludeNode(path[1:-1])
-    return IncludeNode(bits[1])
+        return ConstantIncludeNode(path[1:-1], extra_context=namemap)
+    return IncludeNode(parser.compile_filter(bits[1]), extra_context=namemap)
 
 register.tag('block', do_block)
 register.tag('extends', do_extends)

docs/ref/templates/builtins.txt

@@ -619 +619 @@
 
     * The ``name_snippet.html`` template::
 
-        Hello, {{ person }}
+        {{ greeting }}, {{ person }}
+
+.. versionchanged:: 1.3
+
+You can pass additional context to the template using keyword arguments::
+
+    {% include "name_snippet.html" with person="Jane" greeting="Hello" "%}
+
+This is pretty much syntactic sugar for wrapping :ttag:`include`
+with a :ttag:`with` tag.
 
 See also: ``{% ssi %}``.
 

tests/regressiontests/templates/tests.py

@@ -923 +923 @@
             'include 05': ('template with a space', {}, 'template with a space'),
             'include06': ('{% include "include 05"%}', {}, 'template with a space'),
 
+            # extra inline context
+            'include07': ('{% include "basic-syntax02" with headline="Inline" %}', {'headline': 'Included'}, 'Inline'),
+            'include08': ('{% include headline with headline="Dynamic" %}', {'headline': 'basic-syntax02'}, 'Dynamic'),
+            'include09': ('{{ first }}--{% include "basic-syntax03" with first=second|lower|upper second=first|upper %}--{{ second }}', {'first': 'Ul', 'second': 'lU'}, 'Ul--LU --- UL--lU'),
+
+            'include-error01': ('{% include "basic-syntax01" with %}', {}, template.TemplateSyntaxError),
+            'include-error02': ('{% include "basic-syntax01" with "no key" %}', {}, template.TemplateSyntaxError),
+            'include-error03': ('{% include "basic-syntax01" with dotted.arg="error" %}', {}, template.TemplateSyntaxError),
+            'include-error04': ('{% include "basic-syntax01" something_random %}', {}, template.TemplateSyntaxError),
+            'include-error05': ('{% include "basic-syntax01" foo="duplicate" foo="key" %}', {}, template.TemplateSyntaxError),
+
             ### NAMED ENDBLOCKS #######################################################
 
             # Basic test