Fixed #18651 -- Enabled optional assignments for simple_tag().
This commit is contained in:
Preston Timmons
Tim Graham
parent
8adc59038c
commit
cd4282816d
|
|
@ -61,7 +61,8 @@ from django.apps import apps
|
|||
from django.template.context import (BaseContext, Context, RequestContext, # NOQA: imported for backwards compatibility
|
||||
ContextPopException)
|
||||
from django.utils import lru_cache
|
||||
from django.utils.deprecation import RemovedInDjango20Warning
|
||||
from django.utils.deprecation import (RemovedInDjango20Warning,
|
||||
RemovedInDjango21Warning)
|
||||
from django.utils.itercompat import is_iterable
|
||||
from django.utils.text import (smart_split, unescape_string_literal,
|
||||
get_text_list)
|
||||
|
|
@ -1021,9 +1022,9 @@ def token_kwargs(bits, parser, support_legacy=False):
|
|||
def parse_bits(parser, bits, params, varargs, varkw, defaults,
|
||||
takes_context, name):
|
||||
"""
|
||||
Parses bits for template tag helpers (simple_tag, include_tag and
|
||||
assignment_tag), in particular by detecting syntax errors and by
|
||||
extracting positional and keyword arguments.
|
||||
Parses bits for template tag helpers simple_tag and inclusion_tag, in
|
||||
particular by detecting syntax errors and by extracting positional and
|
||||
keyword arguments.
|
||||
"""
|
||||
if takes_context:
|
||||
if params[0] == 'context':
|
||||
|
|
@ -1099,9 +1100,9 @@ def generic_tag_compiler(parser, token, params, varargs, varkw, defaults,
|
|||
|
||||
class TagHelperNode(Node):
|
||||
"""
|
||||
Base class for tag helper nodes such as SimpleNode, InclusionNode and
|
||||
AssignmentNode. Manages the positional and keyword arguments to be passed
|
||||
to the decorated function.
|
||||
Base class for tag helper nodes such as SimpleNode and InclusionNode.
|
||||
Manages the positional and keyword arguments to be passed to the decorated
|
||||
function.
|
||||
"""
|
||||
|
||||
def __init__(self, takes_context, args, kwargs):
|
||||
|
|
@ -1191,17 +1192,31 @@ class Library(object):
|
|||
params, varargs, varkw, defaults = getargspec(func)
|
||||
|
||||
class SimpleNode(TagHelperNode):
|
||||
def __init__(self, takes_context, args, kwargs, target_var):
|
||||
super(SimpleNode, self).__init__(takes_context, args, kwargs)
|
||||
self.target_var = target_var
|
||||
|
||||
def render(self, context):
|
||||
resolved_args, resolved_kwargs = self.get_resolved_arguments(context)
|
||||
return func(*resolved_args, **resolved_kwargs)
|
||||
output = func(*resolved_args, **resolved_kwargs)
|
||||
if self.target_var is not None:
|
||||
context[self.target_var] = output
|
||||
return ''
|
||||
return output
|
||||
|
||||
function_name = (name or
|
||||
getattr(func, '_decorated_function', func).__name__)
|
||||
compile_func = partial(generic_tag_compiler,
|
||||
params=params, varargs=varargs, varkw=varkw,
|
||||
defaults=defaults, name=function_name,
|
||||
takes_context=takes_context, node_class=SimpleNode)
|
||||
|
||||
def compile_func(parser, token):
|
||||
bits = token.split_contents()[1:]
|
||||
target_var = None
|
||||
if len(bits) >= 2 and bits[-2] == 'as':
|
||||
target_var = bits[-1]
|
||||
bits = bits[:-2]
|
||||
args, kwargs = parse_bits(parser, bits, params,
|
||||
varargs, varkw, defaults, takes_context, function_name)
|
||||
return SimpleNode(takes_context, args, kwargs, target_var)
|
||||
|
||||
compile_func.__doc__ = func.__doc__
|
||||
self.tag(function_name, compile_func)
|
||||
return func
|
||||
|
|
@ -1216,46 +1231,12 @@ class Library(object):
|
|||
raise TemplateSyntaxError("Invalid arguments provided to simple_tag")
|
||||
|
||||
def assignment_tag(self, func=None, takes_context=None, name=None):
|
||||
def dec(func):
|
||||
params, varargs, varkw, defaults = getargspec(func)
|
||||
|
||||
class AssignmentNode(TagHelperNode):
|
||||
def __init__(self, takes_context, args, kwargs, target_var):
|
||||
super(AssignmentNode, self).__init__(takes_context, args, kwargs)
|
||||
self.target_var = target_var
|
||||
|
||||
def render(self, context):
|
||||
resolved_args, resolved_kwargs = self.get_resolved_arguments(context)
|
||||
context[self.target_var] = func(*resolved_args, **resolved_kwargs)
|
||||
return ''
|
||||
|
||||
function_name = (name or
|
||||
getattr(func, '_decorated_function', func).__name__)
|
||||
|
||||
def compile_func(parser, token):
|
||||
bits = token.split_contents()[1:]
|
||||
if len(bits) < 2 or bits[-2] != 'as':
|
||||
raise TemplateSyntaxError(
|
||||
"'%s' tag takes at least 2 arguments and the "
|
||||
"second last argument must be 'as'" % function_name)
|
||||
target_var = bits[-1]
|
||||
bits = bits[:-2]
|
||||
args, kwargs = parse_bits(parser, bits, params,
|
||||
varargs, varkw, defaults, takes_context, function_name)
|
||||
return AssignmentNode(takes_context, args, kwargs, target_var)
|
||||
|
||||
compile_func.__doc__ = func.__doc__
|
||||
self.tag(function_name, compile_func)
|
||||
return func
|
||||
|
||||
if func is None:
|
||||
# @register.assignment_tag(...)
|
||||
return dec
|
||||
elif callable(func):
|
||||
# @register.assignment_tag
|
||||
return dec(func)
|
||||
else:
|
||||
raise TemplateSyntaxError("Invalid arguments provided to assignment_tag")
|
||||
warnings.warn(
|
||||
"assignment_tag() is deprecated. Use simple_tag() instead",
|
||||
RemovedInDjango21Warning,
|
||||
stacklevel=2,
|
||||
)
|
||||
return self.simple_tag(func, takes_context, name)
|
||||
|
||||
def inclusion_tag(self, file_name, takes_context=False, name=None):
|
||||
def dec(func):
|
||||
|
|
|
|||
|
|
@ -388,7 +388,7 @@ Simple tags
|
|||
.. method:: django.template.Library.simple_tag()
|
||||
|
||||
Many template tags take a number of arguments -- strings or template variables
|
||||
-- and return a string after doing some processing based solely on
|
||||
-- and return a result after doing some processing based solely on
|
||||
the input arguments and some external information. For example, a
|
||||
``current_time`` tag might accept a format string and return the time as a
|
||||
string formatted accordingly.
|
||||
|
|
@ -459,6 +459,18 @@ positional arguments. For example:
|
|||
|
||||
{% my_tag 123 "abcd" book.title warning=message|lower profile=user.profile %}
|
||||
|
||||
.. versionadded:: 1.9
|
||||
|
||||
It's possible to store the tag results in a template variable rather than
|
||||
directly outputting it. This is done by using the ``as`` argument followed by
|
||||
the variable name. Doing so enables you to output the content yourself where
|
||||
you see fit:
|
||||
|
||||
.. code-block:: html+django
|
||||
|
||||
{% get_current_time "%Y-%m-%d %I:%M %p" as the_time %}
|
||||
<p>The time is {{ the_time }}.</p>
|
||||
|
||||
.. _howto-custom-template-tags-inclusion-tags:
|
||||
|
||||
Inclusion tags
|
||||
|
|
@ -602,11 +614,15 @@ Assignment tags
|
|||
|
||||
.. method:: django.template.Library.assignment_tag()
|
||||
|
||||
.. deprecated:: 1.9
|
||||
|
||||
``simple_tag`` can now store results in a template variable and should
|
||||
be used instead.
|
||||
|
||||
To ease the creation of tags setting a variable in the context, Django provides
|
||||
a helper function, ``assignment_tag``. This function works the same way as
|
||||
:ref:`simple_tag<howto-custom-template-tags-simple-tags>`, except that it
|
||||
stores the tag's result in a specified context variable instead of directly
|
||||
outputting it.
|
||||
:meth:`~django.template.Library.simple_tag` except that it stores the tag's
|
||||
result in a specified context variable instead of directly outputting it.
|
||||
|
||||
Our earlier ``current_time`` function could thus be written like this::
|
||||
|
||||
|
|
@ -622,38 +638,6 @@ followed by the variable name, and output it yourself where you see fit:
|
|||
{% get_current_time "%Y-%m-%d %I:%M %p" as the_time %}
|
||||
<p>The time is {{ the_time }}.</p>
|
||||
|
||||
If your template tag needs to access the current context, you can use the
|
||||
``takes_context`` argument when registering your tag::
|
||||
|
||||
@register.assignment_tag(takes_context=True)
|
||||
def get_current_time(context, format_string):
|
||||
timezone = context['timezone']
|
||||
return your_get_current_time_method(timezone, format_string)
|
||||
|
||||
Note that the first parameter to the function *must* be called ``context``.
|
||||
|
||||
For more information on how the ``takes_context`` option works, see the section
|
||||
on :ref:`inclusion tags<howto-custom-template-tags-inclusion-tags>`.
|
||||
|
||||
``assignment_tag`` functions may accept any number of positional or keyword
|
||||
arguments. For example::
|
||||
|
||||
@register.assignment_tag
|
||||
def my_tag(a, b, *args, **kwargs):
|
||||
warning = kwargs['warning']
|
||||
profile = kwargs['profile']
|
||||
...
|
||||
return ...
|
||||
|
||||
Then in the template any number of arguments, separated by spaces, may be
|
||||
passed to the template tag. Like in Python, the values for keyword arguments
|
||||
are set using the equal sign ("``=``") and must be provided after the
|
||||
positional arguments. For example:
|
||||
|
||||
.. code-block:: html+django
|
||||
|
||||
{% my_tag 123 "abcd" book.title warning=message|lower profile=user.profile as the_result %}
|
||||
|
||||
Advanced custom template tags
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
|
|
|
|||
|
|
@ -20,6 +20,8 @@ details on these changes.
|
|||
|
||||
* The ``django.forms.extras`` package will be removed.
|
||||
|
||||
* The ``assignment_tag`` helper will be removed.
|
||||
|
||||
.. _deprecation-removed-in-2.0:
|
||||
|
||||
2.0
|
||||
|
|
|
|||
|
|
@ -137,7 +137,9 @@ Signals
|
|||
Templates
|
||||
^^^^^^^^^
|
||||
|
||||
* ...
|
||||
* Template tags created with the :meth:`~django.template.Library.simple_tag`
|
||||
helper can now store results in a template variable by using the ``as``
|
||||
argument.
|
||||
|
||||
Requests and Responses
|
||||
^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
@ -194,6 +196,15 @@ Miscellaneous
|
|||
Features deprecated in 1.9
|
||||
==========================
|
||||
|
||||
``assignment_tag()``
|
||||
~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Django 1.4 added the ``assignment_tag`` helper to ease the creation of
|
||||
template tags that store results in a template variable. The
|
||||
:meth:`~django.template.Library.simple_tag` helper has gained this same
|
||||
ability, making the ``assignment_tag`` obsolete. Tags that use
|
||||
``assignment_tag`` should be updated to use ``simple_tag``.
|
||||
|
||||
Miscellaneous
|
||||
~~~~~~~~~~~~~
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
import operator
|
||||
import warnings
|
||||
|
||||
from django import template
|
||||
from django.template.defaultfilters import stringfilter
|
||||
|
|
@ -125,83 +126,17 @@ def minustwo_overridden_name(value):
|
|||
register.simple_tag(lambda x: x - 1, name='minusone')
|
||||
|
||||
|
||||
@register.assignment_tag
|
||||
def assignment_no_params():
|
||||
"""Expected assignment_no_params __doc__"""
|
||||
return "assignment_no_params - Expected result"
|
||||
assignment_no_params.anything = "Expected assignment_no_params __dict__"
|
||||
with warnings.catch_warnings():
|
||||
warnings.simplefilter('ignore')
|
||||
|
||||
@register.assignment_tag
|
||||
def assignment_no_params():
|
||||
"""Expected assignment_no_params __doc__"""
|
||||
return "assignment_no_params - Expected result"
|
||||
assignment_no_params.anything = "Expected assignment_no_params __dict__"
|
||||
|
||||
@register.assignment_tag
|
||||
def assignment_one_param(arg):
|
||||
"""Expected assignment_one_param __doc__"""
|
||||
return "assignment_one_param - Expected result: %s" % arg
|
||||
assignment_one_param.anything = "Expected assignment_one_param __dict__"
|
||||
|
||||
|
||||
@register.assignment_tag(takes_context=False)
|
||||
def assignment_explicit_no_context(arg):
|
||||
"""Expected assignment_explicit_no_context __doc__"""
|
||||
return "assignment_explicit_no_context - Expected result: %s" % arg
|
||||
assignment_explicit_no_context.anything = "Expected assignment_explicit_no_context __dict__"
|
||||
|
||||
|
||||
@register.assignment_tag(takes_context=True)
|
||||
def assignment_no_params_with_context(context):
|
||||
"""Expected assignment_no_params_with_context __doc__"""
|
||||
return "assignment_no_params_with_context - Expected result (context value: %s)" % context['value']
|
||||
assignment_no_params_with_context.anything = "Expected assignment_no_params_with_context __dict__"
|
||||
|
||||
|
||||
@register.assignment_tag(takes_context=True)
|
||||
def assignment_params_and_context(context, arg):
|
||||
"""Expected assignment_params_and_context __doc__"""
|
||||
return "assignment_params_and_context - Expected result (context value: %s): %s" % (context['value'], arg)
|
||||
assignment_params_and_context.anything = "Expected assignment_params_and_context __dict__"
|
||||
|
||||
|
||||
@register.assignment_tag
|
||||
def assignment_two_params(one, two):
|
||||
"""Expected assignment_two_params __doc__"""
|
||||
return "assignment_two_params - Expected result: %s, %s" % (one, two)
|
||||
assignment_two_params.anything = "Expected assignment_two_params __dict__"
|
||||
|
||||
|
||||
@register.assignment_tag
|
||||
def assignment_one_default(one, two='hi'):
|
||||
"""Expected assignment_one_default __doc__"""
|
||||
return "assignment_one_default - Expected result: %s, %s" % (one, two)
|
||||
assignment_one_default.anything = "Expected assignment_one_default __dict__"
|
||||
|
||||
|
||||
@register.assignment_tag
|
||||
def assignment_unlimited_args(one, two='hi', *args):
|
||||
"""Expected assignment_unlimited_args __doc__"""
|
||||
return "assignment_unlimited_args - Expected result: %s" % (', '.join(six.text_type(arg) for arg in [one, two] + list(args)))
|
||||
assignment_unlimited_args.anything = "Expected assignment_unlimited_args __dict__"
|
||||
|
||||
|
||||
@register.assignment_tag
|
||||
def assignment_only_unlimited_args(*args):
|
||||
"""Expected assignment_only_unlimited_args __doc__"""
|
||||
return "assignment_only_unlimited_args - Expected result: %s" % ', '.join(six.text_type(arg) for arg in args)
|
||||
assignment_only_unlimited_args.anything = "Expected assignment_only_unlimited_args __dict__"
|
||||
|
||||
|
||||
@register.assignment_tag
|
||||
def assignment_unlimited_args_kwargs(one, two='hi', *args, **kwargs):
|
||||
"""Expected assignment_unlimited_args_kwargs __doc__"""
|
||||
# Sort the dictionary by key to guarantee the order for testing.
|
||||
sorted_kwarg = sorted(six.iteritems(kwargs), key=operator.itemgetter(0))
|
||||
return "assignment_unlimited_args_kwargs - Expected result: %s / %s" % (
|
||||
', '.join(six.text_type(arg) for arg in [one, two] + list(args)),
|
||||
', '.join('%s=%s' % (k, v) for (k, v) in sorted_kwarg)
|
||||
)
|
||||
assignment_unlimited_args_kwargs.anything = "Expected assignment_unlimited_args_kwargs __dict__"
|
||||
|
||||
|
||||
@register.assignment_tag(takes_context=True)
|
||||
def assignment_tag_without_context_parameter(arg):
|
||||
"""Expected assignment_tag_without_context_parameter __doc__"""
|
||||
return "Expected result"
|
||||
assignment_tag_without_context_parameter.anything = "Expected assignment_tag_without_context_parameter __dict__"
|
||||
@register.assignment_tag(takes_context=True)
|
||||
def assignment_tag_without_context_parameter(arg):
|
||||
"""Expected assignment_tag_without_context_parameter __doc__"""
|
||||
return "Expected result"
|
||||
assignment_tag_without_context_parameter.anything = "Expected assignment_tag_without_context_parameter __dict__"
|
||||
|
|
|
|||
|
|
@ -28,70 +28,61 @@ class CustomTagTests(TestCase):
|
|||
def test_simple_tags(self):
|
||||
c = template.Context({'value': 42})
|
||||
|
||||
t = template.Template('{% load custom %}{% no_params %}')
|
||||
self.assertEqual(t.render(c), 'no_params - Expected result')
|
||||
templates = [
|
||||
('{% load custom %}{% no_params %}', 'no_params - Expected result'),
|
||||
('{% load custom %}{% one_param 37 %}', 'one_param - Expected result: 37'),
|
||||
('{% load custom %}{% explicit_no_context 37 %}', 'explicit_no_context - Expected result: 37'),
|
||||
('{% load custom %}{% no_params_with_context %}',
|
||||
'no_params_with_context - Expected result (context value: 42)'),
|
||||
('{% load custom %}{% params_and_context 37 %}',
|
||||
'params_and_context - Expected result (context value: 42): 37'),
|
||||
('{% load custom %}{% simple_two_params 37 42 %}', 'simple_two_params - Expected result: 37, 42'),
|
||||
('{% load custom %}{% simple_one_default 37 %}', 'simple_one_default - Expected result: 37, hi'),
|
||||
('{% load custom %}{% simple_one_default 37 two="hello" %}',
|
||||
'simple_one_default - Expected result: 37, hello'),
|
||||
('{% load custom %}{% simple_one_default one=99 two="hello" %}',
|
||||
'simple_one_default - Expected result: 99, hello'),
|
||||
('{% load custom %}{% simple_one_default 37 42 %}',
|
||||
'simple_one_default - Expected result: 37, 42'),
|
||||
('{% load custom %}{% simple_unlimited_args 37 %}', 'simple_unlimited_args - Expected result: 37, hi'),
|
||||
('{% load custom %}{% simple_unlimited_args 37 42 56 89 %}',
|
||||
'simple_unlimited_args - Expected result: 37, 42, 56, 89'),
|
||||
('{% load custom %}{% simple_only_unlimited_args %}', 'simple_only_unlimited_args - Expected result: '),
|
||||
('{% load custom %}{% simple_only_unlimited_args 37 42 56 89 %}',
|
||||
'simple_only_unlimited_args - Expected result: 37, 42, 56, 89'),
|
||||
('{% load custom %}{% simple_unlimited_args_kwargs 37 40|add:2 56 eggs="scrambled" four=1|add:3 %}',
|
||||
'simple_unlimited_args_kwargs - Expected result: 37, 42, 56 / eggs=scrambled, four=4'),
|
||||
]
|
||||
|
||||
t = template.Template('{% load custom %}{% one_param 37 %}')
|
||||
self.assertEqual(t.render(c), 'one_param - Expected result: 37')
|
||||
for entry in templates:
|
||||
t = template.Template(entry[0])
|
||||
self.assertEqual(t.render(c), entry[1])
|
||||
|
||||
t = template.Template('{% load custom %}{% explicit_no_context 37 %}')
|
||||
self.assertEqual(t.render(c), 'explicit_no_context - Expected result: 37')
|
||||
for entry in templates:
|
||||
t = template.Template("%s as var %%}Result: {{ var }}" % entry[0][0:-2])
|
||||
self.assertEqual(t.render(c), "Result: %s" % entry[1])
|
||||
|
||||
t = template.Template('{% load custom %}{% no_params_with_context %}')
|
||||
self.assertEqual(t.render(c), 'no_params_with_context - Expected result (context value: 42)')
|
||||
def test_simple_tag_errors(self):
|
||||
errors = [
|
||||
("'simple_one_default' received unexpected keyword argument 'three'",
|
||||
'{% load custom %}{% simple_one_default 99 two="hello" three="foo" %}'),
|
||||
("'simple_two_params' received too many positional arguments",
|
||||
'{% load custom %}{% simple_two_params 37 42 56 %}'),
|
||||
("'simple_one_default' received too many positional arguments",
|
||||
'{% load custom %}{% simple_one_default 37 42 56 %}'),
|
||||
("'simple_unlimited_args_kwargs' received some positional argument\(s\) after some keyword argument\(s\)",
|
||||
'{% load custom %}{% simple_unlimited_args_kwargs 37 40|add:2 eggs="scrambled" 56 four=1|add:3 %}'),
|
||||
("'simple_unlimited_args_kwargs' received multiple values for keyword argument 'eggs'",
|
||||
'{% load custom %}{% simple_unlimited_args_kwargs 37 eggs="scrambled" eggs="scrambled" %}'),
|
||||
]
|
||||
|
||||
t = template.Template('{% load custom %}{% params_and_context 37 %}')
|
||||
self.assertEqual(t.render(c), 'params_and_context - Expected result (context value: 42): 37')
|
||||
for entry in errors:
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError, entry[0], template.Template, entry[1])
|
||||
|
||||
t = template.Template('{% load custom %}{% simple_two_params 37 42 %}')
|
||||
self.assertEqual(t.render(c), 'simple_two_params - Expected result: 37, 42')
|
||||
|
||||
t = template.Template('{% load custom %}{% simple_one_default 37 %}')
|
||||
self.assertEqual(t.render(c), 'simple_one_default - Expected result: 37, hi')
|
||||
|
||||
t = template.Template('{% load custom %}{% simple_one_default 37 two="hello" %}')
|
||||
self.assertEqual(t.render(c), 'simple_one_default - Expected result: 37, hello')
|
||||
|
||||
t = template.Template('{% load custom %}{% simple_one_default one=99 two="hello" %}')
|
||||
self.assertEqual(t.render(c), 'simple_one_default - Expected result: 99, hello')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'simple_one_default' received unexpected keyword argument 'three'",
|
||||
template.Template, '{% load custom %}{% simple_one_default 99 two="hello" three="foo" %}')
|
||||
|
||||
t = template.Template('{% load custom %}{% simple_one_default 37 42 %}')
|
||||
self.assertEqual(t.render(c), 'simple_one_default - Expected result: 37, 42')
|
||||
|
||||
t = template.Template('{% load custom %}{% simple_unlimited_args 37 %}')
|
||||
self.assertEqual(t.render(c), 'simple_unlimited_args - Expected result: 37, hi')
|
||||
|
||||
t = template.Template('{% load custom %}{% simple_unlimited_args 37 42 56 89 %}')
|
||||
self.assertEqual(t.render(c), 'simple_unlimited_args - Expected result: 37, 42, 56, 89')
|
||||
|
||||
t = template.Template('{% load custom %}{% simple_only_unlimited_args %}')
|
||||
self.assertEqual(t.render(c), 'simple_only_unlimited_args - Expected result: ')
|
||||
|
||||
t = template.Template('{% load custom %}{% simple_only_unlimited_args 37 42 56 89 %}')
|
||||
self.assertEqual(t.render(c), 'simple_only_unlimited_args - Expected result: 37, 42, 56, 89')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'simple_two_params' received too many positional arguments",
|
||||
template.Template, '{% load custom %}{% simple_two_params 37 42 56 %}')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'simple_one_default' received too many positional arguments",
|
||||
template.Template, '{% load custom %}{% simple_one_default 37 42 56 %}')
|
||||
|
||||
t = template.Template('{% load custom %}{% simple_unlimited_args_kwargs 37 40|add:2 56 eggs="scrambled" four=1|add:3 %}')
|
||||
self.assertEqual(t.render(c), 'simple_unlimited_args_kwargs - Expected result: 37, 42, 56 / eggs=scrambled, four=4')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'simple_unlimited_args_kwargs' received some positional argument\(s\) after some keyword argument\(s\)",
|
||||
template.Template, '{% load custom %}{% simple_unlimited_args_kwargs 37 40|add:2 eggs="scrambled" 56 four=1|add:3 %}')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'simple_unlimited_args_kwargs' received multiple values for keyword argument 'eggs'",
|
||||
template.Template, '{% load custom %}{% simple_unlimited_args_kwargs 37 eggs="scrambled" eggs="scrambled" %}')
|
||||
for entry in errors:
|
||||
six.assertRaisesRegex(
|
||||
self, template.TemplateSyntaxError, entry[0], template.Template, "%s as var %%}" % entry[1][0:-2],
|
||||
)
|
||||
|
||||
def test_simple_tag_registration(self):
|
||||
# Test that the decorators preserve the decorated function's docstring, name and attributes.
|
||||
|
|
@ -278,102 +269,9 @@ class CustomTagTests(TestCase):
|
|||
t = template.Template('{% load custom %}{% assignment_no_params as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_no_params - Expected result')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_one_param 37 as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_one_param - Expected result: 37')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_explicit_no_context 37 as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_explicit_no_context - Expected result: 37')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_no_params_with_context as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_no_params_with_context - Expected result (context value: 42)')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_params_and_context 37 as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_params_and_context - Expected result (context value: 42): 37')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_two_params 37 42 as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_two_params - Expected result: 37, 42')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_one_default 37 as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_one_default - Expected result: 37, hi')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_one_default 37 two="hello" as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_one_default - Expected result: 37, hello')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_one_default one=99 two="hello" as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_one_default - Expected result: 99, hello')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'assignment_one_default' received unexpected keyword argument 'three'",
|
||||
template.Template, '{% load custom %}{% assignment_one_default 99 two="hello" three="foo" as var %}')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_one_default 37 42 as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_one_default - Expected result: 37, 42')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_unlimited_args 37 as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_unlimited_args - Expected result: 37, hi')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_unlimited_args 37 42 56 89 as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_unlimited_args - Expected result: 37, 42, 56, 89')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_only_unlimited_args as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_only_unlimited_args - Expected result: ')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_only_unlimited_args 37 42 56 89 as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_only_unlimited_args - Expected result: 37, 42, 56, 89')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'assignment_one_param' tag takes at least 2 arguments and the second last argument must be 'as'",
|
||||
template.Template, '{% load custom %}{% assignment_one_param 37 %}The result is: {{ var }}')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'assignment_one_param' tag takes at least 2 arguments and the second last argument must be 'as'",
|
||||
template.Template, '{% load custom %}{% assignment_one_param 37 as %}The result is: {{ var }}')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'assignment_one_param' tag takes at least 2 arguments and the second last argument must be 'as'",
|
||||
template.Template, '{% load custom %}{% assignment_one_param 37 ass var %}The result is: {{ var }}')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'assignment_two_params' received too many positional arguments",
|
||||
template.Template, '{% load custom %}{% assignment_two_params 37 42 56 as var %}The result is: {{ var }}')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'assignment_one_default' received too many positional arguments",
|
||||
template.Template, '{% load custom %}{% assignment_one_default 37 42 56 as var %}The result is: {{ var }}')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'assignment_one_default' did not receive value\(s\) for the argument\(s\): 'one'",
|
||||
template.Template, '{% load custom %}{% assignment_one_default as var %}The result is: {{ var }}')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'assignment_unlimited_args' did not receive value\(s\) for the argument\(s\): 'one'",
|
||||
template.Template, '{% load custom %}{% assignment_unlimited_args as var %}The result is: {{ var }}')
|
||||
|
||||
t = template.Template('{% load custom %}{% assignment_unlimited_args_kwargs 37 40|add:2 56 eggs="scrambled" four=1|add:3 as var %}The result is: {{ var }}')
|
||||
self.assertEqual(t.render(c), 'The result is: assignment_unlimited_args_kwargs - Expected result: 37, 42, 56 / eggs=scrambled, four=4')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'assignment_unlimited_args_kwargs' received some positional argument\(s\) after some keyword argument\(s\)",
|
||||
template.Template, '{% load custom %}{% assignment_unlimited_args_kwargs 37 40|add:2 eggs="scrambled" 56 four=1|add:3 as var %}The result is: {{ var }}')
|
||||
|
||||
six.assertRaisesRegex(self, template.TemplateSyntaxError,
|
||||
"'assignment_unlimited_args_kwargs' received multiple values for keyword argument 'eggs'",
|
||||
template.Template, '{% load custom %}{% assignment_unlimited_args_kwargs 37 eggs="scrambled" eggs="scrambled" as var %}The result is: {{ var }}')
|
||||
|
||||
def test_assignment_tag_registration(self):
|
||||
# Test that the decorators preserve the decorated function's docstring, name and attributes.
|
||||
self.verify_tag(custom.assignment_no_params, 'assignment_no_params')
|
||||
self.verify_tag(custom.assignment_one_param, 'assignment_one_param')
|
||||
self.verify_tag(custom.assignment_explicit_no_context, 'assignment_explicit_no_context')
|
||||
self.verify_tag(custom.assignment_no_params_with_context, 'assignment_no_params_with_context')
|
||||
self.verify_tag(custom.assignment_params_and_context, 'assignment_params_and_context')
|
||||
self.verify_tag(custom.assignment_one_default, 'assignment_one_default')
|
||||
self.verify_tag(custom.assignment_two_params, 'assignment_two_params')
|
||||
self.verify_tag(custom.assignment_unlimited_args, 'assignment_unlimited_args')
|
||||
self.verify_tag(custom.assignment_only_unlimited_args, 'assignment_only_unlimited_args')
|
||||
self.verify_tag(custom.assignment_unlimited_args, 'assignment_unlimited_args')
|
||||
self.verify_tag(custom.assignment_unlimited_args_kwargs, 'assignment_unlimited_args_kwargs')
|
||||
self.verify_tag(custom.assignment_tag_without_context_parameter, 'assignment_tag_without_context_parameter')
|
||||
|
||||
def test_assignment_tag_missing_context(self):
|
||||
# The 'context' parameter must be present when takes_context is True
|
||||
|
|
|
|||
Loading…
Reference in New Issue