Ticket #9093: inclusion_tag_using_template.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]
+    return node_class(bits, using_template)
+
 class Library(object):
     def __init__(self):
         self.filters = {}
@@ -886 +901 @@
             def render(self, context):
                 resolved_vars = [var.resolve(context) for var in self.vars_to_resolve]
                 return func(*resolved_vars)
-
+        
         compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, SimpleNode)
         compile_func.__doc__ = func.__doc__
         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_template_override=True):
         def dec(func):
             params, xx, xxx, defaults = getargspec(func)
             if takes_context:
@@ -900 +915 @@
                     params = params[1:]
                 else:
                     raise TemplateSyntaxError("Any tag function decorated with takes_context=True must have a first argument of 'context'")
+            
+            class InclusionNode(Node):
+                default_template = file_name
 
-            class InclusionNode(Node):
-                def __init__(self, vars_to_resolve):
+                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 +933 @@
                     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 +943 @@
                         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_template_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
         return dec
 
+
 def get_library(module_name):
     lib = libraries.get(module_name, None)
     if not lib:

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 your inclusion tag with a template other than the
+one specified in ``register.inclusion_tag()``. Template tags offer the
+following syntax for this scenario:
+
+.. code-block:: html+django
+
+    {% show_results poll using "custom/results.html" %}
+
+This will using the template found at ``custom/results.html`` instead of the
+default of ``results.html``. Multiple templates may be provided with this
+syntax -- Django's template loader will select which 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_template_override=False`` in ``register.inclusion_tag()``:
+
+    register.inclusion_tag('results.html', allow_template_override=False)(show_results)
+
 Setting a variable in the context
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~