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

annotate genshi/template/eval.py @ 897:64f04a2c5e66 trunk

Update changelog and copyright years.

author	cmlenz
date	Thu, 22 Apr 2010 12:01:10 +0000
parents	8ae2c1765068
children	37ce31f46e8a

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
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	27 __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	28 'Undefined', 'UndefinedError']
425 073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	29 __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	30
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	31
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	32 # 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	33 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	34 try:
736 a1e8b24bc1bb Yet another followup fix for #221. cmlenz parents: 733 diff changeset	35 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	36 __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	37 exec 'from sys import *' in {}, _FakeMapping()
739 6de290dec976 Another Python 2.3 fix in the wake of #221. cmlenz parents: 736 diff changeset	38 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	39 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	40 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	41
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	42
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	43 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	44 """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	45 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	46 """
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 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	48 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	49 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	50 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	51 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	52 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	53
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	54
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	55 class Code(object):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	56 """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	57 __slots__ = ['source', 'code', 'ast', '_globals']
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	58
606 37ff75bb4301 Changed the default error handling mode to "strict". cmlenz parents: 604 diff changeset	59 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	60 xform=None):
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	61 """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	62
425 073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	63 :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	64 node
073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	65 :param filename: the (preferably absolute) name of the file containing
073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	66 the code
073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	67 :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	68 :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	69 up in the context; can be either "strict" (the default),
37ff75bb4301 Changed the default error handling mode to "strict". cmlenz parents: 604 diff changeset	70 "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	71 :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	72 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	73 depending on the mode
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	74 """
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	75 if isinstance(source, basestring):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	76 self.source = source
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	77 node = _parse(source, mode=self.mode)
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	78 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	79 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	80 '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	81 self.source = '?'
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	82 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	83 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	84 node.body = source
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	85 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	86 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	87 node.body = [source]
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	88
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	89 self.ast = node
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	90 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	91 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	92 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	93 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	94 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	95 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	96 self._globals = lookup.globals
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	97
715 b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	98 def __getstate__(self):
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	99 state = {'source': self.source, 'ast': self.ast,
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	100 'lookup': self._globals.im_self}
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	101 c = self.code
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	102 state['code'] = (c.co_nlocals, c.co_stacksize, c.co_flags, c.co_code,
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	103 c.co_consts, c.co_names, c.co_varnames, c.co_filename,
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	104 c.co_name, c.co_firstlineno, c.co_lnotab, (), ())
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	105 return state
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	106
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	107 def __setstate__(self, state):
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	108 self.source = state['source']
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	109 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	110 self.code = CodeType(0, *state['code'])
715 b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	111 self._globals = state['lookup'].globals
b5bd8c109209 Enable pickling of `Template` and `Code` objects. cmlenz parents: 702 diff changeset	112
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	113 def __eq__(self, other):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	114 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	115
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	116 def __hash__(self):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	117 return hash(self.code)
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	118
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	119 def __ne__(self, other):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	120 return not self == other
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	121
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	122 def __repr__(self):
860 16d55698006a A bit of cleanup of the `Markup` Python implementation. cmlenz parents: 854 diff changeset	123 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	124
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	125
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	126 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	127 """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	128
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	129 >>> 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	130 >>> 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	131 'Foo'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	132
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	133 >>> 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	134 1
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	135 >>> 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	136 3
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	137 >>> 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	138 'thing'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	139
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	140 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	141 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	142
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	143 >>> 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	144 'thing'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	145
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	146 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	147 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	148
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	149 >>> class MyClass(object):
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	150 ... myattr = 'Bar'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	151 >>> 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	152 >>> 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	153 'Bar'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	154 >>> 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	155 'Bar'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	156 >>> 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	157 'Bar'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	158
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	159 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	160 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	161 expressions:
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	162
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	163 >>> 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	164 >>> 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	165 3
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	166 """
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	167 __slots__ = []
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	168 mode = 'eval'
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	169
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	170 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	171 """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	172
425 073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	173 :param data: a mapping containing the data to evaluate against
073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	174 :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	175 """
418 c478a6fa9e77 Make expression error handling more strict. Closes #88. cmlenz parents: 408 diff changeset	176 __traceback_hide__ = 'before_and_this'
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	177 _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	178 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	179
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	180
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	181 class Suite(Code):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	182 """Executes Python statements used in templates.
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	183
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	184 >>> 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	185 >>> 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	186 >>> data['foo']
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	187 'thing'
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	188 """
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	189 __slots__ = []
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	190 mode = 'exec'
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	191
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	192 def execute(self, data):
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	193 """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	194
425 073640758a42 Try to use proper reStructuredText for docstrings throughout. cmlenz parents: 418 diff changeset	195 :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	196 """
418 c478a6fa9e77 Make expression error handling more strict. Closes #88. cmlenz parents: 408 diff changeset	197 __traceback_hide__ = 'before_and_this'
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	198 _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	199 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	200
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	201
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	202 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	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
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 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	206 """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	207 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	208
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 :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	210 """
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 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	212 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	213 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	214 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	215 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	216 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	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
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 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	220 """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	221
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 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	223 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	224 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	225 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	226
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 >>> 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	228 >>> 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	229 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	230 >>> 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	231 []
853 f33ecf3c319e Convert a bunch of print statements to py3k compatible syntax. cmlenz parents: 845 diff changeset	232 >>> 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	233 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	234
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 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	236 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	237 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	238
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	239 >>> foo('bar')
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	240 Traceback (most recent call last):
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	241 ...
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	242 UndefinedError: "foo" not defined
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
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	244 >>> foo.bar
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	245 Traceback (most recent call last):
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	246 ...
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	247 UndefinedError: "foo" not defined
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	248
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 :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	250 """
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 __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	252
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 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	254 """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	255
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 :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	257 :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	258 """
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	259 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	260 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	261
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	262 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	263 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	264
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 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	266 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	267
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 def __repr__(self):
860 16d55698006a A bit of cleanup of the `Markup` Python implementation. cmlenz parents: 854 diff changeset	269 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	270
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 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	272 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	273
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 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	275 """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	276 __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	277 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	278 __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	279
878 c8cac1b264e4 Apply patch from #324 for Python 2.6.2 compatibility fix. cmlenz parents: 860 diff changeset	280 # 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	281 # http://genshi.edgewall.org/ticket/324
c8cac1b264e4 Apply patch from #324 for Python 2.6.2 compatibility fix. cmlenz parents: 860 diff changeset	282 __length_hint__ = None
c8cac1b264e4 Apply patch from #324 for Python 2.6.2 compatibility fix. cmlenz parents: 860 diff changeset	283
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	284
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 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	286 """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	287
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	288 @classmethod
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	289 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	290 """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	291 the expression or suite.
418 c478a6fa9e77 Make expression error handling more strict. Closes #88. cmlenz parents: 408 diff changeset	292 """
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	293 return {
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	294 '__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	295 '_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	296 '_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	297 '_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	298 '_star_import_patch': _star_import_patch,
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	299 '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	300 }
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
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	302 @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	303 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	304 __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	305 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	306 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	307 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	308 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	309 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	310 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	311
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	312 @classmethod
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	313 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	314 __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	315 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	316 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	317 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	318 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	319 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	320 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	321 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	322 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	323 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	324 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	325 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	326
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	327 @classmethod
691 2298d798513e Minor cleanup in eval module. cmlenz parents: 684 diff changeset	328 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	329 __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	330 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	331 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	332 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	333 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	334 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	335 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	336 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	337 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	338 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	339 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	340 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	341
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	342 @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	343 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	344 """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	345 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	346
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 :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	348 :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	349 """
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 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	351
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 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	354 """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	355
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 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	357 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	358
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 >>> 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	360 >>> 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	361 >>> 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	362 <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	363
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 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	365 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	366
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 >>> 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	368 >>> 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	369 <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	370
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 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	372 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	373
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 :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	375 """
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	376
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 @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	378 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	379 """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	380 __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	381 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	382
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 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	385 """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	386
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 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	388 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	389
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 >>> expr = Expression('nothing', lookup='strict')
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.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	392 Traceback (most recent call last):
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	393 ...
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	394 UndefinedError: "nothing" not defined
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	395
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	396 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	397 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	398
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 >>> expr = Expression('something.nil', lookup='strict')
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 >>> 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	401 Traceback (most recent call last):
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	402 ...
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	403 UndefinedError: {} has no member named "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	404 """
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	405
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	406 @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	407 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	408 """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	409 __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	410 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	411
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	412
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	413 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	414 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	415 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	416 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	417 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	418 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	419 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	420 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	421 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	422 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	423 if isinstance(source, unicode):
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	424 source = '\xef\xbb\xbf' + source.encode('utf-8')
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	425 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	426
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	427
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	428 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	429 xform=None):
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	430 if isinstance(filename, unicode):
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	431 # unicode file names not allowed for code objects
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	432 filename = filename.encode('utf-8', 'replace')
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	433 elif not filename:
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	434 filename = '<string>'
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	435 if lineno <= 0:
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	436 lineno = 1
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	437
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	438 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	439 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	440 '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	441 }.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	442 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	443
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	444 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	445 name = '<Expression %r>' % (source or '?')
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	446 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	447 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	448 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	449 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	450 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	451 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	452 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	453 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	454 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	455 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	456 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	457
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	458 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	459 # 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	460 # to clone the code object while adjusting the line number
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	461 return CodeType(0, code.co_nlocals, code.co_stacksize,
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	462 code.co_flags \| 0x0040, code.co_code, code.co_consts,
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 code.co_names, code.co_varnames, filename, 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	464 lineno, code.co_lnotab, (), ())
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	465 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	466 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	467
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
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	469 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	470 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	471 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	472 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	473 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	474 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	475 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	476 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	477 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	478
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	479
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	480 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	481 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	482 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	483
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	484
405 5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	485 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	486 """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	487 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	488 """
7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	489
357 62de137b9322 Improve the way locals (in list comprehensions, lambdas and generator expressions) are handled in template expressions. cmlenz parents: 343 diff changeset	490 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	491 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	492
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	493 def _extract_names(self, node):
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	494 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	495 def _process(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	496 if isinstance(node, _ast.Name):
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	497 names.add(node.id)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	498 elif isinstance(node, _ast.alias):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	499 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	500 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	501 for elt in node.elts:
896 8ae2c1765068 Fix for infinite recursion when parsing argument names from tuples. Closes #383. cmlenz parents: 878 diff changeset	502 _process(elt)
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	503 if hasattr(node, 'args'):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	504 for arg in node.args:
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	505 _process(arg)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	506 if hasattr(node, 'vararg'):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	507 names.add(node.vararg)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	508 if hasattr(node, 'kwarg'):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	509 names.add(node.kwarg)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	510 elif hasattr(node, 'names'):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	511 for elt in node.names:
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	512 _process(elt)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	513 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	514
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	515 def visit_Str(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	516 if isinstance(node.s, str):
357 62de137b9322 Improve the way locals (in list comprehensions, lambdas and generator expressions) are handled in template expressions. cmlenz parents: 343 diff changeset	517 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	518 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	519 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	520 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	521 return node
5340931530e2 Support for Python code blocks using the `<?python ?>` processing instruction. Closes #84. cmlenz parents: 401 diff changeset	522
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	523 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	524 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	525 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	526 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	527 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	528 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	529 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	530 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	531
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	532 def visit_Import(self, node):
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	533 if len(self.locals) > 1:
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	534 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	535 return ASTTransformer.visit_Import(self, node)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	536
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	537 def visit_ImportFrom(self, node):
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	538 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	539 if has_star_import_bug:
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	540 # 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	541 # 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	542 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	543 _new(_ast.Name, '_star_import_patch'), [
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	544 _new(_ast.Name, '__data__'),
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	545 _new(_ast.Str, node.module)
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	546 ], (), ()))
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	547 return node
806 c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	548 if len(self.locals) > 1:
c66c83861266 Fix for import statements in function defs in template code blocks (#276). cmlenz parents: 803 diff changeset	549 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	550 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	551
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	552 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	553 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	554 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	555
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	556 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	557 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	558 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	559 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	560 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	561
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	562 # 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	563 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	564 gens = []
845 4ec4377f49ee Fix nested list comprehensions & generator expressions (fixes #327) mgood parents: 822 diff changeset	565 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	566 # 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	567 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	568 gen = _new(_ast.comprehension, self.visit(generator.target),
845 4ec4377f49ee Fix nested list comprehensions & generator expressions (fixes #327) mgood parents: 822 diff changeset	569 self.visit(generator.iter),
4ec4377f49ee Fix nested list comprehensions & generator expressions (fixes #327) mgood parents: 822 diff changeset	570 [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	571 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	572
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 # 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	574 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	575 #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	576 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	577 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	578
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 # 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	580 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	581
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 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	583 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	584 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	585 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	586 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	587 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	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_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	590 # 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	591 # 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	592 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	593 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	594 # 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	595 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	596 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	597 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	598 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	599 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	600 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	601 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	602
586 3670ea49c65a Fixes for nonlocal variable access in code blocks, as well as nested function and class definitions. cmlenz parents: 582 diff changeset	603 return node
336 7763f7aec949 Refactoring: `genshi.template` is now a package, it was getting way to crowded in that file. cmlenz parents: diff changeset	604
473 4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	605
4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	606 class ExpressionASTTransformer(TemplateASTTransformer):
4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	607 """Concrete AST transformer that implements the AST transformations needed
4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	608 for code embedded in templates.
4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	609 """
4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	610
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	611 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	612 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	613 return ASTTransformer.visit_Attribute(self, node)
473 4ed941aa0cbf Apply patch from #113, also closing #114. cmlenz parents: 442 diff changeset	614
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	615 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	616 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	617 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	618
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 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	620 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	621 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	622 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	623
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 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	625 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	626 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	627 _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	628 ]
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 _new(_ast.Call, func, args, [])

Mercurial > genshi > mirror

annotate genshi/template/eval.py @ 897:64f04a2c5e66 trunk