def get_string_deps(self, text, context=None, *, filename=None): """Find dependencies for a template string.""" lex = lexer.Lexer(text=text, filename=filename, input_encoding='utf-8') lex.parse() deps = [] for n in lex.template.nodes: keyword = getattr(n, 'keyword', None) if keyword in ["inherit", "namespace"] or isinstance( n, parsetree.IncludeTag): filename = n.attributes["file"] if '${' in filename: # Support for comment helper inclusions filename = re.sub(r'''\${context\[['"](.*?)['"]]}''', lambda m: context[m.group(1)], filename) deps.append(filename) # Some templates will include "foo.tmpl" and we need paths, so normalize them # using the template lookup for i, d in enumerate(deps): dep = self.get_template_path(d) if dep: deps[i] = dep else: LOGGER.error("Cannot find template {0} referenced in {1}", d, filename) return deps
def get_deps(filename): text = util.read_file(filename) lex = lexer.Lexer(text=text, filename=filename) lex.parse() deps = [] for n in lex.template.nodes: if getattr(n, 'keyword', None) == "inherit": deps.append(n.attributes['file']) # TODO: include tags are not handled return deps
def get_template_reference(template): lex = lexer.Lexer(template) node = lex.parse() # Dummy compiler. _Identifiers class requires one # but only interested in the reserved_names field compiler = lambda: None compiler.reserved_names = set() identifiers = codegen._Identifiers(compiler, node) return list(identifiers.undeclared)
def get_deps(self, filename): """Get dependencies for a template (internal function).""" text = util.read_file(filename) lex = lexer.Lexer(text=text, filename=filename) lex.parse() deps = [] for n in lex.template.nodes: keyword = getattr(n, 'keyword', None) if keyword in ["inherit", "namespace"] or isinstance(n, parsetree.IncludeTag): deps.append(n.attributes['file']) return deps
def get_deps(self, filename): """Get dependencies for a template (internal function).""" text = util.read_file(filename) lex = lexer.Lexer(text=text, filename=filename) lex.parse() deps = [] for n in lex.template.nodes: keyword = getattr(n, 'keyword', None) if keyword in ["inherit", "namespace"]: deps.append(n.attributes['file']) # TODO: include tags are not handled return deps
def extract_haml(fileobj, keywords, comment_tags, options): """ babel translation token extract function for haml files """ import haml from mako import lexer, parsetree from mako.ext.babelplugin import extract_nodes encoding = options.get('input_encoding', options.get('encoding', None)) template_node = lexer.Lexer(haml.preprocessor(fileobj.read()), input_encoding=encoding).parse() for extracted in extract_nodes(template_node.get_children(), keywords, comment_tags, options): yield extracted
def get_string_deps(self, text, filename=None): """Find dependencies for a template string.""" lex = lexer.Lexer(text=text, filename=filename, input_encoding='utf-8') lex.parse() deps = [] for n in lex.template.nodes: keyword = getattr(n, 'keyword', None) if keyword in ["inherit", "namespace"] or isinstance( n, parsetree.IncludeTag): deps.append(n.attributes['file']) # Some templates will include "foo.tmpl" and we need paths, so normalize them # using the template lookup for i, d in enumerate(deps): deps[i] = self.get_template_path(d) return deps
def extract(fileobj, keywords, comment_tags, options): """Extract messages from plain Mako defs and from Python expressions inside Mako templates. """ encoding = "utf-8" template_node = lexer.Lexer(fileobj.read(), input_encoding=encoding).parse() for extracted in extract_nodes(template_node.get_children(), keywords, comment_tags, options): yield extracted # proceed with the standard Mako extractor for extracted in extract_mako_nodes(template_node.get_children(), keywords, comment_tags, options): yield extracted
def get_template_reference(template): lex = lexer.Lexer(template) try: node = lex.parse() except MakoException as e: logger.warning('pipeline get template[%s] reference error[%s]' % (template, e)) return [] # Dummy compiler. _Identifiers class requires one # but only interested in the reserved_names field def compiler(): return None compiler.reserved_names = set() identifiers = codegen._Identifiers(compiler, node) return list(identifiers.undeclared)
def extract(fileobj, keywords, comment_tags, options): """Extract messages from Mako templates. :param fileobj: the file-like object the messages should be extracted from :param keywords: a list of keywords (i.e. function names) that should be recognized as translation functions :param comment_tags: a list of translator tags to search for and include in the results :param options: a dictionary of additional options (optional) :return: an iterator over ``(lineno, funcname, message, comments)`` tuples :rtype: ``iterator`` """ encoding = options.get('input_encoding', options.get('encoding', None)) template_node = lexer.Lexer(fileobj.read(), input_encoding=encoding).parse() for extracted in extract_nodes(template_node.get_children(), keywords, comment_tags, options): yield extracted
def _mako_template_names(template): """ Return all the used identifiers in the Mako template. From Igonato's code at https://stackoverflow.com/a/23577289/622408. """ from mako import lexer, codegen lexer = lexer.Lexer(template) node = lexer.parse() # ^ The node is the root element for the parse tree. # The tree contains all the data from a template # needed for the code generation process # Dummy compiler. _Identifiers class requires one # but only interested in the reserved_names field compiler = lambda: None compiler.reserved_names = set() identifiers = codegen._Identifiers(compiler, node) return identifiers.undeclared
def process_file(self, fileobj): template_node = lexer.Lexer( fileobj.read(), input_encoding=self.config["encoding"]).parse() for extracted in self.extract_nodes(template_node.get_children()): yield extracted
""" from mako.template import Template bar = Template('Basic template with ${name}.') print('call: bar.render(name=\'...\')') print(bar.render(name='testing epta')) ################################################# # how to find identifiers in bar? from mako import lexer, codegen lexer = lexer.Lexer(bar.source) node = lexer.parse() compiler = lambda: None compiler.reserved_names = set() identifiers = codegen._Identifiers(compiler, node) # All template variables can be found found using this # object but you are probably interested in the # undeclared variables: print('\nIdentifiers in bar template:') print(identifiers.undeclared)