Mercurial > genshi > genshi-test
annotate markup/template.py @ 205:56f5e93edc48
Add doctest to verify that the `py:attrs` directive correctly handles a sequence of `(name, value)` tuples.
author | cmlenz |
---|---|
date | Sat, 26 Aug 2006 00:17:03 +0000 |
parents | 4140bff0d7d2 |
children | d122ff386411 |
rev | line source |
---|---|
1 | 1 # -*- coding: utf-8 -*- |
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 | 4 # All rights reserved. |
5 # | |
6 # This software is licensed as described in the file COPYING, which | |
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 | 9 # |
10 # This software consists of voluntary contributions made by many | |
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 | 13 |
82 | 14 """Implementation of the template engine.""" |
1 | 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 | 22 import compiler |
23 import os | |
24 import re | |
25 from StringIO import StringIO | |
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 | 29 from markup.eval import Expression |
69 | 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 | 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 | 35 |
36 | |
37 class TemplateError(Exception): | |
38 """Base exception class for errors related to template processing.""" | |
39 | |
40 | |
41 class TemplateSyntaxError(TemplateError): | |
42 """Exception raised when an expression in a template causes a Python syntax | |
43 error.""" | |
44 | |
45 def __init__(self, message, filename='<string>', lineno=-1, offset=-1): | |
46 if isinstance(message, SyntaxError) and message.lineno is not None: | |
47 message = str(message).replace(' (line %d)' % message.lineno, '') | |
80 | 48 message = '%s (%s, line %d)' % (message, filename, lineno) |
1 | 49 TemplateError.__init__(self, message) |
50 self.filename = filename | |
51 self.lineno = lineno | |
52 self.offset = offset | |
53 | |
54 | |
55 class BadDirectiveError(TemplateSyntaxError): | |
56 """Exception raised when an unknown directive is encountered when parsing | |
57 a template. | |
58 | |
59 An unknown directive is any attribute using the namespace for directives, | |
60 with a local name that doesn't match any registered directive. | |
61 """ | |
62 | |
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 | 65 TemplateSyntaxError.__init__(self, msg, filename, lineno) |
1 | 66 |
67 | |
68 class TemplateNotFound(TemplateError): | |
69 """Exception raised when a specific template file could not be found.""" | |
70 | |
71 def __init__(self, name, search_path): | |
72 TemplateError.__init__(self, 'Template "%s" not found' % name) | |
73 self.search_path = search_path | |
74 | |
75 | |
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 | 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 | 84 |
85 >>> ctxt = Context(one='foo', other=1) | |
86 >>> ctxt.get('one') | |
87 'foo' | |
88 >>> ctxt.get('other') | |
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 | 91 >>> ctxt.get('one') |
92 'frost' | |
93 >>> ctxt.get('other') | |
94 1 | |
95 >>> ctxt.pop() | |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
96 {'one': 'frost'} |
1 | 97 >>> ctxt.get('one') |
98 'foo' | |
99 """ | |
100 | |
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 | 106 |
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 | 109 |
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 | 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 | 129 if key in frame: |
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 | 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 | 136 |
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 | 139 |
140 | |
141 class Directive(object): | |
142 """Abstract base class for template directives. | |
143 | |
54 | 144 A directive is basically a callable that takes three positional arguments: |
145 `ctxt` is the template data context, `stream` is an iterable over the | |
146 events that the directive applies to, and `directives` is is a list of | |
147 other directives on the same stream that need to be applied. | |
1 | 148 |
149 Directives can be "anonymous" or "registered". Registered directives can be | |
150 applied by the template author using an XML attribute with the | |
151 corresponding name in the template. Such directives should be subclasses of | |
31 | 152 this base class that can be instantiated with the value of the directive |
153 attribute as parameter. | |
1 | 154 |
155 Anonymous directives are simply functions conforming to the protocol | |
156 described above, and can only be applied programmatically (for example by | |
157 template filters). | |
158 """ | |
159 __slots__ = ['expr'] | |
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 | 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 | 171 raise NotImplementedError |
172 | |
173 def __repr__(self): | |
174 expr = '' | |
175 if self.expr is not None: | |
176 expr = ' "%s"' % self.expr.source | |
177 return '<%s%s>' % (self.__class__.__name__, expr) | |
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 | 193 |
194 class AttrsDirective(Directive): | |
195 """Implementation of the `py:attrs` template directive. | |
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 | 200 |
61 | 201 >>> tmpl = Template('''<ul xmlns:py="http://markup.edgewall.org/"> |
1 | 202 ... <li py:attrs="foo">Bar</li> |
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 | 205 <ul> |
206 <li class="collapse">Bar</li> | |
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 | 212 |
213 If the value evaluates to `None` (or any other non-truth value), no | |
214 attributes are added: | |
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 | 217 <ul> |
218 <li>Bar</li> | |
219 </ul> | |
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 | 246 |
247 | |
248 class ContentDirective(Directive): | |
249 """Implementation of the `py:content` template directive. | |
250 | |
251 This directive replaces the content of the element with the result of | |
252 evaluating the value of the `py:content` attribute: | |
253 | |
61 | 254 >>> tmpl = Template('''<ul xmlns:py="http://markup.edgewall.org/"> |
1 | 255 ... <li py:content="bar">Hello</li> |
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 | 258 <ul> |
259 <li>Bye</li> | |
260 </ul> | |
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 | 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 | 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 | 277 |
278 | |
279 class DefDirective(Directive): | |
280 """Implementation of the `py:def` template directive. | |
281 | |
282 This directive can be used to create "Named Template Functions", which | |
283 are template snippets that are not actually output during normal | |
284 processing, but rather can be expanded from expressions in other places | |
285 in the template. | |
286 | |
287 A named template function can be used just like a normal Python function | |
288 from template expressions: | |
289 | |
61 | 290 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 291 ... <p py:def="echo(greeting, name='world')" class="message"> |
292 ... ${greeting}, ${name}! | |
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 | 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 | 297 <div> |
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 | 300 </p> |
301 </div> | |
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 | 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 | 309 ... </p> |
90
242610137d1f
When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents:
89
diff
changeset
|
310 ... ${helloworld} |
1 | 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 | 313 <div> |
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 | 316 </p> |
317 </div> | |
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 | 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 | 325 ast = compiler.parse(args, 'eval').node |
326 self.args = [] | |
327 self.defaults = {} | |
328 if isinstance(ast, compiler.ast.CallFunc): | |
329 self.name = ast.node.name | |
330 for arg in ast.args: | |
331 if isinstance(arg, compiler.ast.Keyword): | |
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 | 335 else: |
336 self.args.append(arg.name) | |
337 else: | |
338 self.name = ast.name | |
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 | 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 | 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 | 374 |
375 class ForDirective(Directive): | |
31 | 376 """Implementation of the `py:for` template directive for repeating an |
377 element based on an iterable in the context data. | |
1 | 378 |
61 | 379 >>> tmpl = Template('''<ul xmlns:py="http://markup.edgewall.org/"> |
1 | 380 ... <li py:for="item in items">${item}</li> |
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 | 383 <ul> |
384 <li>1</li><li>2</li><li>3</li> | |
385 </ul> | |
386 """ | |
387 __slots__ = ['targets'] | |
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 | 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 | 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 | 401 if iterable is None: |
402 return | |
403 | |
404 scope = {} | |
405 stream = list(stream) | |
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 | 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 | 410 scope[targets[0]] = item |
411 else: | |
412 for idx, name in enumerate(targets): | |
413 scope[name] = item[idx] | |
414 ctxt.push(scope) | |
415 for event in _apply_directives(stream, ctxt, directives): | |
416 yield event | |
417 ctxt.pop() | |
1 | 418 |
419 def __repr__(self): | |
420 return '<%s "%s in %s">' % (self.__class__.__name__, | |
421 ', '.join(self.targets), self.expr.source) | |
422 | |
423 | |
424 class IfDirective(Directive): | |
31 | 425 """Implementation of the `py:if` template directive for conditionally |
426 excluding elements from being output. | |
1 | 427 |
61 | 428 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 429 ... <b py:if="foo">${bar}</b> |
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 | 432 <div> |
433 <b>Hello</b> | |
434 </div> | |
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 | 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 | 443 return [] |
444 | |
445 | |
446 class MatchDirective(Directive): | |
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 | 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 | 451 ... Hello ${select('@name')} |
452 ... </span> | |
453 ... <greeting name="Dude" /> | |
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 | 456 <div> |
457 <span> | |
458 Hello Dude | |
459 </span> | |
460 </div> | |
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 | 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 | 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 | 473 return [] |
474 | |
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 | 477 |
478 | |
479 class ReplaceDirective(Directive): | |
480 """Implementation of the `py:replace` template directive. | |
481 | |
31 | 482 This directive replaces the element with the result of evaluating the |
483 value of the `py:replace` attribute: | |
484 | |
61 | 485 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 486 ... <span py:replace="bar">Hello</span> |
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 | 489 <div> |
490 Bye | |
491 </div> | |
492 | |
493 This directive is equivalent to `py:content` combined with `py:strip`, | |
494 providing a less verbose way to achieve the same effect: | |
495 | |
61 | 496 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 497 ... <span py:content="bar" py:strip="">Hello</span> |
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 | 500 <div> |
501 Bye | |
502 </div> | |
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 | 506 def __call__(self, stream, ctxt, directives): |
1 | 507 kind, data, pos = stream.next() |
69 | 508 yield EXPR, self.expr, pos |
1 | 509 |
510 | |
511 class StripDirective(Directive): | |
512 """Implementation of the `py:strip` template directive. | |
513 | |
514 When the value of the `py:strip` attribute evaluates to `True`, the element | |
515 is stripped from the output | |
516 | |
61 | 517 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 518 ... <div py:strip="True"><b>foo</b></div> |
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 | 521 <div> |
522 <b>foo</b> | |
523 </div> | |
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 | 526 |
527 This directive is particulary interesting for named template functions or | |
528 match templates that do not generate a top-level element: | |
529 | |
61 | 530 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 531 ... <div py:def="echo(what)" py:strip=""> |
532 ... <b>${what}</b> | |
533 ... </div> | |
534 ... ${echo('foo')} | |
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 | 537 <div> |
538 <b>foo</b> | |
539 </div> | |
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 | 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 | 560 |
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 | 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 | 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 | 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 | 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 | 683 value = value.strip() |
104
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
684 try: |
190 | 685 ast = compiler.parse(value, 'exec').node |
686 for node in ast.nodes: | |
687 if isinstance(node, compiler.ast.Discard): | |
688 continue | |
689 elif not isinstance(node, compiler.ast.Assign): | |
690 raise TemplateSyntaxError('only assignment allowed in ' | |
691 'value of the "with" directive', | |
692 filename, lineno, offset) | |
693 self.vars.append(([n.name for n in node.nodes], | |
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 | 696 err.msg += ' in expression "%s" of "%s" directive' % (value, |
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 | 702 frame = {} |
703 ctxt.push(frame) | |
704 for names, expr in self.vars: | |
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 | 717 class Template(object): |
718 """Can parse a template and transform it into the corresponding output | |
719 based on context data. | |
720 """ | |
61 | 721 NAMESPACE = Namespace('http://markup.edgewall.org/') |
1 | 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 | 726 directives = [('def', DefDirective), |
727 ('match', MatchDirective), | |
120 | 728 ('when', WhenDirective), |
729 ('otherwise', OtherwiseDirective), | |
1 | 730 ('for', ForDirective), |
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 | 734 ('replace', ReplaceDirective), |
735 ('content', ContentDirective), | |
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 | 738 _dir_by_name = dict(directives) |
739 _dir_order = [directive[1] for directive in directives] | |
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 | 742 """Initialize a template from either a string or a file-like object.""" |
743 if isinstance(source, basestring): | |
744 self.source = StringIO(source) | |
745 else: | |
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 | 753 |
23
00835401c8cc
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
754 self.filters = [] |
1 | 755 self.parse() |
756 | |
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 | 759 |
760 def parse(self): | |
761 """Parse the template. | |
762 | |
763 The parsing stage parses the XML template and constructs a list of | |
764 directives that will be executed in the render stage. The input is | |
765 split up into literal output (markup that does not depend on the | |
766 context data) and actual directives (commands or variable | |
767 substitution). | |
768 """ | |
769 stream = [] # list of events of the "compiled" template | |
770 dirmap = {} # temporary mapping of directives to elements | |
771 ns_prefix = {} | |
772 depth = 0 | |
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 | 775 |
69 | 776 if kind is START_NS: |
1 | 777 # Strip out the namespace declaration for template directives |
778 prefix, uri = data | |
779 if uri == self.NAMESPACE: | |
780 ns_prefix[prefix] = uri | |
781 else: | |
782 stream.append((kind, data, pos)) | |
783 | |
69 | 784 elif kind is END_NS: |
1 | 785 if data in ns_prefix: |
786 del ns_prefix[data] | |
787 else: | |
788 stream.append((kind, data, pos)) | |
789 | |
69 | 790 elif kind is START: |
1 | 791 # Record any directive attributes in start tags |
792 tag, attrib = data | |
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 | 804 new_attrib = [] |
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 | 807 cls = self._dir_by_name.get(name.localname) |
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 | 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 | 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 | 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 | 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 | 826 depth += 1 |
827 | |
69 | 828 elif kind is END: |
1 | 829 depth -= 1 |
830 stream.append((kind, data, pos)) | |
831 | |
832 # If there have have directive attributes with the corresponding | |
833 # start tag, move the events inbetween into a "subprogram" | |
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 | 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 | 839 stream[start_offset:] = [(SUB, (directives, substream), |
840 pos)] | |
1 | 841 |
69 | 842 elif kind is TEXT: |
1 | 843 for kind, data, pos in self._interpolate(data, *pos): |
844 stream.append((kind, data, pos)) | |
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 | 850 else: |
851 stream.append((kind, data, pos)) | |
852 | |
853 self.stream = stream | |
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 | 856 _SHORT_EXPR_RE = re.compile(r'(?<!\$)\$([a-zA-Z][a-zA-Z0-9_\.]*)') |
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 | 859 """Parse the given string and extract expressions. |
860 | |
861 This method returns a list containing both literal text and `Expression` | |
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 | 864 @param text: the text to parse |
865 @param lineno: the line number at which the text was found (optional) | |
866 @param offset: the column number at which the text starts in the source | |
867 (optional) | |
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 | 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 | 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 | 882 yield result |
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 | 893 _interpolate = classmethod(_interpolate) |
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 | 911 if ctxt is None: |
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 | 917 stream = self.stream |
918 for filter_ in [self._eval, self._match, self._flatten] + 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 """ |
172
4b4e80b2b0b5
Fix for #30 (trouble using `py:def`inside a match template)
cmlenz
parents:
166
diff
changeset
|
926 filters = (self._eval, self._match, self._flatten) |
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 | 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 | 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: |
111
8a4d9064f363
Some fixes and more unit tests for the XPath engine.
cmlenz
parents:
104
diff
changeset
|
964 substream = _ensure(result) |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
965 for filter_ in filters: |
77
f1aa49c759b2
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
966 substream = filter_(substream, ctxt) |
f1aa49c759b2
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
967 for event in substream: |
35
3bc4778787c5
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
968 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
|
969 except TypeError: |
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
|
970 # Neither a string nor an iterable, so just pass it |
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
|
971 # through |
69 | 972 yield TEXT, unicode(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
|
973 |
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 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
|
975 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
|
976 |
23
00835401c8cc
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
977 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
|
978 """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
|
979 for kind, data, pos in stream: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
980 if kind is SUB: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
981 # 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
|
982 # events to which those directives should be applied |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
983 directives, substream = data |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
984 substream = _apply_directives(substream, ctxt, directives) |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
985 for filter_ in (self._eval, self._match, self._flatten): |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
986 substream = filter_(substream, ctxt) |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
987 for event in substream: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
988 yield event |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
989 else: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
990 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
|
991 |
36
57d607f25484
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
992 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
|
993 """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
|
994 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
|
995 """ |
36
57d607f25484
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
996 if match_templates is None: |
57d607f25484
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
997 match_templates = ctxt._match_templates |
57d607f25484
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
998 |
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
|
999 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
|
1000 |
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 (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
|
1002 # 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
|
1003 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
|
1004 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
|
1005 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
|
1006 |
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
|
1007 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
|
1008 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
|
1009 |
179
a2e0a7986d19
Implemented support for XPath variables in predicates (#31).
cmlenz
parents:
176
diff
changeset
|
1010 if test(kind, data, pos, ctxt) is True: |
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
|
1011 # 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
|
1012 # 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
|
1013 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
|
1014 depth = 1 |
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
|
1015 while depth > 0: |
73 | 1016 kind, data, pos = stream.next() |
1017 if kind is START: | |
1018 depth += 1 | |
1019 elif kind is END: | |
1020 depth -= 1 | |
1021 content.append((kind, data, pos)) | |
179
a2e0a7986d19
Implemented support for XPath variables in predicates (#31).
cmlenz
parents:
176
diff
changeset
|
1022 test(kind, data, pos, 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
|
1023 |
23
00835401c8cc
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
1024 content = list(self._flatten(content, ctxt)) |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
1025 select = lambda path: Stream(content).select(path) |
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
1026 ctxt.push(dict(select=select)) |
36
57d607f25484
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
1027 |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
1028 template = _apply_directives(template, ctxt, directives) |
69 | 1029 for event in self._match(self._eval(template, ctxt), |
1030 ctxt, match_templates[:idx] + | |
1031 match_templates[idx + 1:]): | |
35
3bc4778787c5
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
1032 yield event |
116 | 1033 |
35
3bc4778787c5
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
1034 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
|
1035 break |
69 | 1036 |
1037 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
|
1038 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
|
1039 |
1 | 1040 |
69 | 1041 EXPR = Template.EXPR |
1042 SUB = Template.SUB | |
1043 | |
1044 | |
1 | 1045 class TemplateLoader(object): |
1046 """Responsible for loading templates from files on the specified search | |
1047 path. | |
1048 | |
1049 >>> import tempfile | |
1050 >>> fd, path = tempfile.mkstemp(suffix='.html', prefix='template') | |
1051 >>> os.write(fd, '<p>$var</p>') | |
1052 11 | |
1053 >>> os.close(fd) | |
1054 | |
1055 The template loader accepts a list of directory paths that are then used | |
1056 when searching for template files, in the given order: | |
1057 | |
1058 >>> loader = TemplateLoader([os.path.dirname(path)]) | |
1059 | |
1060 The `load()` method first checks the template cache whether the requested | |
1061 template has already been loaded. If not, it attempts to locate the | |
1062 template file, and returns the corresponding `Template` object: | |
1063 | |
1064 >>> template = loader.load(os.path.basename(path)) | |
1065 >>> isinstance(template, Template) | |
1066 True | |
1067 | |
1068 Template instances are cached: requesting a template with the same name | |
1069 results in the same instance being returned: | |
1070 | |
1071 >>> loader.load(os.path.basename(path)) is template | |
1072 True | |
152
064ba1078f92
Add some tests for relative template includes (see #27).
cmlenz
parents:
150
diff
changeset
|
1073 |
064ba1078f92
Add some tests for relative template includes (see #27).
cmlenz
parents:
150
diff
changeset
|
1074 >>> os.remove(path) |
1 | 1075 """ |
1076 def __init__(self, search_path=None, auto_reload=False): | |
1077 """Create the template laoder. | |
1078 | |
1079 @param search_path: a list of absolute path names that should be | |
1080 searched for template files | |
1081 @param auto_reload: whether to check the last modification time of | |
1082 template files, and reload them if they have changed | |
1083 """ | |
1084 self.search_path = search_path | |
1085 if self.search_path is None: | |
1086 self.search_path = [] | |
1087 self.auto_reload = auto_reload | |
1088 self._cache = {} | |
1089 self._mtime = {} | |
1090 | |
21
eca77129518a
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1091 def load(self, filename, relative_to=None): |
1 | 1092 """Load the template with the given name. |
1093 | |
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
|
1094 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
|
1095 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
|
1096 name is an absolute path, the search path is not bypassed. |
1 | 1097 |
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
|
1098 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
|
1099 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
|
1100 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
|
1101 |
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 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
|
1103 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
|
1104 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
|
1105 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
|
1106 changed since the last parse.) |
1 | 1107 |
21
eca77129518a
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1108 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
|
1109 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
|
1110 |
1 | 1111 @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
|
1112 @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
|
1113 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
|
1114 directly |
1 | 1115 """ |
69 | 1116 from markup.filters import IncludeFilter |
1117 | |
21
eca77129518a
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1118 if relative_to: |
153 | 1119 filename = os.path.join(os.path.dirname(relative_to), filename) |
1 | 1120 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
|
1121 |
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
|
1122 # First check the cache to avoid reparsing the same file |
1 | 1123 try: |
1124 tmpl = self._cache[filename] | |
1125 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
|
1126 os.path.getmtime(tmpl.filepath) == self._mtime[filename]: |
1 | 1127 return tmpl |
1128 except KeyError: | |
1129 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
|
1130 |
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
|
1131 # 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
|
1132 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
|
1133 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
|
1134 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
|
1135 |
176
7efcbf6b1cf2
Fix control flow for error message when template search path is empty.
cmlenz
parents:
175
diff
changeset
|
1136 if not search_path: |
7efcbf6b1cf2
Fix control flow for error message when template search path is empty.
cmlenz
parents:
175
diff
changeset
|
1137 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
|
1138 |
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
|
1139 for dirname in search_path: |
1 | 1140 filepath = os.path.join(dirname, filename) |
1141 try: | |
133
b9a0031d4bbb
Minor cleanup and performance improvement for the builder module.
cmlenz
parents:
120
diff
changeset
|
1142 fileobj = open(filepath, 'U') |
1 | 1143 try: |
21
eca77129518a
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1144 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
|
1145 tmpl.filters.append(IncludeFilter(self)) |
1 | 1146 finally: |
1147 fileobj.close() | |
1148 self._cache[filename] = tmpl | |
1149 self._mtime[filename] = os.path.getmtime(filepath) | |
1150 return tmpl | |
1151 except IOError: | |
1152 continue | |
175 | 1153 |
1 | 1154 raise TemplateNotFound(filename, self.search_path) |