def do_xextends(parser, token):
bits = token.contents.split()
kwargs = {}
if 'with' in bits:
pos = bits.index('with')
argslist = bits[pos + 1:]
bits = bits[:pos]
for i in argslist:
try:
a, b = i.split('=', 1)
a = a.strip()
b = b.strip()
keys = list(
tokenize.generate_tokens(StringIO.StringIO(a).readline))
if keys[0][0] == tokenize.NAME:
kwargs[str(a)] = parser.compile_filter(b)
else:
raise ValueError
except ValueError:
raise template.TemplateSyntaxError, "Argument syntax wrong: should be key=value"
# before we are done, remove the argument part from the token contents,
# or django's extends tag won't be able to handle it.
# TODO: find a better solution that preserves the orginal token including whitespace etc.
token.contents = " ".join(bits)
# let the orginal do_extends parse the tag, and wrap the ExtendsNode
return XExtendsNode(do_extends(parser, token), kwargs)
def extends_with_args(parser, token):
"""
Parse extends_with_args extension declarations.
Arguments are made available in context to the extended template
and its includes.
E.g.:
{% extends_with_args "base.html" with foo="bar" baz="toto" %}
"""
bits = token.split_contents()
kwargs = {}
if "with" in bits:
pos = bits.index("with")
argspos = pos + 1
argslist = bits[argspos:]
bits = bits[:pos]
for i in argslist:
a, b = i.split("=", 1)
a = a.strip()
b = b.strip()
# Strip double quotes from value
kwargs[str(a)] = b.strip('"')
token.contents = " ".join(bits)
# Use do_extends to parse the tag
return ExtendsWithArgsNode(do_extends(parser, token), kwargs)
def do_xextends(parser, token):
bits = token.split_contents()
kwargs = {}
if 'with' in bits:
pos = bits.index('with')
argslist = bits[pos + 1:]
bits = bits[:pos]
for i in argslist:
try:
a, b = i.split('=', 1); a = a.strip(); b = b.strip()
keys = list(tokenize.generate_tokens(StringIO.StringIO(a).readline))
if keys[0][0] == tokenize.NAME:
kwargs[str(a)] = parser.compile_filter(b)
else: raise ValueError
except ValueError:
raise template.TemplateSyntaxError, "Argument syntax wrong: should be key=value"
# before we are done, remove the argument part from the token contents,
# or django's extends tag won't be able to handle it.
# TODO(jweyrich): Find a better solution that preserves the orginal token including whitespace etc.
token.contents = " ".join(bits)
# let the orginal do_extends parse the tag, and wrap the ExtendsNode
node = do_extends(parser, token)
node.__class__ = XExtendsNode
node.kwargs = kwargs
return node
def do_xextends(parser, token):
bits = token.contents.split()
kwargs = {}
if 'with' in bits:
pos = bits.index('with')
argslist = bits[pos + 1:]
i = 0
while i < len(argslist):
if argslist[i].count('"') % 2 or argslist[i].count("'") % 2:
argslist[i] += ' ' + argslist[i + 1]
argslist.pop(i + 1)
else:
i += 1
bits = bits[:pos]
for i in argslist:
try:
a, b = i.split('=', 1)
a = a.strip()
b = b.strip()
keys = list(
tokenize.generate_tokens(StringIO.StringIO(a).readline))
if keys[0][0] == tokenize.NAME:
kwargs[str(a)] = eval(b)
else:
raise ValueError
except ValueError:
raise template.TemplateSyntaxError, 'Argument syntax wrong: should be key=value'
# before we are done, remove the argument part from the token contents,
# or django's extends tag won't be able to handle it.
token.contents = ' '.join(bits)
# let the orginal do_extends parse the tag, and wrap the ExtendsNode
return XExtendsNode(do_extends(parser, token), kwargs)
def do_xextends(parser, token):
"""Process the custom extends tag."""
bits = token.contents.split()
kwargs = {}
if 'with' in bits:
pos = bits.index('with')
argslist = bits[pos + 1:]
bits = bits[:pos]
for i in argslist:
try:
variable, value = i.split('=', 1)
variable = variable.strip()
value = value.strip()
keys = list(tokenize.generate_tokens(
StringIO.StringIO(variable).readline))
if keys[0][0] == tokenize.NAME:
kwargs[str(variable)] = parser.compile_filter(value)
else:
raise ValueError
except ValueError:
raise template.TemplateSyntaxError(
"Argument syntax wrong: should be key=value")
# before we are done, remove the argument part from the token contents,
# or django's extends tag won't be able to handle it.
# TODO: find a better solution that preserves the orginal token
# including whitespace etc.
token.contents = " ".join(bits)
# let the orginal do_extends parse the tag, and wrap the ExtendsNode
return XExtendsNode(do_extends(parser, token), kwargs)
def do_xextends(parser, token):
bits = token.contents.split()
kwargs = {}
if 'with' in bits:
pos = bits.index('with')
argslist = bits[pos+1:]
i = 0
while i < len(argslist):
if argslist[i].count('"') % 2 or argslist[i].count("'") % 2:
argslist[i] += ' ' + argslist[i + 1]
argslist.pop(i + 1)
else:
i += 1
bits = bits[:pos]
for i in argslist:
try:
a, b = i.split('=', 1); a = a.strip(); b = b.strip()
keys = list(tokenize.generate_tokens(StringIO.StringIO(a).readline))
if keys[0][0] == tokenize.NAME:
kwargs[str(a)] = eval(b)
else: raise ValueError
except ValueError:
raise template.TemplateSyntaxError, 'Argument syntax wrong: should be key=value'
# before we are done, remove the argument part from the token contents,
# or django's extends tag won't be able to handle it.
token.contents = ' '.join(bits)
# let the orginal do_extends parse the tag, and wrap the ExtendsNode
return XExtendsNode(do_extends(parser, token), kwargs)
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_extends_with_macros(parser, token):
from django.template.loader_tags import do_extends
# parse it as an ExtendsNode, but also create a fake MacroRoot node
# and add it to the parser, like we do in do_enablemacros().
parser._macro_root = MacroRoot()
extendsnode = do_extends(parser, token)
parser._macro_root.nodelist = extendsnode.nodelist
return extendsnode
def do_extends_with_macros(parser, token):
from django.template.loader_tags import do_extends
# parse it as an ExtendsNode, but also create a fake MacroRoot node
# and add it to the parser, like we do in do_enablemacros().
parser._macro_root = MacroRoot()
extendsnode = do_extends(parser, token)
parser._macro_root.nodelist = extendsnode.nodelist
return extendsnode
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_extends_with_macros(parser, token):
""" Activer les macros avec les nœuds du template et de ses ancêtres """
from django.template.loader_tags import do_extends
# Ajouter un macroRoot dont la liste de nœuds est celle du extends
parser._macro_root = MacroRoot()
extendsnode = do_extends(parser, token)
parser._macro_root.nodelist = extendsnode.nodelist
return extendsnode
def do_extends_jinja(parser, token):
bits = token.split_contents()
if len(bits) != 2:
raise template.TemplateSyntaxError("'%s' takes one argument" % bits[0])
tmpl = bits[1][1:-1]
if engines['djinga'].env.use_jinja(tmpl):
# extends a Jinja2 template
nodelist = parser.parse()
return JinjaNode(tmpl, nodelist)
else:
# extends a Django template, use Django's do_extend
return do_extends(parser, token)
def extends_with_args(parser, token):
"""
Parse extends_with_args extension declarations.
Arguments are made available in context to the extended template
and its includes.
E.g.:
{% extends_with_args "base.html" foo="bar" baz="toto" %}
"""
all_arguments = token.split_contents()
token.contents = " ".join(all_arguments[:2])
# Use do_extends to parse the tag
return ExtendsWithArgsNode(do_extends(parser, token), all_arguments[2:])
def theme_extends(*args, **kwargs):
node = do_extends(*args, **kwargs)
node.must_be_first = False
return node
def new_do_extends(parser, token):
extends_node = do_extends(parser, token)
return NewExtendsNode(extends_node)
