Python parser.Parser类代码示例

def render_str(src, **kw):
    from jinja2.environment import Environment
    env = Environment()
    parsed = Parser(env, src)
    gen = JsGenerator(env, '<internal>', '<internal>')
    gen.visit(parsed.parse())

    return render(source=gen.stream.getvalue(), **kw)

    def compile_expression(self, source, undefined_to_none = True):
        parser = Parser(self, source, state='variable')
        exc_info = None
        try:
            expr = parser.parse_expression()
            if not parser.stream.eos:
                raise TemplateSyntaxError('chunk after expression', parser.stream.current.lineno, None, None)
            expr.set_environment(self)
        except TemplateSyntaxError:
            exc_info = sys.exc_info()

        if exc_info is not None:
            self.handle_exception(exc_info, source_hint=source)
        body = [nodes.Assign(nodes.Name('result', 'store'), expr, lineno=1)]
        template = self.from_string(nodes.Template(body, lineno=1))
        return TemplateExpression(template, undefined_to_none)

    def compile_expression(self, source, undefined_to_none=True):
        """A handy helper method that returns a callable that accepts keyword
        arguments that appear as variables in the expression.  If called it
        returns the result of the expression.

        This is useful if applications want to use the same rules as Jinja
        in template "configuration files" or similar situations.

        Example usage:

        >>> env = Environment()
        >>> expr = env.compile_expression('foo == 42')
        >>> expr(foo=23)
        False
        >>> expr(foo=42)
        True

        Per default the return value is converted to `None` if the
        expression returns an undefined value.  This can be changed
        by setting `undefined_to_none` to `False`.

        >>> env.compile_expression('var')() is None
        True
        >>> env.compile_expression('var', undefined_to_none=False)()
        Undefined

        .. versionadded:: 2.1
        """
        parser = Parser(self, source, state='variable')
        exc_info = None
        try:
            expr = parser.parse_expression()
            if not parser.stream.eos:
                raise TemplateSyntaxError('chunk after expression',
                                          parser.stream.current.lineno,
                                          None, None)
            expr.set_environment(self)
        except TemplateSyntaxError:
            exc_info = sys.exc_info()
        if exc_info is not None:
            self.handle_exception(exc_info, source_hint=source)
        body = [nodes.Assign(nodes.Name('result', 'store'), expr, lineno=1)]
        template = self.from_string(nodes.Template(body, lineno=1))
        return TemplateExpression(template, undefined_to_none)

def dump_tpl(**ctx):
    """
    Here I`m compiling template into js code
    and dumping it to browser.

    Template selected by function "splash" which is 
    view function for "/".

    This handler called every time, somebody GETs /?js
    """
    from jinja2.parser import Parser
    from jscrap.generator import JsGenerator

    ret = []
    for tpl in env.loader.list_templates():
        source,_,_ = env.loader.get_source(env, tpl)
        code = Parser(env, source)
        gen = JsGenerator(env, tpl, tpl)
        gen.visit(code.parse())
        ret.append(gen.stream.getvalue())

    return ret, 'text/plain'

    def compile_expression(self, source, undefined_to_none=True):
        """A handy helper method that returns a callable that accepts keyword
        arguments that appear as variables in the expression.  If called it
        returns the result of the expression.

        This is useful if applications want to use the same rules as Jinja
        in template "configuration files" or similar situations.

        Example usage:

        >>> env = Environment()
        >>> expr = env.compile_expression('foo == 42')
        >>> expr(foo=23)
        False
        >>> expr(foo=42)
        True

        Per default the return value is converted to `None` if the
        expression returns an undefined value.  This can be changed
        by setting `undefined_to_none` to `False`.

        >>> env.compile_expression('var')() is None
        True
        >>> env.compile_expression('var', undefined_to_none=False)()
        Undefined

        **new in Jinja 2.1**
        """
        parser = Parser(self, source, state='variable')
        try:
            expr = parser.parse_expression()
            if not parser.stream.eos:
                raise TemplateSyntaxError('chunk after expression',
                                          parser.stream.current.lineno,
                                          None, None)
        except TemplateSyntaxError, e:
            e.source = source
            raise e

from jinja2.lexer import Lexer, compile_rules
from jinja2.environment import Environment
from jinja2.parser import Parser
from jinja2 import nodes
import re


env = Environment()
le = Lexer(env)
source = r'''{% for user in users %}\n<html>\n    Hello {{ user }}\n</html>\n{% endfor %}'''
pas = Parser(env, source)
token = le.tokenize(source)

for x in token:
    print((x.lineno, x.type, x.value))
m = pas.subparse()
print(m)

result = nodes.Template(m, lineno=1)
print(result)

rex = r'(?P<raw_begin>(?:\{\%\+?)\s*raw\s*(?:\%\}\+?))'
s = '{% raw %}'
rec = re.compile(rex)
m = rec.match(s)
print(m.groupdict())

rule = compile_rules(env)
print(rule)

from jinja2 import _stringdefs

 def js_compile(self, source, name):
     code = Parser(self.env, source)
     gen = JsGenerator(self.env, name, name)
     gen.visit(code.parse())
     return gen.stream.getvalue()

 def jinja_compile(source, name, generator):
     code = Parser(env, source)
     gen = generator(env, name, name)
     gen.visit(code.parse())
     return gen.stream.getvalue()