cmlenz@1: # -*- coding: utf-8 -*-
cmlenz@1: #
cmlenz@1: # Copyright (C) 2006 Christopher Lenz
cmlenz@1: # All rights reserved.
cmlenz@1: #
cmlenz@1: # This software is licensed as described in the file COPYING, which
cmlenz@1: # you should have received as part of this distribution. The terms
cmlenz@1: # are also available at http://trac.edgewall.com/license.html.
cmlenz@1: #
cmlenz@1: # This software consists of voluntary contributions made by many
cmlenz@1: # individuals. For the exact contribution history, see the revision
cmlenz@1: # history and logs, available at http://projects.edgewall.com/trac/.
cmlenz@1: 
cmlenz@1: import __builtin__
cmlenz@1: import compiler
cmlenz@1: import operator
cmlenz@1: 
cmlenz@1: from markup.core import Stream
cmlenz@1: 
cmlenz@1: __all__ = ['Expression']
cmlenz@1: 
cmlenz@1: 
cmlenz@1: class Expression(object):
cmlenz@1:     """Evaluates Python expressions used in templates.
cmlenz@1: 
cmlenz@1:     >>> data = dict(test='Foo', items=[1, 2, 3], dict={'some': 'thing'})
cmlenz@1:     >>> Expression('test').evaluate(data)
cmlenz@1:     'Foo'
cmlenz@1:     >>> Expression('items[0]').evaluate(data)
cmlenz@1:     1
cmlenz@1:     >>> Expression('items[-1]').evaluate(data)
cmlenz@1:     3
cmlenz@1:     >>> Expression('dict["some"]').evaluate(data)
cmlenz@1:     'thing'
cmlenz@1:     
cmlenz@1:     Similar to e.g. Javascript, expressions in templates can use the dot
cmlenz@1:     notation for attribute access to access items in mappings:
cmlenz@1:     
cmlenz@1:     >>> Expression('dict.some').evaluate(data)
cmlenz@1:     'thing'
cmlenz@1:     
cmlenz@1:     This also works the other way around: item access can be used to access
cmlenz@1:     any object attribute (meaning there's no use for `getattr()` in templates):
cmlenz@1:     
cmlenz@1:     >>> class MyClass(object):
cmlenz@1:     ...     myattr = 'Bar'
cmlenz@1:     >>> data = dict(mine=MyClass(), key='myattr')
cmlenz@1:     >>> Expression('mine.myattr').evaluate(data)
cmlenz@1:     'Bar'
cmlenz@1:     >>> Expression('mine["myattr"]').evaluate(data)
cmlenz@1:     'Bar'
cmlenz@1:     >>> Expression('mine[key]').evaluate(data)
cmlenz@1:     'Bar'
cmlenz@1:     
cmlenz@1:     Most of the standard Python operators are also available to template
cmlenz@1:     expressions. Bitwise operators (including inversion and shifting) are not
cmlenz@1:     supported.
cmlenz@1:     
cmlenz@1:     >>> Expression('1 + 1').evaluate(data)
cmlenz@1:     2
cmlenz@1:     >>> Expression('3 - 1').evaluate(data)
cmlenz@1:     2
cmlenz@1:     >>> Expression('1 * 2').evaluate(data)
cmlenz@1:     2
cmlenz@1:     >>> Expression('4 / 2').evaluate(data)
cmlenz@1:     2
cmlenz@1:     >>> Expression('4 // 3').evaluate(data)
cmlenz@1:     1
cmlenz@1:     >>> Expression('4 % 3').evaluate(data)
cmlenz@1:     1
cmlenz@1:     >>> Expression('2 ** 3').evaluate(data)
cmlenz@1:     8
cmlenz@1:     >>> Expression('not True').evaluate(data)
cmlenz@1:     False
cmlenz@1:     >>> Expression('True and False').evaluate(data)
cmlenz@1:     False
cmlenz@1:     >>> Expression('True or False').evaluate(data)
cmlenz@1:     True
cmlenz@1:     >>> Expression('1 == 3').evaluate(data)
cmlenz@1:     False
cmlenz@1:     >>> Expression('1 != 3 == 3').evaluate(data)
cmlenz@1:     True
cmlenz@7:     >>> Expression('1 > 0').evaluate(data)
cmlenz@7:     True
cmlenz@7:     >>> Expression('True and "Foo"').evaluate(data)
cmlenz@7:     'Foo'
cmlenz@7:     >>> data = dict(items=[1, 2, 3])
cmlenz@7:     >>> Expression('2 in items').evaluate(data)
cmlenz@7:     True
cmlenz@7:     >>> Expression('not 2 in items').evaluate(data)
cmlenz@7:     False
cmlenz@1:     
cmlenz@1:     Built-in functions such as `len()` are also available in template
cmlenz@1:     expressions:
cmlenz@1:     
cmlenz@1:     >>> data = dict(items=[1, 2, 3])
cmlenz@1:     >>> Expression('len(items)').evaluate(data)
cmlenz@1:     3
cmlenz@1:     """
cmlenz@1:     __slots__ = ['source', 'ast']
cmlenz@1:     __visitors = {}
cmlenz@1: 
cmlenz@1:     def __init__(self, source):
cmlenz@1:         self.source = source
cmlenz@1:         self.ast = None
cmlenz@1: 
cmlenz@1:     def evaluate(self, data, default=None):
cmlenz@1:         if not self.ast:
cmlenz@1:             self.ast = compiler.parse(self.source, 'eval')
cmlenz@1:         retval = self._visit(self.ast.node, data)
cmlenz@1:         if retval is not None:
cmlenz@1:             return retval
cmlenz@1:         return default
cmlenz@1: 
cmlenz@1:     def __repr__(self):
cmlenz@1:         return '<Expression "%s">' % self.source
cmlenz@1: 
cmlenz@1:     # AST traversal
cmlenz@1: 
cmlenz@1:     def _visit(self, node, data):
cmlenz@1:         v = self.__visitors.get(node.__class__)
cmlenz@1:         if not v:
cmlenz@1:             v = getattr(self, '_visit_%s' % node.__class__.__name__.lower())
cmlenz@1:             self.__visitors[node.__class__] = v
cmlenz@1:         return v(node, data)
cmlenz@1: 
cmlenz@1:     def _visit_expression(self, node, data):
cmlenz@1:         for child in node.getChildNodes():
cmlenz@1:             return self._visit(child, data)
cmlenz@1: 
cmlenz@1:     # Functions & Accessors
cmlenz@1: 
cmlenz@1:     def _visit_callfunc(self, node, data):
cmlenz@1:         func = self._visit(node.node, data)
cmlenz@1:         if func is None:
cmlenz@1:             return None
cmlenz@1:         args = [self._visit(arg, data) for arg in node.args
cmlenz@1:                 if not isinstance(arg, compiler.ast.Keyword)]
cmlenz@1:         kwargs = dict([(arg.name, self._visit(arg.expr, data)) for arg
cmlenz@1:                        in node.args if isinstance(arg, compiler.ast.Keyword)])
cmlenz@1:         return func(*args, **kwargs)
cmlenz@1: 
cmlenz@1:     def _visit_getattr(self, node, data):
cmlenz@1:         obj = self._visit(node.expr, data)
cmlenz@1:         try:
cmlenz@1:             return getattr(obj, node.attrname)
cmlenz@1:         except AttributeError, e:
cmlenz@1:             try:
cmlenz@1:                 return obj[node.attrname]
cmlenz@1:             except (KeyError, TypeError):
cmlenz@1:                 return None
cmlenz@1: 
cmlenz@1:     def _visit_slice(self, node, data):
cmlenz@1:         obj = self._visit(node.expr, data)
cmlenz@1:         lower = node.lower and self._visit(node.lower, data) or None
cmlenz@1:         upper = node.upper and self._visit(node.upper, data) or None
cmlenz@1:         return obj[lower:upper]
cmlenz@1: 
cmlenz@1:     def _visit_subscript(self, node, data):
cmlenz@1:         obj = self._visit(node.expr, data)
cmlenz@1:         subs = map(lambda sub: self._visit(sub, data), node.subs)
cmlenz@1:         if len(subs) == 1:
cmlenz@1:             subs = subs[0]
cmlenz@1:         try:
cmlenz@1:             return obj[subs]
cmlenz@1:         except (KeyError, IndexError, TypeError):
cmlenz@1:             try:
cmlenz@1:                 return getattr(obj, subs)
cmlenz@1:             except (AttributeError, TypeError):
cmlenz@1:                 return None
cmlenz@1: 
cmlenz@1:     # Operators
cmlenz@1: 
cmlenz@1:     def _visit_and(self, node, data):
cmlenz@7:         return reduce(lambda x, y: x and y,
cmlenz@7:                       [self._visit(n, data) for n in node.nodes])
cmlenz@1: 
cmlenz@1:     def _visit_or(self, node, data):
cmlenz@7:         return reduce(lambda x, y: x or y,
cmlenz@7:                       [self._visit(n, data) for n in node.nodes])
cmlenz@1: 
cmlenz@1:     _OP_MAP = {'==': operator.eq, '!=': operator.ne,
cmlenz@1:                '<':  operator.lt, '<=': operator.le,
cmlenz@1:                '>':  operator.gt, '>=': operator.ge,
cmlenz@7:                'in': lambda x, y: operator.contains(y, x),
cmlenz@7:                'not in': lambda x, y: not operator.contains(y, x)}
cmlenz@1:     def _visit_compare(self, node, data):
cmlenz@1:         result = self._visit(node.expr, data)
cmlenz@1:         ops = node.ops[:]
cmlenz@1:         ops.reverse()
cmlenz@1:         for op, rval in ops:
cmlenz@1:             result = self._OP_MAP[op](result, self._visit(rval, data))
cmlenz@1:         return result
cmlenz@1: 
cmlenz@1:     def _visit_add(self, node, data):
cmlenz@1:         return self._visit(node.left, data) + self._visit(node.right, data)
cmlenz@1: 
cmlenz@1:     def _visit_div(self, node, data):
cmlenz@1:         return self._visit(node.left, data) / self._visit(node.right, data)
cmlenz@1: 
cmlenz@1:     def _visit_floordiv(self, node, data):
cmlenz@1:         return self._visit(node.left, data) // self._visit(node.right, data)
cmlenz@1: 
cmlenz@1:     def _visit_mod(self, node, data):
cmlenz@1:         return self._visit(node.left, data) % self._visit(node.right, data)
cmlenz@1: 
cmlenz@1:     def _visit_mul(self, node, data):
cmlenz@1:         return self._visit(node.left, data) * self._visit(node.right, data)
cmlenz@1: 
cmlenz@1:     def _visit_power(self, node, data):
cmlenz@1:         return self._visit(node.left, data) ** self._visit(node.right, data)
cmlenz@1: 
cmlenz@1:     def _visit_sub(self, node, data):
cmlenz@1:         return self._visit(node.left, data) - self._visit(node.right, data)
cmlenz@1: 
cmlenz@1:     def _visit_not(self, node, data):
cmlenz@1:         return not self._visit(node.expr, data)
cmlenz@1: 
cmlenz@1:     def _visit_unaryadd(self, node, data):
cmlenz@1:         return +self._visit(node.expr, data)
cmlenz@1: 
cmlenz@1:     def _visit_unarysub(self, node, data):
cmlenz@1:         return -self._visit(node.expr, data)
cmlenz@1: 
cmlenz@1:     # Identifiers & Literals
cmlenz@1: 
cmlenz@1:     def _visit_name(self, node, data):
cmlenz@1:         val = data.get(node.name)
cmlenz@1:         if val is None:
cmlenz@1:             val = getattr(__builtin__, node.name, None)
cmlenz@1:         return val
cmlenz@1: 
cmlenz@1:     def _visit_const(self, node, data):
cmlenz@1:         return node.value
cmlenz@1: 
cmlenz@1:     def _visit_dict(self, node, data):
cmlenz@1:         return dict([(self._visit(k, data), self._visit(v, data))
cmlenz@1:                      for k, v in node.items])
cmlenz@1: 
cmlenz@1:     def _visit_tuple(self, node, data):
cmlenz@1:         return tuple([self._visit(n, data) for n in node.nodes])
cmlenz@1: 
cmlenz@1:     def _visit_list(self, node, data):
cmlenz@1:         return [self._visit(n, data) for n in node.nodes]