Ticket #13956: indefinite_inclusion_tag_args_with_tests.diff

django/template/__init__.py

@@ -848 +848 @@
             return ''
         return _render_value_in_context(output, context)
 
-def generic_tag_compiler(params, defaults, name, node_class, parser, token):
+def generic_tag_compiler(params, defaults, name, node_class, parser, token, varargs=None):
     "Returns a template.Node subclass."
     bits = token.split_contents()[1:]
     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)
+    if varargs is None:
+        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)
+    else:
+        if(len(bits) < bmin):
+            message = "%s takes at least %s arguments" % (name, bmin)
+            raise TemplateSyntaxError(message)
     return node_class(bits)
 
 class Library(object):
@@ -916 +921 @@
         return func
 
     def simple_tag(self,func):
-        params, xx, xxx, defaults = getargspec(func)
+        params, varargs, xx, defaults = getargspec(func)
 
         class SimpleNode(Node):
             def __init__(self, vars_to_resolve):
@@ -926 +931 @@
                 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 = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, SimpleNode, varargs=varargs)
         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 dec(func):
-            params, xx, xxx, defaults = getargspec(func)
+            params, varargs, xx, defaults = getargspec(func)
             if takes_context:
                 if params[0] == 'context':
                     params = params[1:]
@@ -968 +973 @@
                     if csrf_token is not None:
                         new_context['csrf_token'] = csrf_token
                     return self.nodelist.render(new_context)
-
-            compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode)
+            compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode, varargs=varargs)
             compile_func.__doc__ = func.__doc__
             self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
             return func

tests/regressiontests/templates/simple_tag.py

@@ +1 @@
+import unittest
+from django.template import Context, Template, TemplateSyntaxError
+
+
+class SimpleTagTests(unittest.TestCase):
+    def test_simple_tag_with_fixed_number_of_arguments(self):
+        c = Context({})
+        t = Template('{% load custom %}{% simple_tag_with_three_arguments "one" "two" "three" %}')
+        self.assertEquals(t.render(c), u'one, two, three')
+
+        c = Context({'one': '1', 'two': '2', 'three': '3'})
+        t = Template('{% load custom %}{% simple_tag_with_three_arguments one two three %}')
+        self.assertEquals(t.render(c), u'1, 2, 3')
+
+        self.assertRaises(TemplateSyntaxError, Template, '{% load custom %}{% simple_tag_with_three_arguments "one" "three" %}')
+        self.assertRaises(TemplateSyntaxError, Template, '{% load custom %}{% simple_tag_with_three_arguments "one" "two" "three" "four" %}')
+
+    def test_simple_tag_with_var_number_of_arguments(self):
+        c = Context({})
+        t = Template('{% load custom %}{% simple_tag_with_two_default_arguments "one" "two" "three" %}')
+        self.assertEquals(t.render(c), u'one, two, three')
+
+        c = Context({'one': '1', 'two': '2', 'three': '3'})
+        t = Template('{% load custom %}{% simple_tag_with_two_default_arguments one three %}')
+        self.assertEquals(t.render(c), u'1, 3, 3')
+
+        c = Context({'one': 'first'})
+        t = Template('{% load custom %}{% simple_tag_with_two_default_arguments one %}')
+        self.assertEquals(t.render(c), u'first, 2, 3')
+
+        self.assertRaises(TemplateSyntaxError, Template, '{% load custom %}{% simple_tag_with_two_default_arguments %}')
+        self.assertRaises(TemplateSyntaxError, Template, '{% load custom %}{% simple_tag_with_two_default_arguments "one" "two" "three" "four" %}')
+
+    def test_simple_tag_with_unlimited_number_of_arguments(self):
+        c = Context({})
+        t = Template('{% load custom %}{% simple_tag_with_unlimited_arguments "one" "two" "three" %}')
+        self.assertEquals(t.render(c), u'one, two, three')
+
+        c = Context({})
+        t = Template('{% load custom %}{% simple_tag_with_unlimited_arguments "one" %}')
+        self.assertEquals(t.render(c), u'one, 2')
+
+        c = Context({'one': '1', 'two': '2', 'three': '3', 'four': '4', 'five': '5'})
+        t = Template('{% load custom %}{% simple_tag_with_unlimited_arguments one two three four five %}')
+        self.assertEquals(t.render(c), u'1, 2, 3, 4, 5')
+
+        c = Context({'one': 'first'})
+        t = Template('{% load custom %}{% simple_tag_with_unlimited_arguments one %}')
+        self.assertEquals(t.render(c), u'first, 2')
+
+        self.assertRaises(TemplateSyntaxError, Template, '{% load custom %}{% simple_tag_with_two_default_arguments %}')

tests/regressiontests/templates/templatetags/custom.py

@@ -9 +9 @@
 
 register.filter(trim)
 
+
+def simple_tag_with_three_arguments(one, two, three):
+    return ', '.join((one, two, three))
+
+register.simple_tag(simple_tag_with_three_arguments)
+
+
+def simple_tag_with_two_default_arguments(one, two='2', three='3'):
+    return ', '.join((one, two, three))
+
+register.simple_tag(simple_tag_with_two_default_arguments)
+
+
+def simple_tag_with_unlimited_arguments(one, two='2', *args):
+    return ', '.join([one, two] + list(args))
+
+register.simple_tag(simple_tag_with_unlimited_arguments)

tests/regressiontests/templates/tests.py

@@ -27 +27 @@
 from unicode import unicode_tests
 from nodelist import NodelistTest
 from smartif import *
+from simple_tag import SimpleTagTests
 
 try:
     from loaders import *