def do_with(parser, token):
"""
Adds one or more values to the context (inside of this block) for caching
and easy access.
For example::
{% with total=person.some_sql_method %}
{{ total }} object{{ total|pluralize }}
{% endwith %}
Multiple values can be added to the context::
{% with foo=1 bar=2 %}
...
{% endwith %}
The legacy format of ``{% with person.some_sql_method as total %}`` is
still accepted.
"""
bits = token.split_contents()
remaining_bits = bits[1:]
extra_context = token_kwargs(remaining_bits, parser, support_legacy=True)
if not extra_context:
raise TemplateSyntaxError("%r expected at least one variable "
"assignment" % bits[0])
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" %
(bits[0], remaining_bits[0]))
nodelist = parser.parse(('endwith', ))
parser.delete_first_token()
return WithNode(None, None, nodelist, extra_context=extra_context)
def parse(cls, parser, token):
bits = token.split_contents()
tagname = bits.pop(0)
if len(bits) < 1:
raise TemplateSyntaxError(
"{tagname!r} requires at least one argument.".format(
tagname=tagname))
field = bits.pop(0)
if bits:
if bits[0] == 'with':
bits.pop(0)
arg_dict = token_kwargs(bits, parser, support_legacy=False)
# Validate against spaces around the '='.
has_lonely_equal_sign = any(
bit.startswith('=') or bit.endswith('=') for bit in bits)
if has_lonely_equal_sign:
# If '=' is leading/trailing or is the own char in the token,
# then the user has used spaces around it. We can use a
# distinct error message for this to aid the user.
raise TemplateSyntaxError(
"In the {tagname} tag, "
"you must not put spaces around the '='. "
"For example, do label='value', not label = 'value'."
".".format(tagname=tagname))
else:
arg_dict = {}
if bits:
raise TemplateSyntaxError(
'Unknown argument for {tagname} tag: {bits!r}'.format(
tagname=tagname, bits=bits))
return cls(field, arg_dict)
def parse(cls, parser, token):
bits = token.split_contents()
tagname = bits.pop(0)
if len(bits) < 1:
raise TemplateSyntaxError(
"{tagname!r} requires at least one argument.".format(
tagname=tagname))
field = bits.pop(0)
if bits:
with_ = bits.pop(0)
if with_ != 'with':
raise TemplateSyntaxError(
"{tagname}'s second argument must be 'with'.".format(
tagname=tagname))
with_arguments = token_kwargs(bits, parser, support_legacy=False)
if not with_arguments:
raise TemplateSyntaxError(
"'with' in {tagname} tag needs at least one keyword "
"argument.".format(tagname=tagname))
else:
with_arguments = {}
if bits:
raise TemplateSyntaxError(
'Unkown argument for {tagname} tag: {bits!r}'.format(
tagname=tagname,
bits=bits))
return cls(field, with_arguments)
def parse(cls, parser, tokens):
'''
Renders a object in the current context. ::
{% render object %} calls object.render(context)
You can set some extra context with the 'with' argument::
{% render object with value=1 %}
'''
bits = tokens.split_contents()
tag_name = bits.pop(0)
if not bits or bits[0] == 'with':
raise template.TemplateSyntaxError(
u'%r tag requires at least one argument' % tag_name)
renderable = parser.compile_filter(bits.pop(0))
if bits and bits[0] == 'with':
bits.pop(0)
arguments = token_kwargs(bits, parser, support_legacy=False)
if not arguments:
raise template.TemplateSyntaxError(
'"with" in %s tag needs at least one keyword argument.' %
tag_name)
with_variables = arguments
else:
with_variables = {}
return cls(renderable, with_variables)
def parse(cls, parser, token):
bits = token.split_contents()
tagname = bits.pop(0)
if len(bits) < 1:
raise TemplateSyntaxError(
"{tagname!r} requires at least one argument.".format(
tagname=tagname))
field = bits.pop(0)
if bits:
if bits[0] == 'with':
bits.pop(0)
arg_dict = token_kwargs(bits, parser, support_legacy=False)
# Validate against spaces around the '='.
has_lonely_equal_sign = any(
bit.startswith('=') or bit.endswith('=')
for bit in bits)
if has_lonely_equal_sign:
# If '=' is leading/trailing or is the own char in the token,
# then the user has used spaces around it. We can use a
# distinct error message for this to aid the user.
raise TemplateSyntaxError(
"In the {tagname} tag, "
"you must not put spaces around the '='. "
"For example, do label='value', not label = 'value'."
".".format(tagname=tagname))
else:
arg_dict = {}
if bits:
raise TemplateSyntaxError(
'Unknown argument for {tagname} tag: {bits!r}'.format(
tagname=tagname,
bits=bits))
return cls(field, arg_dict)
def font_awesome_icon(parser, token):
bits = token.split_contents()
remaining_bits = bits[1:]
extra_context = token_kwargs(bits, parser, support_legacy=False)
if not extra_context:
raise TemplateSyntaxError(
format_lazy('{bit} accepts one argument', bit=bits[0]))
def parse(cls, parser, token: Token):
# here is how split_contents() works:
# {% formfield player.f1 label="f1 label" %}
# ...yields:
# ['formfield', 'player.f1', 'label="f1 label"']
# {% formfield player.f2 "f2 label with no kwarg" %}
# ...yields:
# ['formfield', 'player.f2', '"f2 label with no kwarg"']
# handle where the user did {% formfield player.f label = "foo" %}
token.contents = token.contents.replace('label = ', 'label=')
bits = token.split_contents()
tagname = bits.pop(0)
if len(bits) < 1:
raise TemplateSyntaxError(f"{tagname} requires the name of the field.")
field_name = bits.pop(0)
if bits[:1] == ['with']:
bits.pop(0)
arg_dict = token_kwargs(bits, parser, support_legacy=False)
if bits:
raise TemplateSyntaxError(f'Unused parameter to formfield tag: {bits[0]}')
return cls(field_name, **arg_dict)
def do_include(parser, token):
"""
A copy of Django's built-in {% include ... %} tag that uses our custom
IncludeNode to allow us to load dummy context for the pattern library.
"""
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError(
"%r tag takes at least one argument: the name of the template to "
"be included." % bits[0])
options = {}
remaining_bits = bits[2:]
while remaining_bits:
option = remaining_bits.pop(0)
if option in options:
raise TemplateSyntaxError('The %r option was specified more '
'than once.' % option)
if option == 'with':
value = token_kwargs(remaining_bits, parser, support_legacy=False)
if not value:
raise TemplateSyntaxError('"with" in %r tag needs at least '
'one keyword argument.' % bits[0])
elif option == 'only':
value = True
else:
raise TemplateSyntaxError('Unknown argument for %r tag: %r.' %
(bits[0], option))
options[option] = value
isolated_context = options.get('only', False)
namemap = options.get('with', {})
bits[1] = construct_relative_path(parser.origin.template_name, bits[1])
return IncludeNode(parser.compile_filter(bits[1]),
extra_context=namemap,
isolated_context=isolated_context)
def __init__(self, parser, token):
bits = token.split_contents()
if len(bits) == 0:
raise TemplateSyntaxError(
"%r received invalid args, expected one element for render. Got: %r" %
(bits[0], bits[1:]))
remaining_bits = bits[2:]
self.kwargs = token_kwargs(remaining_bits, parser)
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" %
(bits[0], remaining_bits[0]))
for key in self.kwargs:
if key not in ('template', 'widget'):
raise TemplateSyntaxError("%r received an invalid key: %r" %
(bits[0], key))
self.kwargs[key] = self.kwargs[key]
self.nodelist = parser.parse(('end{}'.format(bits[0]),))
parser.delete_first_token()
self.element = Variable(bits[1])
def do_include(parser, token):
"""
Same as core function, with construct_relative_path call
"""
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError(
"%r tag takes at least one argument: "
"the name of the template to be included."
% bits[0]
)
options = {}
remaining_bits = bits[2:]
while remaining_bits:
option = remaining_bits.pop(0)
if option in options:
raise TemplateSyntaxError('The %r option was specified more '
'than once.' % option)
if option == 'with':
value = token_kwargs(remaining_bits, parser, support_legacy=False)
if not value:
raise TemplateSyntaxError('"with" in %r tag needs at least '
'one keyword argument.' % bits[0])
elif option == 'only':
value = True
else:
raise TemplateSyntaxError('Unknown argument for %r tag: %r.' %
(bits[0], option))
options[option] = value
isolated_context = options.get('only', False)
namemap = options.get('with', {})
bits[1] = construct_relative_path(parser.template_name, bits[1])
return IncludeNode(parser.compile_filter(bits[1]), extra_context=namemap,
isolated_context=isolated_context)
def do_with(parser, token):
"""
Adds one or more values to the context (inside of this block) for caching
and easy access.
For example::
{% with total=person.some_sql_method %}
{{ total }} object{{ total|pluralize }}
{% endwith %}
Multiple values can be added to the context::
{% with foo=1 bar=2 %}
...
{% endwith %}
The legacy format of ``{% with person.some_sql_method as total %}`` is
still accepted.
"""
bits = token.split_contents()
remaining_bits = bits[1:]
extra_context = token_kwargs(remaining_bits, parser, support_legacy=True)
if not extra_context:
raise TemplateSyntaxError("%r expected at least one variable "
"assignment" % bits[0])
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" %
(bits[0], remaining_bits[0]))
nodelist = parser.parse(('endwith',))
parser.delete_first_token()
return WithNode(None, None, nodelist, extra_context=extra_context)
def accordion(parser, token):
kwargs = token_kwargs(token.split_contents()[1:], parser)
if not kwargs.get('name'):
raise template.TemplateSyntaxError('accordion requires name argument')
node_list = parser.parse(('endaccordion', ))
parser.delete_first_token()
return AccordionNode(node_list, **kwargs)
def do_include(parser, token):
"""
Same as core function, with construct_relative_path call
"""
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError("%r tag takes at least one argument: "
"the name of the template to be included." %
bits[0])
options = {}
remaining_bits = bits[2:]
while remaining_bits:
option = remaining_bits.pop(0)
if option in options:
raise TemplateSyntaxError('The %r option was specified more '
'than once.' % option)
if option == 'with':
value = token_kwargs(remaining_bits, parser, support_legacy=False)
if not value:
raise TemplateSyntaxError('"with" in %r tag needs at least '
'one keyword argument.' % bits[0])
elif option == 'only':
value = True
else:
raise TemplateSyntaxError('Unknown argument for %r tag: %r.' %
(bits[0], option))
options[option] = value
isolated_context = options.get('only', False)
namemap = options.get('with', {})
bits[1] = construct_relative_path(parser.template_name, bits[1])
return IncludeNode(parser.compile_filter(bits[1]),
extra_context=namemap,
isolated_context=isolated_context)
def __init__(self, parser, token):
bits = token.split_contents()
if len(bits) == 0:
raise TemplateSyntaxError(
"%r received invalid args, expected one element for render. Got: %r" %
(bits[0], bits[1:]))
remaining_bits = bits[2:]
self.kwargs = token_kwargs(remaining_bits, parser)
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" %
(bits[0], remaining_bits[0]))
for key in self.kwargs:
if key not in ('template', 'widget'):
raise TemplateSyntaxError("%r received an invalid key: %r" %
(bits[0], key))
self.kwargs[key] = self.kwargs[key]
self.nodelist = parser.parse(('end{}'.format(bits[0]),))
parser.delete_first_token()
self.element = Variable(bits[1])
def clarity(parser, token):
bits = token.split_contents()
remaining_bits = bits[1:]
if len(remaining_bits) < 1:
raise TemplateSyntaxError('This tag requires at least one argument')
tags = token_kwargs(remaining_bits, parser, support_legacy=False)
return SimpleAnalyticNode(tags)
def extend(parser, token):
'''
Extends another template, passing additional variables to the parent.
'''
bits = token.split_contents()
kwargs = token_kwargs(bits[2:], parser)
token.contents = " ".join(bits[:2])
return ExtendNode(do_extends(parser, token), kwargs)
def do_tenant(parser, token):
bits = token.split_contents()
remaining_bits = bits[1:]
extra_context = token_kwargs(remaining_bits, parser, support_legacy=True)
nodelist = parser.parse(("endtenant",))
parser.delete_first_token()
return TenantNode(nodelist, tenant_var=remaining_bits[0])
def accordionsection(parser, token):
kwargs = token_kwargs(token.split_contents()[1:], parser)
if 'heading' not in kwargs:
raise template.TemplateSyntaxError(
'accordion section requires heading argument')
node_list = parser.parse(('endaccordionsection', ))
parser.delete_first_token()
return AccordionSectionNode(node_list, **kwargs)
def template_variable(parser, token):
bits = token.split_contents()
remaining_bits = bits[1:]
extra_context = token_kwargs(remaining_bits, parser, support_legacy=False)
if not extra_context:
raise TemplateSyntaxError(
f"'{bits[0]}' expects at least one key word variable")
return MacroNode(remaining_bits, extra_context=extra_context)
def extend(parser, token):
'''
Extends another template, passing additional variables to the parent.
'''
bits = token.split_contents()
kwargs = token_kwargs(bits[2:], parser)
token.contents = " ".join(bits[:2])
return ExtendNode(do_extends(parser, token), kwargs)
def get_kwargs(parser, token):
"""helper for parsing token kwargs"""
kwargs = {}
bits = token.split_contents()
bits = bits[1:]
if len(bits):
kwargs = token_kwargs(bits, parser)
return kwargs
def __init__(self, tag_name, parser, token):
self.tag_name = tag_name
bits = token.split_contents()[1:]
self.kwargs = {k: v.var for k, v in token_kwargs(bits, parser).items()}
nodelist = parser.parse(('end{0}'.format(tag_name), ))
parser.delete_first_token()
self.nodelist = nodelist
def script(parser, token):
# Parse out any keyword args
token_args = token.split_contents()
kwargs = token_kwargs(token_args[1:], parser)
nodelist = parser.parse(('endscript', ))
parser.delete_first_token()
return NonceScriptNode(nodelist, **kwargs)
def __init__(self, tag_name, parser, token):
self.tag_name = tag_name
bits = token.split_contents()[1:]
self.kwargs = {k: v.var for k,v in token_kwargs(bits, parser).items()}
nodelist = parser.parse(('end{0}'.format(tag_name),))
parser.delete_first_token()
self.nodelist = nodelist
def script(parser, token):
# Parse out any keyword args
token_args = token.split_contents()
kwargs = token_kwargs(token_args[1:], parser)
nodelist = parser.parse(('endscript',))
parser.delete_first_token()
return NonceScriptNode(nodelist, **kwargs)
def icon(parser, token):
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError("'%s' requires at least one argument." % bits[0])
name = parser.compile_filter(bits[1])
remaining_bits = bits[2:]
extra_context = token_kwargs(remaining_bits, parser)
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" % (bits[0], remaining_bits[0]))
return IconNode(name=name, extra_context=extra_context)
def icon(parser, token):
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError("'%s' requires at least one argument." % bits[0])
name = parser.compile_filter(bits[1])
remaining_bits = bits[2:]
extra_context = token_kwargs(remaining_bits, parser)
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" % (bits[0], remaining_bits[0]))
return IconNode(name=name, extra_context=extra_context)
def _if_feature(parser, token, enabled_first):
"""Common implementation for feature-based if statements.
This constructs a :py:class:`IfFeatureNode` for the consuming template tag,
allowing for "if" and "if not" checks.
Args:
parser (django.template.Parser):
The parser being used to parse this template tag.
token (django.template.Token):
The token representing this template tag.
enabled_first (bool):
If ``True``, this behaves as an "if enabled" check.
If ``False``, this behaves as a "if disabled' check.
Returns:
IfFeatureNode:
The feature checker node to use for the template.
"""
bits = token.split_contents()
tag = bits[0]
end_tag = 'end%s' % tag
if len(bits) < 2:
raise TemplateSyntaxError('%r requires a feature ID argument'
% tag)
nodelist_1 = parser.parse(('else', end_tag))
token = parser.next_token()
if token.contents == 'else':
nodelist_2 = parser.parse((end_tag,))
parser.delete_first_token()
else:
nodelist_2 = NodeList()
if enabled_first:
nodelist_enabled = nodelist_1
nodelist_disabled = nodelist_2
else:
nodelist_disabled = nodelist_1
nodelist_enabled = nodelist_2
feature_id = parser.compile_filter(bits[1])
remaining_bits = bits[2:]
extra_kwargs = token_kwargs(remaining_bits, parser)
if remaining_bits:
raise TemplateSyntaxError('%r received an invalid token: %r'
% (tag, remaining_bits[0]))
return IfFeatureNode(nodelist_enabled, nodelist_disabled, feature_id,
extra_kwargs)
def do_card(
parser,
token,
):
nodelist = parser.parse(('endcard', ))
parser.delete_first_token()
bits = token.split_contents()
tagname = bits.pop(0)
arg_dict = token_kwargs(bits, parser)
return CardNode(nodelist, **arg_dict)
def do_form_renderer(parser, token):
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError("%r tag takes at least one argument: the form that will be rendered" % bits[0])
remaining_bits = bits[2:]
options = token_kwargs(remaining_bits, parser, support_legacy=False)
template_name = options.get("template", parser.compile_filter("'forms/default_form.html'"))
options["use_csrf"] = options.get("use_csrf", parser.compile_filter("True"))
options["form"] = parser.compile_filter(bits[1])
options["method"] = options.get("method", parser.compile_filter("'POST'"))
return SnippetsIncludeNode(template_name, extra_context=options)
def do_form_renderer(parser, token):
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError("%r tag takes at least one argument: the form that will be rendered" % bits[0])
remaining_bits = bits[2:]
options = token_kwargs(remaining_bits, parser, support_legacy=False)
template_name = options.get('template', parser.compile_filter("'is_core/forms/default_form.html'"))
options['use_csrf'] = options.get('use_csrf', parser.compile_filter('True'))
options['form'] = parser.compile_filter(bits[1])
options['method'] = options.get('method', parser.compile_filter("'POST'"))
return IncludeNode(template_name, extra_context=options)
def collapse(parser, token):
bits = token.split_contents()
remaining_bits = bits[1:]
extra_context = token_kwargs(remaining_bits, parser, support_legacy=True)
if not extra_context:
raise TemplateSyntaxError("%r expected at least one variable assignment" % bits[0])
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" % (bits[0], remaining_bits[0]))
nodelist = parser.parse(('endcollapse',))
parser.delete_first_token()
return CollapseNode(nodelist, extra_context=extra_context)
def collapse(parser, token):
bits = token.split_contents()
remaining_bits = bits[1:]
extra_context = token_kwargs(remaining_bits, parser, support_legacy=True)
if not extra_context:
raise TemplateSyntaxError("%r expected at least one variable assignment" % bits[0])
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" % (bits[0], remaining_bits[0]))
nodelist = parser.parse(('endcollapse',))
parser.delete_first_token()
return CollapseNode(nodelist, extra_context=extra_context)
def impressions_for_cart(parser, token):
"""
{% analytics_impressions queryset=queryset brand="Nawoka" metrics="a b c" %}
"""
bits = token.split_contents()
remaining_bits = bits[1:]
extra_context = token_kwargs(remaining_bits, parser, support_legacy=False)
if not extra_context:
raise TemplateSyntaxError(
f"'{bits[0]}' expects at least one key word variable")
return AnalyticsNode(extra_context=extra_context)
def __init__(self, parser, token):
bits = token.split_contents()[1:]
self.kwargs = token_kwargs(bits, parser)
for key in self.kwargs:
if key not in (
'key',
'templatename',
'text',
):
raise TemplateSyntaxError(
"'table_sortlink' received invalid key: %s" % key)
def do_form_renderer(parser, token):
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError("%r tag takes at least one argument: the form that will be rendered" % bits[0])
remaining_bits = bits[2:]
options = token_kwargs(remaining_bits, parser, support_legacy=False)
template_name = options.get('template', parser.compile_filter("'forms/default_form.html'"))
options['use_csrf'] = options.get('use_csrf', parser.compile_filter('True'))
options['form'] = parser.compile_filter(bits[1])
options['method'] = options.get('method', parser.compile_filter("'POST'"))
return SnippetsIncludeNode(template_name, extra_context=options)
def urlquerify(parser, token):
bits = token.split_contents()
remaining_bits = bits[1:]
update_items = token_kwargs(remaining_bits, parser, support_legacy=True)
named_args = token_named_args(remaining_bits, ['remove', 'only'])
remove_items = named_args.get('remove', '').split(',')
only_items = named_args.get('only', '').split(',')
return UrlquerifyNode(update_items, remove_items, only_items)
def _if_feature(parser, token, enabled_first):
"""Common implementation for feature-based if statements.
This constructs a :py:class:`IfFeatureNode` for the consuming template tag,
allowing for "if" and "if not" checks.
Args:
parser (django.template.Parser):
The parser being used to parse this template tag.
token (django.template.Token):
The token representing this template tag.
enabled_first (bool):
If ``True``, this behaves as an "if enabled" check.
If ``False``, this behaves as a "if disabled' check.
Returns:
IfFeatureNode:
The feature checker node to use for the template.
"""
bits = token.split_contents()
tag = bits[0]
end_tag = 'end%s' % tag
if len(bits) < 2:
raise TemplateSyntaxError('%r requires a feature ID argument' % tag)
nodelist_1 = parser.parse(('else', end_tag))
token = parser.next_token()
if token.contents == 'else':
nodelist_2 = parser.parse((end_tag, ))
parser.delete_first_token()
else:
nodelist_2 = NodeList()
if enabled_first:
nodelist_enabled = nodelist_1
nodelist_disabled = nodelist_2
else:
nodelist_disabled = nodelist_1
nodelist_enabled = nodelist_2
feature_id = parser.compile_filter(bits[1])
remaining_bits = bits[2:]
extra_kwargs = token_kwargs(remaining_bits, parser)
if remaining_bits:
raise TemplateSyntaxError('%r received an invalid token: %r' %
(tag, remaining_bits[0]))
return IfFeatureNode(nodelist_enabled, nodelist_disabled, feature_id,
extra_kwargs)
def foundation_form(parser, token):
'''
Renders a form with Foundation markup.
'''
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError('Incorrect number of arguements for %s, Form object required' % bits[0])
form = parser.compile_filter(bits[1])
kwargs = token_kwargs(bits[2:], parser)
nodelist = parser.parse(('end_foundation_form',))
parser.delete_first_token()
return FoundationFormNode(form, nodelist, **kwargs)
def do_component(parser, token):
"""
{% component_block "name" variable="value" variable2="value2" ... %}
"""
bits = token.split_contents()
tag_args, tag_kwargs = parse_bits(
parser=parser,
bits=bits,
params=["tag_name", "component_name"],
takes_context=False,
name="component_block",
**PARSE_BITS_DEFAULTS
)
tag_name = tag_args.pop(0)
if len(bits) < 2:
raise TemplateSyntaxError(
"Call the '%s' tag with a component name as the first parameter" % tag_name
)
component_name = bits[1]
if not component_name.startswith(('"', "'")) or not component_name.endswith(
('"', "'")
):
raise TemplateSyntaxError(
"Component name '%s' should be in quotes" % component_name
)
component_name = component_name.strip('"\'')
component_class = registry.get(component_name)
component = component_class()
extra_context = {}
if len(bits) > 2:
extra_context = component.context(**token_kwargs(bits[2:], parser))
slots_filled = NodeList()
tag_name = bits[0]
while tag_name != "endcomponent_block":
token = parser.next_token()
if token.token_type != TokenType.BLOCK:
continue
tag_name = token.split_contents()[0]
if tag_name == "slot":
slots_filled += do_slot(parser, token, component=component)
elif tag_name == "endcomponent_block":
break
return ComponentNode(component, extra_context, slots_filled)
def cinclude(parser, token):
"""
Loads a template and renders it with the current context. You can pass
additional context using keyword arguments. This is bascially a enhanced
version of the base django {% include filter %}. The difference is, that
this tag is client template aware and will look into client template
directories before falling back to django's standard loading.
Example::
{% cinclude "foo/some_include" %}
{% cinclude "foo/some_include" with bar="BAZZ!" baz="BING!" %}
Use the ``only`` argument to exclude the current context when rendering
the included template::
{% cinclude "foo/some_include" only %}
{% cinclude "foo/some_include" with bar="1" only %}
"""
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError(
"%r tag takes at least one argument: the name of the template to "
"be included." % bits[0])
options = {}
remaining_bits = bits[2:]
while remaining_bits:
option = remaining_bits.pop(0)
if option in options:
raise TemplateSyntaxError('The %r option was specified more '
'than once.' % option)
if option == 'with':
value = token_kwargs(remaining_bits, parser, support_legacy=False)
if not value:
raise TemplateSyntaxError('"with" in %r tag needs at least '
'one keyword argument.' % bits[0])
elif option == 'only':
value = True
else:
raise TemplateSyntaxError('Unknown argument for %r tag: %r.' %
(bits[0], option))
options[option] = value
isolated_context = options.get('only', False)
namemap = options.get('with', {})
path = bits[1]
if path[0] in ('"', "'") and path[-1] == path[0]:
return ClientIncludeNode(
path[1:-1], extra_context=namemap,
isolated_context=isolated_context)
return ClientIncludeNode(
parser.compile_filter(
bits[1]), extra_context=namemap, isolated_context=isolated_context)
def do_embed(parser, token):
"""{% embed %} template tag. Allows to include a template and optionally override its slots, in a similar fashion
to block tags in extended templates.
Example::
{% embed 'section.html' %}
{% slot title %}<h1>Title</h1>{% endslot %}
{% slot content %}<p>Content</p>{% endslot %}
{% endembed %}
You may use the ``only`` argument and keyword arguments using ``with`` like when using ``{% include %}``
"""
# Exact copy from do_include_node()
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError(
"%r tag takes at least one argument: the name of the template to "
"be included." % bits[0])
options = {}
remaining_bits = bits[2:]
while remaining_bits:
option = remaining_bits.pop(0)
if option in options:
raise TemplateSyntaxError("The %r option was specified more "
"than once." % option)
if option == "with":
value = token_kwargs(remaining_bits, parser, support_legacy=False)
if not value:
raise TemplateSyntaxError('"with" in %r tag needs at least '
"one keyword argument." % bits[0])
elif option == "only":
value = True
else:
raise TemplateSyntaxError(
f"Unknown argument for {bits[0]!r} tag: {option!r}.")
options[option] = value
isolated_context = options.get("only", False)
namemap = options.get("with", {})
bits[1] = construct_relative_path(parser.origin.template_name, bits[1])
# End exact copy from do_include_node()
nodelist = parser.parse(("endembed", ))
parser.delete_first_token()
return EmbedNode(
parser.compile_filter(bits[1]),
nodelist,
extra_context=namemap,
isolated_context=isolated_context,
)
def do_html_widget(parser, token):
bits = token.split_contents()
remaining_bits = bits[1:]
extra_context = token_kwargs(remaining_bits, parser, support_legacy=True)
if not extra_context:
raise TemplateSyntaxError("%r expected at least one variable assignment" % bits[0])
if not 'id' in extra_context or not 'class' in extra_context:
raise TemplateSyntaxError("id and class parameters are required")
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" % (bits[0], remaining_bits[0]))
nodelist = parser.parse(('endwidget',))
parser.delete_first_token()
return HtmlWidgetNode("widgets/widget.html", None, None, nodelist, extra_context=extra_context)
def do_html_widget(parser, token):
bits = token.split_contents()
remaining_bits = bits[1:]
extra_context = token_kwargs(remaining_bits, parser, support_legacy=True)
if not extra_context:
raise TemplateSyntaxError("%r expected at least one variable assignment" % bits[0])
if not 'id' in extra_context or not 'class' in extra_context:
raise TemplateSyntaxError("id and class parameters are required")
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" % (bits[0], remaining_bits[0]))
nodelist = parser.parse(('endwidget',))
parser.delete_first_token()
return HtmlWidgetNode("widgets/widget.html", None, None, nodelist, extra_context=extra_context)
def transpiling_block(parser, token):
bits = token.split_contents()
remaining_bits = bits[1:]
options = token_kwargs(remaining_bits, parser, support_legacy=True)
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" %
(bits[0], remaining_bits[0]))
nodelist = parser.parse(('endpostcssmodules', ))
parser.delete_first_token()
return TranspilingNode(nodelist,
options=options,
path=f'{parser.origin.name}.{token.lineno}.cssm')
def __init__(self, parser, token):
bits = token.split_contents()[1:]
self.kwargs = token_kwargs(bits, parser)
for key in self.kwargs:
if key not in (
'view',
'args',
'classname',
'text',
'addnextparam',
):
raise TemplateSyntaxError(
"'tablerowaction' received invalid key: %s" % key)
def oauth2_authorize(parser, token):
bits = token.contents.split()
remaining_bits = bits[1:]
params = token_kwargs(remaining_bits, parser, support_legacy=True)
if not params or not ('redirect_uri' in params and 'callback' in params
and 'elem_id' in params):
raise TemplateSyntaxError(
"%r expected at least three variables namely: "
"'elem_id', 'redirect_uri' and 'callback'" % bits[0])
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" %
(bits[0], remaining_bits[0]))
return AuthorizeNode(params)
def wepay_oauth2(parser, token):
bits = token.contents.split()
remaining_bits = bits[1:]
params = token_kwargs(remaining_bits, parser, support_legacy=True)
if not params or not ('redirect_uri' in params and 'callback' in params
and 'elem_id' in params):
raise TemplateSyntaxError(
"%r expected at least three variables namely: "
"'elem_id', 'redirect_uri' and 'callback'" % bits[0])
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" %
(bits[0], remaining_bits[0]))
return AuthorizeNode(params)
def _do_include(parser, token, _class):
"""
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!" %}
Use the ``only`` argument to exclude the current context when rendering
the included template::
{% include "foo/some_include" only %}
{% include "foo/some_include" with bar="1" only %}
"""
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError("%r tag takes at least one argument: the name of the template to be included." % bits[0])
options = {}
remaining_bits = bits[2:]
template_type = None
while remaining_bits:
option = remaining_bits.pop(0)
if option in options:
raise TemplateSyntaxError('The %r option was specified more '
'than once.' % option)
if option == 'with':
value = token_kwargs(remaining_bits, parser, support_legacy=False)
if not value:
raise TemplateSyntaxError('"with" in %r tag needs at least '
'one keyword argument.' % bits[0])
elif option == 'only':
value = True
elif option[:4] == 'type':
template_type = option[5:]
continue
else:
raise TemplateSyntaxError('Unknown argument for %r tag: %r.' %
(bits[0], option))
options[option] = value
isolated_context = options.get('only', False)
namemap = options.get('with', {})
template_filename = str(bits[1]).replace("'", '').replace('"', '')
if not template_type:
template_type = template_filename.split('.')[-1]
return _class(template_type, template_filename, parser.compile_filter(bits[1]), extra_context=namemap,
isolated_context=isolated_context)
def do_include(parser, token):
"""
Loads a template and renders it with the current context, if it exists.
You can pass additional context using keyword arguments.
Example::
{% optional_include "foo/some_include" %}
{% optional_include "foo/some_include" with bar="BAZZ!" baz="BING!" %}
Use the ``only`` argument to exclude the current context when rendering
the included template::
{% optional_include "foo/some_include" only %}
{% optional_include "foo/some_include" with bar="1" only %}
"""
bits = token.split_contents()
if len(bits) < 2:
msg = (
"%r tag takes at least one argument: the name of the template "
"to be optionally included."
) % bits[0]
raise TemplateSyntaxError(msg)
options = {}
remaining_bits = bits[2:]
while remaining_bits:
option = remaining_bits.pop(0)
if option in options:
raise TemplateSyntaxError('The %r option was specified more '
'than once.' % option)
if option == 'with':
value = token_kwargs(remaining_bits, parser, support_legacy=False)
if not value:
raise TemplateSyntaxError('"with" in %r tag needs at least '
'one keyword argument.' % bits[0])
elif option == 'only':
value = True
else:
raise TemplateSyntaxError('Unknown argument for %r tag: %r.' %
(bits[0], option))
options[option] = value
isolated_context = options.get('only', False)
namemap = options.get('with', {})
node = OptionalIncludeNode(
parser.compile_filter(bits[1]),
extra_context=namemap,
isolated_context=isolated_context,
)
return node
def include_compressed(parser, token):
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError(
"%r tag takes at least one argument: the name of the template to "
"be included." % bits[0]
)
compress_types = ['js', 'css', 'html']
options = {}
remaining_bits = bits[2:]
while remaining_bits:
option = remaining_bits.pop(0)
if option in options:
raise TemplateSyntaxError('The %r option was specified more '
'than once.' % option)
if option == 'with':
value = token_kwargs(remaining_bits, parser, support_legacy=False)
if not value:
raise TemplateSyntaxError('"with" in %r tag needs at least '
'one keyword argument.' % bits[0])
elif option == 'only':
value = True
elif option in compress_types:
unused = compress_types.copy()
unused.remove(option)
for t in unused:
options[t] = False
value = True
options['type'] = option
else:
raise TemplateSyntaxError('Unknown argument for %r tag: %r.' %
(bits[0], option))
options[option] = value
if not "type" in options:
TemplateSyntaxError("'html','css' or 'js' not specified "
"for %r tag." % bits[0])
compress_type = options.get('type', 'html')
isolated_context = options.get('only', False)
namemap = options.get('with', {})
bits[1] = construct_relative_path(parser.origin.template_name, bits[1])
return CompressedIncludeNode(parser.compile_filter(bits[1]), extra_context=namemap,
isolated_context=isolated_context,
compress_type=compress_type)
def parse_with(cls, tagname, parser, bits, options):
if bits:
if bits[0] == "with":
bits.pop(0)
arguments = token_kwargs(bits, parser, support_legacy=False)
if not arguments:
raise TemplateSyntaxError('"with" in %s tag needs at ' "least one keyword argument." % tagname)
options["with"] = arguments
elif bits[0] not in ("only",) and not cls.optional_with_parameter:
raise TemplateSyntaxError("Unknown argument for %s tag: %r." % (tagname, bits[0]))
if bits:
if cls.accept_only_parameter and bits[0] == "only":
bits.pop(0)
options["only"] = True
def do_include(parser, token):
"""
Loads a template and renders it with the current context. You can pass
additional context using keyword arguments.
Example::
{% include "foo/some_include" "foo/some_other_include" %}
{% include "foo/some_include" "foo/some_other_include" with bar="BAZZ!" baz="BING!" %}
Use the ``only`` argument to exclude the current context when rendering
the included template::
{% include "foo/some_include" "foo/some_other_include" only %}
{% include "foo/some_include" "foo/some_other_include" with bar="1" only %}
"""
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError("%r tag takes at least one argument: the name of the template to be included." % bits[0])
options = {}
remaining_bits = bits[1:]
paths = []
stop_markers = ('only', 'with')
while remaining_bits and remaining_bits[0] not in stop_markers:
paths.append(remaining_bits.pop(0))
while remaining_bits:
option = remaining_bits.pop(0)
if option in options:
raise TemplateSyntaxError('The %r option was specified more '
'than once.' % option)
if option == 'with':
value = token_kwargs(remaining_bits, parser, support_legacy=False)
if not value:
raise TemplateSyntaxError('"with" in %r tag needs at least '
'one keyword argument.' % bits[0])
elif option == 'only':
value = True
else:
raise TemplateSyntaxError('Unknown argument for %r tag: %r.' %
(bits[0], option))
options[option] = value
isolated_context = options.get('only', False)
namemap = options.get('with', {})
template_names = [parser.compile_filter(path) for path in paths]
return MultipleIncludeNode(template_names, extra_context=namemap,
isolated_context=isolated_context)
def parse(cls, parser, token):
bits = token.split_contents()
tagname = bits.pop(0)
if len(bits) < 1:
raise TemplateSyntaxError(
"{tagname!r} requires at least one argument.".format(
tagname=tagname))
field = bits.pop(0)
if bits:
with_ = bits.pop(0)
if with_ != 'with':
raise TemplateSyntaxError(
"{tagname}'s second argument must be 'with'.".format(
tagname=tagname))
with_arguments = token_kwargs(bits, parser, support_legacy=False)
# Validate against spaces around the '='.
has_lonely_equal_sign = any(
bit == '=' or bit.startswith('=') or bit.endswith('=')
for bit in bits)
if has_lonely_equal_sign:
# If '=' is leading/trailing or is the own char in the token,
# then the user has used spaces around it. We can use a
# distinct error message for this to aid the user.
raise TemplateSyntaxError(
"The keyword arguments after 'with' in {tagname} tag "
"must not contain spaces around the '='. "
"A keyword argument must be in the form of "
"{example}.".format(
tagname=tagname,
example='{% formfield ... with name="value" %}'))
if not with_arguments:
example = '{% formfield ... with name="value" %}'
raise TemplateSyntaxError(
"'with' in {tagname} tag needs at least one keyword "
"argument. A keyword argument must be in the form of "
"{example}.".format(
tagname=tagname,
example=example))
else:
with_arguments = {}
if bits:
raise TemplateSyntaxError(
'Unkown argument for {tagname} tag: {bits!r}'.format(
tagname=tagname,
bits=bits))
return cls(field, with_arguments)
def widget(parser, token):
bits = token.split_contents()
tag_name = bits.pop(0)
try:
widget = parser.compile_filter(bits.pop(0))
except IndexError:
raise template.TemplateSyntaxError('%s requires one positional argument' % tag_name)
asvar = pop_asvar(bits)
kwargs = token_kwargs(bits, parser)
if bits:
raise template.TemplateSyntaxError('%s accepts only one positional argument' % tag_name)
return Widget(widget, kwargs, asvar)
def parse_with(cls, tagname, parser, bits, options):
if bits:
if bits[0] == 'with':
bits.pop[0]
arguments = token_kwargs(bits, parser, support_legacy=False)
if not arguments:
raise TemplateSyntaxError('"with" in %s tag needs at '
'least one keyword argument.' %
tagname)
options['with'] = arguments
elif bits[0] not in ('only',) and not cls.optional_with_parameter:
raise TemplateSyntaxError('Unknown argument for %s tag: %r.' %
(tagname, bits[0]))
if bits:
if cls.accept_only_parameter and vits[0] == 'only':
bits.pop(0)
options['only'] = True
def do_define(parser, token):
bits = token.split_contents()[1:]
initial_values = None
if len(bits) < 3 and bits[1] != 'as':
raise template.TemplateSyntaxError(error_message)
del bits[1] # "as"
try:
variable_name, variable_type = bits[:2]
except ValueError:
raise TemplateSyntaxError(error_message)
try:
optional = bits[2] == 'optional'
except IndexError:
optional = False
if not optional and 'optional' in bits:
raise TemplateSyntaxError(error_message)
try:
if optional:
index = 3
else:
index = 2
with_tag = bits[index]
assert with_tag, 'with'
bits = bits[index + 1:]
except IndexError:
pass
except AssertionError:
raise TemplateSyntaxError(error_message)
else:
initial_values = token_kwargs(bits, parser, support_legacy=False)
if not initial_values:
raise TemplateSyntaxError(error_message)
for var, val in initial_values.items():
initial_values[var] = val.resolve({}) # nasty, don't have access to context.
return DefineNode(variable_name, variable_type, optional, initial_values)
def handle_token(cls, parser, token):
bits = token.split_contents()
attrs = {}
if len(bits) < 2:
raise template.TemplateSyntaxError("'%s' takes at least one argument (js module)" % bits[0])
if len(bits) > 2:
for bit in bits[2:]:
# First we try to extract a potential kwarg from the bit
kwarg = token_kwargs([bit], parser)
if kwarg:
attrs.update(kwarg)
else:
attrs[bit] = True # for flatatt
path = parser.compile_filter(bits[1])
return cls(path, tag_attrs=attrs)
def __init__(self, parser, token):
bits = token.split_contents()
remaining_bits = bits[1:]
self.kwargs = token_kwargs(remaining_bits, parser)
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" %
(bits[0], remaining_bits[0]))
for key in self.kwargs:
if key not in ('form', 'layout', 'template'):
raise TemplateSyntaxError("%r received an invalid key: %r" %
(bits[0], key))
self.kwargs[key] = self.kwargs[key]
self.nodelist = parser.parse(('end{}'.format(bits[0]),))
parser.delete_first_token()
