eric: comparison DebugClients/Python3/coverage/templite.py

-:f1cbc18f88b2
+:fac17a82b431
 """A simple Python template renderer, for a nano-subset of Django syntax."""
 # Coincidentally named the same as http://code.activestate.com/recipes/496702/
-import re, sys
+import re
+from .backward import set                       # pylint: disable=W0622
+class CodeBuilder(object):
+"""Build source code conveniently."""
+def __init__(self, indent=0):
+self.code = []
+self.indent_amount = indent
+def add_line(self, line):
+"""Add a line of source to the code.
+Don't include indentations or newlines.
+"""
+self.code.append(" " * self.indent_amount)
+self.code.append(line)
+self.code.append("\n")
+def add_section(self):
+"""Add a section, a sub-CodeBuilder."""
+sect = CodeBuilder(self.indent_amount)
+self.code.append(sect)
+return sect
+def indent(self):
+"""Increase the current indent for following lines."""
+self.indent_amount += 4
+def dedent(self):
+"""Decrease the current indent for following lines."""
+self.indent_amount -= 4
+def __str__(self):
+return "".join([str(c) for c in self.code])
+def get_function(self, fn_name):
+"""Compile the code, and return the function `fn_name`."""
+assert self.indent_amount == 0
+g = {}
+code_text = str(self)
+exec(code_text, g)
+return g[fn_name]
 class Templite(object):
 """A simple template renderer, for a nano-subset of Django syntax.
 Supported constructs are extended variable access::
 self.text = text
 self.context = {}
 for context in contexts:
 self.context.update(context)
+# We construct a function in source form, then compile it and hold onto
+# it, and execute it to render the template.
+code = CodeBuilder()
+code.add_line("def render(ctx, dot):")
+code.indent()
+vars_code = code.add_section()
+self.all_vars = set()
+self.loop_vars = set()
+code.add_line("result = []")
+code.add_line("a = result.append")
+code.add_line("e = result.extend")
+code.add_line("s = str")
+buffered = []
+def flush_output():
+"""Force `buffered` to the code builder."""
+if len(buffered) == 1:
+code.add_line("a(%s)" % buffered[0])
+elif len(buffered) > 1:
+code.add_line("e([%s])" % ",".join(buffered))
+del buffered[:]
 # Split the text to form a list of tokens.
 toks = re.split(r"(?s)({{.*?}}|{%.*?%}|{#.*?#})", text)
-# Parse the tokens into a nested list of operations.  Each item in the
-# list is a tuple with an opcode, and arguments.  They'll be
-# interpreted by TempliteEngine.
-#
-# When parsing an action tag with nested content (if, for), the current
-# ops list is pushed onto ops_stack, and the parsing continues in a new
-# ops list that is part of the arguments to the if or for op.
-ops = []
 ops_stack = []
 for tok in toks:
 if tok.startswith('{{'):
-# Expression: ('exp', expr)
+# An expression to evaluate.
-ops.append(('exp', tok[2:-2].strip()))
+buffered.append("s(%s)" % self.expr_code(tok[2:-2].strip()))
 elif tok.startswith('{#'):
 # Comment: ignore it and move on.
 continue
 elif tok.startswith('{%'):
 # Action tag: split into words and parse further.
+flush_output()
 words = tok[2:-2].strip().split()
 if words[0] == 'if':
-# If: ('if', (expr, body_ops))
+# An if statement: evaluate the expression to determine if.
-if_ops = []
 assert len(words) == 2
-ops.append(('if', (words[1], if_ops)))
+ops_stack.append('if')
-ops_stack.append(ops)
+code.add_line("if %s:" % self.expr_code(words[1]))
-ops = if_ops
+code.indent()
 elif words[0] == 'for':
-# For: ('for', (varname, listexpr, body_ops))
+# A loop: iterate over expression result.
 assert len(words) == 4 and words[2] == 'in'
-for_ops = []
+ops_stack.append('for')
-ops.append(('for', (words[1], words[3], for_ops)))
+self.loop_vars.add(words[1])
-ops_stack.append(ops)
+code.add_line(
-ops = for_ops
+"for c_%s in %s:" % (
+words[1],
+self.expr_code(words[3])
+)
+)
+code.indent()
 elif words[0].startswith('end'):
 # Endsomething.  Pop the ops stack
-ops = ops_stack.pop()
+end_what = words[0][3:]
-assert ops[-1][0] == words[0][3:]
+if ops_stack[-1] != end_what:
+raise SyntaxError("Mismatched end tag: %r" % end_what)
+ops_stack.pop()
+code.dedent()
 else:
-raise SyntaxError("Don't understand tag %r" % words)
+raise SyntaxError("Don't understand tag: %r" % words[0])
 else:
-ops.append(('lit', tok))
+# Literal content.  If it isn't empty, output it.
+if tok:
-assert not ops_stack, "Unmatched action tag: %r" % ops_stack[-1][0]
+buffered.append("%r" % tok)
-self.ops = ops
+flush_output()
+for var_name in self.all_vars - self.loop_vars:
+vars_code.add_line("c_%s = ctx[%r]" % (var_name, var_name))
+if ops_stack:
+raise SyntaxError("Unmatched action tag: %r" % ops_stack[-1])
+code.add_line("return ''.join(result)")
+code.dedent()
+self.render_function = code.get_function('render')
+def expr_code(self, expr):
+"""Generate a Python expression for `expr`."""
+if "|" in expr:
+pipes = expr.split("|")
+code = self.expr_code(pipes[0])
+for func in pipes[1:]:
+self.all_vars.add(func)
+code = "c_%s(%s)" % (func, code)
+elif "." in expr:
+dots = expr.split(".")
+code = self.expr_code(dots[0])
+args = [repr(d) for d in dots[1:]]
+code = "dot(%s, %s)" % (code, ", ".join(args))
+else:
+self.all_vars.add(expr)
+code = "c_%s" % expr
+return code
 def render(self, context=None):
 """Render this template by applying it to `context`.
 `context` is a dictionary of values to use in this rendering.
 """
 # Make the complete context we'll use.
 ctx = dict(self.context)
 if context:
 ctx.update(context)
+return self.render_function(ctx, self.do_dots)
-# Run it through an engine, and return the result.
-engine = _TempliteEngine(ctx)
+def do_dots(self, value, *dots):
-engine.execute(self.ops)
+"""Evaluate dotted expressions at runtime."""
-return engine.result
+for dot in dots:
+try:
+value = getattr(value, dot)
-class _TempliteEngine(object):
+except AttributeError:
-"""Executes Templite objects to produce strings."""
+value = value[dot]
-def __init__(self, context):
+if hasattr(value, '__call__'):
-self.context = context
+value = value()
-self.result = ""
-def execute(self, ops):
-"""Execute `ops` in the engine.
-Called recursively for the bodies of if's and loops.
-"""
-for op, args in ops:
-if op == 'lit':
-self.result += args
-elif op == 'exp':
-try:
-self.result += str(self.evaluate(args))
-except:
-exc_class, exc, _ = sys.exc_info()
-new_exc = exc_class("Couldn't evaluate {{ %s }}: %s"
-% (args, exc))
-raise new_exc
-elif op == 'if':
-expr, body = args
-if self.evaluate(expr):
-self.execute(body)
-elif op == 'for':
-var, lis, body = args
-vals = self.evaluate(lis)
-for val in vals:
-self.context[var] = val
-self.execute(body)
-else:
-raise AssertionError("TempliteEngine doesn't grok op %r" % op)
-def evaluate(self, expr):
-"""Evaluate an expression.
-`expr` can have pipes and dots to indicate data access and filtering.
-"""
-if "|" in expr:
-pipes = expr.split("|")
-value = self.evaluate(pipes[0])
-for func in pipes[1:]:
-value = self.evaluate(func)(value)
-elif "." in expr:
-dots = expr.split('.')
-value = self.evaluate(dots[0])
-for dot in dots[1:]:
-try:
-value = getattr(value, dot)
-except AttributeError:
-value = value[dot]
-if hasattr(value, '__call__'):
-value = value()
-else:
-value = self.context[expr]
 return value

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python3/coverage/templite.py

DebugClients/Python3/coverage/templite.py