Ticket #9093: inclusion_tag_using_template4.diff

django/template/__init__.py

@@ -823 +823 @@
         raise TemplateSyntaxError(message)
     return node_class(bits)
 
+def inclusion_tag_compiler(params, defaults, name, node_class, parser, token):
+    "Returns an InclusionNode."
+    bits = token.split_contents()[1:]
+    using_template = [] # Allow multiple templates via select_template.
+    try:
+        using_index = bits.index('using')
+    except ValueError:
+        pass
+    else:
+        if using_index != len(bits) - 1:
+            # Get everything after the 'using' keyword.
+            using_template[:] = bits[using_index + 1:]
+            bits = bits[:using_index]
+
+    # Note: Copied from generic_tag_compiler. These should both probably use
+    # FilterExpression.arg_check, which does the same thing.
+    bmax = len(params)
+    def_len = defaults and len(defaults) or 0
+    bmin = bmax - def_len
+    if(len(bits) < bmin or len(bits) > bmax):
+        if bmin == bmax:
+            message = "%s takes %s arguments" % (name, bmin)
+        else:
+            message = "%s takes between %s and %s arguments" % (name, bmin, bmax)
+        raise TemplateSyntaxError(message)
+    return node_class(bits, using_template)
+
 class Library(object):
     def __init__(self):
         self.filters = {}
@@ -892 +919 @@
         self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
         return func
 
-    def inclusion_tag(self, file_name, context_class=Context, takes_context=False):
+    def inclusion_tag(self, file_name, context_class=Context, takes_context=False, allow_override=True):
         def dec(func):
             params, xx, xxx, defaults = getargspec(func)
             if takes_context:
@@ -902 +929 @@
                     raise TemplateSyntaxError("Any tag function decorated with takes_context=True must have a first argument of 'context'")
 
             class InclusionNode(Node):
-                def __init__(self, vars_to_resolve):
+                default_template = file_name
+
+                def __init__(self, vars_to_resolve, using_template=()):
+                    self.using_template = map(Variable, using_template)
                     self.vars_to_resolve = map(Variable, vars_to_resolve)
 
                 def render(self, context):
@@ -915 +945 @@
                     dict = func(*args)
 
                     if not getattr(self, 'nodelist', False):
+                        using_template = [var.resolve(context) for var in self.using_template]
+                        file_name = using_template or self.default_template
                         from django.template.loader import get_template, select_template
                         if not isinstance(file_name, basestring) and is_iterable(file_name):
                             t = select_template(file_name)
@@ -923 +955 @@
                         self.nodelist = t.nodelist
                     return self.nodelist.render(context_class(dict,
                             autoescape=context.autoescape))
-
-            compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode)
+            
+            if allow_override:
+                tag_compiler = inclusion_tag_compiler
+            else:
+                tag_compiler = generic_tag_compiler
+            compile_func = curry(tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode)
             compile_func.__doc__ = func.__doc__
             self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
             return func

docs/howto/custom-template-tags.txt

@@ -706 +706 @@
 the tag is passed the context object, as in this example. That's the only
 difference between this case and the previous ``inclusion_tag`` example.
 
+Sometimes you may wish to use an inclusion tag with a template other than the
+one specified in ``register.inclusion_tag()``. Inclusion tags offer the
+following syntax for this scenario:
+
+.. code-block:: html+django
+
+    {% show_results poll using "custom/results.html" %}
+
+This will use the template found at ``custom/results.html`` instead of the
+default of ``results.html`` (specified when the inclusion tag was registered).
+Multiple templates may be provided with this syntax -- Django's template loader
+will select which one to use:
+
+.. code-block:: html+django
+
+    {% show_results poll using "site/results.html" "app/results.html" %}
+
+To disallow overriding the template for your inclusion tag, specify
+``allow_override=False`` in ``register.inclusion_tag()``:
+
+    register.inclusion_tag('results.html', allow_override=False)(show_results)
+
 Setting a variable in the context
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~