Home | History | Annotate | Download | only in coverage 
      1 """A simple Python template renderer, for a nano-subset of Django syntax."""
      2 
      3 # Coincidentally named the same as http://code.activestate.com/recipes/496702/
      4 
      5 import re, sys
      6 
      7 class Templite(object):
      8     """A simple template renderer, for a nano-subset of Django syntax.
      9 
     10     Supported constructs are extended variable access::
     11 
     12         {{var.modifer.modifier|filter|filter}}
     13 
     14     loops::
     15 
     16         {% for var in list %}...{% endfor %}
     17 
     18     and ifs::
     19 
     20         {% if var %}...{% endif %}
     21 
     22     Comments are within curly-hash markers::
     23 
     24         {# This will be ignored #}
     25 
     26     Construct a Templite with the template text, then use `render` against a
     27     dictionary context to create a finished string.
     28 
     29     """
     30     def __init__(self, text, *contexts):
     31         """Construct a Templite with the given `text`.
     32 
     33         `contexts` are dictionaries of values to use for future renderings.
     34         These are good for filters and global values.
     35 
     36         """
     37         self.text = text
     38         self.context = {}
     39         for context in contexts:
     40             self.context.update(context)
     41 
     42         # Split the text to form a list of tokens.
     43         toks = re.split(r"(?s)({{.*?}}|{%.*?%}|{#.*?#})", text)
     44 
     45         # Parse the tokens into a nested list of operations.  Each item in the
     46         # list is a tuple with an opcode, and arguments.  They'll be
     47         # interpreted by TempliteEngine.
     48         #
     49         # When parsing an action tag with nested content (if, for), the current
     50         # ops list is pushed onto ops_stack, and the parsing continues in a new
     51         # ops list that is part of the arguments to the if or for op.
     52         ops = []
     53         ops_stack = []
     54         for tok in toks:
     55             if tok.startswith('{{'):
     56                 # Expression: ('exp', expr)
     57                 ops.append(('exp', tok[2:-2].strip()))
     58             elif tok.startswith('{#'):
     59                 # Comment: ignore it and move on.
     60                 continue
     61             elif tok.startswith('{%'):
     62                 # Action tag: split into words and parse further.
     63                 words = tok[2:-2].strip().split()
     64                 if words[0] == 'if':
     65                     # If: ('if', (expr, body_ops))
     66                     if_ops = []
     67                     assert len(words) == 2
     68                     ops.append(('if', (words[1], if_ops)))
     69                     ops_stack.append(ops)
     70                     ops = if_ops
     71                 elif words[0] == 'for':
     72                     # For: ('for', (varname, listexpr, body_ops))
     73                     assert len(words) == 4 and words[2] == 'in'
     74                     for_ops = []
     75                     ops.append(('for', (words[1], words[3], for_ops)))
     76                     ops_stack.append(ops)
     77                     ops = for_ops
     78                 elif words[0].startswith('end'):
     79                     # Endsomething.  Pop the ops stack
     80                     ops = ops_stack.pop()
     81                     assert ops[-1][0] == words[0][3:]
     82                 else:
     83                     raise SyntaxError("Don't understand tag %r" % words)
     84             else:
     85                 ops.append(('lit', tok))
     86 
     87         assert not ops_stack, "Unmatched action tag: %r" % ops_stack[-1][0]
     88         self.ops = ops
     89 
     90     def render(self, context=None):
     91         """Render this template by applying it to `context`.
     92 
     93         `context` is a dictionary of values to use in this rendering.
     94 
     95         """
     96         # Make the complete context we'll use.
     97         ctx = dict(self.context)
     98         if context:
     99             ctx.update(context)
    100 
    101         # Run it through an engine, and return the result.
    102         engine = _TempliteEngine(ctx)
    103         engine.execute(self.ops)
    104         return "".join(engine.result)
    105 
    106 
    107 class _TempliteEngine(object):
    108     """Executes Templite objects to produce strings."""
    109     def __init__(self, context):
    110         self.context = context
    111         self.result = []
    112 
    113     def execute(self, ops):
    114         """Execute `ops` in the engine.
    115 
    116         Called recursively for the bodies of if's and loops.
    117 
    118         """
    119         for op, args in ops:
    120             if op == 'lit':
    121                 self.result.append(args)
    122             elif op == 'exp':
    123                 try:
    124                     self.result.append(str(self.evaluate(args)))
    125                 except:
    126                     exc_class, exc, _ = sys.exc_info()
    127                     new_exc = exc_class("Couldn't evaluate {{ %s }}: %s"
    128                                         % (args, exc))
    129                     raise new_exc
    130             elif op == 'if':
    131                 expr, body = args
    132                 if self.evaluate(expr):
    133                     self.execute(body)
    134             elif op == 'for':
    135                 var, lis, body = args
    136                 vals = self.evaluate(lis)
    137                 for val in vals:
    138                     self.context[var] = val
    139                     self.execute(body)
    140             else:
    141                 raise AssertionError("TempliteEngine doesn't grok op %r" % op)
    142 
    143     def evaluate(self, expr):
    144         """Evaluate an expression.
    145 
    146         `expr` can have pipes and dots to indicate data access and filtering.
    147 
    148         """
    149         if "|" in expr:
    150             pipes = expr.split("|")
    151             value = self.evaluate(pipes[0])
    152             for func in pipes[1:]:
    153                 value = self.evaluate(func)(value)
    154         elif "." in expr:
    155             dots = expr.split('.')
    156             value = self.evaluate(dots[0])
    157             for dot in dots[1:]:
    158                 try:
    159                     value = getattr(value, dot)
    160                 except AttributeError:
    161                     value = value[dot]
    162                 if hasattr(value, '__call__'):
    163                     value = value()
    164         else:
    165             value = self.context[expr]
    166         return value
    167