def parse(self, parser):
lineno = next(parser.stream).lineno
parts = [parser.stream.expect('name').value]
while parser.stream.current.type != 'block_end':
parser.stream.expect('dot')
parts.append(parser.stream.expect('name').value)
body = parser.parse_statements(['name:endeditable'], drop_needle=True)
call = self.call_method(
'_editable_loader',
[nodes.Name(parts[-2], 'load'),
nodes.Const(parts[-1])])
output_nodes = [
nodes.Output([
nodes.MarkSafe(
nodes.TemplateData('<div class="editable-container">')),
nodes.MarkSafe(
nodes.TemplateData('<div class="editable-content">'))
])
]
output_nodes.extend(body)
output_nodes.extend([
nodes.Output([nodes.MarkSafe(nodes.TemplateData('</div>'))]),
nodes.Output([nodes.MarkSafe(call)]),
nodes.Output([nodes.MarkSafe(nodes.TemplateData('</div>'))])
])
block_name = '%s_%s_%d' % (parts[-2], parts[-1], random.randint(
0, 500))
return nodes.Block(block_name, output_nodes, True)
def parse(self, parser):
lineno = next(parser.stream).lineno
args = [parser.parse_expression()]
return nodes.Output([
nodes.MarkSafe(nodes.Const('assets/')),
nodes.MarkSafe(args[0]),
], lineno=lineno)
def _make_node(self, singular, plural, variables, plural_expr):
"""Generates a useful node from the data provided."""
# singular only:
if plural_expr is None:
gettext = nodes.Name('gettext', 'load')
node = nodes.Call(gettext, [nodes.Const(singular)],
[], None, None)
# singular and plural
else:
ngettext = nodes.Name('ngettext', 'load')
node = nodes.Call(ngettext, [
nodes.Const(singular),
nodes.Const(plural),
plural_expr
], [], None, None)
# mark the return value as safe if we are in an
# environment with autoescaping turned on
if self.environment.autoescape:
node = nodes.MarkSafe(node)
if variables:
node = nodes.Mod(node, variables)
return nodes.Output([node])
def parse(self, parser):
lineno = parser.stream.expect('name:meld').lineno
component = parser.parse_expression()
call = self.call_method('_render', [component], lineno=lineno)
return nodes.Output([nodes.MarkSafe(call)]).set_lineno(lineno)
def parse(self, parser):
lineno = parser.stream.expect('name:csrf_token').lineno
call = self.call_method(
'_render',
[nodes.Name('csrf_token', 'load', lineno=lineno)],
lineno=lineno
)
return nodes.Output([nodes.MarkSafe(call)])
def parse(self, parser):
lineno = parser.stream.expect("name:csrf_token").lineno
call = self.call_method(
"_csrf_token",
[nodes.Name("csrf_token", "load", lineno=lineno)],
lineno=lineno,
)
return nodes.Output([nodes.MarkSafe(call)])
def parse(self, parser):
list_of_paths = getattr(settings, 'LATEX_GRAPHICSPATH',
[settings.BASE_DIR])
value = '\graphicspath{ ' + ' '.join(
map(format_path_for_latex, list_of_paths)) + ' }'
node = nodes.Output(lineno=next(parser.stream).lineno)
node.nodes = [nodes.MarkSafe(nodes.Const(value))]
return node
def parse(self, parser):
self.parser = parser
lineno = parser.stream.expect('name:csrf_token_raw').lineno
call = self.call_method('_csrf_token', [
nodes.Getattr(nodes.Name('request', 'load'), 'csrf_token', 'load')
],
lineno=lineno)
return nodes.Output([nodes.MarkSafe(call)])
def parse_formrow_template(self, parser, tag):
lineno = tag.lineno
template_name = parser.parse_expression()
if not parser.stream.current.test('block_end'):
raise TemplateSyntaxError("Too many arguments", lineno)
call = self.call_method('_process', [
template_name,
nodes.Name('form_utils_form', 'load', lineno=lineno)
])
return nodes.Output([nodes.MarkSafe(call)]).set_lineno(lineno)
def parse(self, parser):
stream = parser.stream
tag = next(stream)
if stream.current.test('string'):
path = parser.parse_primary()
else:
raise TemplateSyntaxError('''
"%s" requires path to asset file''' % tag.value, tag.lineno)
while not parser.stream.current.type == 'block_end':
next(parser.stream)
result = self.call_method('_build_url', args=[path])
return nodes.Output([nodes.MarkSafe(result)]).set_lineno(tag.lineno)
def parse(self, parser):
stream = parser.stream
tag = stream.next()
if stream.current.test('string'):
path = parser.parse_primary()
else:
raise TemplateSyntaxError(
'''\
"%s" requires path to asset file, relative to STATICFILES_URL''' % tag.value,
tag.lineno)
while not parser.stream.current.type == 'block_end':
parser.stream.next()
result = self.call_method(self.build_method, args=[path])
return nodes.Output([nodes.MarkSafe(result)]).set_lineno(tag.lineno)
def parse(self, parser):
lineno = parser.stream.expect("name:meld_scripts").lineno
call = self.call_method("_render", lineno=lineno)
return nodes.Output([nodes.MarkSafe(call)]).set_lineno(lineno)
def _parse_blocktrans(self, parser, lineno):
with_vars = {}
count = None
context = None
trimmed = False
as_var = None
if parser.stream.skip_if('name:trimmed'):
trimmed = True
if parser.stream.skip_if('name:asvar'):
as_var = parser.stream.expect(lexer.TOKEN_NAME)
as_var = nodes.Name(as_var.value, 'store', lineno=as_var.lineno)
if parser.stream.skip_if('name:with'):
while parser.stream.look().type == lexer.TOKEN_ASSIGN:
token = parser.stream.expect(lexer.TOKEN_NAME)
key = token.value
next(parser.stream)
with_vars[key] = parser.parse_expression(False)
if parser.stream.skip_if('name:count'):
name = parser.stream.expect(lexer.TOKEN_NAME).value
parser.stream.expect(lexer.TOKEN_ASSIGN)
value = parser.parse_expression(False)
count = (name, value)
if parser.stream.skip_if('name:context'):
context = parser.stream.expect(lexer.TOKEN_STRING).value
parser.stream.expect(lexer.TOKEN_BLOCK_END)
body_singular = None
body = []
additional_vars = set()
for token in parser.stream:
if token is lexer.TOKEN_EOF:
parser.fail(
'unexpected end of template, expected endblocktrans tag')
if token.type is lexer.TOKEN_DATA:
body.append(token.value)
elif token.type is lexer.TOKEN_VARIABLE_BEGIN:
name = parser.stream.expect(lexer.TOKEN_NAME).value
if name not in with_vars and (count is None
or count[0] != name):
additional_vars.add(name)
parser.stream.expect(lexer.TOKEN_VARIABLE_END)
# django converts variables inside the blocktrans tag into
# "%(var_name)s" format, so we do the same.
body.append('%({})s'.format(name))
elif token.type is lexer.TOKEN_BLOCK_BEGIN:
if body_singular is None and parser.stream.skip_if(
'name:plural'):
if count is None:
parser.fail('used plural without specifying count')
parser.stream.expect(lexer.TOKEN_BLOCK_END)
body_singular = body
body = []
else:
parser.stream.expect('name:endblocktrans')
break
if count is not None and body_singular is None:
parser.fail('plural form not found')
trans_vars = [
nodes.Pair(nodes.Const(key), val, lineno=lineno)
for key, val in with_vars.items()
]
if count is not None:
trans_vars.append(
nodes.Pair(nodes.Const(count[0]), count[1], lineno=lineno))
trans_vars.extend(
nodes.Pair(nodes.Const(key),
nodes.Name(key, 'load', lineno=lineno),
lineno=lineno) for key in additional_vars)
kwargs = [
nodes.Keyword('trans_vars',
nodes.Dict(trans_vars, lineno=lineno),
lineno=lineno)
]
if context is not None:
kwargs.append(
nodes.Keyword('context',
nodes.Const(context, lineno=lineno),
lineno=lineno))
if count is not None:
kwargs.append(
nodes.Keyword('count_var',
nodes.Const(count[0], lineno=lineno),
lineno=lineno))
body = ''.join(body)
if trimmed:
body = ' '.join(map(lambda s: s.strip(),
body.strip().splitlines()))
if body_singular is not None:
body_singular = ''.join(body_singular)
if trimmed:
body_singular = ' '.join(
map(lambda s: s.strip(),
body_singular.strip().splitlines()))
if body_singular is None:
args = []
else:
args = [nodes.TemplateData(body_singular, lineno=lineno)]
args.append(nodes.TemplateData(body, lineno=lineno))
call = nodes.MarkSafe(self.call_method('_make_blocktrans', args,
kwargs),
lineno=lineno)
if as_var is None:
return nodes.Output([call], lineno=lineno)
else:
return nodes.Assign(as_var, call)
def parse(self, parser):
lineno = parser.stream.expect('name:debug').lineno
context = ContextReference()
call = self.call_method('_render', [context], lineno=lineno)
return nodes.Output([nodes.MarkSafe(call)])
def output(self, parser, block_call, target, tag_name, lineno):
if target:
target_node = nodes.Name(target, 'store', lineno=lineno)
return nodes.Assign(target_node, block_call, lineno=lineno)
call = nodes.MarkSafe(block_call, lineno=lineno)
return nodes.Output([call], lineno=lineno)
