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

-:9513afbd57f1
+:744cd0b4b8cd
 """A simple Python template renderer, for a nano-subset of Django syntax."""
-# Started from http://blog.ianbicking.org/templating-via-dict-wrappers.html
+# Coincidentally named the same as http://code.activestate.com/recipes/496702/
-# and http://jtauber.com/2006/05/templates.html
-# and http://code.activestate.com/recipes/496730/
-import re
+import re, sys
 class Templite(object):
 """A simple template renderer, for a nano-subset of Django syntax.
 Supported constructs are extended variable access::
 {{var.modifer.modifier|filter|filter}}
-and loops::
+loops::
 {% for var in list %}...{% endfor %}
+and ifs::
+{% if var %}...{% endif %}
+Comments are within curly-hash markers::
+{# This will be ignored #}
 Construct a Templite with the template text, then use `render` against a
 dictionary context to create a finished string.
 """
 def __init__(self, text, *contexts):
 """Construct a Templite with the given `text`.
 `contexts` are dictionaries of values to use for future renderings.
 These are good for filters and global values.
 """
-self.loops = []
+self.text = text
-self.text = self._prepare(text)
 self.context = {}
 for context in contexts:
 self.context.update(context)
+# 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)
+ops.append(('exp', 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.
+words = tok[2:-2].strip().split()
+if words[0] == 'if':
+# If: ('if', (expr, body_ops))
+if_ops = []
+assert len(words) == 2
+ops.append(('if', (words[1], if_ops)))
+ops_stack.append(ops)
+ops = if_ops
+elif words[0] == 'for':
+# For: ('for', (varname, listexpr, body_ops))
+assert len(words) == 4 and words[2] == 'in'
+for_ops = []
+ops.append(('for', (words[1], words[3], for_ops)))
+ops_stack.append(ops)
+ops = for_ops
+elif words[0].startswith('end'):
+# Endsomething.  Pop the ops stack
+ops = ops_stack.pop()
+assert ops[-1][0] == words[0][3:]
+else:
+raise SyntaxError("Don't understand tag %r" % words)
+else:
+ops.append(('lit', tok))
+assert not ops_stack, "Unmatched action tag: %r" % ops_stack[-1][0]
+self.ops = ops
 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)
-ctxaccess = _ContextAccess(ctx)
-# Render the loops.
-for iloop, (loopvar, listvar, loopbody) in enumerate(self.loops):
-result = ""
-for listval in ctxaccess[listvar]:
-ctx[loopvar] = listval
-result += loopbody % ctxaccess
-ctx["loop:%d" % iloop] = result
-# Render the final template.
-return self.text % ctxaccess
-def _prepare(self, text):
+# Run it through an engine, and return the result.
-"""Convert Django-style data references into Python-native ones."""
+engine = _TempliteEngine(ctx)
-# Pull out loops.
+engine.execute(self.ops)
-text = re.sub(
+return engine.result
-r"(?s){% for ([a-z0-9_]+) in ([a-z0-9_.|]+) %}(.*?){% endfor %}",
-self._loop_prepare, text
-)
-# Protect actual percent signs in the text.
-text = text.replace("%", "%%")
-# Convert {{foo}} into %(foo)s
-text = re.sub(r"{{([^}]+)}}", r"%(\1)s", text)
-return text
-def _loop_prepare(self, match):
-"""Prepare a loop body for `_prepare`."""
-nloop = len(self.loops)
-# Append (loopvar, listvar, loopbody) to self.loops
-loopvar, listvar, loopbody = match.groups()
-loopbody = self._prepare(loopbody)
-self.loops.append((loopvar, listvar, loopbody))
-return "{{loop:%d}}" % nloop
-class _ContextAccess(object):
+class _TempliteEngine(object):
-"""A mediator for a context.
+"""Executes Templite objects to produce strings."""
-Implements __getitem__ on a context for Templite, so that string formatting
-references can pull data from the context.
-"""
 def __init__(self, context):
 self.context = context
+self.result = ""
-def __getitem__(self, key):
+def execute(self, ops):
-if "|" in key:
+"""Execute `ops` in the engine.
-pipes = key.split("|")
-value = self[pipes[0]]
+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[func](value)
+value = self.evaluate(func)(value)
-elif "." in key:
+elif "." in expr:
-dots = key.split('.')
+dots = expr.split('.')
-value = self[dots[0]]
+value = self.evaluate(dots[0])
 for dot in dots[1:]:
 try:
 value = getattr(value, dot)
 except AttributeError:
 value = value[dot]
-if callable(value):
+if hasattr(value, '__call__'):
 value = value()
 else:
-value = self.context[key]
+value = self.context[expr]
 return value

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/coverage/templite.py

DebugClients/Python/coverage/templite.py