Edgewall Software

Ticket #84: python_pi.5.diff

File python_pi.5.diff, 22.0 KB (added by cmlenz, 5 years ago)

Updated patch

  • genshi/template/base.py

     
    109109    def __repr__(self): 
    110110        return repr(list(self.frames)) 
    111111 
     112    def __contains__(self, key): 
     113        """Return whether a variable exists in any of the scopes.""" 
     114        return self._find(key)[1] is not None 
     115 
     116    def __delitem__(self, key): 
     117        """Set a variable in the current scope.""" 
     118        for frame in self.frames: 
     119            if key in frame: 
     120                del frame[key] 
     121 
     122    def __getitem__(self, key): 
     123        """Get a variables's value, starting at the current scope and going 
     124        upward. 
     125         
     126        Raises `KeyError` if the requested variable wasn't found in any scope. 
     127        """ 
     128        value, frame = self._find(key) 
     129        if frame is None: 
     130            raise KeyError(key) 
     131        return value 
     132 
    112133    def __setitem__(self, key, value): 
    113134        """Set a variable in the current scope.""" 
    114135        self.frames[0][key] = value 
    … …  
    131152            if key in frame: 
    132153                return frame[key] 
    133154        return default 
    134     __getitem__ = get 
    135155 
     156    def keys(self): 
     157        keys = [] 
     158        for frame in self.frames: 
     159            keys += [key for key in frame if key not in keys] 
     160        return keys 
     161 
     162    def items(self): 
     163        return [(key, self.get(key)) for key in self.keys()] 
     164 
    136165    def push(self, data): 
    137166        """Push a new scope on the stack.""" 
    138167 

  • genshi/template/tests/markup.py

     
    195195          \xf6 
    196196        </div>""", unicode(tmpl.generate())) 
    197197 
     198    def test_exec_import(self): 
     199        tmpl = MarkupTemplate(u"""<?python from datetime import timedelta ?> 
     200        <div xmlns:py="http://genshi.edgewall.org/"> 
     201          ${timedelta(days=2)} 
     202        </div>""") 
     203        self.assertEqual(u"""<div> 
     204          2 days, 0:00:00 
     205        </div>""", str(tmpl.generate())) 
     206 
     207    def test_exec_def(self): 
     208        tmpl = MarkupTemplate(u""" 
     209        <?python 
     210        def foo(): 
     211            return 42 
     212        ?> 
     213        <div xmlns:py="http://genshi.edgewall.org/"> 
     214          ${foo()} 
     215        </div>""") 
     216        self.assertEqual(u"""<div> 
     217          42 
     218        </div>""", str(tmpl.generate())) 
     219 
    198220    def test_include_in_loop(self): 
    199221        dirname = tempfile.mkdtemp(suffix='genshi_test') 
    200222        try: 

  • genshi/template/tests/eval.py

     
    1616import unittest 
    1717 
    1818from genshi.core import Markup 
    19 from genshi.template.eval import Expression, Undefined 
     19from genshi.template.eval import Expression, Suite, Undefined 
    2020 
    2121 
    2222class ExpressionTestCase(unittest.TestCase): 
    … …  
    399399        self.assertRaises(TypeError, expr.evaluate, {'nothing': object()}) 
    400400 
    401401 
     402class SuiteTestCase(unittest.TestCase): 
     403 
     404    def test_assign(self): 
     405        suite = Suite("foo = 42") 
     406        data = {} 
     407        suite.execute(data) 
     408        self.assertEqual(42, data['foo']) 
     409 
     410    def test_def(self): 
     411        suite = Suite("def donothing(): pass") 
     412        data = {} 
     413        suite.execute(data) 
     414        assert 'donothing' in data 
     415        self.assertEqual(None, data['donothing']()) 
     416 
     417    def test_delete(self): 
     418        suite = Suite("""foo = 42 
     419del foo 
     420""") 
     421        data = {} 
     422        suite.execute(data) 
     423        assert 'foo' not in data 
     424 
     425    def test_class(self): 
     426        suite = Suite("class plain(object): pass") 
     427        data = {} 
     428        suite.execute(data) 
     429        assert 'plain' in data 
     430 
     431    def test_import(self): 
     432        suite = Suite("from itertools import ifilter") 
     433        data = {} 
     434        suite.execute(data) 
     435        assert 'ifilter' in data 
     436 
     437    def test_for(self): 
     438        suite = Suite("""x = [] 
     439for i in range(3): 
     440    x.append(i**2) 
     441""") 
     442        data = {} 
     443        suite.execute(data) 
     444        self.assertEqual([0, 1, 4], data['x']) 
     445 
     446    def test_if(self): 
     447        suite = Suite("""if foo == 42: 
     448    x = True 
     449""") 
     450        data = {'foo': 42} 
     451        suite.execute(data) 
     452        self.assertEqual(True, data['x']) 
     453 
     454    def test_raise(self): 
     455        suite = Suite("""raise NotImplementedError""") 
     456        self.assertRaises(NotImplementedError, suite.execute, {}) 
     457 
     458    def test_try_except(self): 
     459        suite = Suite("""try: 
     460    import somemod 
     461except ImportError: 
     462    somemod = None 
     463else: 
     464    somemod.dosth()""") 
     465        data = {} 
     466        suite.execute(data) 
     467        self.assertEqual(None, data['somemod']) 
     468 
     469    def test_finally(self): 
     470        suite = Suite("""try: 
     471    x = 2 
     472finally: 
     473    x = None 
     474""") 
     475        data = {} 
     476        suite.execute(data) 
     477        self.assertEqual(None, data['x']) 
     478 
     479    def test_while_break(self): 
     480        suite = Suite("""x = 0 
     481while x < 5: 
     482    x += step 
     483    if x == 4: 
     484        break 
     485""") 
     486        data = {'step': 2} 
     487        suite.execute(data) 
     488        self.assertEqual(4, data['x']) 
     489 
     490 
    402491def suite(): 
    403492    suite = unittest.TestSuite() 
    404493    suite.addTest(doctest.DocTestSuite(Expression.__module__)) 
    405494    suite.addTest(unittest.makeSuite(ExpressionTestCase, 'test')) 
     495    suite.addTest(unittest.makeSuite(SuiteTestCase, 'test')) 
    406496    return suite 
    407497 
    408498if __name__ == '__main__': 

  • genshi/template/markup.py

     
    1414"""Markup templating engine.""" 
    1515 
    1616from itertools import chain 
     17import sys 
     18from textwrap import dedent 
    1719 
    1820from genshi.core import Attrs, Namespace, Stream, StreamEventKind 
    19 from genshi.core import START, END, START_NS, END_NS, TEXT, COMMENT 
     21from genshi.core import START, END, START_NS, END_NS, TEXT, PI, COMMENT 
    2022from genshi.input import XMLParser 
    2123from genshi.template.base import BadDirectiveError, Template, \ 
    22                                  _apply_directives, SUB 
     24                                 TemplateSyntaxError, _apply_directives, SUB 
     25from genshi.template.eval import Suite 
    2326from genshi.template.loader import TemplateNotFound 
    2427from genshi.template.directives import * 
    2528 
     29if sys.version_info < (2, 4): 
     30    _ctxt2dict = lambda ctxt: ctxt.frames[0] 
     31else: 
     32    _ctxt2dict = lambda ctxt: ctxt 
    2633 
     34 
    2735class MarkupTemplate(Template): 
    2836    """Implementation of the template language for XML-based templates. 
    2937     
    … …  
    3543      <li>1</li><li>2</li><li>3</li> 
    3644    </ul> 
    3745    """ 
     46    EXEC = StreamEventKind('EXEC') 
    3847    INCLUDE = StreamEventKind('INCLUDE') 
    3948 
    4049    DIRECTIVE_NAMESPACE = Namespace('http://genshi.edgewall.org/') 
    … …  
    5968        Template.__init__(self, source, basedir=basedir, filename=filename, 
    6069                          loader=loader, encoding=encoding) 
    6170 
    62         self.filters.append(self._match) 
     71        self.filters += [self._exec, self._match] 
    6372        if loader: 
    6473            self.filters.append(self._include) 
    6574 
    … …  
    169178                    stream[start_offset:] = [(SUB, (directives, substream), 
    170179                                              pos)] 
    171180 
     181            elif kind is PI and data[0] == 'python': 
     182                try: 
     183                    # As Expat doesn't report whitespace between the PI target 
     184                    # and the data, we have to jump through some hoops here to 
     185                    # get correctly indented Python code 
     186                    # Unfortunately, we'll still probably not get the line 
     187                    # number quite right 
     188                    lines = [line.expandtabs() for line in data[1].splitlines()] 
     189                    first = lines[0] 
     190                    rest = dedent('\n'.join(lines[1:])) 
     191                    if first.rstrip().endswith(':') and not rest[0].isspace(): 
     192                        rest = '\n'.join(['    ' + line for line 
     193                                          in rest.splitlines()]) 
     194                    source = '\n'.join([first, rest]) 
     195                    suite = Suite(source, self.filepath, pos[1]) 
     196                except SyntaxError, err: 
     197                    raise TemplateSyntaxError(err, self.filepath, 
     198                                              pos[1] + (err.lineno or 1) - 1, 
     199                                              pos[2] + (err.offset or 0)) 
     200                stream.append((EXEC, suite, pos)) 
     201 
    172202            elif kind is TEXT: 
    173203                for kind, data, pos in self._interpolate(data, self.basedir, 
    174204                                                         *pos): 
    … …  
    190220                data = data[0], list(self._prepare(data[1])) 
    191221            yield kind, data, pos 
    192222 
     223    def _exec(self, stream, ctxt): 
     224        """Internal stream filter that executes code in <?python ?> processing 
     225        instructions. 
     226        """ 
     227        for event in stream: 
     228            if event[0] is EXEC: 
     229                event[1].execute(_ctxt2dict(ctxt)) 
     230            else: 
     231                yield event 
     232 
    193233    def _include(self, stream, ctxt): 
    194234        """Internal stream filter that performs inclusion of external 
    195235        template files. 
    … …  
    291331                yield event 
    292332 
    293333 
     334EXEC = MarkupTemplate.EXEC 
    294335INCLUDE = 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 
    2222except NameError: 
    2323    from sets import Set as set 
     24import sys 
    2425 
    2526from genshi.core import Markup 
    2627from genshi.util import flatten 
    2728 
    28 __all__ = ['Expression', 'Undefined'] 
     29if sys.version_info < (2, 4): 
     30    _locals = dict 
     31else: 
     32    _locals = lambda x: x 
    2933 
     34__all__ = ['Expression', 'Suite', 'Undefined'] 
    3035 
    31 class Expression(object): 
     36 
     37class Code(object): 
     38    """Abstract base class for the `Expression` and `Suite` classes.""" 
     39    __slots__ = ['source', 'code'] 
     40 
     41    def __init__(self, source, filename=None, lineno=-1): 
     42        """Create the code object, either from a string, or from an AST node. 
     43         
     44        @param source: either a string containing the source code, or an AST 
     45            node 
     46        @param filename: the (preferably absolute) name of the file containing 
     47            the code 
     48        @param lineno: the number of the line on which the code was found 
     49        """ 
     50        if isinstance(source, basestring): 
     51            self.source = source 
     52            node = _parse(source, mode=self.mode) 
     53        else: 
     54            assert isinstance(source, ast.Node) 
     55            self.source = '?' 
     56            if self.mode == 'eval': 
     57                node = ast.Expression(source) 
     58            else: 
     59                node = ast.Module(None, source) 
     60 
     61        self.code = _compile(node, self.source, mode=self.mode, 
     62                             filename=filename, lineno=lineno) 
     63 
     64    def __eq__(self, other): 
     65        return (type(other) == type(self)) and (self.code == other.code) 
     66 
     67    def __hash__(self): 
     68        return hash(self.code) 
     69 
     70    def __ne__(self, other): 
     71        return not self == other 
     72 
     73    def __repr__(self): 
     74        return '%s(%r)' % (self.__class__.__name__, self.source) 
     75 
     76 
     77class Expression(Code): 
    3278    """Evaluates Python expressions used in templates. 
    3379 
    3480    >>> data = dict(test='Foo', items=[1, 2, 3], dict={'some': 'thing'}) 
    … …  
    69115    >>> Expression('len(items)').evaluate(data) 
    70116    3 
    71117    """ 
    72     __slots__ = ['source', 'code'] 
     118    __slots__ = [] 
     119    mode = 'eval' 
    73120 
    74     def __init__(self, source, filename=None, lineno=-1): 
    75         """Create the expression, either from a string, or from an AST node. 
    76          
    77         @param source: either a string containing the source code of the 
    78             expression, or an AST node 
    79         @param filename: the (preferably absolute) name of the file containing 
    80             the expression 
    81         @param lineno: the number of the line on which the expression was found 
    82         """ 
    83         if isinstance(source, basestring): 
    84             self.source = source 
    85             self.code = _compile(_parse(source), self.source, filename=filename, 
    86                                  lineno=lineno) 
    87         else: 
    88             assert isinstance(source, ast.Node) 
    89             self.source = '?' 
    90             self.code = _compile(ast.Expression(source), filename=filename, 
    91                                  lineno=lineno) 
    92  
    93     def __eq__(self, other): 
    94         return (type(other) == Expression) and (self.code == other.code) 
    95  
    96     def __hash__(self): 
    97         return hash(self.code) 
    98  
    99     def __ne__(self, other): 
    100         return not self == other 
    101  
    102     def __repr__(self): 
    103         return 'Expression(%r)' % self.source 
    104  
    105121    def evaluate(self, data): 
    106122        """Evaluate the expression against the given data dictionary. 
    107123         
    … …  
    111127        return eval(self.code, {'data': data, 
    112128                                '_lookup_name': _lookup_name, 
    113129                                '_lookup_attr': _lookup_attr, 
    114                                 '_lookup_item': _lookup_item}, 
    115                                {'data': data}) 
     130                                '_lookup_item': _lookup_item}, _locals(data)) 
    116131 
    117132 
     133class Suite(Code): 
     134    """Executes Python statements used in templates. 
     135 
     136    >>> data = dict(test='Foo', items=[1, 2, 3], dict={'some': 'thing'}) 
     137    >>> Suite('foo = dict.some').execute(data) 
     138    >>> data['foo'] 
     139    'thing' 
     140    """ 
     141    __slots__ = [] 
     142    mode = 'exec' 
     143 
     144    def execute(self, data): 
     145        """Execute the suite in the given data dictionary. 
     146         
     147        @param data: a mapping containing the data to execute in 
     148        """ 
     149        exec self.code in {'data': data, 
     150                           '_lookup_name': _lookup_name, 
     151                           '_lookup_attr': _lookup_attr, 
     152                           '_lookup_item': _lookup_item}, data 
     153 
     154 
    118155class Undefined(object): 
    119156    """Represents a reference to an undefined variable. 
    120157     
    … …  
    177214        source = '\xef\xbb\xbf' + source.encode('utf-8') 
    178215    return parse(source, mode) 
    179216 
    180 def _compile(node, source=None, filename=None, lineno=-1): 
    181     tree = ExpressionASTTransformer().visit(node) 
     217def _compile(node, source=None, mode='eval', filename=None, lineno=-1): 
     218    tree = TemplateASTTransformer().visit(node) 
    182219    if isinstance(filename, unicode): 
    183220        # unicode file names not allowed for code objects 
    184221        filename = filename.encode('utf-8', 'replace') 
    … …  
    188225    if lineno <= 0: 
    189226        lineno = 1 
    190227 
    191     gen = ExpressionCodeGenerator(tree) 
     228    if mode == 'eval': 
     229        gen = ExpressionCodeGenerator(tree) 
     230        name = '<Expression %s>' % (repr(source or '?').replace("'", '"')) 
     231    else: 
     232        gen = ModuleCodeGenerator(tree) 
     233        name = '<Suite>' 
    192234    gen.optimized = True 
    193235    code = gen.getCode() 
    194236 
    … …  
    196238    # clone the code object while adjusting the line number 
    197239    return new.code(0, code.co_nlocals, code.co_stacksize, 
    198240                    code.co_flags | 0x0040, code.co_code, code.co_consts, 
    199                     code.co_names, code.co_varnames, filename, 
    200                     '<Expression %s>' % (repr(source or '?').replace("'", '"')), 
    201                     lineno, code.co_lnotab, (), ()) 
     241                    code.co_names, code.co_varnames, filename, name, lineno, 
     242                    code.co_lnotab, (), ()) 
    202243 
    203244BUILTINS = __builtin__.__dict__.copy() 
    204245BUILTINS.update({'Markup': Markup, 'Undefined': Undefined}) 
    … …  
    232273        key = key[0] 
    233274    try: 
    234275        return obj[key] 
    235     except (KeyError, IndexError, TypeError), e: 
     276    except (AttributeError, KeyError, IndexError, TypeError), e: 
    236277        if isinstance(key, basestring): 
    237278            val = getattr(obj, key, _UNDEF) 
    238279            if val is _UNDEF: 
    … …  
    250291    _visitors = {} 
    251292 
    252293    def visit(self, node): 
     294        if node is None: 
     295            return None 
    253296        v = self._visitors.get(node.__class__) 
    254297        if not v: 
    255             v = getattr(self, 'visit%s' % node.__class__.__name__) 
    256             self._visitors[node.__class__] = v 
    257         return v(node) 
     298            v = getattr(self.__class__, 'visit%s' % node.__class__.__name__, 
     299                        self.__class__._visitDefault) 
     300            #self._visitors[node.__class__] = v 
     301        return v(self, node) 
    258302 
     303    def _visitDefault(self, node): 
     304        return node 
     305 
    259306    def visitExpression(self, node): 
    260307        node.node = self.visit(node.node) 
    261308        return node 
    262309 
    263     # Functions & Accessors 
     310    def visitModule(self, node): 
     311        node.node = self.visit(node.node) 
     312        return node 
    264313 
     314    def visitStmt(self, node): 
     315        node.nodes = [self.visit(x) for x in node.nodes] 
     316        return node 
     317 
     318    # Classes, Functions & Accessors 
     319 
    265320    def visitCallFunc(self, node): 
    266321        node.node = self.visit(node.node) 
    267322        node.args = [self.visit(x) for x in node.args] 
    … …  
    271326            node.dstar_args = self.visit(node.dstar_args) 
    272327        return node 
    273328 
    274     def visitLambda(self, node): 
     329    def visitClass(self, node): 
     330        node.bases = [self.visit(x) for x in node.bases] 
    275331        node.code = self.visit(node.code) 
    276332        node.filename = '<string>' # workaround for bug in pycodegen 
    277333        return node 
    278334 
     335    def visitFunction(self, node): 
     336        if hasattr(node, 'decorators'): 
     337            node.decorators = self.visit(node.decorators) 
     338        node.defaults = [self.visit(x) for x in node.defaults] 
     339        node.code = self.visit(node.code) 
     340        node.filename = '<string>' # workaround for bug in pycodegen 
     341        return node 
     342 
    279343    def visitGetattr(self, node): 
    280344        node.expr = self.visit(node.expr) 
    281345        return node 
    282346 
     347    def visitLambda(self, node): 
     348        node.code = self.visit(node.code) 
     349        node.filename = '<string>' # workaround for bug in pycodegen 
     350        return node 
     351 
    283352    def visitSubscript(self, node): 
    284353        node.expr = self.visit(node.expr) 
    285354        node.subs = [self.visit(x) for x in node.subs] 
    286355        return node 
    287356 
     357    # Statements 
     358 
     359    def visitAssert(self, node): 
     360        node.test = self.visit(node.test) 
     361        node.fail = self.visit(node.fail) 
     362        return node 
     363 
     364    def visitAssign(self, node): 
     365        node.nodes = [self.visit(x) for x in node.nodes] 
     366        node.expr = self.visit(node.expr) 
     367        return node 
     368 
     369    def visitDecorators(self, node): 
     370        node.nodes = [self.visit(x) for x in node.nodes] 
     371        return node 
     372 
     373    def visitFor(self, node): 
     374        node.assign = self.visit(node.assign) 
     375        node.list = self.visit(node.list) 
     376        node.body = self.visit(node.body) 
     377        node.else_ = self.visit(node.else_) 
     378        return node 
     379 
     380    def visitIf(self, node): 
     381        node.tests = [self.visit(x) for x in node.tests] 
     382        node.else_ = self.visit(node.else_) 
     383        return node 
     384 
     385    def _visitPrint(self, node): 
     386        node.nodes = [self.visit(x) for x in node.nodes] 
     387        node.dest = self.visit(node.dest) 
     388        return node 
     389    visitPrint = visitPrintnl = _visitPrint 
     390 
     391    def visitRaise(self, node): 
     392        node.expr1 = self.visit(node.expr1) 
     393        node.expr2 = self.visit(node.expr2) 
     394        node.expr3 = self.visit(node.expr3) 
     395        return node 
     396 
     397    def visitTryExcept(self, node): 
     398        node.body = self.visit(node.body) 
     399        node.handlers = self.visit(node.handlers) 
     400        node.else_ = self.visit(node.else_) 
     401        return node 
     402 
     403    def visitTryFinally(self, node): 
     404        node.body = self.visit(node.body) 
     405        node.final = self.visit(node.final) 
     406        return node 
     407 
     408    def visitWhile(self, node): 
     409        node.test = self.visit(node.test) 
     410        node.body = self.visit(node.body) 
     411        node.else_ = self.visit(node.else_) 
     412        return node 
     413 
     414    def visitWith(self, node): 
     415        node.expr = self.visit(node.expr) 
     416        node.vars = [self.visit(x) for x in node.vars] 
     417        node.body = self.visit(node.body) 
     418        return node 
     419 
     420    def visitYield(self, node): 
     421        node.value = self.visit(node.value) 
     422        return node 
     423 
    288424    # Operators 
    289425 
    290426    def _visitBoolOp(self, node): 
    … …  
    310446        node.expr = self.visit(node.expr) 
    311447        return node 
    312448    visitUnaryAdd = visitUnarySub = visitNot = visitInvert = _visitUnaryOp 
    313     visitBackquote = _visitUnaryOp 
     449    visitBackquote = visitDiscard = _visitUnaryOp 
    314450 
    315451    def visitIfExp(self, node): 
    316452        node.test = self.visit(node.test) 
    … …  
    320456 
    321457    # Identifiers, Literals and Comprehensions 
    322458 
    323     def _visitDefault(self, node): 
    324         return node 
    325     visitAssName = visitConst = visitName = _visitDefault 
    326  
    327459    def visitDict(self, node): 
    328460        node.items = [(self.visit(k), 
    329461                       self.visit(v)) for k, v in node.items] 
    … …  
    389521        return node 
    390522 
    391523 
    392 class ExpressionASTTransformer(ASTTransformer): 
     524class TemplateASTTransformer(ASTTransformer): 
    393525    """Concrete AST transformer that implements the AST transformations needed 
    394     for template expressions. 
     526    for code embedded in templates. 
    395527    """ 
    396528 
    397529    def __init__(self): 
    … …  
    406538        return node 
    407539 
    408540    def visitAssName(self, node): 
    409         self.locals[-1].add(node.name) 
     541        if self.locals: 
     542            self.locals[-1].add(node.name) 
    410543        return node 
    411544 
     545    def visitClass(self, node): 
     546        self.locals.append(set()) 
     547        node = ASTTransformer.visitClass(self, node) 
     548        self.locals.pop() 
     549        return node 
     550 
     551    def visitFor(self, node): 
     552        self.locals.append(set()) 
     553        node = ASTTransformer.visitFor(self, node) 
     554        self.locals.pop() 
     555        return node 
     556 
     557    def visitFunction(self, node): 
     558        self.locals.append(set(node.argnames)) 
     559        node = ASTTransformer.visitFunction(self, node) 
     560        self.locals.pop() 
     561        return node 
     562 
    412563    def visitGenExpr(self, node): 
    413564        self.locals.append(set()) 
    414565        node = ASTTransformer.visitGenExpr(self, node)