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): """ 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)