| """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 | |
| from coverage.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:: | |
| {{var.modifer.modifier|filter|filter}} | |
| 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.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) | |
| ops_stack = [] | |
| for tok in toks: | |
| if tok.startswith('{{'): | |
| # An expression to evaluate. | |
| 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': | |
| # An if statement: evaluate the expression to determine if. | |
| assert len(words) == 2 | |
| ops_stack.append('if') | |
| code.add_line("if %s:" % self.expr_code(words[1])) | |
| code.indent() | |
| elif words[0] == 'for': | |
| # A loop: iterate over expression result. | |
| assert len(words) == 4 and words[2] == 'in' | |
| ops_stack.append('for') | |
| self.loop_vars.add(words[1]) | |
| code.add_line( | |
| "for c_%s in %s:" % ( | |
| words[1], | |
| self.expr_code(words[3]) | |
| ) | |
| ) | |
| code.indent() | |
| elif words[0].startswith('end'): | |
| # Endsomething. Pop the ops stack | |
| end_what = 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[0]) | |
| else: | |
| # Literal content. If it isn't empty, output it. | |
| if tok: | |
| buffered.append("%r" % tok) | |
| 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) | |
| def do_dots(self, value, *dots): | |
| """Evaluate dotted expressions at runtime.""" | |
| for dot in dots: | |
| try: | |
| value = getattr(value, dot) | |
| except AttributeError: | |
| value = value[dot] | |
| if hasattr(value, '__call__'): | |
| value = value() | |
| return value |