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)