Edgewall Software

Ticket #84: python_pi.2.diff

File python_pi.2.diff, 18.1 KB (added by cmlenz, 17 years ago)

Updated patch, supports more Python statements

  • genshi/template/core.py

     
    107107    def __repr__(self):
    108108        return repr(list(self.frames))
    109109
     110    def __contains__(self, key):
     111        """Return whether a variable exists in any of the scopes."""
     112        return self._find(key)[1] is not None
     113
     114    def __getitem__(self, key):
     115        """Get a variables's value, starting at the current scope and going
     116        upward.
     117       
     118        Raises `KeyError` if the requested variable wasn't found in any scope.
     119        """
     120        value, frame = self._find(key)
     121        if frame is None:
     122            raise KeyError(key)
     123        return value
     124
    110125    def __setitem__(self, key, value):
    111126        """Set a variable in the current scope."""
    112127        self.frames[0][key] = value
    … …  
    129144            if key in frame:
    130145                return frame[key]
    131146        return default
    132     __getitem__ = get
    133147
    134148    def push(self, data):
    135149        """Push a new scope on the stack."""

  • genshi/template/tests/eval.py

     
    1515import sys
    1616import unittest
    1717
    18 from genshi.template.eval import Expression, Undefined
     18from genshi.template.eval import Expression, Suite, Undefined
    1919
    2020
    2121class ExpressionTestCase(unittest.TestCase):
    … …  
    382382        self.assertRaises(TypeError, expr.evaluate, {'nothing': object()})
    383383
    384384
     385class SuiteTestCase(unittest.TestCase):
     386
     387    def test_assign(self):
     388        suite = Suite("foo = 42")
     389        data = {}
     390        suite.execute(data)
     391        self.assertEqual(42, data['foo'])
     392
     393    def test_def(self):
     394        suite = Suite("def donothing(): pass")
     395        data = {}
     396        suite.execute(data)
     397        assert 'donothing' in data
     398        self.assertEqual(None, data['donothing']())
     399
     400    def test_delete(self):
     401        suite = Suite("""foo = 42
     402del foo
     403""")
     404        data = {}
     405        suite.execute(data)
     406        assert 'foo' not in data
     407
     408    def test_class(self):
     409        suite = Suite("class plain(object): pass")
     410        data = {}
     411        suite.execute(data)
     412        assert 'plain' in data
     413
     414    def test_import(self):
     415        suite = Suite("from itertools import groupby")
     416        data = {}
     417        suite.execute(data)
     418        assert 'groupby' in data
     419
     420    def test_for(self):
     421        suite = Suite("""x = []
     422for i in range(3):
     423    x.append(i**2)
     424""")
     425        data = {}
     426        suite.execute(data)
     427        self.assertEqual([0, 1, 4], data['x'])
     428
     429    def test_if(self):
     430        suite = Suite("""if foo == 42:
     431    x = True
     432""")
     433        data = {'foo': 42}
     434        suite.execute(data)
     435        self.assertEqual(True, data['x'])
     436
     437    def test_raise(self):
     438        suite = Suite("""raise NotImplementedError""")
     439        self.assertRaises(NotImplementedError, suite.execute, {})
     440
     441    def test_try_except(self):
     442        suite = Suite("""try:
     443    import somemod
     444except ImportError:
     445    somemod = None
     446else:
     447    somemod.dosth()""")
     448        data = {}
     449        suite.execute(data)
     450        self.assertEqual(None, data['somemod'])
     451
     452    def test_finally(self):
     453        suite = Suite("""try:
     454    x = 2
     455finally:
     456    x = None
     457""")
     458        data = {}
     459        suite.execute(data)
     460        self.assertEqual(None, data['x'])
     461
     462    def test_while_break(self):
     463        suite = Suite("""x = 0
     464while x < 5:
     465    x += step
     466    if x == 4:
     467        break
     468""")
     469        data = {'step': 2}
     470        suite.execute(data)
     471        self.assertEqual(4, data['x'])
     472
     473
    385474def suite():
    386475    suite = unittest.TestSuite()
    387476    suite.addTest(doctest.DocTestSuite(Expression.__module__))
    388477    suite.addTest(unittest.makeSuite(ExpressionTestCase, 'test'))
     478    suite.addTest(unittest.makeSuite(SuiteTestCase, 'test'))
    389479    return suite
    390480
    391481if __name__ == '__main__':

  • genshi/template/markup.py

     
    1616from itertools import chain
    1717
    1818from genshi.core import Attrs, Namespace, Stream, StreamEventKind
    19 from genshi.core import START, END, START_NS, END_NS, TEXT, COMMENT
     19from genshi.core import START, END, START_NS, END_NS, TEXT, PI, COMMENT
    2020from genshi.input import XMLParser
    2121from genshi.template.core import BadDirectiveError, Template, \
    22                                  _apply_directives, SUB
     22                                 TemplateSyntaxError, _apply_directives, SUB
     23from genshi.template.eval import Suite
    2324from genshi.template.loader import TemplateNotFound
    2425from genshi.template.directives import *
    2526
    … …  
    3536      <li>1</li><li>2</li><li>3</li>
    3637    </ul>
    3738    """
     39    EXEC = StreamEventKind('EXEC')
    3840    INCLUDE = StreamEventKind('INCLUDE')
    3941
    4042    DIRECTIVE_NAMESPACE = Namespace('http://genshi.edgewall.org/')
    … …  
    5961        Template.__init__(self, source, basedir=basedir, filename=filename,
    6062                          loader=loader, encoding=encoding)
    6163
    62         self.filters.append(self._match)
     64        self.filters += [self._exec, self._match]
    6365        if loader:
    6466            self.filters.append(self._include)
    6567
    … …  
    169171                    stream[start_offset:] = [(SUB, (directives, substream),
    170172                                              pos)]
    171173
     174            elif kind is PI and data[0] == 'python':
     175                try:
     176                    suite = Suite(data[1], self.filepath, pos[1])
     177                except SyntaxError, err:
     178                    raise TemplateSyntaxError(err, self.filepath,
     179                                              pos[1] + (err.lineno or 1) - 1,
     180                                              pos[2] + (err.offset or 0))
     181                stream.append((EXEC, suite, pos))
     182
    172183            elif kind is TEXT:
    173184                for kind, data, pos in self._interpolate(data, self.basedir,
    174185                                                         *pos):
    … …  
    190201                data = data[0], list(self._prepare(data[1]))
    191202            yield kind, data, pos
    192203
     204    def _exec(self, stream, ctxt):
     205        """Internal stream filter that executes code in <?python ?> processing
     206        instructions.
     207        """
     208        for event in stream:
     209            if event[0] is EXEC:
     210                event[1].execute(ctxt.frames[0])
     211            else:
     212                yield event
     213
    193214    def _include(self, stream, ctxt):
    194215        """Internal stream filter that performs inclusion of external
    195216        template files.
    … …  
    291312                yield event
    292313
    293314
     315EXEC = MarkupTemplate.EXEC
    294316INCLUDE = MarkupTemplate.INCLUDE

  • genshi/template/eval.py

     
    1515
    1616import __builtin__
    1717from compiler import ast, parse
    18 from compiler.pycodegen import ExpressionCodeGenerator
     18from compiler.pycodegen import ExpressionCodeGenerator, ModuleCodeGenerator
    1919import new
    2020try:
    2121    set
    … …  
    2424
    2525from genshi.util import flatten
    2626
    27 __all__ = ['Expression', 'Undefined']
     27__all__ = ['Expression', 'Suite', 'Undefined']
    2828
    2929
    30 class Expression(object):
     30class Code(object):
     31    """Abstract base class for the `Expression` and `Suite` classes."""
     32    __slots__ = ['source', 'code']
     33
     34    def __init__(self, source, filename=None, lineno=-1):
     35        """Create the code object, either from a string, or from an AST node.
     36       
     37        @param source: either a string containing the source code, or an AST
     38            node
     39        @param filename: the (preferably absolute) name of the file containing
     40            the code
     41        @param lineno: the number of the line on which the code was found
     42        """
     43        if isinstance(source, basestring):
     44            self.source = source
     45            node = _parse(source, mode=self.mode)
     46        else:
     47            assert isinstance(source, ast.Node)
     48            self.source = '?'
     49            if self.mode == 'eval':
     50                node = ast.Expression(source)
     51            else:
     52                node = ast.Module(None, source)
     53
     54        self.code = _compile(node, self.source, mode=self.mode,
     55                             filename=filename, lineno=lineno)
     56
     57    def __eq__(self, other):
     58        return (type(other) == type(self)) and (self.code == other.code)
     59
     60    def __hash__(self):
     61        return hash(self.code)
     62
     63    def __ne__(self, other):
     64        return not self == other
     65
     66    def __repr__(self):
     67        return '%s(%r)' % (self.__class__.__name__, self.source)
     68
     69
     70class Expression(Code):
    3171    """Evaluates Python expressions used in templates.
    3272
    3373    >>> data = dict(test='Foo', items=[1, 2, 3], dict={'some': 'thing'})
    … …  
    68108    >>> Expression('len(items)').evaluate(data)
    69109    3
    70110    """
    71     __slots__ = ['source', 'code']
     111    __slots__ = []
     112    mode = 'eval'
    72113
    73     def __init__(self, source, filename=None, lineno=-1):
    74         """Create the expression, either from a string, or from an AST node.
    75        
    76         @param source: either a string containing the source code of the
    77             expression, or an AST node
    78         @param filename: the (preferably absolute) name of the file containing
    79             the expression
    80         @param lineno: the number of the line on which the expression was found
    81         """
    82         if isinstance(source, basestring):
    83             self.source = source
    84             self.code = _compile(_parse(source), self.source, filename=filename,
    85                                  lineno=lineno)
    86         else:
    87             assert isinstance(source, ast.Node)
    88             self.source = '?'
    89             self.code = _compile(ast.Expression(source), filename=filename,
    90                                  lineno=lineno)
    91 
    92     def __eq__(self, other):
    93         return (type(other) == Expression) and (self.code == other.code)
    94 
    95     def __hash__(self):
    96         return hash(self.code)
    97 
    98     def __ne__(self, other):
    99         return not self == other
    100 
    101     def __repr__(self):
    102         return 'Expression(%r)' % self.source
    103 
    104114    def evaluate(self, data):
    105115        """Evaluate the expression against the given data dictionary.
    106116       
    … …  
    114124                               {'data': data})
    115125
    116126
     127class Suite(Code):
     128    """Executes Python statements used in templates.
     129
     130    >>> data = dict(test='Foo', items=[1, 2, 3], dict={'some': 'thing'})
     131    >>> Suite('foo = dict.some').execute(data)
     132    >>> data['foo']
     133    'thing'
     134    """
     135    __slots__ = []
     136    mode = 'exec'
     137
     138    def execute(self, data):
     139        """Execute the suite in the given data dictionary.
     140       
     141        @param data: a mapping containing the data to execute in
     142        """
     143        exec self.code in {'data': data,
     144                           '_lookup_name': _lookup_name,
     145                           '_lookup_attr': _lookup_attr,
     146                           '_lookup_item': _lookup_item}, data
     147
     148
    117149class Undefined(object):
    118150    """Represents a reference to an undefined variable.
    119151   
    … …  
    176208        source = '\xef\xbb\xbf' + source.encode('utf-8')
    177209    return parse(source, mode)
    178210
    179 def _compile(node, source=None, filename=None, lineno=-1):
    180     tree = ExpressionASTTransformer().visit(node)
     211def _compile(node, source=None, mode='eval', filename=None, lineno=-1):
     212    tree = TemplateASTTransformer().visit(node)
    181213    if isinstance(filename, unicode):
    182214        # unicode file names not allowed for code objects
    183215        filename = filename.encode('utf-8', 'replace')
    … …  
    187219    if lineno <= 0:
    188220        lineno = 1
    189221
    190     gen = ExpressionCodeGenerator(tree)
     222    if mode == 'eval':
     223        gen = ExpressionCodeGenerator(tree)
     224        name = '<Expression %s>' % (repr(source or '?').replace("'", '"'))
     225    else:
     226        gen = ModuleCodeGenerator(tree)
     227        name = '<Suite>'
    191228    gen.optimized = True
    192229    code = gen.getCode()
    193230
    … …  
    195232    # clone the code object while adjusting the line number
    196233    return new.code(0, code.co_nlocals, code.co_stacksize,
    197234                    code.co_flags | 0x0040, code.co_code, code.co_consts,
    198                     code.co_names, code.co_varnames, filename,
    199                     '<Expression %s>' % (repr(source or '?').replace("'", '"')),
    200                     lineno, code.co_lnotab, (), ())
     235                    code.co_names, code.co_varnames, filename, name, lineno,
     236                    code.co_lnotab, (), ())
    201237
    202238BUILTINS = __builtin__.__dict__.copy()
    203239BUILTINS['Undefined'] = Undefined
    … …  
    231267        key = key[0]
    232268    try:
    233269        return obj[key]
    234     except (KeyError, IndexError, TypeError), e:
     270    except (AttributeError, KeyError, IndexError, TypeError), e:
    235271        if isinstance(key, basestring):
    236272            val = getattr(obj, key, _UNDEF)
    237273            if val is _UNDEF:
    … …  
    249285    _visitors = {}
    250286
    251287    def visit(self, node):
     288        if node is None:
     289            return None
    252290        v = self._visitors.get(node.__class__)
    253291        if not v:
    254             v = getattr(self, 'visit%s' % node.__class__.__name__)
     292            v = getattr(self.__class__, 'visit%s' % node.__class__.__name__,
     293                        self.__class__._visitDefault)
    255294            self._visitors[node.__class__] = v
    256         return v(node)
     295        return v(self, node)
    257296
     297    def _visitDefault(self, node):
     298        return node
     299
    258300    def visitExpression(self, node):
    259301        node.node = self.visit(node.node)
    260302        return node
    261303
    262     # Functions & Accessors
     304    def visitModule(self, node):
     305        node.node = self.visit(node.node)
     306        return node
    263307
     308    def visitStmt(self, node):
     309        node.nodes = [self.visit(x) for x in node.nodes]
     310        return node
     311
     312    # Classes, Functions & Accessors
     313
    264314    def visitCallFunc(self, node):
    265315        node.node = self.visit(node.node)
    266316        node.args = [self.visit(x) for x in node.args]
    … …  
    270320            node.dstar_args = self.visit(node.dstar_args)
    271321        return node
    272322
    273     def visitLambda(self, node):
     323    def visitClass(self, node):
     324        node.bases = [self.visit(x) for x in node.bases]
    274325        node.code = self.visit(node.code)
    275326        node.filename = '<string>' # workaround for bug in pycodegen
    276327        return node
    277328
     329    def visitFunction(self, node):
     330        node.defaults = [self.visit(x) for x in node.defaults]
     331        node.code = self.visit(node.code)
     332        node.filename = '<string>' # workaround for bug in pycodegen
     333        return node
     334
    278335    def visitGetattr(self, node):
    279336        node.expr = self.visit(node.expr)
    280337        return node
    281338
     339    def visitLambda(self, node):
     340        node.code = self.visit(node.code)
     341        node.filename = '<string>' # workaround for bug in pycodegen
     342        return node
     343
    282344    def visitSubscript(self, node):
    283345        node.expr = self.visit(node.expr)
    284346        node.subs = [self.visit(x) for x in node.subs]
    285347        return node
    286348
     349    # Statements
     350
     351    def visitAssign(self, node):
     352        node.nodes = [self.visit(x) for x in node.nodes]
     353        node.expr = self.visit(node.expr)
     354        return node
     355
     356    def visitFor(self, node):
     357        node.assign = self.visit(node.assign)
     358        node.list = self.visit(node.list)
     359        node.body = self.visit(node.body)
     360        node.else_ = self.visit(node.else_)
     361        return node
     362
     363    def _visitPrint(self, node):
     364        node.nodes = [self.visit(x) for x in node.nodes]
     365        node.dest = self.visit(node.dest)
     366        return node
     367    visitPrint = visitPrintnl = _visitPrint
     368
     369    def visitRaise(self, node):
     370        node.expr1 = self.visit(node.expr1)
     371        node.expr2 = self.visit(node.expr2)
     372        node.expr3 = self.visit(node.expr3)
     373        return node
     374
     375    def visitTryExcept(self, node):
     376        node.body = self.visit(node.body)
     377        node.handlers = self.visit(node.handlers)
     378        node.else_ = self.visit(node.else_)
     379        return node
     380
     381    def visitTryFinally(self, node):
     382        node.body = self.visit(node.body)
     383        node.final = self.visit(node.final)
     384        return node
     385
     386    def visitWhile(self, node):
     387        node.test = self.visit(node.test)
     388        node.body = self.visit(node.body)
     389        node.else_ = self.visit(node.else_)
     390        return node
     391
     392    def visitYield(self, node):
     393        node.value = self.visit(node.value)
     394        return node
     395
    287396    # Operators
    288397
    289398    def _visitBoolOp(self, node):
    … …  
    308417        node.expr = self.visit(node.expr)
    309418        return node
    310419    visitUnaryAdd = visitUnarySub = visitNot = visitInvert = _visitUnaryOp
    311     visitBackquote = _visitUnaryOp
     420    visitBackquote = visitDiscard = _visitUnaryOp
    312421
    313422    # Identifiers, Literals and Comprehensions
    314423
    315     def _visitDefault(self, node):
    316         return node
    317     visitAssName = visitConst = visitName = _visitDefault
    318 
    319424    def visitDict(self, node):
    320425        node.items = [(self.visit(k),
    321426                       self.visit(v)) for k, v in node.items]
    … …  
    381486        return node
    382487
    383488
    384 class ExpressionASTTransformer(ASTTransformer):
     489class TemplateASTTransformer(ASTTransformer):
    385490    """Concrete AST transformer that implements the AST transformations needed
    386     for template expressions.
     491    for code embedded in templates.
    387492    """
    388493
    389494    def __init__(self):
    … …  
    398503        return node
    399504
    400505    def visitAssName(self, node):
    401         self.locals[-1].add(node.name)
     506        if self.locals:
     507            self.locals[-1].add(node.name)
    402508        return node
    403509
     510    def visitClass(self, node):
     511        self.locals.append(set())
     512        node = ASTTransformer.visitClass(self, node)
     513        self.locals.pop()
     514        return node
     515
     516    def visitFor(self, node):
     517        self.locals.append(set())
     518        node = ASTTransformer.visitFor(self, node)
     519        self.locals.pop()
     520        return node
     521
     522    def visitFunction(self, node):
     523        self.locals.append(set(node.argnames))
     524        node = ASTTransformer.visitFunction(self, node)
     525        self.locals.pop()
     526        return node
     527
    404528    def visitGenExpr(self, node):
    405529        self.locals.append(set())
    406530        node = ASTTransformer.visitGenExpr(self, node)