genshi/genshi-test: markup/template.py annotate

annotate markup/template.py @ 208:835203f3b8fd

Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35.

author	cmlenz
date	Tue, 29 Aug 2006 15:44:54 +0000
parents	d122ff386411
children	c0c70dc5bf95

rev	line source
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1 # -- coding: utf-8 --
821114ec4f69 Initial import. cmlenz parents: diff changeset	2 #
66 822089ae65ce Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 65 diff changeset	3 # Copyright (C) 2006 Edgewall Software
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	4 # All rights reserved.
821114ec4f69 Initial import. cmlenz parents: diff changeset	5 #
821114ec4f69 Initial import. cmlenz parents: diff changeset	6 # This software is licensed as described in the file COPYING, which
821114ec4f69 Initial import. cmlenz parents: diff changeset	7 # you should have received as part of this distribution. The terms
66 822089ae65ce Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 65 diff changeset	8 # are also available at http://markup.edgewall.org/wiki/License.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	9 #
821114ec4f69 Initial import. cmlenz parents: diff changeset	10 # This software consists of voluntary contributions made by many
821114ec4f69 Initial import. cmlenz parents: diff changeset	11 # individuals. For the exact contribution history, see the revision
66 822089ae65ce Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 65 diff changeset	12 # history and logs, available at http://markup.edgewall.org/log/.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	13
82 c82c002d4c32 Some minor cleanup. cmlenz parents: 81 diff changeset	14 """Implementation of the template engine."""
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	15
70 0498da8e5de7 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations. cmlenz parents: 69 diff changeset	16 try:
0498da8e5de7 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations. cmlenz parents: 69 diff changeset	17 from collections import deque
0498da8e5de7 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations. cmlenz parents: 69 diff changeset	18 except ImportError:
0498da8e5de7 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations. cmlenz parents: 69 diff changeset	19 class deque(list):
0498da8e5de7 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations. cmlenz parents: 69 diff changeset	20 def appendleft(self, x): self.insert(0, x)
0498da8e5de7 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations. cmlenz parents: 69 diff changeset	21 def popleft(self): return self.pop(0)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	22 import compiler
821114ec4f69 Initial import. cmlenz parents: diff changeset	23 import os
821114ec4f69 Initial import. cmlenz parents: diff changeset	24 import re
821114ec4f69 Initial import. cmlenz parents: diff changeset	25 from StringIO import StringIO
821114ec4f69 Initial import. cmlenz parents: diff changeset	26
182 41db0260ebb1 Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 181 diff changeset	27 from markup.core import Attrs, Namespace, Stream, StreamEventKind, _ensure
145 56d534eb53f9 * Fix error in expression evaluation when the expression evaluates to an iterable that does not produce event tuples. cmlenz parents: 140 diff changeset	28 from markup.core import START, END, START_NS, END_NS, TEXT, COMMENT
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	29 from markup.eval import Expression
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	30 from markup.input import XMLParser
14 76b5d4b189e6 The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general. cmlenz parents: 13 diff changeset	31 from markup.path import Path
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	32
150 39a8012f60e3 Removed to many classes from the `__all__` list of `markup.template` in [191]. cmlenz parents: 149 diff changeset	33 __all__ = ['BadDirectiveError', 'TemplateError', 'TemplateSyntaxError',
39a8012f60e3 Removed to many classes from the `__all__` list of `markup.template` in [191]. cmlenz parents: 149 diff changeset	34 'TemplateNotFound', 'Template', 'TemplateLoader']
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	35
821114ec4f69 Initial import. cmlenz parents: diff changeset	36
821114ec4f69 Initial import. cmlenz parents: diff changeset	37 class TemplateError(Exception):
821114ec4f69 Initial import. cmlenz parents: diff changeset	38 """Base exception class for errors related to template processing."""
821114ec4f69 Initial import. cmlenz parents: diff changeset	39
821114ec4f69 Initial import. cmlenz parents: diff changeset	40
821114ec4f69 Initial import. cmlenz parents: diff changeset	41 class TemplateSyntaxError(TemplateError):
821114ec4f69 Initial import. cmlenz parents: diff changeset	42 """Exception raised when an expression in a template causes a Python syntax
821114ec4f69 Initial import. cmlenz parents: diff changeset	43 error."""
821114ec4f69 Initial import. cmlenz parents: diff changeset	44
821114ec4f69 Initial import. cmlenz parents: diff changeset	45 def __init__(self, message, filename='<string>', lineno=-1, offset=-1):
821114ec4f69 Initial import. cmlenz parents: diff changeset	46 if isinstance(message, SyntaxError) and message.lineno is not None:
821114ec4f69 Initial import. cmlenz parents: diff changeset	47 message = str(message).replace(' (line %d)' % message.lineno, '')
80 d5db5e3aec58 * Improve template error messages cmlenz parents: 78 diff changeset	48 message = '%s (%s, line %d)' % (message, filename, lineno)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	49 TemplateError.__init__(self, message)
821114ec4f69 Initial import. cmlenz parents: diff changeset	50 self.filename = filename
821114ec4f69 Initial import. cmlenz parents: diff changeset	51 self.lineno = lineno
821114ec4f69 Initial import. cmlenz parents: diff changeset	52 self.offset = offset
821114ec4f69 Initial import. cmlenz parents: diff changeset	53
821114ec4f69 Initial import. cmlenz parents: diff changeset	54
821114ec4f69 Initial import. cmlenz parents: diff changeset	55 class BadDirectiveError(TemplateSyntaxError):
821114ec4f69 Initial import. cmlenz parents: diff changeset	56 """Exception raised when an unknown directive is encountered when parsing
821114ec4f69 Initial import. cmlenz parents: diff changeset	57 a template.
821114ec4f69 Initial import. cmlenz parents: diff changeset	58
821114ec4f69 Initial import. cmlenz parents: diff changeset	59 An unknown directive is any attribute using the namespace for directives,
821114ec4f69 Initial import. cmlenz parents: diff changeset	60 with a local name that doesn't match any registered directive.
821114ec4f69 Initial import. cmlenz parents: diff changeset	61 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	62
821114ec4f69 Initial import. cmlenz parents: diff changeset	63 def __init__(self, name, filename='<string>', lineno=-1):
181 d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	64 msg = 'bad directive "%s"' % name.localname
80 d5db5e3aec58 * Improve template error messages cmlenz parents: 78 diff changeset	65 TemplateSyntaxError.__init__(self, msg, filename, lineno)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	66
821114ec4f69 Initial import. cmlenz parents: diff changeset	67
821114ec4f69 Initial import. cmlenz parents: diff changeset	68 class TemplateNotFound(TemplateError):
821114ec4f69 Initial import. cmlenz parents: diff changeset	69 """Exception raised when a specific template file could not be found."""
821114ec4f69 Initial import. cmlenz parents: diff changeset	70
821114ec4f69 Initial import. cmlenz parents: diff changeset	71 def __init__(self, name, search_path):
821114ec4f69 Initial import. cmlenz parents: diff changeset	72 TemplateError.__init__(self, 'Template "%s" not found' % name)
821114ec4f69 Initial import. cmlenz parents: diff changeset	73 self.search_path = search_path
821114ec4f69 Initial import. cmlenz parents: diff changeset	74
821114ec4f69 Initial import. cmlenz parents: diff changeset	75
821114ec4f69 Initial import. cmlenz parents: diff changeset	76 class Context(object):
95 7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	77 """Container for template input data.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	78
95 7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	79 A context provides a stack of scopes (represented by dictionaries).
7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	80
7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	81 Template directives such as loops can push a new scope on the stack with
7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	82 data that should only be available inside the loop. When the loop
7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	83 terminates, that scope can get popped off the stack again.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	84
821114ec4f69 Initial import. cmlenz parents: diff changeset	85 >>> ctxt = Context(one='foo', other=1)
821114ec4f69 Initial import. cmlenz parents: diff changeset	86 >>> ctxt.get('one')
821114ec4f69 Initial import. cmlenz parents: diff changeset	87 'foo'
821114ec4f69 Initial import. cmlenz parents: diff changeset	88 >>> ctxt.get('other')
821114ec4f69 Initial import. cmlenz parents: diff changeset	89 1
95 7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	90 >>> ctxt.push(dict(one='frost'))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	91 >>> ctxt.get('one')
821114ec4f69 Initial import. cmlenz parents: diff changeset	92 'frost'
821114ec4f69 Initial import. cmlenz parents: diff changeset	93 >>> ctxt.get('other')
821114ec4f69 Initial import. cmlenz parents: diff changeset	94 1
821114ec4f69 Initial import. cmlenz parents: diff changeset	95 >>> ctxt.pop()
95 7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	96 {'one': 'frost'}
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	97 >>> ctxt.get('one')
821114ec4f69 Initial import. cmlenz parents: diff changeset	98 'foo'
821114ec4f69 Initial import. cmlenz parents: diff changeset	99 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	100
821114ec4f69 Initial import. cmlenz parents: diff changeset	101 def __init__(self, **data):
70 0498da8e5de7 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations. cmlenz parents: 69 diff changeset	102 self.frames = deque([data])
95 7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	103 self.pop = self.frames.popleft
7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	104 self.push = self.frames.appendleft
157 40fc3d36f5b4 Fix for backwards compatibility proposed by cboos in #28. cmlenz parents: 154 diff changeset	105 self._match_templates = []
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	106
821114ec4f69 Initial import. cmlenz parents: diff changeset	107 def __repr__(self):
70 0498da8e5de7 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations. cmlenz parents: 69 diff changeset	108 return repr(self.frames)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	109
821114ec4f69 Initial import. cmlenz parents: diff changeset	110 def __setitem__(self, key, value):
95 7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	111 """Set a variable in the current scope."""
70 0498da8e5de7 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations. cmlenz parents: 69 diff changeset	112 self.frames[0][key] = value
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	113
202 4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	114 def _find(self, key, default=None):
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	115 """Retrieve a given variable's value and frame it was found in.
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	116
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	117 Intented for internal use by directives.
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	118 """
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	119 for frame in self.frames:
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	120 if key in frame:
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	121 return frame[key], frame
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	122 return default, None
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	123
192 cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 191 diff changeset	124 def get(self, key, default=None):
95 7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	125 """Get a variable's value, starting at the current scope and going
7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	126 upward.
29 4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	127 """
70 0498da8e5de7 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations. cmlenz parents: 69 diff changeset	128 for frame in self.frames:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	129 if key in frame:
821114ec4f69 Initial import. cmlenz parents: diff changeset	130 return frame[key]
192 cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 191 diff changeset	131 return default
70 0498da8e5de7 Use `collections.deque` for the template context stack on Python 2.4, which improves performance if there are many context frame pop/push operations. cmlenz parents: 69 diff changeset	132 __getitem__ = get
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	133
95 7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	134 def push(self, data):
7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	135 """Push a new scope on the stack."""
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	136
821114ec4f69 Initial import. cmlenz parents: diff changeset	137 def pop(self):
95 7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	138 """Pop the top-most scope from the stack."""
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	139
821114ec4f69 Initial import. cmlenz parents: diff changeset	140
821114ec4f69 Initial import. cmlenz parents: diff changeset	141 class Directive(object):
821114ec4f69 Initial import. cmlenz parents: diff changeset	142 """Abstract base class for template directives.
821114ec4f69 Initial import. cmlenz parents: diff changeset	143
54 01981cbc7575 Fix a number of escaping problems: cmlenz parents: 53 diff changeset	144 A directive is basically a callable that takes three positional arguments:
01981cbc7575 Fix a number of escaping problems: cmlenz parents: 53 diff changeset	145 `ctxt` is the template data context, `stream` is an iterable over the
01981cbc7575 Fix a number of escaping problems: cmlenz parents: 53 diff changeset	146 events that the directive applies to, and `directives` is is a list of
01981cbc7575 Fix a number of escaping problems: cmlenz parents: 53 diff changeset	147 other directives on the same stream that need to be applied.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	148
821114ec4f69 Initial import. cmlenz parents: diff changeset	149 Directives can be "anonymous" or "registered". Registered directives can be
821114ec4f69 Initial import. cmlenz parents: diff changeset	150 applied by the template author using an XML attribute with the
821114ec4f69 Initial import. cmlenz parents: diff changeset	151 corresponding name in the template. Such directives should be subclasses of
31 9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 29 diff changeset	152 this base class that can be instantiated with the value of the directive
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 29 diff changeset	153 attribute as parameter.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	154
821114ec4f69 Initial import. cmlenz parents: diff changeset	155 Anonymous directives are simply functions conforming to the protocol
821114ec4f69 Initial import. cmlenz parents: diff changeset	156 described above, and can only be applied programmatically (for example by
821114ec4f69 Initial import. cmlenz parents: diff changeset	157 template filters).
821114ec4f69 Initial import. cmlenz parents: diff changeset	158 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	159 __slots__ = ['expr']
821114ec4f69 Initial import. cmlenz parents: diff changeset	160
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	161 def __init__(self, value, filename=None, lineno=-1, offset=-1):
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	162 try:
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	163 self.expr = value and Expression(value, filename, lineno) or None
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	164 except SyntaxError, err:
166 718cba809cea Better error reporting for errors in directive expressions, and when `py:otherwise`/`py:when` are used outside a `py:choose` directive. Thanks to Christian Boos for the initial patch. cmlenz parents: 165 diff changeset	165 err.msg += ' in expression "%s" of "%s" directive' % (value,
172 4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 166 diff changeset	166 self.tagname)
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	167 raise TemplateSyntaxError(err, filename, lineno,
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	168 offset + (err.offset or 0))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	169
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	170 def __call__(self, stream, ctxt, directives):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	171 raise NotImplementedError
821114ec4f69 Initial import. cmlenz parents: diff changeset	172
821114ec4f69 Initial import. cmlenz parents: diff changeset	173 def __repr__(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	174 expr = ''
821114ec4f69 Initial import. cmlenz parents: diff changeset	175 if self.expr is not None:
821114ec4f69 Initial import. cmlenz parents: diff changeset	176 expr = ' "%s"' % self.expr.source
821114ec4f69 Initial import. cmlenz parents: diff changeset	177 return '<%s%s>' % (self.__class__.__name__, expr)
821114ec4f69 Initial import. cmlenz parents: diff changeset	178
172 4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 166 diff changeset	179 def tagname(self):
4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 166 diff changeset	180 """Return the local tag name of the directive as it is used in
4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 166 diff changeset	181 templates.
4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 166 diff changeset	182 """
166 718cba809cea Better error reporting for errors in directive expressions, and when `py:otherwise`/`py:when` are used outside a `py:choose` directive. Thanks to Christian Boos for the initial patch. cmlenz parents: 165 diff changeset	183 return self.__class__.__name__.lower().replace('directive', '')
172 4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 166 diff changeset	184 tagname = property(tagname)
166 718cba809cea Better error reporting for errors in directive expressions, and when `py:otherwise`/`py:when` are used outside a `py:choose` directive. Thanks to Christian Boos for the initial patch. cmlenz parents: 165 diff changeset	185
78 fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	186
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	187 def _apply_directives(stream, ctxt, directives):
161 a25f9fc5787d Various docstring additions and other cosmetic changes. cmlenz parents: 157 diff changeset	188 """Apply the given directives to the stream."""
78 fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	189 if directives:
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	190 stream = directives[0](iter(stream), ctxt, directives[1:])
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	191 return stream
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	192
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	193
821114ec4f69 Initial import. cmlenz parents: diff changeset	194 class AttrsDirective(Directive):
821114ec4f69 Initial import. cmlenz parents: diff changeset	195 """Implementation of the `py:attrs` template directive.
821114ec4f69 Initial import. cmlenz parents: diff changeset	196
205 56f5e93edc48 Add doctest to verify that the `py:attrs` directive correctly handles a sequence of `(name, value)` tuples. cmlenz parents: 202 diff changeset	197 The value of the `py:attrs` attribute should be a dictionary or a sequence
56f5e93edc48 Add doctest to verify that the `py:attrs` directive correctly handles a sequence of `(name, value)` tuples. cmlenz parents: 202 diff changeset	198 of `(name, value)` tuples. The items in that dictionary or sequence are
56f5e93edc48 Add doctest to verify that the `py:attrs` directive correctly handles a sequence of `(name, value)` tuples. cmlenz parents: 202 diff changeset	199 added as attributes to the element:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	200
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	201 >>> tmpl = Template('''<ul xmlns:py="http://markup.edgewall.org/">
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	202 ... <li py:attrs="foo">Bar</li>
821114ec4f69 Initial import. cmlenz parents: diff changeset	203 ... </ul>''')
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	204 >>> print tmpl.generate(foo={'class': 'collapse'})
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	205 <ul>
821114ec4f69 Initial import. cmlenz parents: diff changeset	206 <li class="collapse">Bar</li>
821114ec4f69 Initial import. cmlenz parents: diff changeset	207 </ul>
205 56f5e93edc48 Add doctest to verify that the `py:attrs` directive correctly handles a sequence of `(name, value)` tuples. cmlenz parents: 202 diff changeset	208 >>> print tmpl.generate(foo=[('class', 'collapse')])
56f5e93edc48 Add doctest to verify that the `py:attrs` directive correctly handles a sequence of `(name, value)` tuples. cmlenz parents: 202 diff changeset	209 <ul>
56f5e93edc48 Add doctest to verify that the `py:attrs` directive correctly handles a sequence of `(name, value)` tuples. cmlenz parents: 202 diff changeset	210 <li class="collapse">Bar</li>
56f5e93edc48 Add doctest to verify that the `py:attrs` directive correctly handles a sequence of `(name, value)` tuples. cmlenz parents: 202 diff changeset	211 </ul>
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	212
821114ec4f69 Initial import. cmlenz parents: diff changeset	213 If the value evaluates to `None` (or any other non-truth value), no
821114ec4f69 Initial import. cmlenz parents: diff changeset	214 attributes are added:
821114ec4f69 Initial import. cmlenz parents: diff changeset	215
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	216 >>> print tmpl.generate(foo=None)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	217 <ul>
821114ec4f69 Initial import. cmlenz parents: diff changeset	218 <li>Bar</li>
821114ec4f69 Initial import. cmlenz parents: diff changeset	219 </ul>
821114ec4f69 Initial import. cmlenz parents: diff changeset	220 """
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	221 __slots__ = []
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	222
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	223 def __call__(self, stream, ctxt, directives):
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	224 def _generate():
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	225 kind, (tag, attrib), pos = stream.next()
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	226 attrs = self.expr.evaluate(ctxt)
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	227 if attrs:
182 41db0260ebb1 Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 181 diff changeset	228 attrib = Attrs(attrib[:])
77 f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 75 diff changeset	229 if isinstance(attrs, Stream):
f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 75 diff changeset	230 try:
f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 75 diff changeset	231 attrs = iter(attrs).next()
f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 75 diff changeset	232 except StopIteration:
f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 75 diff changeset	233 attrs = []
f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 75 diff changeset	234 elif not isinstance(attrs, list): # assume it's a dict
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	235 attrs = attrs.items()
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	236 for name, value in attrs:
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	237 if value is None:
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	238 attrib.remove(name)
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	239 else:
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	240 attrib.set(name, unicode(value).strip())
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	241 yield kind, (tag, attrib), pos
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	242 for event in stream:
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	243 yield event
77 f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 75 diff changeset	244
78 fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	245 return _apply_directives(_generate(), ctxt, directives)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	246
821114ec4f69 Initial import. cmlenz parents: diff changeset	247
821114ec4f69 Initial import. cmlenz parents: diff changeset	248 class ContentDirective(Directive):
821114ec4f69 Initial import. cmlenz parents: diff changeset	249 """Implementation of the `py:content` template directive.
821114ec4f69 Initial import. cmlenz parents: diff changeset	250
821114ec4f69 Initial import. cmlenz parents: diff changeset	251 This directive replaces the content of the element with the result of
821114ec4f69 Initial import. cmlenz parents: diff changeset	252 evaluating the value of the `py:content` attribute:
821114ec4f69 Initial import. cmlenz parents: diff changeset	253
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	254 >>> tmpl = Template('''<ul xmlns:py="http://markup.edgewall.org/">
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	255 ... <li py:content="bar">Hello</li>
821114ec4f69 Initial import. cmlenz parents: diff changeset	256 ... </ul>''')
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	257 >>> print tmpl.generate(bar='Bye')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	258 <ul>
821114ec4f69 Initial import. cmlenz parents: diff changeset	259 <li>Bye</li>
821114ec4f69 Initial import. cmlenz parents: diff changeset	260 </ul>
821114ec4f69 Initial import. cmlenz parents: diff changeset	261 """
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	262 __slots__ = []
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	263
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	264 def __call__(self, stream, ctxt, directives):
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	265 def _generate():
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	266 kind, data, pos = stream.next()
101 ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	267 if kind is START:
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	268 yield kind, data, pos # emit start tag
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	269 yield EXPR, self.expr, pos
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	270 previous = stream.next()
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	271 for event in stream:
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	272 previous = event
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	273 if previous is not None:
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	274 yield previous
87 c6f07b7cd3ea Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13. cmlenz parents: 82 diff changeset	275
78 fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	276 return _apply_directives(_generate(), ctxt, directives)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	277
821114ec4f69 Initial import. cmlenz parents: diff changeset	278
821114ec4f69 Initial import. cmlenz parents: diff changeset	279 class DefDirective(Directive):
821114ec4f69 Initial import. cmlenz parents: diff changeset	280 """Implementation of the `py:def` template directive.
821114ec4f69 Initial import. cmlenz parents: diff changeset	281
821114ec4f69 Initial import. cmlenz parents: diff changeset	282 This directive can be used to create "Named Template Functions", which
821114ec4f69 Initial import. cmlenz parents: diff changeset	283 are template snippets that are not actually output during normal
821114ec4f69 Initial import. cmlenz parents: diff changeset	284 processing, but rather can be expanded from expressions in other places
821114ec4f69 Initial import. cmlenz parents: diff changeset	285 in the template.
821114ec4f69 Initial import. cmlenz parents: diff changeset	286
821114ec4f69 Initial import. cmlenz parents: diff changeset	287 A named template function can be used just like a normal Python function
821114ec4f69 Initial import. cmlenz parents: diff changeset	288 from template expressions:
821114ec4f69 Initial import. cmlenz parents: diff changeset	289
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	290 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/">
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	291 ... <p py:def="echo(greeting, name='world')" class="message">
821114ec4f69 Initial import. cmlenz parents: diff changeset	292 ... ${greeting}, ${name}!
821114ec4f69 Initial import. cmlenz parents: diff changeset	293 ... </p>
90 242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 89 diff changeset	294 ... ${echo('Hi', name='you')}
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	295 ... </div>''')
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	296 >>> print tmpl.generate(bar='Bye')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	297 <div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	298 <p class="message">
90 242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 89 diff changeset	299 Hi, you!
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	300 </p>
821114ec4f69 Initial import. cmlenz parents: diff changeset	301 </div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	302
90 242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 89 diff changeset	303 If a function does not require parameters, the parenthesis can be omitted
242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 89 diff changeset	304 both when defining and when calling it:
242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 89 diff changeset	305
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	306 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/">
90 242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 89 diff changeset	307 ... <p py:def="helloworld" class="message">
242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 89 diff changeset	308 ... Hello, world!
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	309 ... </p>
90 242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 89 diff changeset	310 ... ${helloworld}
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	311 ... </div>''')
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	312 >>> print tmpl.generate(bar='Bye')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	313 <div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	314 <p class="message">
90 242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 89 diff changeset	315 Hello, world!
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	316 </p>
821114ec4f69 Initial import. cmlenz parents: diff changeset	317 </div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	318 """
154 1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	319 __slots__ = ['name', 'args', 'defaults']
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	320
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	321 ATTRIBUTE = 'function'
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	322
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	323 def __init__(self, args, filename=None, lineno=-1, offset=-1):
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	324 Directive.__init__(self, None, filename, lineno, offset)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	325 ast = compiler.parse(args, 'eval').node
821114ec4f69 Initial import. cmlenz parents: diff changeset	326 self.args = []
821114ec4f69 Initial import. cmlenz parents: diff changeset	327 self.defaults = {}
821114ec4f69 Initial import. cmlenz parents: diff changeset	328 if isinstance(ast, compiler.ast.CallFunc):
821114ec4f69 Initial import. cmlenz parents: diff changeset	329 self.name = ast.node.name
821114ec4f69 Initial import. cmlenz parents: diff changeset	330 for arg in ast.args:
821114ec4f69 Initial import. cmlenz parents: diff changeset	331 if isinstance(arg, compiler.ast.Keyword):
821114ec4f69 Initial import. cmlenz parents: diff changeset	332 self.args.append(arg.name)
165 4ed68a904235 Fix handling of keyword arguments in `py:def` directive. Thanks to Christian Boos for reporting the problem and providing the basic patch for this change. cmlenz parents: 161 diff changeset	333 self.defaults[arg.name] = Expression(arg.expr, filename,
4ed68a904235 Fix handling of keyword arguments in `py:def` directive. Thanks to Christian Boos for reporting the problem and providing the basic patch for this change. cmlenz parents: 161 diff changeset	334 lineno)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	335 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	336 self.args.append(arg.name)
821114ec4f69 Initial import. cmlenz parents: diff changeset	337 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	338 self.name = ast.name
821114ec4f69 Initial import. cmlenz parents: diff changeset	339
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	340 def __call__(self, stream, ctxt, directives):
154 1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	341 stream = list(stream)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	342
154 1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	343 def function(args, *kwargs):
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	344 scope = {}
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	345 args = list(args) # make mutable
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	346 for name in self.args:
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	347 if args:
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	348 scope[name] = args.pop(0)
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	349 else:
165 4ed68a904235 Fix handling of keyword arguments in `py:def` directive. Thanks to Christian Boos for reporting the problem and providing the basic patch for this change. cmlenz parents: 161 diff changeset	350 if name in kwargs:
4ed68a904235 Fix handling of keyword arguments in `py:def` directive. Thanks to Christian Boos for reporting the problem and providing the basic patch for this change. cmlenz parents: 161 diff changeset	351 val = kwargs.pop(name)
4ed68a904235 Fix handling of keyword arguments in `py:def` directive. Thanks to Christian Boos for reporting the problem and providing the basic patch for this change. cmlenz parents: 161 diff changeset	352 else:
4ed68a904235 Fix handling of keyword arguments in `py:def` directive. Thanks to Christian Boos for reporting the problem and providing the basic patch for this change. cmlenz parents: 161 diff changeset	353 val = self.defaults.get(name).evaluate(ctxt)
4ed68a904235 Fix handling of keyword arguments in `py:def` directive. Thanks to Christian Boos for reporting the problem and providing the basic patch for this change. cmlenz parents: 161 diff changeset	354 scope[name] = val
154 1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	355 ctxt.push(scope)
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	356 for event in _apply_directives(stream, ctxt, directives):
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	357 yield event
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	358 ctxt.pop()
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	359 try:
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	360 function.__name__ = self.name
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	361 except TypeError:
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	362 # Function name can't be set in Python 2.3
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	363 pass
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	364
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	365 # Store the function reference in the bottom context frame so that it
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	366 # doesn't get popped off before processing the template has finished
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	367 ctxt.frames[-1][self.name] = function
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	368
1c404be518d1 * Make sure `py:def` macros don't go out of scope if they are defined inside another directive. cmlenz parents: 153 diff changeset	369 return []
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	370
172 4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 166 diff changeset	371 def __repr__(self):
4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 166 diff changeset	372 return '<%s "%s">' % (self.__class__.__name__, self.name)
4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 166 diff changeset	373
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	374
821114ec4f69 Initial import. cmlenz parents: diff changeset	375 class ForDirective(Directive):
31 9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 29 diff changeset	376 """Implementation of the `py:for` template directive for repeating an
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 29 diff changeset	377 element based on an iterable in the context data.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	378
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	379 >>> tmpl = Template('''<ul xmlns:py="http://markup.edgewall.org/">
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	380 ... <li py:for="item in items">${item}</li>
821114ec4f69 Initial import. cmlenz parents: diff changeset	381 ... </ul>''')
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	382 >>> print tmpl.generate(items=[1, 2, 3])
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	383 <ul>
821114ec4f69 Initial import. cmlenz parents: diff changeset	384 <li>1</li><li>2</li><li>3</li>
821114ec4f69 Initial import. cmlenz parents: diff changeset	385 </ul>
821114ec4f69 Initial import. cmlenz parents: diff changeset	386 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	387 __slots__ = ['targets']
821114ec4f69 Initial import. cmlenz parents: diff changeset	388
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	389 ATTRIBUTE = 'each'
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	390
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	391 def __init__(self, value, filename=None, lineno=-1, offset=-1):
181 d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	392 if ' in ' not in value:
d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	393 raise TemplateSyntaxError('"in" keyword missing in "for" directive',
d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	394 filename, lineno, offset)
29 4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	395 targets, value = value.split(' in ', 1)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	396 self.targets = [str(name.strip()) for name in targets.split(',')]
140 a2edde90ad24 Fix bug in HTML serializer, plus some other minor tweaks. cmlenz parents: 139 diff changeset	397 Directive.__init__(self, value.strip(), filename, lineno, offset)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	398
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	399 def __call__(self, stream, ctxt, directives):
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	400 iterable = self.expr.evaluate(ctxt)
101 ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	401 if iterable is None:
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	402 return
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	403
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	404 scope = {}
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	405 stream = list(stream)
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	406 targets = self.targets
140 a2edde90ad24 Fix bug in HTML serializer, plus some other minor tweaks. cmlenz parents: 139 diff changeset	407 single = len(targets) == 1
101 ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	408 for item in iter(iterable):
140 a2edde90ad24 Fix bug in HTML serializer, plus some other minor tweaks. cmlenz parents: 139 diff changeset	409 if single:
101 ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	410 scope[targets[0]] = item
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	411 else:
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	412 for idx, name in enumerate(targets):
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	413 scope[name] = item[idx]
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	414 ctxt.push(scope)
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	415 for event in _apply_directives(stream, ctxt, directives):
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	416 yield event
ef6794139671 Ported [115] to trunk. cmlenz parents: 95 diff changeset	417 ctxt.pop()
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	418
821114ec4f69 Initial import. cmlenz parents: diff changeset	419 def __repr__(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	420 return '<%s "%s in %s">' % (self.__class__.__name__,
821114ec4f69 Initial import. cmlenz parents: diff changeset	421 ', '.join(self.targets), self.expr.source)
821114ec4f69 Initial import. cmlenz parents: diff changeset	422
821114ec4f69 Initial import. cmlenz parents: diff changeset	423
821114ec4f69 Initial import. cmlenz parents: diff changeset	424 class IfDirective(Directive):
31 9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 29 diff changeset	425 """Implementation of the `py:if` template directive for conditionally
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 29 diff changeset	426 excluding elements from being output.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	427
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	428 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/">
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	429 ... <b py:if="foo">${bar}</b>
821114ec4f69 Initial import. cmlenz parents: diff changeset	430 ... </div>''')
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	431 >>> print tmpl.generate(foo=True, bar='Hello')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	432 <div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	433 <b>Hello</b>
821114ec4f69 Initial import. cmlenz parents: diff changeset	434 </div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	435 """
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	436 __slots__ = []
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	437
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	438 ATTRIBUTE = 'test'
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	439
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	440 def __call__(self, stream, ctxt, directives):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	441 if self.expr.evaluate(ctxt):
78 fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	442 return _apply_directives(stream, ctxt, directives)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	443 return []
821114ec4f69 Initial import. cmlenz parents: diff changeset	444
821114ec4f69 Initial import. cmlenz parents: diff changeset	445
821114ec4f69 Initial import. cmlenz parents: diff changeset	446 class MatchDirective(Directive):
821114ec4f69 Initial import. cmlenz parents: diff changeset	447 """Implementation of the `py:match` template directive.
14 76b5d4b189e6 The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general. cmlenz parents: 13 diff changeset	448
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	449 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/">
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	450 ... <span py:match="greeting">
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	451 ... Hello ${select('@name')}
821114ec4f69 Initial import. cmlenz parents: diff changeset	452 ... </span>
821114ec4f69 Initial import. cmlenz parents: diff changeset	453 ... <greeting name="Dude" />
821114ec4f69 Initial import. cmlenz parents: diff changeset	454 ... </div>''')
14 76b5d4b189e6 The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general. cmlenz parents: 13 diff changeset	455 >>> print tmpl.generate()
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	456 <div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	457 <span>
821114ec4f69 Initial import. cmlenz parents: diff changeset	458 Hello Dude
821114ec4f69 Initial import. cmlenz parents: diff changeset	459 </span>
821114ec4f69 Initial import. cmlenz parents: diff changeset	460 </div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	461 """
199 58284b6b0009 * Removed storage of substream in `MatchDirective`, because it's already being stored in the match templates (related to #39). cmlenz parents: 193 diff changeset	462 __slots__ = ['path']
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	463
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	464 ATTRIBUTE = 'path'
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	465
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	466 def __init__(self, value, filename=None, lineno=-1, offset=-1):
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	467 Directive.__init__(self, None, filename, lineno, offset)
139 54131cbb91a5 Implement position reporting for XPath syntax errors. Closes #20. cmlenz parents: 134 diff changeset	468 self.path = Path(value, filename, lineno)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	469
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	470 def __call__(self, stream, ctxt, directives):
38 fec9f4897415 Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now. cmlenz parents: 37 diff changeset	471 ctxt._match_templates.append((self.path.test(ignore_context=True),
199 58284b6b0009 * Removed storage of substream in `MatchDirective`, because it's already being stored in the match templates (related to #39). cmlenz parents: 193 diff changeset	472 self.path, list(stream), directives))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	473 return []
821114ec4f69 Initial import. cmlenz parents: diff changeset	474
821114ec4f69 Initial import. cmlenz parents: diff changeset	475 def __repr__(self):
14 76b5d4b189e6 The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general. cmlenz parents: 13 diff changeset	476 return '<%s "%s">' % (self.__class__.__name__, self.path.source)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	477
821114ec4f69 Initial import. cmlenz parents: diff changeset	478
821114ec4f69 Initial import. cmlenz parents: diff changeset	479 class ReplaceDirective(Directive):
821114ec4f69 Initial import. cmlenz parents: diff changeset	480 """Implementation of the `py:replace` template directive.
821114ec4f69 Initial import. cmlenz parents: diff changeset	481
31 9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 29 diff changeset	482 This directive replaces the element with the result of evaluating the
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 29 diff changeset	483 value of the `py:replace` attribute:
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 29 diff changeset	484
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	485 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/">
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	486 ... <span py:replace="bar">Hello</span>
821114ec4f69 Initial import. cmlenz parents: diff changeset	487 ... </div>''')
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	488 >>> print tmpl.generate(bar='Bye')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	489 <div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	490 Bye
821114ec4f69 Initial import. cmlenz parents: diff changeset	491 </div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	492
821114ec4f69 Initial import. cmlenz parents: diff changeset	493 This directive is equivalent to `py:content` combined with `py:strip`,
821114ec4f69 Initial import. cmlenz parents: diff changeset	494 providing a less verbose way to achieve the same effect:
821114ec4f69 Initial import. cmlenz parents: diff changeset	495
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	496 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/">
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	497 ... <span py:content="bar" py:strip="">Hello</span>
821114ec4f69 Initial import. cmlenz parents: diff changeset	498 ... </div>''')
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	499 >>> print tmpl.generate(bar='Bye')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	500 <div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	501 Bye
821114ec4f69 Initial import. cmlenz parents: diff changeset	502 </div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	503 """
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	504 __slots__ = []
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	505
54 01981cbc7575 Fix a number of escaping problems: cmlenz parents: 53 diff changeset	506 def __call__(self, stream, ctxt, directives):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	507 kind, data, pos = stream.next()
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	508 yield EXPR, self.expr, pos
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	509
821114ec4f69 Initial import. cmlenz parents: diff changeset	510
821114ec4f69 Initial import. cmlenz parents: diff changeset	511 class StripDirective(Directive):
821114ec4f69 Initial import. cmlenz parents: diff changeset	512 """Implementation of the `py:strip` template directive.
821114ec4f69 Initial import. cmlenz parents: diff changeset	513
821114ec4f69 Initial import. cmlenz parents: diff changeset	514 When the value of the `py:strip` attribute evaluates to `True`, the element
821114ec4f69 Initial import. cmlenz parents: diff changeset	515 is stripped from the output
821114ec4f69 Initial import. cmlenz parents: diff changeset	516
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	517 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/">
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	518 ... <div py:strip="True"><b>foo</b></div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	519 ... </div>''')
14 76b5d4b189e6 The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general. cmlenz parents: 13 diff changeset	520 >>> print tmpl.generate()
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	521 <div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	522 <b>foo</b>
821114ec4f69 Initial import. cmlenz parents: diff changeset	523 </div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	524
37 224b0b41d1da Moved some of the tests for the strip directive to a new unittest test case to not clutter up the documentation. cmlenz parents: 36 diff changeset	525 Leaving the attribute value empty is equivalent to a truth value.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	526
821114ec4f69 Initial import. cmlenz parents: diff changeset	527 This directive is particulary interesting for named template functions or
821114ec4f69 Initial import. cmlenz parents: diff changeset	528 match templates that do not generate a top-level element:
821114ec4f69 Initial import. cmlenz parents: diff changeset	529
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	530 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/">
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	531 ... <div py:def="echo(what)" py:strip="">
821114ec4f69 Initial import. cmlenz parents: diff changeset	532 ... <b>${what}</b>
821114ec4f69 Initial import. cmlenz parents: diff changeset	533 ... </div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	534 ... ${echo('foo')}
821114ec4f69 Initial import. cmlenz parents: diff changeset	535 ... </div>''')
14 76b5d4b189e6 The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general. cmlenz parents: 13 diff changeset	536 >>> print tmpl.generate()
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	537 <div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	538 <b>foo</b>
821114ec4f69 Initial import. cmlenz parents: diff changeset	539 </div>
821114ec4f69 Initial import. cmlenz parents: diff changeset	540 """
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	541 __slots__ = []
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	542
54 01981cbc7575 Fix a number of escaping problems: cmlenz parents: 53 diff changeset	543 def __call__(self, stream, ctxt, directives):
78 fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	544 def _generate():
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	545 if self.expr:
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	546 strip = self.expr.evaluate(ctxt)
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	547 else:
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	548 strip = True
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	549 if strip:
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	550 stream.next() # skip start tag
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	551 previous = stream.next()
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	552 for event in stream:
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	553 yield previous
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	554 previous = event
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	555 else:
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	556 for event in stream:
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	557 yield event
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	558
fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	559 return _apply_directives(_generate(), ctxt, directives)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	560
821114ec4f69 Initial import. cmlenz parents: diff changeset	561
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	562 class ChooseDirective(Directive):
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	563 """Implementation of the `py:choose` directive for conditionally selecting
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	564 one of several body elements to display.
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	565
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	566 If the `py:choose` expression is empty the expressions of nested `py:when`
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	567 directives are tested for truth. The first true `py:when` body is output.
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	568 If no `py:when` directive is matched then the fallback directive
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	569 `py:otherwise` will be used.
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	570
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	571 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	572 ... py:choose="">
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	573 ... <span py:when="0 == 1">0</span>
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	574 ... <span py:when="1 == 1">1</span>
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	575 ... <span py:otherwise="">2</span>
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	576 ... </div>''')
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	577 >>> print tmpl.generate()
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	578 <div>
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	579 <span>1</span>
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	580 </div>
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	581
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	582 If the `py:choose` directive contains an expression, the nested `py:when`
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	583 directives are tested for equality to the `py:choose` expression:
60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	584
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	585 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	586 ... py:choose="2">
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	587 ... <span py:when="1">1</span>
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	588 ... <span py:when="2">2</span>
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	589 ... </div>''')
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	590 >>> print tmpl.generate()
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	591 <div>
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	592 <span>2</span>
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	593 </div>
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	594
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	595 Behavior is undefined if a `py:choose` block contains content outside a
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	596 `py:when` or `py:otherwise` block. Behavior is also undefined if a
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	597 `py:otherwise` occurs before `py:when` blocks.
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	598 """
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	599 __slots__ = ['matched', 'value']
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	600
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	601 ATTRIBUTE = 'test'
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	602
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	603 def __call__(self, stream, ctxt, directives):
202 4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	604 frame = dict({'_choose.matched': False})
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	605 if self.expr:
202 4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	606 frame['_choose.value'] = self.expr.evaluate(ctxt)
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	607 ctxt.push(frame)
78 fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	608 for event in _apply_directives(stream, ctxt, directives):
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	609 yield event
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	610 ctxt.pop()
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	611
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	612
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	613 class WhenDirective(Directive):
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	614 """Implementation of the `py:when` directive for nesting in a parent with
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	615 the `py:choose` directive.
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	616
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	617 See the documentation of `py:choose` for usage.
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	618 """
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	619
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	620 ATTRIBUTE = 'test'
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	621
54 01981cbc7575 Fix a number of escaping problems: cmlenz parents: 53 diff changeset	622 def __call__(self, stream, ctxt, directives):
202 4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	623 matched, frame = ctxt._find('_choose.matched')
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	624 if not frame:
181 d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	625 raise TemplateSyntaxError('"when" directives can only be used '
d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	626 'inside a "choose" directive',
d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	627 *stream.next()[2])
202 4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	628 if matched:
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	629 return []
181 d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	630 if not self.expr:
d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	631 raise TemplateSyntaxError('"when" directive has no test condition',
d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	632 *stream.next()[2])
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	633 value = self.expr.evaluate(ctxt)
202 4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	634 if '_choose.value' in frame:
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	635 matched = (value == frame['_choose.value'])
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	636 else:
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	637 matched = bool(value)
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	638 frame['_choose.matched'] = matched
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	639 if not matched:
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	640 return []
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	641
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	642 return _apply_directives(stream, ctxt, directives)
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	643
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	644
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	645 class OtherwiseDirective(Directive):
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	646 """Implementation of the `py:otherwise` directive for nesting in a parent
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	647 with the `py:choose` directive.
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	648
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	649 See the documentation of `py:choose` for usage.
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	650 """
54 01981cbc7575 Fix a number of escaping problems: cmlenz parents: 53 diff changeset	651 def __call__(self, stream, ctxt, directives):
202 4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	652 matched, frame = ctxt._find('_choose.matched')
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	653 if not frame:
181 d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	654 raise TemplateSyntaxError('an "otherwise" directive can only be '
d07ce6c1dbbe Some error message improvements for template directives. Thanks to Christian Boos for the patch! cmlenz parents: 179 diff changeset	655 'used inside a "choose" directive',
166 718cba809cea Better error reporting for errors in directive expressions, and when `py:otherwise`/`py:when` are used outside a `py:choose` directive. Thanks to Christian Boos for the initial patch. cmlenz parents: 165 diff changeset	656 *stream.next()[2])
202 4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	657 if matched:
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	658 return []
202 4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	659 frame['_choose.matched'] = True
4140bff0d7d2 Remove the (hopefully) last instance where directives store state in instance variables, allowing templates to be cached and reused in a threadsafe manner. Closes #39. Many thanks to Christian Boos for the patch! cmlenz parents: 199 diff changeset	660
78 fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	661 return _apply_directives(stream, ctxt, directives)
44 42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	662
42bcb91bf025 implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks mgood parents: 38 diff changeset	663
104 e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	664 class WithDirective(Directive):
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	665 """Implementation of the `py:with` template directive, which allows
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	666 shorthand access to variables and expressions.
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	667
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	668 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/">
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	669 ... <span py:with="y=7; z=x+10">$x $y $z</span>
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	670 ... </div>''')
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	671 >>> print tmpl.generate(x=42)
104 e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	672 <div>
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	673 <span>42 7 52</span>
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	674 </div>
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	675 """
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	676 __slots__ = ['vars']
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	677
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	678 ATTRIBUTE = 'vars'
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	679
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	680 def __init__(self, value, filename=None, lineno=-1, offset=-1):
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	681 Directive.__init__(self, None, filename, lineno, offset)
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	682 self.vars = []
190 f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	683 value = value.strip()
104 e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	684 try:
190 f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	685 ast = compiler.parse(value, 'exec').node
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	686 for node in ast.nodes:
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	687 if isinstance(node, compiler.ast.Discard):
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	688 continue
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	689 elif not isinstance(node, compiler.ast.Assign):
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	690 raise TemplateSyntaxError('only assignment allowed in '
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	691 'value of the "with" directive',
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	692 filename, lineno, offset)
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	693 self.vars.append(([n.name for n in node.nodes],
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	694 Expression(node.expr, filename, lineno)))
104 e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	695 except SyntaxError, err:
190 f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	696 err.msg += ' in expression "%s" of "%s" directive' % (value,
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	697 self.tagname)
104 e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	698 raise TemplateSyntaxError(err, filename, lineno,
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	699 offset + (err.offset or 0))
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	700
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	701 def __call__(self, stream, ctxt, directives):
190 f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	702 frame = {}
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	703 ctxt.push(frame)
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	704 for names, expr in self.vars:
f0b32f1c478c Improvements for the `py:with` directive: cmlenz parents: 185 diff changeset	705 value = expr.evaluate(ctxt, nocall=True)
193 76129a79458d Fix for Python 2.3 compatibility in `py:with` directive (regression in [240]). cmlenz parents: 192 diff changeset	706 frame.update(dict([(name, value) for name in names]))
104 e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	707 for event in _apply_directives(stream, ctxt, directives):
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	708 yield event
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	709 ctxt.pop()
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	710
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	711 def __repr__(self):
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	712 return '<%s "%s">' % (self.__class__.__name__,
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	713 '; '.join(['%s = %s' % (name, expr.source)
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	714 for name, expr in self.vars]))
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	715
e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	716
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	717 class Template(object):
821114ec4f69 Initial import. cmlenz parents: diff changeset	718 """Can parse a template and transform it into the corresponding output
821114ec4f69 Initial import. cmlenz parents: diff changeset	719 based on context data.
821114ec4f69 Initial import. cmlenz parents: diff changeset	720 """
61 33c2702cf6da Use a different namespace than Kid uses. cmlenz parents: 54 diff changeset	721 NAMESPACE = Namespace('http://markup.edgewall.org/')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	722
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	723 EXPR = StreamEventKind('EXPR') # an expression
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	724 SUB = StreamEventKind('SUB') # a "subprogram"
10 c5890ef863ba Moved the template-specific stream event kinds into the template module. cmlenz parents: 6 diff changeset	725
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	726 directives = [('def', DefDirective),
821114ec4f69 Initial import. cmlenz parents: diff changeset	727 ('match', MatchDirective),
120 eb6cead67474 * Allow `py:with` directives to define `lambda`s cmlenz parents: 116 diff changeset	728 ('when', WhenDirective),
eb6cead67474 * Allow `py:with` directives to define `lambda`s cmlenz parents: 116 diff changeset	729 ('otherwise', OtherwiseDirective),
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	730 ('for', ForDirective),
821114ec4f69 Initial import. cmlenz parents: diff changeset	731 ('if', IfDirective),
53 60f1a556690e * Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive. cmlenz parents: 51 diff changeset	732 ('choose', ChooseDirective),
104 e9259920db05 Added `py:with` directive based on Jonas' patch in #17. cmlenz parents: 101 diff changeset	733 ('with', WithDirective),
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	734 ('replace', ReplaceDirective),
821114ec4f69 Initial import. cmlenz parents: diff changeset	735 ('content', ContentDirective),
821114ec4f69 Initial import. cmlenz parents: diff changeset	736 ('attrs', AttrsDirective),
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	737 ('strip', StripDirective)]
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	738 _dir_by_name = dict(directives)
821114ec4f69 Initial import. cmlenz parents: diff changeset	739 _dir_order = [directive[1] for directive in directives]
821114ec4f69 Initial import. cmlenz parents: diff changeset	740
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	741 def __init__(self, source, basedir=None, filename=None):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	742 """Initialize a template from either a string or a file-like object."""
821114ec4f69 Initial import. cmlenz parents: diff changeset	743 if isinstance(source, basestring):
821114ec4f69 Initial import. cmlenz parents: diff changeset	744 self.source = StringIO(source)
821114ec4f69 Initial import. cmlenz parents: diff changeset	745 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	746 self.source = source
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	747 self.basedir = basedir
172 4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 166 diff changeset	748 self.filename = filename
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	749 if basedir and filename:
eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	750 self.filepath = os.path.join(basedir, filename)
eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	751 else:
172 4b4e80b2b0b5 Fix for #30 (trouble using `py:def`inside a match template) cmlenz parents: 166 diff changeset	752 self.filepath = None
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	753
23 00835401c8cc Separate match and eval filters from the include and user-supplied filters. cmlenz parents: 22 diff changeset	754 self.filters = []
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	755 self.parse()
821114ec4f69 Initial import. cmlenz parents: diff changeset	756
821114ec4f69 Initial import. cmlenz parents: diff changeset	757 def __repr__(self):
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	758 return '<%s "%s">' % (self.__class__.__name__, self.filename)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	759
821114ec4f69 Initial import. cmlenz parents: diff changeset	760 def parse(self):
821114ec4f69 Initial import. cmlenz parents: diff changeset	761 """Parse the template.
821114ec4f69 Initial import. cmlenz parents: diff changeset	762
821114ec4f69 Initial import. cmlenz parents: diff changeset	763 The parsing stage parses the XML template and constructs a list of
821114ec4f69 Initial import. cmlenz parents: diff changeset	764 directives that will be executed in the render stage. The input is
821114ec4f69 Initial import. cmlenz parents: diff changeset	765 split up into literal output (markup that does not depend on the
821114ec4f69 Initial import. cmlenz parents: diff changeset	766 context data) and actual directives (commands or variable
821114ec4f69 Initial import. cmlenz parents: diff changeset	767 substitution).
821114ec4f69 Initial import. cmlenz parents: diff changeset	768 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	769 stream = [] # list of events of the "compiled" template
821114ec4f69 Initial import. cmlenz parents: diff changeset	770 dirmap = {} # temporary mapping of directives to elements
821114ec4f69 Initial import. cmlenz parents: diff changeset	771 ns_prefix = {}
821114ec4f69 Initial import. cmlenz parents: diff changeset	772 depth = 0
821114ec4f69 Initial import. cmlenz parents: diff changeset	773
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	774 for kind, data, pos in XMLParser(self.source, filename=self.filename):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	775
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	776 if kind is START_NS:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	777 # Strip out the namespace declaration for template directives
821114ec4f69 Initial import. cmlenz parents: diff changeset	778 prefix, uri = data
821114ec4f69 Initial import. cmlenz parents: diff changeset	779 if uri == self.NAMESPACE:
821114ec4f69 Initial import. cmlenz parents: diff changeset	780 ns_prefix[prefix] = uri
821114ec4f69 Initial import. cmlenz parents: diff changeset	781 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	782 stream.append((kind, data, pos))
821114ec4f69 Initial import. cmlenz parents: diff changeset	783
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	784 elif kind is END_NS:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	785 if data in ns_prefix:
821114ec4f69 Initial import. cmlenz parents: diff changeset	786 del ns_prefix[data]
821114ec4f69 Initial import. cmlenz parents: diff changeset	787 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	788 stream.append((kind, data, pos))
821114ec4f69 Initial import. cmlenz parents: diff changeset	789
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	790 elif kind is START:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	791 # Record any directive attributes in start tags
821114ec4f69 Initial import. cmlenz parents: diff changeset	792 tag, attrib = data
821114ec4f69 Initial import. cmlenz parents: diff changeset	793 directives = []
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	794 strip = False
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	795
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	796 if tag in self.NAMESPACE:
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	797 cls = self._dir_by_name.get(tag.localname)
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	798 if cls is None:
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	799 raise BadDirectiveError(tag, pos[0], pos[1])
66 822089ae65ce Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 65 diff changeset	800 value = attrib.get(getattr(cls, 'ATTRIBUTE', None), '')
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	801 directives.append(cls(value, *pos))
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	802 strip = True
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	803
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	804 new_attrib = []
821114ec4f69 Initial import. cmlenz parents: diff changeset	805 for name, value in attrib:
18 4cbebb15a834 Actually make use of the `markup.core.Namespace` class, and add a couple of doctests. cmlenz parents: 17 diff changeset	806 if name in self.NAMESPACE:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	807 cls = self._dir_by_name.get(name.localname)
821114ec4f69 Initial import. cmlenz parents: diff changeset	808 if cls is None:
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	809 raise BadDirectiveError(name, pos[0], pos[1])
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	810 directives.append(cls(value, *pos))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	811 else:
75 c3c26300a46d Empty attributes in templates were being stripped out. Thanks to Jonas for the patch. cmlenz parents: 74 diff changeset	812 if value:
c3c26300a46d Empty attributes in templates were being stripped out. Thanks to Jonas for the patch. cmlenz parents: 74 diff changeset	813 value = list(self._interpolate(value, *pos))
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	814 if len(value) == 1 and value[0][0] is TEXT:
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	815 value = value[0][1]
75 c3c26300a46d Empty attributes in templates were being stripped out. Thanks to Jonas for the patch. cmlenz parents: 74 diff changeset	816 else:
c3c26300a46d Empty attributes in templates were being stripped out. Thanks to Jonas for the patch. cmlenz parents: 74 diff changeset	817 value = [(TEXT, u'', pos)]
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	818 new_attrib.append((name, value))
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	819
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	820 if directives:
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	821 directives.sort(lambda a, b: cmp(self._dir_order.index(a.__class__),
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	822 self._dir_order.index(b.__class__)))
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	823 dirmap[(depth, tag)] = (directives, len(stream), strip)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	824
182 41db0260ebb1 Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 181 diff changeset	825 stream.append((kind, (tag, Attrs(new_attrib)), pos))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	826 depth += 1
821114ec4f69 Initial import. cmlenz parents: diff changeset	827
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	828 elif kind is END:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	829 depth -= 1
821114ec4f69 Initial import. cmlenz parents: diff changeset	830 stream.append((kind, data, pos))
821114ec4f69 Initial import. cmlenz parents: diff changeset	831
821114ec4f69 Initial import. cmlenz parents: diff changeset	832 # If there have have directive attributes with the corresponding
821114ec4f69 Initial import. cmlenz parents: diff changeset	833 # start tag, move the events inbetween into a "subprogram"
821114ec4f69 Initial import. cmlenz parents: diff changeset	834 if (depth, data) in dirmap:
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	835 directives, start_offset, strip = dirmap.pop((depth, data))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	836 substream = stream[start_offset:]
65 5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	837 if strip:
5c024cf58ecb Support the use of directives as elements to reduce the need for using `py:strip`. cmlenz parents: 61 diff changeset	838 substream = substream[1:-1]
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	839 stream[start_offset:] = [(SUB, (directives, substream),
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	840 pos)]
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	841
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	842 elif kind is TEXT:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	843 for kind, data, pos in self._interpolate(data, *pos):
821114ec4f69 Initial import. cmlenz parents: diff changeset	844 stream.append((kind, data, pos))
821114ec4f69 Initial import. cmlenz parents: diff changeset	845
89 d4c7617900e3 Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output. cmlenz parents: 87 diff changeset	846 elif kind is COMMENT:
d4c7617900e3 Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output. cmlenz parents: 87 diff changeset	847 if not data.lstrip().startswith('!'):
d4c7617900e3 Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output. cmlenz parents: 87 diff changeset	848 stream.append((kind, data, pos))
d4c7617900e3 Support comments in templates that are not included in the output, in the same way Kid does: if the comment text starts with a `!` character, it is stripped from the output. cmlenz parents: 87 diff changeset	849
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	850 else:
821114ec4f69 Initial import. cmlenz parents: diff changeset	851 stream.append((kind, data, pos))
821114ec4f69 Initial import. cmlenz parents: diff changeset	852
821114ec4f69 Initial import. cmlenz parents: diff changeset	853 self.stream = stream
821114ec4f69 Initial import. cmlenz parents: diff changeset	854
184 e27a48802987 Interpolate multiline expressions in templates. Thanks to Christian Boos for reporting the problem and providing the fix. cmlenz parents: 182 diff changeset	855 _FULL_EXPR_RE = re.compile(r'(?<!\$)\$\{(.+?)\}', re.DOTALL)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	856 _SHORT_EXPR_RE = re.compile(r'(?<!\$)\$([a-zA-Z][a-zA-Z0-9_\.]*)')
821114ec4f69 Initial import. cmlenz parents: diff changeset	857
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	858 def _interpolate(cls, text, filename=None, lineno=-1, offset=-1):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	859 """Parse the given string and extract expressions.
821114ec4f69 Initial import. cmlenz parents: diff changeset	860
821114ec4f69 Initial import. cmlenz parents: diff changeset	861 This method returns a list containing both literal text and `Expression`
821114ec4f69 Initial import. cmlenz parents: diff changeset	862 objects.
14 76b5d4b189e6 The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general. cmlenz parents: 13 diff changeset	863
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	864 @param text: the text to parse
821114ec4f69 Initial import. cmlenz parents: diff changeset	865 @param lineno: the line number at which the text was found (optional)
821114ec4f69 Initial import. cmlenz parents: diff changeset	866 @param offset: the column number at which the text starts in the source
821114ec4f69 Initial import. cmlenz parents: diff changeset	867 (optional)
821114ec4f69 Initial import. cmlenz parents: diff changeset	868 """
134 df44110ca91d * Improve the accuracy of line numbers for text nodes, so that reported errors about syntax or evaluation errors in expressions point to the right line (not quite perfect yet, though). cmlenz parents: 133 diff changeset	869 def _interpolate(text, patterns, filename=filename, lineno=lineno,
df44110ca91d * Improve the accuracy of line numbers for text nodes, so that reported errors about syntax or evaluation errors in expressions point to the right line (not quite perfect yet, though). cmlenz parents: 133 diff changeset	870 offset=offset):
191 929ef2913b87 Allow leading whitespace in expressions. Closes #38. Thanks to Christian Boos for the patch! cmlenz parents: 190 diff changeset	871 for idx, grp in enumerate(patterns.pop(0).split(text)):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	872 if idx % 2:
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	873 try:
191 929ef2913b87 Allow leading whitespace in expressions. Closes #38. Thanks to Christian Boos for the patch! cmlenz parents: 190 diff changeset	874 yield EXPR, Expression(grp.strip(), filename, lineno), \
134 df44110ca91d * Improve the accuracy of line numbers for text nodes, so that reported errors about syntax or evaluation errors in expressions point to the right line (not quite perfect yet, though). cmlenz parents: 133 diff changeset	875 (filename, lineno, offset)
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	876 except SyntaxError, err:
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	877 raise TemplateSyntaxError(err, filename, lineno,
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	878 offset + (err.offset or 0))
191 929ef2913b87 Allow leading whitespace in expressions. Closes #38. Thanks to Christian Boos for the patch! cmlenz parents: 190 diff changeset	879 elif grp:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	880 if patterns:
191 929ef2913b87 Allow leading whitespace in expressions. Closes #38. Thanks to Christian Boos for the patch! cmlenz parents: 190 diff changeset	881 for result in _interpolate(grp, patterns[:]):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	882 yield result
821114ec4f69 Initial import. cmlenz parents: diff changeset	883 else:
191 929ef2913b87 Allow leading whitespace in expressions. Closes #38. Thanks to Christian Boos for the patch! cmlenz parents: 190 diff changeset	884 yield TEXT, grp.replace('$$', '$'), \
134 df44110ca91d * Improve the accuracy of line numbers for text nodes, so that reported errors about syntax or evaluation errors in expressions point to the right line (not quite perfect yet, though). cmlenz parents: 133 diff changeset	885 (filename, lineno, offset)
191 929ef2913b87 Allow leading whitespace in expressions. Closes #38. Thanks to Christian Boos for the patch! cmlenz parents: 190 diff changeset	886 if '\n' in grp:
929ef2913b87 Allow leading whitespace in expressions. Closes #38. Thanks to Christian Boos for the patch! cmlenz parents: 190 diff changeset	887 lines = grp.splitlines()
134 df44110ca91d * Improve the accuracy of line numbers for text nodes, so that reported errors about syntax or evaluation errors in expressions point to the right line (not quite perfect yet, though). cmlenz parents: 133 diff changeset	888 lineno += len(lines) - 1
df44110ca91d * Improve the accuracy of line numbers for text nodes, so that reported errors about syntax or evaluation errors in expressions point to the right line (not quite perfect yet, though). cmlenz parents: 133 diff changeset	889 offset += len(lines[-1])
df44110ca91d * Improve the accuracy of line numbers for text nodes, so that reported errors about syntax or evaluation errors in expressions point to the right line (not quite perfect yet, though). cmlenz parents: 133 diff changeset	890 else:
191 929ef2913b87 Allow leading whitespace in expressions. Closes #38. Thanks to Christian Boos for the patch! cmlenz parents: 190 diff changeset	891 offset += len(grp)
74 3c271699c398 Fix expression interpolation where both shorthand notation and full notation are used inside a single text node. Thanks Jonas. cmlenz parents: 73 diff changeset	892 return _interpolate(text, [cls._FULL_EXPR_RE, cls._SHORT_EXPR_RE])
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	893 _interpolate = classmethod(_interpolate)
821114ec4f69 Initial import. cmlenz parents: diff changeset	894
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	895 def generate(self, args, *kwargs):
29 4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	896 """Apply the template to the given context data.
4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	897
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	898 Any keyword arguments are made available to the template as context
7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	899 data.
7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	900
7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	901 Only one positional argument is accepted: if it is provided, it must be
7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	902 an instance of the `Context` class, and keyword arguments are ignored.
7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	903 This calling style is used for internal processing.
7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	904
29 4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	905 @return: a markup event stream representing the result of applying
4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	906 the template to the context data.
4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	907 """
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	908 if args:
7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	909 assert len(args) == 1
7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	910 ctxt = args[0]
173 ae5d2f4a378a Fix for #33. cmlenz parents: 172 diff changeset	911 if ctxt is None:
ae5d2f4a378a Fix for #33. cmlenz parents: 172 diff changeset	912 ctxt = Context(**kwargs)
149 7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	913 assert isinstance(ctxt, Context)
7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	914 else:
7306bf730ff3 `Template.generate()` now accepts the context data as keyword arguments, so that you don't have to import the `Context` class every time you want to pass data into a template. cmlenz parents: 145 diff changeset	915 ctxt = Context(**kwargs)
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	916
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	917 stream = self.stream
208 835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	918 for filter_ in [self._flatten, self._eval, self._match] + self.filters:
35 3bc4778787c5 Simplify template processing model by removing dynamically generated `SUB` events. cmlenz parents: 31 diff changeset	919 stream = filter_(iter(stream), ctxt)
3bc4778787c5 Simplify template processing model by removing dynamically generated `SUB` events. cmlenz parents: 31 diff changeset	920 return Stream(stream)
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	921
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	922 def _eval(self, stream, ctxt=None):
29 4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	923 """Internal stream filter that evaluates any expressions in `START` and
4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	924 `TEXT` events.
4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	925 """
208 835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	926 filters = (self._flatten, self._eval)
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	927
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	928 for kind, data, pos in stream:
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	929
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	930 if kind is START and data[1]:
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	931 # Attributes may still contain expressions in start tags at
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	932 # this point, so do some evaluation
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	933 tag, attrib = data
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	934 new_attrib = []
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	935 for name, substream in attrib:
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	936 if isinstance(substream, basestring):
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	937 value = substream
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	938 else:
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	939 values = []
185 8e5a3048b359 Fix for #34: `py:def` macros can now be invoked from within expressions in attribute values. cmlenz parents: 184 diff changeset	940 for subkind, subdata, subpos in self._eval(substream,
8e5a3048b359 Fix for #34: `py:def` macros can now be invoked from within expressions in attribute values. cmlenz parents: 184 diff changeset	941 ctxt):
8e5a3048b359 Fix for #34: `py:def` macros can now be invoked from within expressions in attribute values. cmlenz parents: 184 diff changeset	942 if subkind is TEXT:
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	943 values.append(subdata)
185 8e5a3048b359 Fix for #34: `py:def` macros can now be invoked from within expressions in attribute values. cmlenz parents: 184 diff changeset	944 value = [x for x in values if x is not None]
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	945 if not value:
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	946 continue
23 00835401c8cc Separate match and eval filters from the include and user-supplied filters. cmlenz parents: 22 diff changeset	947 new_attrib.append((name, u''.join(value)))
182 41db0260ebb1 Renamed `Attributes` to `Attrs` to reduce the verbosity. cmlenz parents: 181 diff changeset	948 yield kind, (tag, Attrs(new_attrib)), pos
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	949
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	950 elif kind is EXPR:
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	951 result = data.evaluate(ctxt)
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	952 if result is None:
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	953 continue
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	954
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	955 # First check for a string, otherwise the iterable test below
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	956 # succeeds, and the string will be chopped up into individual
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	957 # characters
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	958 if isinstance(result, basestring):
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	959 yield TEXT, result, pos
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	960 else:
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	961 # Test if the expression evaluated to an iterable, in which
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	962 # case we yield the individual items
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	963 try:
206 d122ff386411 `TypeError`s raised by `py:def` macros (and other expressions producing streams) are no longer silently ignored. Closes #44. cmlenz parents: 205 diff changeset	964 substream = _ensure(iter(result))
d122ff386411 `TypeError`s raised by `py:def` macros (and other expressions producing streams) are no longer silently ignored. Closes #44. cmlenz parents: 205 diff changeset	965 except TypeError:
d122ff386411 `TypeError`s raised by `py:def` macros (and other expressions producing streams) are no longer silently ignored. Closes #44. cmlenz parents: 205 diff changeset	966 # Neither a string nor an iterable, so just pass it
d122ff386411 `TypeError`s raised by `py:def` macros (and other expressions producing streams) are no longer silently ignored. Closes #44. cmlenz parents: 205 diff changeset	967 # through
d122ff386411 `TypeError`s raised by `py:def` macros (and other expressions producing streams) are no longer silently ignored. Closes #44. cmlenz parents: 205 diff changeset	968 yield TEXT, unicode(result), pos
d122ff386411 `TypeError`s raised by `py:def` macros (and other expressions producing streams) are no longer silently ignored. Closes #44. cmlenz parents: 205 diff changeset	969 else:
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	970 for filter_ in filters:
77 f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 75 diff changeset	971 substream = filter_(substream, ctxt)
f1aa49c759b2 * Simplify implementation of the individual XPath tests (use closures instead of callable classes) cmlenz parents: 75 diff changeset	972 for event in substream:
35 3bc4778787c5 Simplify template processing model by removing dynamically generated `SUB` events. cmlenz parents: 31 diff changeset	973 yield event
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	974
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	975 else:
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	976 yield kind, data, pos
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	977
23 00835401c8cc Separate match and eval filters from the include and user-supplied filters. cmlenz parents: 22 diff changeset	978 def _flatten(self, stream, ctxt=None):
29 4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	979 """Internal stream filter that expands `SUB` events in the stream."""
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	980 for kind, data, pos in stream:
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	981 if kind is SUB:
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	982 # This event is a list of directives and a list of nested
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	983 # events to which those directives should be applied
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	984 directives, substream = data
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	985 substream = _apply_directives(substream, ctxt, directives)
208 835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	986 for event in self._flatten(substream, ctxt):
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	987 yield event
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	988 else:
cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 80 diff changeset	989 yield kind, data, pos
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	990
36 57d607f25484 Fix for #7: match templates no longer process their own output. cmlenz parents: 35 diff changeset	991 def _match(self, stream, ctxt=None, match_templates=None):
29 4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	992 """Internal stream filter that applies any defined match templates
4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	993 to the stream.
4b6cee37ce62 * Minor simplification of template directives: they no longer get passed the template instance and the position, as no directive was actually using cmlenz parents: 27 diff changeset	994 """
36 57d607f25484 Fix for #7: match templates no longer process their own output. cmlenz parents: 35 diff changeset	995 if match_templates is None:
57d607f25484 Fix for #7: match templates no longer process their own output. cmlenz parents: 35 diff changeset	996 match_templates = ctxt._match_templates
57d607f25484 Fix for #7: match templates no longer process their own output. cmlenz parents: 35 diff changeset	997
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	998 for kind, data, pos in stream:
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	999
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1000 # We (currently) only care about start and end events for matching
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1001 # We might care about namespace events in the future, though
92 3b75c6730b29 More performance improvements... this time for whitespace normalization and template loops. cmlenz parents: 90 diff changeset	1002 if not match_templates or kind not in (START, END):
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1003 yield kind, data, pos
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1004 continue
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1005
50 a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	1006 for idx, (test, path, template, directives) in \
a053ffb834cb Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives. cmlenz parents: 48 diff changeset	1007 enumerate(match_templates):
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1008
179 a2e0a7986d19 Implemented support for XPath variables in predicates (#31). cmlenz parents: 176 diff changeset	1009 if test(kind, data, pos, ctxt) is True:
208 835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1010
835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1011 # Let the remaining match templates know about the event so
835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1012 # they get a chance to update their internal state
835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1013 for test in [mt[0] for mt in match_templates[idx + 1:]]:
835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1014 test(kind, data, pos, ctxt)
835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1015
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1016 # Consume and store all events until an end event
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1017 # corresponding to this start event is encountered
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1018 content = [(kind, data, pos)]
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1019 depth = 1
208 835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1020 stream = self._match(stream, ctxt)
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1021 while depth > 0:
73 b0fd16111f2e Some more performance tweaks. cmlenz parents: 71 diff changeset	1022 kind, data, pos = stream.next()
b0fd16111f2e Some more performance tweaks. cmlenz parents: 71 diff changeset	1023 if kind is START:
b0fd16111f2e Some more performance tweaks. cmlenz parents: 71 diff changeset	1024 depth += 1
b0fd16111f2e Some more performance tweaks. cmlenz parents: 71 diff changeset	1025 elif kind is END:
b0fd16111f2e Some more performance tweaks. cmlenz parents: 71 diff changeset	1026 depth -= 1
b0fd16111f2e Some more performance tweaks. cmlenz parents: 71 diff changeset	1027 content.append((kind, data, pos))
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1028
208 835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1029 # Make the select() function available in the body of the
835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1030 # match template
835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1031 def select(path):
835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1032 return Stream(content).select(path)
95 7d6426183a90 Improve performance of push/pop operations on the context. cmlenz parents: 93 diff changeset	1033 ctxt.push(dict(select=select))
36 57d607f25484 Fix for #7: match templates no longer process their own output. cmlenz parents: 35 diff changeset	1034
208 835203f3b8fd Cleanup the application of template processing steps (flatten, eval, match) so that they are only performed when necessary. Results in a small performance boost, and also fixes #35. cmlenz parents: 206 diff changeset	1035 # Recursively process the output
78 fa4bafcbe4c7 Minor improvements to how directives are applied in template processing. cmlenz parents: 77 diff changeset	1036 template = _apply_directives(template, ctxt, directives)
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	1037 for event in self._match(self._eval(template, ctxt),
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	1038 ctxt, match_templates[:idx] +
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	1039 match_templates[idx + 1:]):
35 3bc4778787c5 Simplify template processing model by removing dynamically generated `SUB` events. cmlenz parents: 31 diff changeset	1040 yield event
116 88ac4c680120 Merged [135:138/branches/experimental/cspeedups]. cmlenz parents: 111 diff changeset	1041
35 3bc4778787c5 Simplify template processing model by removing dynamically generated `SUB` events. cmlenz parents: 31 diff changeset	1042 ctxt.pop()
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1043 break
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	1044
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	1045 else: # no matches
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1046 yield kind, data, pos
ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1047
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1048
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	1049 EXPR = Template.EXPR
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	1050 SUB = Template.SUB
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	1051
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	1052
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1053 class TemplateLoader(object):
821114ec4f69 Initial import. cmlenz parents: diff changeset	1054 """Responsible for loading templates from files on the specified search
821114ec4f69 Initial import. cmlenz parents: diff changeset	1055 path.
821114ec4f69 Initial import. cmlenz parents: diff changeset	1056
821114ec4f69 Initial import. cmlenz parents: diff changeset	1057 >>> import tempfile
821114ec4f69 Initial import. cmlenz parents: diff changeset	1058 >>> fd, path = tempfile.mkstemp(suffix='.html', prefix='template')
821114ec4f69 Initial import. cmlenz parents: diff changeset	1059 >>> os.write(fd, '<p>$var</p>')
821114ec4f69 Initial import. cmlenz parents: diff changeset	1060 11
821114ec4f69 Initial import. cmlenz parents: diff changeset	1061 >>> os.close(fd)
821114ec4f69 Initial import. cmlenz parents: diff changeset	1062
821114ec4f69 Initial import. cmlenz parents: diff changeset	1063 The template loader accepts a list of directory paths that are then used
821114ec4f69 Initial import. cmlenz parents: diff changeset	1064 when searching for template files, in the given order:
821114ec4f69 Initial import. cmlenz parents: diff changeset	1065
821114ec4f69 Initial import. cmlenz parents: diff changeset	1066 >>> loader = TemplateLoader([os.path.dirname(path)])
821114ec4f69 Initial import. cmlenz parents: diff changeset	1067
821114ec4f69 Initial import. cmlenz parents: diff changeset	1068 The `load()` method first checks the template cache whether the requested
821114ec4f69 Initial import. cmlenz parents: diff changeset	1069 template has already been loaded. If not, it attempts to locate the
821114ec4f69 Initial import. cmlenz parents: diff changeset	1070 template file, and returns the corresponding `Template` object:
821114ec4f69 Initial import. cmlenz parents: diff changeset	1071
821114ec4f69 Initial import. cmlenz parents: diff changeset	1072 >>> template = loader.load(os.path.basename(path))
821114ec4f69 Initial import. cmlenz parents: diff changeset	1073 >>> isinstance(template, Template)
821114ec4f69 Initial import. cmlenz parents: diff changeset	1074 True
821114ec4f69 Initial import. cmlenz parents: diff changeset	1075
821114ec4f69 Initial import. cmlenz parents: diff changeset	1076 Template instances are cached: requesting a template with the same name
821114ec4f69 Initial import. cmlenz parents: diff changeset	1077 results in the same instance being returned:
821114ec4f69 Initial import. cmlenz parents: diff changeset	1078
821114ec4f69 Initial import. cmlenz parents: diff changeset	1079 >>> loader.load(os.path.basename(path)) is template
821114ec4f69 Initial import. cmlenz parents: diff changeset	1080 True
152 064ba1078f92 Add some tests for relative template includes (see #27). cmlenz parents: 150 diff changeset	1081
064ba1078f92 Add some tests for relative template includes (see #27). cmlenz parents: 150 diff changeset	1082 >>> os.remove(path)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1083 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	1084 def __init__(self, search_path=None, auto_reload=False):
821114ec4f69 Initial import. cmlenz parents: diff changeset	1085 """Create the template laoder.
821114ec4f69 Initial import. cmlenz parents: diff changeset	1086
821114ec4f69 Initial import. cmlenz parents: diff changeset	1087 @param search_path: a list of absolute path names that should be
821114ec4f69 Initial import. cmlenz parents: diff changeset	1088 searched for template files
821114ec4f69 Initial import. cmlenz parents: diff changeset	1089 @param auto_reload: whether to check the last modification time of
821114ec4f69 Initial import. cmlenz parents: diff changeset	1090 template files, and reload them if they have changed
821114ec4f69 Initial import. cmlenz parents: diff changeset	1091 """
821114ec4f69 Initial import. cmlenz parents: diff changeset	1092 self.search_path = search_path
821114ec4f69 Initial import. cmlenz parents: diff changeset	1093 if self.search_path is None:
821114ec4f69 Initial import. cmlenz parents: diff changeset	1094 self.search_path = []
821114ec4f69 Initial import. cmlenz parents: diff changeset	1095 self.auto_reload = auto_reload
821114ec4f69 Initial import. cmlenz parents: diff changeset	1096 self._cache = {}
821114ec4f69 Initial import. cmlenz parents: diff changeset	1097 self._mtime = {}
821114ec4f69 Initial import. cmlenz parents: diff changeset	1098
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	1099 def load(self, filename, relative_to=None):
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1100 """Load the template with the given name.
821114ec4f69 Initial import. cmlenz parents: diff changeset	1101
22 31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1102 If the `filename` parameter is relative, this method searches the search
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1103 path trying to locate a template matching the given name. If the file
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1104 name is an absolute path, the search path is not bypassed.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1105
22 31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1106 If requested template is not found, a `TemplateNotFound` exception is
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1107 raised. Otherwise, a `Template` object is returned that represents the
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1108 parsed template.
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1109
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1110 Template instances are cached to avoid having to parse the same
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1111 template file more than once. Thus, subsequent calls of this method
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1112 with the same template file name will return the same `Template`
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1113 object (unless the `auto_reload` option is enabled and the file was
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1114 changed since the last parse.)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1115
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	1116 If the `relative_to` parameter is provided, the `filename` is
eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	1117 interpreted as being relative to that path.
eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	1118
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1119 @param filename: the relative path of the template file to load
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	1120 @param relative_to: the filename of the template from which the new
eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	1121 template is being loaded, or `None` if the template is being loaded
eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	1122 directly
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1123 """
69 e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	1124 from markup.filters import IncludeFilter
e9a3930f8823 A couple of minor performance improvements. cmlenz parents: 66 diff changeset	1125
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	1126 if relative_to:
153 7a4086c22a64 Fix relative includes on Windows. Closes #27. cmlenz parents: 152 diff changeset	1127 filename = os.path.join(os.path.dirname(relative_to), filename)
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1128 filename = os.path.normpath(filename)
22 31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1129
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1130 # First check the cache to avoid reparsing the same file
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1131 try:
821114ec4f69 Initial import. cmlenz parents: diff changeset	1132 tmpl = self._cache[filename]
821114ec4f69 Initial import. cmlenz parents: diff changeset	1133 if not self.auto_reload or \
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	1134 os.path.getmtime(tmpl.filepath) == self._mtime[filename]:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1135 return tmpl
821114ec4f69 Initial import. cmlenz parents: diff changeset	1136 except KeyError:
821114ec4f69 Initial import. cmlenz parents: diff changeset	1137 pass
22 31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1138
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1139 # Bypass the search path if the filename is absolute
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1140 search_path = self.search_path
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1141 if os.path.isabs(filename):
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1142 search_path = [os.path.dirname(filename)]
31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1143
176 7efcbf6b1cf2 Fix control flow for error message when template search path is empty. cmlenz parents: 175 diff changeset	1144 if not search_path:
7efcbf6b1cf2 Fix control flow for error message when template search path is empty. cmlenz parents: 175 diff changeset	1145 raise TemplateError('Search path for templates not configured')
7efcbf6b1cf2 Fix control flow for error message when template search path is empty. cmlenz parents: 175 diff changeset	1146
22 31b13ddf9f53 Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute. cmlenz parents: 21 diff changeset	1147 for dirname in search_path:
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1148 filepath = os.path.join(dirname, filename)
821114ec4f69 Initial import. cmlenz parents: diff changeset	1149 try:
133 b9a0031d4bbb Minor cleanup and performance improvement for the builder module. cmlenz parents: 120 diff changeset	1150 fileobj = open(filepath, 'U')
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1151 try:
21 eca77129518a * Include paths are now interpreted relative to the path of the including template. Closes #3. cmlenz parents: 18 diff changeset	1152 tmpl = Template(fileobj, basedir=dirname, filename=filename)
17 ad63ad459524 Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs. cmlenz parents: 14 diff changeset	1153 tmpl.filters.append(IncludeFilter(self))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1154 finally:
821114ec4f69 Initial import. cmlenz parents: diff changeset	1155 fileobj.close()
821114ec4f69 Initial import. cmlenz parents: diff changeset	1156 self._cache[filename] = tmpl
821114ec4f69 Initial import. cmlenz parents: diff changeset	1157 self._mtime[filename] = os.path.getmtime(filepath)
821114ec4f69 Initial import. cmlenz parents: diff changeset	1158 return tmpl
821114ec4f69 Initial import. cmlenz parents: diff changeset	1159 except IOError:
821114ec4f69 Initial import. cmlenz parents: diff changeset	1160 continue
175 f0cdfcdaa092 Raise error when template search path is empty. cmlenz parents: 173 diff changeset	1161
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1162 raise TemplateNotFound(filename, self.search_path)

Mercurial > genshi > genshi-test

annotate markup/template.py @ 208:835203f3b8fd