genshi/mirror: genshi/template/eval.py annotate

annotate genshi/template/eval.py @ 934:31bbb6f9e87b trunk

Merge r1142 from py3k: add support for python 3 to genshi.template expression evaluator: * add support for python 3 AST: * AST for raise has changed in Python 3. * Python 3 adds AST nodes for individual arguments and Bytes. * use genshi.compat functions for dealing with code objects. * do not coerce byte strings to unicode in Python 3 ASTTransformer. * replace doctests that reply on exception names with uglier but more compatible try:.. except:.. doctest * handle filename preferences of Python 2 and 3 (2 prefers bytes, 3 prefers unicode). * ifilter is gone from itertools in Python 3 so use repeat for tests instead.

author	hodgestar
date	Fri, 18 Mar 2011 09:15:29 +0000
parents	64f04a2c5e66
children	2036193f89e7 2e169deb0adc

rev	line source
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	1 # -- coding: utf-8 --
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	2 #
897 64f04a2c5e66 Update changelog and copyright years. cmlenz parents: 896 diff changeset	3 # Copyright (C) 2006-2010 Edgewall Software
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	4 # All rights reserved.
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	5 #
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	6 # This software is licensed as described in the file COPYING, which
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	7 # you should have received as part of this distribution. The terms
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	8 # are also available at http://genshi.edgewall.org/wiki/License.
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	9 #
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	10 # This software consists of voluntary contributions made by many
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	11 # individuals. For the exact contribution history, see the revision
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	12 # history and logs, available at http://genshi.edgewall.org/log/.
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	13
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	14 """Support for "safe" evaluation of Python expressions."""
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	15
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	16 import __builtin__
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	17
601 59fbd7586454 Simplify implementation of `py:with` directive by compiling to a `Suite`, instead of manually breaking up the statement and compiling each part to an `Expression`. Also, the first line of code in a `Suite` is now stored as the "function name" of the bytecode, so that it shows up in tracebacks. cmlenz parents: 586 diff changeset	18 from textwrap import dedent
793 be88c77839fc Get rid of a couple more -3 warnings. cmlenz parents: 750 diff changeset	19 from types import CodeType
357 62de137b9322 Improve the way locals (in list comprehensions, lambdas and generator expressions) are handled in template expressions. cmlenz parents: 343 diff changeset	20
401 68772732c896 Make the `Markup` class available by default in template expressions. Closes #67. cmlenz parents: 396 diff changeset	21 from genshi.core import Markup
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	22 from genshi.template.astutil import ASTTransformer, ASTCodeGenerator, \
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	23 _ast, parse
418 c478a6fa9e77 Make expression error handling more strict. Closes #88. cmlenz parents: 408 diff changeset	24 from genshi.template.base import TemplateRuntimeError
357 62de137b9322 Improve the way locals (in list comprehensions, lambdas and generator expressions) are handled in template expressions. cmlenz parents: 343 diff changeset	25 from genshi.util import flatten
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	26
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	27 from genshi.compat import get_code_params, build_code_chunk, IS_PYTHON2
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	28
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	29 __all__ = ['Code', 'Expression', 'Suite', 'LenientLookup', 'StrictLookup',
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	30 'Undefined', 'UndefinedError']
425 073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	31 __docformat__ = 'restructuredtext en'
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	32
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	33
731 01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	34 # Check for a Python 2.4 bug in the eval loop
739 6de290dec976 Another Python 2.3 fix in the wake of #221. cmlenz parents: 736 diff changeset	35 has_star_import_bug = False
731 01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	36 try:
736 a1e8b24bc1bb Yet another followup fix for #221. cmlenz parents: 733 diff changeset	37 class _FakeMapping(object):
731 01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	38 __getitem__ = __setitem__ = lambda *a: None
01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	39 exec 'from sys import *' in {}, _FakeMapping()
739 6de290dec976 Another Python 2.3 fix in the wake of #221. cmlenz parents: 736 diff changeset	40 except SystemError:
731 01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	41 has_star_import_bug = True
01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	42 del _FakeMapping
01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	43
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	44
731 01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	45 def _star_import_patch(mapping, modname):
01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	46 """This function is used as helper if a Python version with a broken
01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	47 star-import opcode is in use.
01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	48 """
01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	49 module = __import__(modname, None, None, ['__all__'])
01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	50 if hasattr(module, '__all__'):
01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	51 members = module.__all__
01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	52 else:
01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	53 members = [x for x in module.__dict__ if not x.startswith('_')]
733 43147cbc9ea3 Update to r855 for Python 2.3 support. Fixes #221 (hopefully). athomas parents: 731 diff changeset	54 mapping.update([(name, getattr(module, name)) for name in members])
731 01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	55
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	56
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	57 class Code(object):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	58 """Abstract base class for the `Expression` and `Suite` classes."""
565 53b37e4f2921 * The I18n extractor now handles gettext function calls that use non-string parameters as well as keyword arguments. cmlenz parents: 564 diff changeset	59 __slots__ = ['source', 'code', 'ast', '_globals']
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	60
606 37ff75bb4301 Changed the default error handling mode to "strict". cmlenz parents: 604 diff changeset	61 def __init__(self, source, filename=None, lineno=-1, lookup='strict',
604 416e46209da1 Fix bug that slipped into [717]: the code of a `py:with` directive was not being compiled with AST transformations applied. cmlenz parents: 601 diff changeset	62 xform=None):
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	63 """Create the code object, either from a string, or from an AST node.
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	64
425 073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	65 :param source: either a string containing the source code, or an AST
073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	66 node
073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	67 :param filename: the (preferably absolute) name of the file containing
073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	68 the code
073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	69 :param lineno: the number of the line on which the code was found
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	70 :param lookup: the lookup class that defines how variables are looked
606 37ff75bb4301 Changed the default error handling mode to "strict". cmlenz parents: 604 diff changeset	71 up in the context; can be either "strict" (the default),
37ff75bb4301 Changed the default error handling mode to "strict". cmlenz parents: 604 diff changeset	72 "lenient", or a custom lookup class
604 416e46209da1 Fix bug that slipped into [717]: the code of a `py:with` directive was not being compiled with AST transformations applied. cmlenz parents: 601 diff changeset	73 :param xform: the AST transformer that should be applied to the code;
416e46209da1 Fix bug that slipped into [717]: the code of a `py:with` directive was not being compiled with AST transformations applied. cmlenz parents: 601 diff changeset	74 if `None`, the appropriate transformation is chosen
416e46209da1 Fix bug that slipped into [717]: the code of a `py:with` directive was not being compiled with AST transformations applied. cmlenz parents: 601 diff changeset	75 depending on the mode
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	76 """
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	77 if isinstance(source, basestring):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	78 self.source = source
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	79 node = _parse(source, mode=self.mode)
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	80 else:
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	81 assert isinstance(source, _ast.AST), \
601 59fbd7586454 Simplify implementation of `py:with` directive by compiling to a `Suite`, instead of manually breaking up the statement and compiling each part to an `Expression`. Also, the first line of code in a `Suite` is now stored as the "function name" of the bytecode, so that it shows up in tracebacks. cmlenz parents: 586 diff changeset	82 'Expected string or AST node, but got %r' % source
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	83 self.source = '?'
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	84 if self.mode == 'eval':
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	85 node = _ast.Expression()
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	86 node.body = source
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	87 else:
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	88 node = _ast.Module()
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	89 node.body = [source]
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	90
565 53b37e4f2921 * The I18n extractor now handles gettext function calls that use non-string parameters as well as keyword arguments. cmlenz parents: 564 diff changeset	91 self.ast = node
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	92 self.code = _compile(node, self.source, mode=self.mode,
604 416e46209da1 Fix bug that slipped into [717]: the code of a `py:with` directive was not being compiled with AST transformations applied. cmlenz parents: 601 diff changeset	93 filename=filename, lineno=lineno, xform=xform)
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	94 if lookup is None:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	95 lookup = LenientLookup
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	96 elif isinstance(lookup, basestring):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	97 lookup = {'lenient': LenientLookup, 'strict': StrictLookup}[lookup]
654 23b5138fd835 Fix thread-safety problem in template code evaluation. Closes #158. Thanks to Christian Boos for the patch. cmlenz parents: 606 diff changeset	98 self._globals = lookup.globals
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	99
715 b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	100 def __getstate__(self):
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	101 state = {'source': self.source, 'ast': self.ast,
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	102 'lookup': self._globals.im_self}
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	103 state['code'] = get_code_params(self.code)
715 b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	104 return state
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	105
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	106 def __setstate__(self, state):
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	107 self.source = state['source']
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	108 self.ast = state['ast']
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	109 self.code = CodeType(0, *state['code'])
715 b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	110 self._globals = state['lookup'].globals
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	111
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	112 def __eq__(self, other):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	113 return (type(other) == type(self)) and (self.code == other.code)
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	114
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	115 def __hash__(self):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	116 return hash(self.code)
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	117
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	118 def __ne__(self, other):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	119 return not self == other
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	120
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	121 def __repr__(self):
860 16d55698006a A bit of cleanup of the `Markup` Python implementation. cmlenz parents: 854 diff changeset	122 return '%s(%r)' % (type(self).__name__, self.source)
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	123
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	124
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	125 class Expression(Code):
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	126 """Evaluates Python expressions used in templates.
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	127
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	128 >>> data = dict(test='Foo', items=[1, 2, 3], dict={'some': 'thing'})
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	129 >>> Expression('test').evaluate(data)
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	130 'Foo'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	131
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	132 >>> Expression('items[0]').evaluate(data)
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	133 1
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	134 >>> Expression('items[-1]').evaluate(data)
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	135 3
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	136 >>> Expression('dict["some"]').evaluate(data)
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	137 'thing'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	138
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	139 Similar to e.g. Javascript, expressions in templates can use the dot
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	140 notation for attribute access to access items in mappings:
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	141
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	142 >>> Expression('dict.some').evaluate(data)
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	143 'thing'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	144
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	145 This also works the other way around: item access can be used to access
425 073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	146 any object attribute:
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	147
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	148 >>> class MyClass(object):
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	149 ... myattr = 'Bar'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	150 >>> data = dict(mine=MyClass(), key='myattr')
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	151 >>> Expression('mine.myattr').evaluate(data)
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	152 'Bar'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	153 >>> Expression('mine["myattr"]').evaluate(data)
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	154 'Bar'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	155 >>> Expression('mine[key]').evaluate(data)
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	156 'Bar'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	157
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	158 All of the standard Python operators are available to template expressions.
425 073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	159 Built-in functions such as ``len()`` are also available in template
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	160 expressions:
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	161
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	162 >>> data = dict(items=[1, 2, 3])
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	163 >>> Expression('len(items)').evaluate(data)
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	164 3
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	165 """
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	166 __slots__ = []
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	167 mode = 'eval'
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	168
343 35189e960252 Remove automatic calling of expression evaluation results if they are callable. See [http://groups.google.com/group/genshi/browse_thread/thread/f515986760918d41 this mailing list thread]. cmlenz parents: 340 diff changeset	169 def evaluate(self, data):
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	170 """Evaluate the expression against the given data dictionary.
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	171
425 073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	172 :param data: a mapping containing the data to evaluate against
073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	173 :return: the result of the evaluation
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	174 """
418 c478a6fa9e77 Make expression error handling more strict. Closes #88. cmlenz parents: 408 diff changeset	175 __traceback_hide__ = 'before_and_this'
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	176 _globals = self._globals(data)
682 0653f6c1ffdf Assigning to a variable named `data` in a Python code block no longer breaks context lookup. We now use the name `__data__` for internal data, hoping that that name is not as commonly used in templates. cmlenz parents: 654 diff changeset	177 return eval(self.code, _globals, {'__data__': data})
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	178
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	179
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	180 class Suite(Code):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	181 """Executes Python statements used in templates.
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	182
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	183 >>> data = dict(test='Foo', items=[1, 2, 3], dict={'some': 'thing'})
473 4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	184 >>> Suite("foo = dict['some']").execute(data)
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	185 >>> data['foo']
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	186 'thing'
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	187 """
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	188 __slots__ = []
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	189 mode = 'exec'
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	190
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	191 def execute(self, data):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	192 """Execute the suite in the given data dictionary.
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	193
425 073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	194 :param data: a mapping containing the data to execute in
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	195 """
418 c478a6fa9e77 Make expression error handling more strict. Closes #88. cmlenz parents: 408 diff changeset	196 __traceback_hide__ = 'before_and_this'
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	197 _globals = self._globals(data)
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	198 exec self.code in _globals, data
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	199
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	200
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	201 UNDEFINED = object()
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	202
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	203
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	204 class UndefinedError(TemplateRuntimeError):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	205 """Exception thrown when a template expression attempts to access a variable
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	206 not defined in the context.
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	207
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	208 :see: `LenientLookup`, `StrictLookup`
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	209 """
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	210 def __init__(self, name, owner=UNDEFINED):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	211 if owner is not UNDEFINED:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	212 message = '%s has no member named "%s"' % (repr(owner), name)
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	213 else:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	214 message = '"%s" not defined' % name
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	215 TemplateRuntimeError.__init__(self, message)
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	216
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	217
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	218 class Undefined(object):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	219 """Represents a reference to an undefined variable.
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	220
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	221 Unlike the Python runtime, template expressions can refer to an undefined
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	222 variable without causing a `NameError` to be raised. The result will be an
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	223 instance of the `Undefined` class, which is treated the same as ``False`` in
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	224 conditions, but raise an exception on any other operation:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	225
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	226 >>> foo = Undefined('foo')
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	227 >>> bool(foo)
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	228 False
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	229 >>> list(foo)
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	230 []
853 f33ecf3c319e Convert a bunch of print statements to py3k compatible syntax. cmlenz parents: 845 diff changeset	231 >>> print(foo)
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	232 undefined
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	233
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	234 However, calling an undefined variable, or trying to access an attribute
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	235 of that variable, will raise an exception that includes the name used to
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	236 reference that undefined variable.
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	237
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	238 >>> try:
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	239 ... foo('bar')
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	240 ... except UndefinedError, e:
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	241 ... print e.msg
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	242 "foo" not defined
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	243
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	244 >>> try:
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	245 ... foo.bar
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	246 ... except UndefinedError, e:
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	247 ... print e.msg
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	248 "foo" not defined
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	249
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	250 :see: `LenientLookup`
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	251 """
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	252 __slots__ = ['_name', '_owner']
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	253
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	254 def __init__(self, name, owner=UNDEFINED):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	255 """Initialize the object.
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	256
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	257 :param name: the name of the reference
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	258 :param owner: the owning object, if the variable is accessed as a member
418 c478a6fa9e77 Make expression error handling more strict. Closes #88. cmlenz parents: 408 diff changeset	259 """
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	260 self._name = name
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	261 self._owner = owner
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	262
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	263 def __iter__(self):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	264 return iter([])
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	265
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	266 def __nonzero__(self):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	267 return False
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	268
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	269 def __repr__(self):
860 16d55698006a A bit of cleanup of the `Markup` Python implementation. cmlenz parents: 854 diff changeset	270 return '<%s %r>' % (type(self).__name__, self._name)
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	271
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	272 def __str__(self):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	273 return 'undefined'
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	274
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	275 def _die(self, args, *kwargs):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	276 """Raise an `UndefinedError`."""
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	277 __traceback_hide__ = True
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	278 raise UndefinedError(self._name, self._owner)
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	279 __call__ = __getattr__ = __getitem__ = _die
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	280
878 c8cac1b264e4 Apply patch from #324 for Python 2.6.2 compatibility fix. cmlenz parents: 860 diff changeset	281 # Hack around some behavior introduced in Python 2.6.2
c8cac1b264e4 Apply patch from #324 for Python 2.6.2 compatibility fix. cmlenz parents: 860 diff changeset	282 # http://genshi.edgewall.org/ticket/324
c8cac1b264e4 Apply patch from #324 for Python 2.6.2 compatibility fix. cmlenz parents: 860 diff changeset	283 __length_hint__ = None
c8cac1b264e4 Apply patch from #324 for Python 2.6.2 compatibility fix. cmlenz parents: 860 diff changeset	284
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	285
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	286 class LookupBase(object):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	287 """Abstract base class for variable lookup implementations."""
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	288
822 70fddd2262f5 Get rid of some Python 2.3 legacy that's no longer needed now that 2.4 is the baseline. cmlenz parents: 806 diff changeset	289 @classmethod
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	290 def globals(cls, data):
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	291 """Construct the globals dictionary to use as the execution context for
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	292 the expression or suite.
418 c478a6fa9e77 Make expression error handling more strict. Closes #88. cmlenz parents: 408 diff changeset	293 """
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	294 return {
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	295 '__data__': data,
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	296 '_lookup_name': cls.lookup_name,
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	297 '_lookup_attr': cls.lookup_attr,
579 2f7f6b70d5b9 Fix for augmented assignments to local variables. Thanks to Erik Bray for reporting the problem. cmlenz parents: 569 diff changeset	298 '_lookup_item': cls.lookup_item,
731 01bdf155db95 Workaround for a Python 2.4 bug that broke star imports in template code blocks. Closes #221. Many thanks to Armin Ronacher for the patch. cmlenz parents: 719 diff changeset	299 '_star_import_patch': _star_import_patch,
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	300 'UndefinedError': UndefinedError,
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	301 }
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	302
822 70fddd2262f5 Get rid of some Python 2.3 legacy that's no longer needed now that 2.4 is the baseline. cmlenz parents: 806 diff changeset	303 @classmethod
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	304 def lookup_name(cls, data, name):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	305 __traceback_hide__ = True
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	306 val = data.get(name, UNDEFINED)
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	307 if val is UNDEFINED:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	308 val = BUILTINS.get(name, val)
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	309 if val is UNDEFINED:
569 c17342ef9efb Attribute access in template expressions no longer silently ignores exceptions other than `AttributeError` raised in the attribute accessor. cmlenz parents: 568 diff changeset	310 val = cls.undefined(name)
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	311 return val
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	312
822 70fddd2262f5 Get rid of some Python 2.3 legacy that's no longer needed now that 2.4 is the baseline. cmlenz parents: 806 diff changeset	313 @classmethod
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	314 def lookup_attr(cls, obj, key):
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	315 __traceback_hide__ = True
702 e5b0d9d6b406 Improve error reporting when accessing an attribute in a Python expression raises an `AttributeError`. Closes #191. Thanks to Michele Cella for the patch! cmlenz parents: 691 diff changeset	316 try:
e5b0d9d6b406 Improve error reporting when accessing an attribute in a Python expression raises an `AttributeError`. Closes #191. Thanks to Michele Cella for the patch! cmlenz parents: 691 diff changeset	317 val = getattr(obj, key)
e5b0d9d6b406 Improve error reporting when accessing an attribute in a Python expression raises an `AttributeError`. Closes #191. Thanks to Michele Cella for the patch! cmlenz parents: 691 diff changeset	318 except AttributeError:
e5b0d9d6b406 Improve error reporting when accessing an attribute in a Python expression raises an `AttributeError`. Closes #191. Thanks to Michele Cella for the patch! cmlenz parents: 691 diff changeset	319 if hasattr(obj.__class__, key):
e5b0d9d6b406 Improve error reporting when accessing an attribute in a Python expression raises an `AttributeError`. Closes #191. Thanks to Michele Cella for the patch! cmlenz parents: 691 diff changeset	320 raise
e5b0d9d6b406 Improve error reporting when accessing an attribute in a Python expression raises an `AttributeError`. Closes #191. Thanks to Michele Cella for the patch! cmlenz parents: 691 diff changeset	321 else:
e5b0d9d6b406 Improve error reporting when accessing an attribute in a Python expression raises an `AttributeError`. Closes #191. Thanks to Michele Cella for the patch! cmlenz parents: 691 diff changeset	322 try:
e5b0d9d6b406 Improve error reporting when accessing an attribute in a Python expression raises an `AttributeError`. Closes #191. Thanks to Michele Cella for the patch! cmlenz parents: 691 diff changeset	323 val = obj[key]
e5b0d9d6b406 Improve error reporting when accessing an attribute in a Python expression raises an `AttributeError`. Closes #191. Thanks to Michele Cella for the patch! cmlenz parents: 691 diff changeset	324 except (KeyError, TypeError):
e5b0d9d6b406 Improve error reporting when accessing an attribute in a Python expression raises an `AttributeError`. Closes #191. Thanks to Michele Cella for the patch! cmlenz parents: 691 diff changeset	325 val = cls.undefined(key, owner=obj)
569 c17342ef9efb Attribute access in template expressions no longer silently ignores exceptions other than `AttributeError` raised in the attribute accessor. cmlenz parents: 568 diff changeset	326 return val
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	327
822 70fddd2262f5 Get rid of some Python 2.3 legacy that's no longer needed now that 2.4 is the baseline. cmlenz parents: 806 diff changeset	328 @classmethod
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	329 def lookup_item(cls, obj, key):
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	330 __traceback_hide__ = True
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	331 if len(key) == 1:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	332 key = key[0]
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	333 try:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	334 return obj[key]
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	335 except (AttributeError, KeyError, IndexError, TypeError), e:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	336 if isinstance(key, basestring):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	337 val = getattr(obj, key, UNDEFINED)
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	338 if val is UNDEFINED:
569 c17342ef9efb Attribute access in template expressions no longer silently ignores exceptions other than `AttributeError` raised in the attribute accessor. cmlenz parents: 568 diff changeset	339 val = cls.undefined(key, owner=obj)
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	340 return val
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	341 raise
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	342
822 70fddd2262f5 Get rid of some Python 2.3 legacy that's no longer needed now that 2.4 is the baseline. cmlenz parents: 806 diff changeset	343 @classmethod
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	344 def undefined(cls, key, owner=UNDEFINED):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	345 """Can be overridden by subclasses to specify behavior when undefined
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	346 variables are accessed.
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	347
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	348 :param key: the name of the variable
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	349 :param owner: the owning object, if the variable is accessed as a member
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	350 """
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	351 raise NotImplementedError
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	352
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	353
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	354 class LenientLookup(LookupBase):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	355 """Default variable lookup mechanism for expressions.
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	356
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	357 When an undefined variable is referenced using this lookup style, the
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	358 reference evaluates to an instance of the `Undefined` class:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	359
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	360 >>> expr = Expression('nothing', lookup='lenient')
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	361 >>> undef = expr.evaluate({})
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	362 >>> undef
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	363 <Undefined 'nothing'>
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	364
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	365 The same will happen when a non-existing attribute or item is accessed on
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	366 an existing object:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	367
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	368 >>> expr = Expression('something.nil', lookup='lenient')
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	369 >>> expr.evaluate({'something': dict()})
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	370 <Undefined 'nil'>
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	371
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	372 See the documentation of the `Undefined` class for details on the behavior
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	373 of such objects.
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	374
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	375 :see: `StrictLookup`
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	376 """
822 70fddd2262f5 Get rid of some Python 2.3 legacy that's no longer needed now that 2.4 is the baseline. cmlenz parents: 806 diff changeset	377
70fddd2262f5 Get rid of some Python 2.3 legacy that's no longer needed now that 2.4 is the baseline. cmlenz parents: 806 diff changeset	378 @classmethod
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	379 def undefined(cls, key, owner=UNDEFINED):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	380 """Return an ``Undefined`` object."""
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	381 __traceback_hide__ = True
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	382 return Undefined(key, owner=owner)
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	383
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	384
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	385 class StrictLookup(LookupBase):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	386 """Strict variable lookup mechanism for expressions.
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	387
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	388 Referencing an undefined variable using this lookup style will immediately
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	389 raise an ``UndefinedError``:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	390
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	391 >>> expr = Expression('nothing', lookup='strict')
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	392 >>> try:
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	393 ... expr.evaluate({})
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	394 ... except UndefinedError, e:
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	395 ... print e.msg
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	396 "nothing" not defined
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	397
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	398 The same happens when a non-existing attribute or item is accessed on an
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	399 existing object:
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	400
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	401 >>> expr = Expression('something.nil', lookup='strict')
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	402 >>> try:
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	403 ... expr.evaluate({'something': dict()})
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	404 ... except UndefinedError, e:
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	405 ... print e.msg
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	406 {} has no member named "nil"
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	407 """
822 70fddd2262f5 Get rid of some Python 2.3 legacy that's no longer needed now that 2.4 is the baseline. cmlenz parents: 806 diff changeset	408
70fddd2262f5 Get rid of some Python 2.3 legacy that's no longer needed now that 2.4 is the baseline. cmlenz parents: 806 diff changeset	409 @classmethod
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	410 def undefined(cls, key, owner=UNDEFINED):
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	411 """Raise an ``UndefinedError`` immediately."""
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	412 __traceback_hide__ = True
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	413 raise UndefinedError(key, owner=owner)
97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	414
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	415
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	416 def _parse(source, mode='eval'):
601 59fbd7586454 Simplify implementation of `py:with` directive by compiling to a `Suite`, instead of manually breaking up the statement and compiling each part to an `Expression`. Also, the first line of code in a `Suite` is now stored as the "function name" of the bytecode, so that it shows up in tracebacks. cmlenz parents: 586 diff changeset	417 source = source.strip()
59fbd7586454 Simplify implementation of `py:with` directive by compiling to a `Suite`, instead of manually breaking up the statement and compiling each part to an `Expression`. Also, the first line of code in a `Suite` is now stored as the "function name" of the bytecode, so that it shows up in tracebacks. cmlenz parents: 586 diff changeset	418 if mode == 'exec':
59fbd7586454 Simplify implementation of `py:with` directive by compiling to a `Suite`, instead of manually breaking up the statement and compiling each part to an `Expression`. Also, the first line of code in a `Suite` is now stored as the "function name" of the bytecode, so that it shows up in tracebacks. cmlenz parents: 586 diff changeset	419 lines = [line.expandtabs() for line in source.splitlines()]
716 eee7483041dd fix ticket [209] - make sure py:with is valid, and add a test to make sure empty py:for is invalid aflett parents: 715 diff changeset	420 if lines:
eee7483041dd fix ticket [209] - make sure py:with is valid, and add a test to make sure empty py:for is invalid aflett parents: 715 diff changeset	421 first = lines[0]
eee7483041dd fix ticket [209] - make sure py:with is valid, and add a test to make sure empty py:for is invalid aflett parents: 715 diff changeset	422 rest = dedent('\n'.join(lines[1:])).rstrip()
eee7483041dd fix ticket [209] - make sure py:with is valid, and add a test to make sure empty py:for is invalid aflett parents: 715 diff changeset	423 if first.rstrip().endswith(':') and not rest[0].isspace():
eee7483041dd fix ticket [209] - make sure py:with is valid, and add a test to make sure empty py:for is invalid aflett parents: 715 diff changeset	424 rest = '\n'.join([' %s' % line for line in rest.splitlines()])
eee7483041dd fix ticket [209] - make sure py:with is valid, and add a test to make sure empty py:for is invalid aflett parents: 715 diff changeset	425 source = '\n'.join([first, rest])
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	426 if isinstance(source, unicode):
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	427 source = (u'\ufeff' + source).encode('utf-8')
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	428 return parse(source, mode)
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	429
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	430
604 416e46209da1 Fix bug that slipped into [717]: the code of a `py:with` directive was not being compiled with AST transformations applied. cmlenz parents: 601 diff changeset	431 def _compile(node, source=None, mode='eval', filename=None, lineno=-1,
416e46209da1 Fix bug that slipped into [717]: the code of a `py:with` directive was not being compiled with AST transformations applied. cmlenz parents: 601 diff changeset	432 xform=None):
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	433 if not filename:
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	434 filename = '<string>'
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	435 if IS_PYTHON2:
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	436 # Python 2 requires non-unicode filenames
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	437 if isinstance(filename, unicode):
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	438 filename = filename.encode('utf-8', 'replace')
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	439 else:
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	440 # Python 3 requires unicode filenames
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	441 if not isinstance(filename, unicode):
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	442 filename = filename.decode('utf-8', 'replace')
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	443 if lineno <= 0:
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	444 lineno = 1
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	445
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	446 if xform is None:
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	447 xform = {
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	448 'eval': ExpressionASTTransformer
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	449 }.get(mode, TemplateASTTransformer)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	450 tree = xform().visit(node)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	451
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	452 if mode == 'eval':
601 59fbd7586454 Simplify implementation of `py:with` directive by compiling to a `Suite`, instead of manually breaking up the statement and compiling each part to an `Expression`. Also, the first line of code in a `Suite` is now stored as the "function name" of the bytecode, so that it shows up in tracebacks. cmlenz parents: 586 diff changeset	453 name = '<Expression %r>' % (source or '?')
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	454 else:
601 59fbd7586454 Simplify implementation of `py:with` directive by compiling to a `Suite`, instead of manually breaking up the statement and compiling each part to an `Expression`. Also, the first line of code in a `Suite` is now stored as the "function name" of the bytecode, so that it shows up in tracebacks. cmlenz parents: 586 diff changeset	455 lines = source.splitlines()
716 eee7483041dd fix ticket [209] - make sure py:with is valid, and add a test to make sure empty py:for is invalid aflett parents: 715 diff changeset	456 if not lines:
eee7483041dd fix ticket [209] - make sure py:with is valid, and add a test to make sure empty py:for is invalid aflett parents: 715 diff changeset	457 extract = ''
eee7483041dd fix ticket [209] - make sure py:with is valid, and add a test to make sure empty py:for is invalid aflett parents: 715 diff changeset	458 else:
eee7483041dd fix ticket [209] - make sure py:with is valid, and add a test to make sure empty py:for is invalid aflett parents: 715 diff changeset	459 extract = lines[0]
601 59fbd7586454 Simplify implementation of `py:with` directive by compiling to a `Suite`, instead of manually breaking up the statement and compiling each part to an `Expression`. Also, the first line of code in a `Suite` is now stored as the "function name" of the bytecode, so that it shows up in tracebacks. cmlenz parents: 586 diff changeset	460 if len(lines) > 1:
59fbd7586454 Simplify implementation of `py:with` directive by compiling to a `Suite`, instead of manually breaking up the statement and compiling each part to an `Expression`. Also, the first line of code in a `Suite` is now stored as the "function name" of the bytecode, so that it shows up in tracebacks. cmlenz parents: 586 diff changeset	461 extract += ' ...'
59fbd7586454 Simplify implementation of `py:with` directive by compiling to a `Suite`, instead of manually breaking up the statement and compiling each part to an `Expression`. Also, the first line of code in a `Suite` is now stored as the "function name" of the bytecode, so that it shows up in tracebacks. cmlenz parents: 586 diff changeset	462 name = '<Suite %r>' % (extract)
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	463 new_source = ASTCodeGenerator(tree).code
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	464 code = compile(new_source, filename, mode)
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	465
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	466 try:
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	467 # We'd like to just set co_firstlineno, but it's readonly. So we need
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	468 # to clone the code object while adjusting the line number
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	469 return build_code_chunk(code, filename, name, lineno)
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	470 except RuntimeError:
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	471 return code
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	472
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	473
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	474 def _new(class_, args, *kwargs):
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	475 ret = class_()
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	476 for attr, value in zip(ret._fields, args):
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	477 if attr in kwargs:
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	478 raise ValueError('Field set both in args and kwargs')
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	479 setattr(ret, attr, value)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	480 for attr, value in kwargs:
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	481 setattr(ret, attr, value)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	482 return ret
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	483
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	484
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	485 BUILTINS = __builtin__.__dict__.copy()
442 97544725bb7f Back out [510] and instead implement configurable error handling modes. The default is the old 0.3.x behaviour, but more strict error handling is available as an option. cmlenz parents: 438 diff changeset	486 BUILTINS.update({'Markup': Markup, 'Undefined': Undefined})
563 9d1c5c290254 Built-in Python constants (such as `None`) in expressions are used directly instead of being looked up from the context. cmlenz parents: 473 diff changeset	487 CONSTANTS = frozenset(['False', 'True', 'None', 'NotImplemented', 'Ellipsis'])
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	488
564 aeb89e9730df Alias `__contains__` to `has_key` in `Context` class for code outside of Genshi that may expect that for some wild reason. cmlenz parents: 563 diff changeset	489
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	490 class TemplateASTTransformer(ASTTransformer):
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	491 """Concrete AST transformer that implements the AST transformations needed
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	492 for code embedded in templates.
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	493 """
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	494
357 62de137b9322 Improve the way locals (in list comprehensions, lambdas and generator expressions) are handled in template expressions. cmlenz parents: 343 diff changeset	495 def __init__(self):
586 3670ea49c65a Fixes for nonlocal variable access in code blocks, as well as nested function and class definitions. cmlenz parents: 582 diff changeset	496 self.locals = [CONSTANTS]
357 62de137b9322 Improve the way locals (in list comprehensions, lambdas and generator expressions) are handled in template expressions. cmlenz parents: 343 diff changeset	497
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	498 def _extract_names(self, node):
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	499 names = set()
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	500 def _process(node):
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	501 if not IS_PYTHON2 and isinstance(node, _ast.arg):
31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	502 names.add(node.arg)
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	503 if isinstance(node, _ast.Name):
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	504 names.add(node.id)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	505 elif isinstance(node, _ast.alias):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	506 names.add(node.asname or node.name)
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	507 elif isinstance(node, _ast.Tuple):
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	508 for elt in node.elts:
896 8ae2c1765068 Fix for infinite recursion when parsing argument names from tuples. Closes #383. cmlenz parents: 878 diff changeset	509 _process(elt)
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	510 if hasattr(node, 'args'):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	511 for arg in node.args:
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	512 _process(arg)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	513 if hasattr(node, 'vararg'):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	514 names.add(node.vararg)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	515 if hasattr(node, 'kwarg'):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	516 names.add(node.kwarg)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	517 elif hasattr(node, 'names'):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	518 for elt in node.names:
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	519 _process(elt)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	520 return names
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	521
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	522 def visit_Str(self, node):
934 31bbb6f9e87b Merge r1142 from py3k: hodgestar parents: 897 diff changeset	523 if not isinstance(node.s, unicode):
357 62de137b9322 Improve the way locals (in list comprehensions, lambdas and generator expressions) are handled in template expressions. cmlenz parents: 343 diff changeset	524 try: # If the string is ASCII, return a `str` object
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	525 node.s.decode('ascii')
357 62de137b9322 Improve the way locals (in list comprehensions, lambdas and generator expressions) are handled in template expressions. cmlenz parents: 343 diff changeset	526 except ValueError: # Otherwise return a `unicode` object
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	527 return _new(_ast.Str, node.s.decode('utf-8'))
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	528 return node
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	529
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	530 def visit_ClassDef(self, node):
586 3670ea49c65a Fixes for nonlocal variable access in code blocks, as well as nested function and class definitions. cmlenz parents: 582 diff changeset	531 if len(self.locals) > 1:
3670ea49c65a Fixes for nonlocal variable access in code blocks, as well as nested function and class definitions. cmlenz parents: 582 diff changeset	532 self.locals[-1].add(node.name)
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	533 self.locals.append(set())
565 53b37e4f2921 * The I18n extractor now handles gettext function calls that use non-string parameters as well as keyword arguments. cmlenz parents: 564 diff changeset	534 try:
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	535 return ASTTransformer.visit_ClassDef(self, node)
565 53b37e4f2921 * The I18n extractor now handles gettext function calls that use non-string parameters as well as keyword arguments. cmlenz parents: 564 diff changeset	536 finally:
53b37e4f2921 * The I18n extractor now handles gettext function calls that use non-string parameters as well as keyword arguments. cmlenz parents: 564 diff changeset	537 self.locals.pop()
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	538
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	539 def visit_Import(self, node):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	540 if len(self.locals) > 1:
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	541 self.locals[-1].update(self._extract_names(node))
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	542 return ASTTransformer.visit_Import(self, node)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	543
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	544 def visit_ImportFrom(self, node):
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	545 if [a.name for a in node.names] == ['*']:
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	546 if has_star_import_bug:
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	547 # This is a Python 2.4 bug. Only if we have a broken Python
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	548 # version do we need to apply this hack
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	549 node = _new(_ast.Expr, _new(_ast.Call,
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	550 _new(_ast.Name, '_star_import_patch'), [
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	551 _new(_ast.Name, '__data__'),
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	552 _new(_ast.Str, node.module)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	553 ], (), ()))
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	554 return node
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	555 if len(self.locals) > 1:
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	556 self.locals[-1].update(self._extract_names(node))
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	557 return ASTTransformer.visit_ImportFrom(self, node)
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	558
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	559 def visit_FunctionDef(self, node):
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	560 if len(self.locals) > 1:
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	561 self.locals[-1].add(node.name)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	562
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	563 self.locals.append(self._extract_names(node.args))
565 53b37e4f2921 * The I18n extractor now handles gettext function calls that use non-string parameters as well as keyword arguments. cmlenz parents: 564 diff changeset	564 try:
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	565 return ASTTransformer.visit_FunctionDef(self, node)
565 53b37e4f2921 * The I18n extractor now handles gettext function calls that use non-string parameters as well as keyword arguments. cmlenz parents: 564 diff changeset	566 finally:
53b37e4f2921 * The I18n extractor now handles gettext function calls that use non-string parameters as well as keyword arguments. cmlenz parents: 564 diff changeset	567 self.locals.pop()
357 62de137b9322 Improve the way locals (in list comprehensions, lambdas and generator expressions) are handled in template expressions. cmlenz parents: 343 diff changeset	568
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	569 # GeneratorExp(expr elt, comprehension* generators)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	570 def visit_GeneratorExp(self, node):
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	571 gens = []
845 4ec4377f49ee Fix nested list comprehensions & generator expressions (fixes #327) mgood parents: 822 diff changeset	572 for generator in node.generators:
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	573 # comprehension = (expr target, expr iter, expr* ifs)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	574 self.locals.append(set())
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	575 gen = _new(_ast.comprehension, self.visit(generator.target),
845 4ec4377f49ee Fix nested list comprehensions & generator expressions (fixes #327) mgood parents: 822 diff changeset	576 self.visit(generator.iter),
4ec4377f49ee Fix nested list comprehensions & generator expressions (fixes #327) mgood parents: 822 diff changeset	577 [self.visit(if_) for if_ in generator.ifs])
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	578 gens.append(gen)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	579
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	580 # use node.__class__ to make it reusable as ListComp
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	581 ret = _new(node.__class__, self.visit(node.elt), gens)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	582 #delete inserted locals
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	583 del self.locals[-len(node.generators):]
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	584 return ret
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	585
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	586 # ListComp(expr elt, comprehension* generators)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	587 visit_ListComp = visit_GeneratorExp
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	588
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	589 def visit_Lambda(self, node):
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	590 self.locals.append(self._extract_names(node.args))
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	591 try:
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	592 return ASTTransformer.visit_Lambda(self, node)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	593 finally:
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	594 self.locals.pop()
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	595
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	596 def visit_Name(self, node):
357 62de137b9322 Improve the way locals (in list comprehensions, lambdas and generator expressions) are handled in template expressions. cmlenz parents: 343 diff changeset	597 # If the name refers to a local inside a lambda, list comprehension, or
62de137b9322 Improve the way locals (in list comprehensions, lambdas and generator expressions) are handled in template expressions. cmlenz parents: 343 diff changeset	598 # generator expression, leave it alone
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	599 if isinstance(node.ctx, _ast.Load) and \
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	600 node.id not in flatten(self.locals):
586 3670ea49c65a Fixes for nonlocal variable access in code blocks, as well as nested function and class definitions. cmlenz parents: 582 diff changeset	601 # Otherwise, translate the name ref into a context lookup
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	602 name = _new(_ast.Name, '_lookup_name', _ast.Load())
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	603 namearg = _new(_ast.Name, '__data__', _ast.Load())
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	604 strarg = _new(_ast.Str, node.id)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	605 node = _new(_ast.Call, name, [namearg, strarg], [])
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	606 elif isinstance(node.ctx, _ast.Store):
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	607 if len(self.locals) > 1:
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	608 self.locals[-1].add(node.id)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	609
586 3670ea49c65a Fixes for nonlocal variable access in code blocks, as well as nested function and class definitions. cmlenz parents: 582 diff changeset	610 return node
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	611
473 4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	612
4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	613 class ExpressionASTTransformer(TemplateASTTransformer):
4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	614 """Concrete AST transformer that implements the AST transformations needed
4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	615 for code embedded in templates.
4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	616 """
4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	617
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	618 def visit_Attribute(self, node):
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	619 if not isinstance(node.ctx, _ast.Load):
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	620 return ASTTransformer.visit_Attribute(self, node)
473 4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	621
794 f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	622 func = _new(_ast.Name, '_lookup_attr', _ast.Load())
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	623 args = [self.visit(node.value), _new(_ast.Str, node.attr)]
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	624 return _new(_ast.Call, func, args, [])
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	625
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	626 def visit_Subscript(self, node):
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	627 if not isinstance(node.ctx, _ast.Load) or \
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	628 not isinstance(node.slice, _ast.Index):
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	629 return ASTTransformer.visit_Subscript(self, node)
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	630
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	631 func = _new(_ast.Name, '_lookup_item', _ast.Load())
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	632 args = [
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	633 self.visit(node.value),
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	634 _new(_ast.Tuple, (self.visit(node.slice.value),), _ast.Load())
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	635 ]
f9e23d472a6e Merged AST branch back into trunk. Most of this code was written by Marcin Kurczych for his Google Summer of Code 2008 project. The merge of this branch means that Genshi now uses the native `_ast` module on Python >= 2.5, and an emulation thereof on Python 2.4. This replaces the usage of the `compiler` package, which was deprecated in Python 2.6 and removed in Python 3.0. Another effect is that Genshi now runs on Google AppEngine (although performance is bad due to the lack of template caching). cmlenz parents: 793 diff changeset	636 return _new(_ast.Call, func, args, [])

Mercurial > genshi > mirror

annotate genshi/template/eval.py @ 934:31bbb6f9e87b trunk