Mercurial > genshi > genshi-test
annotate markup/template.py @ 177:dbae9efe5704
* Minor fix for the XHTML serializer (the local namespace var got clobbered)
* Additional unit tests for empty element serialization, and using XHTML as non-default namespace (with a prefix)
author | cmlenz |
---|---|
date | Mon, 21 Aug 2006 15:00:35 +0000 |
parents | 7efcbf6b1cf2 |
children | a2e0a7986d19 |
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 | |
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
|
27 from markup.core import Attributes, Namespace, Stream, StreamEventKind, _ensure |
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): | |
80 | 64 msg = 'bad directive "%s" (%s, line %d)' % (name.localname, filename, |
65 lineno) | |
66 TemplateSyntaxError.__init__(self, msg, filename, lineno) | |
1 | 67 |
68 | |
69 class TemplateNotFound(TemplateError): | |
70 """Exception raised when a specific template file could not be found.""" | |
71 | |
72 def __init__(self, name, search_path): | |
73 TemplateError.__init__(self, 'Template "%s" not found' % name) | |
74 self.search_path = search_path | |
75 | |
76 | |
77 class Context(object): | |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
78 """Container for template input data. |
1 | 79 |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
80 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
|
81 |
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
82 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
|
83 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
|
84 terminates, that scope can get popped off the stack again. |
1 | 85 |
86 >>> ctxt = Context(one='foo', other=1) | |
87 >>> ctxt.get('one') | |
88 'foo' | |
89 >>> ctxt.get('other') | |
90 1 | |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
91 >>> ctxt.push(dict(one='frost')) |
1 | 92 >>> ctxt.get('one') |
93 'frost' | |
94 >>> ctxt.get('other') | |
95 1 | |
96 >>> ctxt.pop() | |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
97 {'one': 'frost'} |
1 | 98 >>> ctxt.get('one') |
99 'foo' | |
100 """ | |
101 | |
102 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
|
103 self.frames = deque([data]) |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
104 self.pop = self.frames.popleft |
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
105 self.push = self.frames.appendleft |
157
40fc3d36f5b4
Fix for backwards compatibility proposed by cboos in #28.
cmlenz
parents:
154
diff
changeset
|
106 self._match_templates = [] |
1 | 107 |
108 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
|
109 return repr(self.frames) |
1 | 110 |
111 def __setitem__(self, key, value): | |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
112 """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
|
113 self.frames[0][key] = value |
1 | 114 |
115 def get(self, key): | |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
116 """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
|
117 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
|
118 """ |
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
|
119 for frame in self.frames: |
1 | 120 if key in frame: |
121 return frame[key] | |
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
|
122 __getitem__ = get |
1 | 123 |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
124 def push(self, data): |
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
125 """Push a new scope on the stack.""" |
1 | 126 |
127 def pop(self): | |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
128 """Pop the top-most scope from the stack.""" |
1 | 129 |
130 | |
131 class Directive(object): | |
132 """Abstract base class for template directives. | |
133 | |
54 | 134 A directive is basically a callable that takes three positional arguments: |
135 `ctxt` is the template data context, `stream` is an iterable over the | |
136 events that the directive applies to, and `directives` is is a list of | |
137 other directives on the same stream that need to be applied. | |
1 | 138 |
139 Directives can be "anonymous" or "registered". Registered directives can be | |
140 applied by the template author using an XML attribute with the | |
141 corresponding name in the template. Such directives should be subclasses of | |
31 | 142 this base class that can be instantiated with the value of the directive |
143 attribute as parameter. | |
1 | 144 |
145 Anonymous directives are simply functions conforming to the protocol | |
146 described above, and can only be applied programmatically (for example by | |
147 template filters). | |
148 """ | |
149 __slots__ = ['expr'] | |
150 | |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
151 def __init__(self, value, filename=None, lineno=-1, offset=-1): |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
152 try: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
153 self.expr = value and Expression(value, filename, lineno) or None |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
154 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
|
155 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
|
156 self.tagname) |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
157 raise TemplateSyntaxError(err, filename, lineno, |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
158 offset + (err.offset or 0)) |
1 | 159 |
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
|
160 def __call__(self, stream, ctxt, directives): |
1 | 161 raise NotImplementedError |
162 | |
163 def __repr__(self): | |
164 expr = '' | |
165 if self.expr is not None: | |
166 expr = ' "%s"' % self.expr.source | |
167 return '<%s%s>' % (self.__class__.__name__, expr) | |
168 | |
172
4b4e80b2b0b5
Fix for #30 (trouble using `py:def`inside a match template)
cmlenz
parents:
166
diff
changeset
|
169 def tagname(self): |
4b4e80b2b0b5
Fix for #30 (trouble using `py:def`inside a match template)
cmlenz
parents:
166
diff
changeset
|
170 """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
|
171 templates. |
4b4e80b2b0b5
Fix for #30 (trouble using `py:def`inside a match template)
cmlenz
parents:
166
diff
changeset
|
172 """ |
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
|
173 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
|
174 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
|
175 |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
176 |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
177 def _apply_directives(stream, ctxt, directives): |
161
a25f9fc5787d
Various docstring additions and other cosmetic changes.
cmlenz
parents:
157
diff
changeset
|
178 """Apply the given directives to the stream.""" |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
179 if directives: |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
180 stream = directives[0](iter(stream), ctxt, directives[1:]) |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
181 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
|
182 |
1 | 183 |
184 class AttrsDirective(Directive): | |
185 """Implementation of the `py:attrs` template directive. | |
186 | |
187 The value of the `py:attrs` attribute should be a dictionary. The keys and | |
188 values of that dictionary will be added as attributes to the element: | |
189 | |
61 | 190 >>> tmpl = Template('''<ul xmlns:py="http://markup.edgewall.org/"> |
1 | 191 ... <li py:attrs="foo">Bar</li> |
192 ... </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
|
193 >>> print tmpl.generate(foo={'class': 'collapse'}) |
1 | 194 <ul> |
195 <li class="collapse">Bar</li> | |
196 </ul> | |
197 | |
198 If the value evaluates to `None` (or any other non-truth value), no | |
199 attributes are added: | |
200 | |
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
|
201 >>> print tmpl.generate(foo=None) |
1 | 202 <ul> |
203 <li>Bar</li> | |
204 </ul> | |
205 """ | |
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
|
206 __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
|
207 |
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
|
208 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
|
209 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
|
210 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
|
211 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
|
212 if 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
|
213 attrib = Attributes(attrib[:]) |
77
f1aa49c759b2
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
214 if isinstance(attrs, Stream): |
f1aa49c759b2
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
215 try: |
f1aa49c759b2
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
216 attrs = iter(attrs).next() |
f1aa49c759b2
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
217 except StopIteration: |
f1aa49c759b2
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
218 attrs = [] |
f1aa49c759b2
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
219 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
|
220 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
|
221 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
|
222 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
|
223 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
|
224 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
|
225 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
|
226 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
|
227 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
|
228 yield event |
77
f1aa49c759b2
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
229 |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
230 return _apply_directives(_generate(), ctxt, directives) |
1 | 231 |
232 | |
233 class ContentDirective(Directive): | |
234 """Implementation of the `py:content` template directive. | |
235 | |
236 This directive replaces the content of the element with the result of | |
237 evaluating the value of the `py:content` attribute: | |
238 | |
61 | 239 >>> tmpl = Template('''<ul xmlns:py="http://markup.edgewall.org/"> |
1 | 240 ... <li py:content="bar">Hello</li> |
241 ... </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
|
242 >>> print tmpl.generate(bar='Bye') |
1 | 243 <ul> |
244 <li>Bye</li> | |
245 </ul> | |
246 """ | |
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
|
247 __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
|
248 |
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
|
249 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
|
250 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
|
251 kind, data, pos = stream.next() |
101 | 252 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
|
253 yield kind, data, pos # emit start tag |
69 | 254 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
|
255 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
|
256 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
|
257 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
|
258 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
|
259 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
|
260 |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
261 return _apply_directives(_generate(), ctxt, directives) |
1 | 262 |
263 | |
264 class DefDirective(Directive): | |
265 """Implementation of the `py:def` template directive. | |
266 | |
267 This directive can be used to create "Named Template Functions", which | |
268 are template snippets that are not actually output during normal | |
269 processing, but rather can be expanded from expressions in other places | |
270 in the template. | |
271 | |
272 A named template function can be used just like a normal Python function | |
273 from template expressions: | |
274 | |
61 | 275 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 276 ... <p py:def="echo(greeting, name='world')" class="message"> |
277 ... ${greeting}, ${name}! | |
278 ... </p> | |
90
242610137d1f
When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents:
89
diff
changeset
|
279 ... ${echo('Hi', name='you')} |
1 | 280 ... </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
|
281 >>> print tmpl.generate(bar='Bye') |
1 | 282 <div> |
283 <p class="message"> | |
90
242610137d1f
When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents:
89
diff
changeset
|
284 Hi, you! |
1 | 285 </p> |
286 </div> | |
287 | |
90
242610137d1f
When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents:
89
diff
changeset
|
288 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
|
289 both when defining and when calling it: |
242610137d1f
When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents:
89
diff
changeset
|
290 |
61 | 291 >>> 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
|
292 ... <p py:def="helloworld" class="message"> |
242610137d1f
When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents:
89
diff
changeset
|
293 ... Hello, world! |
1 | 294 ... </p> |
90
242610137d1f
When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents:
89
diff
changeset
|
295 ... ${helloworld} |
1 | 296 ... </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
|
297 >>> print tmpl.generate(bar='Bye') |
1 | 298 <div> |
299 <p class="message"> | |
90
242610137d1f
When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents:
89
diff
changeset
|
300 Hello, world! |
1 | 301 </p> |
302 </div> | |
303 """ | |
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
|
304 __slots__ = ['name', 'args', 'defaults'] |
1 | 305 |
65
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
306 ATTRIBUTE = 'function' |
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
307 |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
308 def __init__(self, args, filename=None, lineno=-1, offset=-1): |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
309 Directive.__init__(self, None, filename, lineno, offset) |
1 | 310 ast = compiler.parse(args, 'eval').node |
311 self.args = [] | |
312 self.defaults = {} | |
313 if isinstance(ast, compiler.ast.CallFunc): | |
314 self.name = ast.node.name | |
315 for arg in ast.args: | |
316 if isinstance(arg, compiler.ast.Keyword): | |
317 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
|
318 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
|
319 lineno) |
1 | 320 else: |
321 self.args.append(arg.name) | |
322 else: | |
323 self.name = ast.name | |
324 | |
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
|
325 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
|
326 stream = list(stream) |
1 | 327 |
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
|
328 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
|
329 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
|
330 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
|
331 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
|
332 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
|
333 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
|
334 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
|
335 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
|
336 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
|
337 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
|
338 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
|
339 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
|
340 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
|
341 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
|
342 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
|
343 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
|
344 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
|
345 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
|
346 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
|
347 # 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
|
348 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
|
349 |
1c404be518d1
* Make sure `py:def` macros don't go out of scope if they are defined inside another directive.
cmlenz
parents:
153
diff
changeset
|
350 # 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
|
351 # 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
|
352 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
|
353 |
1c404be518d1
* Make sure `py:def` macros don't go out of scope if they are defined inside another directive.
cmlenz
parents:
153
diff
changeset
|
354 return [] |
1 | 355 |
172
4b4e80b2b0b5
Fix for #30 (trouble using `py:def`inside a match template)
cmlenz
parents:
166
diff
changeset
|
356 def __repr__(self): |
4b4e80b2b0b5
Fix for #30 (trouble using `py:def`inside a match template)
cmlenz
parents:
166
diff
changeset
|
357 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
|
358 |
1 | 359 |
360 class ForDirective(Directive): | |
31 | 361 """Implementation of the `py:for` template directive for repeating an |
362 element based on an iterable in the context data. | |
1 | 363 |
61 | 364 >>> tmpl = Template('''<ul xmlns:py="http://markup.edgewall.org/"> |
1 | 365 ... <li py:for="item in items">${item}</li> |
366 ... </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
|
367 >>> print tmpl.generate(items=[1, 2, 3]) |
1 | 368 <ul> |
369 <li>1</li><li>2</li><li>3</li> | |
370 </ul> | |
371 """ | |
372 __slots__ = ['targets'] | |
373 | |
65
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
374 ATTRIBUTE = 'each' |
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
375 |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
376 def __init__(self, value, filename=None, lineno=-1, offset=-1): |
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
|
377 targets, value = value.split(' in ', 1) |
1 | 378 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
|
379 Directive.__init__(self, value.strip(), filename, lineno, offset) |
1 | 380 |
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
|
381 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
|
382 iterable = self.expr.evaluate(ctxt) |
101 | 383 if iterable is None: |
384 return | |
385 | |
386 scope = {} | |
387 stream = list(stream) | |
388 targets = self.targets | |
140
a2edde90ad24
Fix bug in HTML serializer, plus some other minor tweaks.
cmlenz
parents:
139
diff
changeset
|
389 single = len(targets) == 1 |
101 | 390 for item in iter(iterable): |
140
a2edde90ad24
Fix bug in HTML serializer, plus some other minor tweaks.
cmlenz
parents:
139
diff
changeset
|
391 if single: |
101 | 392 scope[targets[0]] = item |
393 else: | |
394 for idx, name in enumerate(targets): | |
395 scope[name] = item[idx] | |
396 ctxt.push(scope) | |
397 for event in _apply_directives(stream, ctxt, directives): | |
398 yield event | |
399 ctxt.pop() | |
1 | 400 |
401 def __repr__(self): | |
402 return '<%s "%s in %s">' % (self.__class__.__name__, | |
403 ', '.join(self.targets), self.expr.source) | |
404 | |
405 | |
406 class IfDirective(Directive): | |
31 | 407 """Implementation of the `py:if` template directive for conditionally |
408 excluding elements from being output. | |
1 | 409 |
61 | 410 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 411 ... <b py:if="foo">${bar}</b> |
412 ... </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
|
413 >>> print tmpl.generate(foo=True, bar='Hello') |
1 | 414 <div> |
415 <b>Hello</b> | |
416 </div> | |
417 """ | |
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
|
418 __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
|
419 |
65
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
420 ATTRIBUTE = 'test' |
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
421 |
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
|
422 def __call__(self, stream, ctxt, directives): |
1 | 423 if self.expr.evaluate(ctxt): |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
424 return _apply_directives(stream, ctxt, directives) |
1 | 425 return [] |
426 | |
427 | |
428 class MatchDirective(Directive): | |
429 """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
|
430 |
61 | 431 >>> 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
|
432 ... <span py:match="greeting"> |
1 | 433 ... Hello ${select('@name')} |
434 ... </span> | |
435 ... <greeting name="Dude" /> | |
436 ... </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
|
437 >>> print tmpl.generate() |
1 | 438 <div> |
439 <span> | |
440 Hello Dude | |
441 </span> | |
442 </div> | |
443 """ | |
444 __slots__ = ['path', 'stream'] | |
445 | |
65
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
446 ATTRIBUTE = 'path' |
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
447 |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
448 def __init__(self, value, filename=None, lineno=-1, offset=-1): |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
449 Directive.__init__(self, None, filename, lineno, offset) |
139
54131cbb91a5
Implement position reporting for XPath syntax errors. Closes #20.
cmlenz
parents:
134
diff
changeset
|
450 self.path = Path(value, filename, lineno) |
1 | 451 self.stream = [] |
452 | |
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
|
453 def __call__(self, stream, ctxt, directives): |
1 | 454 self.stream = list(stream) |
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
|
455 ctxt._match_templates.append((self.path.test(ignore_context=True), |
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
|
456 self.path, self.stream, directives)) |
1 | 457 return [] |
458 | |
459 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
|
460 return '<%s "%s">' % (self.__class__.__name__, self.path.source) |
1 | 461 |
462 | |
463 class ReplaceDirective(Directive): | |
464 """Implementation of the `py:replace` template directive. | |
465 | |
31 | 466 This directive replaces the element with the result of evaluating the |
467 value of the `py:replace` attribute: | |
468 | |
61 | 469 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 470 ... <span py:replace="bar">Hello</span> |
471 ... </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
|
472 >>> print tmpl.generate(bar='Bye') |
1 | 473 <div> |
474 Bye | |
475 </div> | |
476 | |
477 This directive is equivalent to `py:content` combined with `py:strip`, | |
478 providing a less verbose way to achieve the same effect: | |
479 | |
61 | 480 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 481 ... <span py:content="bar" py:strip="">Hello</span> |
482 ... </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
|
483 >>> print tmpl.generate(bar='Bye') |
1 | 484 <div> |
485 Bye | |
486 </div> | |
487 """ | |
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
|
488 __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
|
489 |
54 | 490 def __call__(self, stream, ctxt, directives): |
1 | 491 kind, data, pos = stream.next() |
69 | 492 yield EXPR, self.expr, pos |
1 | 493 |
494 | |
495 class StripDirective(Directive): | |
496 """Implementation of the `py:strip` template directive. | |
497 | |
498 When the value of the `py:strip` attribute evaluates to `True`, the element | |
499 is stripped from the output | |
500 | |
61 | 501 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 502 ... <div py:strip="True"><b>foo</b></div> |
503 ... </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
|
504 >>> print tmpl.generate() |
1 | 505 <div> |
506 <b>foo</b> | |
507 </div> | |
508 | |
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
|
509 Leaving the attribute value empty is equivalent to a truth value. |
1 | 510 |
511 This directive is particulary interesting for named template functions or | |
512 match templates that do not generate a top-level element: | |
513 | |
61 | 514 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
1 | 515 ... <div py:def="echo(what)" py:strip=""> |
516 ... <b>${what}</b> | |
517 ... </div> | |
518 ... ${echo('foo')} | |
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 """ | |
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
|
525 __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
|
526 |
54 | 527 def __call__(self, stream, ctxt, directives): |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
528 def _generate(): |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
529 if self.expr: |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
530 strip = self.expr.evaluate(ctxt) |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
531 else: |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
532 strip = True |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
533 if strip: |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
534 stream.next() # skip start tag |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
535 previous = stream.next() |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
536 for event in stream: |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
537 yield previous |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
538 previous = event |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
539 else: |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
540 for event in stream: |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
541 yield event |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
542 |
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
543 return _apply_directives(_generate(), ctxt, directives) |
1 | 544 |
545 | |
44
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
546 class ChooseDirective(Directive): |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
547 """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
|
548 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
|
549 |
44
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
550 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
|
551 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
|
552 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
|
553 `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
|
554 |
61 | 555 >>> 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
|
556 ... py:choose=""> |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
557 ... <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
|
558 ... <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
|
559 ... <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
|
560 ... </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
|
561 >>> print tmpl.generate() |
44
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
562 <div> |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
563 <span>1</span> |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
564 </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
|
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` 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
|
567 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
|
568 |
61 | 569 >>> 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
|
570 ... py:choose="2"> |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
571 ... <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
|
572 ... <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
|
573 ... </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
|
574 >>> print tmpl.generate() |
44
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
575 <div> |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
576 <span>2</span> |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
577 </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
|
578 |
44
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
579 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
|
580 `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
|
581 `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
|
582 """ |
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
|
583 __slots__ = ['matched', 'value'] |
44
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
584 |
65
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
585 ATTRIBUTE = 'test' |
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
586 |
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
|
587 def __call__(self, stream, ctxt, directives): |
44
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
588 if self.expr: |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
589 self.value = self.expr.evaluate(ctxt) |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
590 self.matched = False |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
591 ctxt.push(dict(_choose=self)) |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
592 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
|
593 yield event |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
594 ctxt.pop() |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
595 |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
596 |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
597 class WhenDirective(Directive): |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
598 """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
|
599 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
|
600 |
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
|
601 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
|
602 """ |
65
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
603 |
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
604 ATTRIBUTE = 'test' |
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
605 |
54 | 606 def __call__(self, stream, ctxt, 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
|
607 choose = ctxt['_choose'] |
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
|
608 if not choose: |
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
|
609 raise TemplateSyntaxError('when directives can only be used inside ' |
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
|
610 'a choose directive', *stream.next()[2]) |
44
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
611 if choose.matched: |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
612 return [] |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
613 value = self.expr.evaluate(ctxt) |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
614 try: |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
615 if value == choose.value: |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
616 choose.matched = True |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
617 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
|
618 except AttributeError: |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
619 if value: |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
620 choose.matched = True |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
621 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
|
622 return [] |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
623 |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
624 |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
625 class OtherwiseDirective(Directive): |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
626 """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
|
627 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
|
628 |
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
|
629 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
|
630 """ |
54 | 631 def __call__(self, stream, ctxt, 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
|
632 choose = ctxt['_choose'] |
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
|
633 if not choose: |
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
|
634 raise TemplateSyntaxError('an otherwise directive can only be used ' |
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
|
635 'inside a choose directive', |
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
|
636 *stream.next()[2]) |
44
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
637 if choose.matched: |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
638 return [] |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
639 choose.matched = True |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
640 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
|
641 |
42bcb91bf025
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
642 |
104
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
643 class WithDirective(Directive): |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
644 """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
|
645 shorthand access to variables and expressions. |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
646 |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
647 >>> 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
|
648 ... <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
|
649 ... </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
|
650 >>> print tmpl.generate(x=42) |
104
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
651 <div> |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
652 <span>42 7 52</span> |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
653 </div> |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
654 """ |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
655 __slots__ = ['vars'] |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
656 |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
657 ATTRIBUTE = 'vars' |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
658 |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
659 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
|
660 Directive.__init__(self, None, filename, lineno, offset) |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
661 self.vars = [] |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
662 try: |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
663 for stmt in value.split(';'): |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
664 name, value = stmt.split('=', 1) |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
665 self.vars.append((name.strip(), |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
666 Expression(value.strip(), filename, lineno))) |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
667 except SyntaxError, err: |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
668 raise TemplateSyntaxError(err, filename, lineno, |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
669 offset + (err.offset or 0)) |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
670 |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
671 def __call__(self, stream, ctxt, directives): |
120 | 672 ctxt.push(dict([(name, expr.evaluate(ctxt, nocall=True)) |
104
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
673 for name, expr in self.vars])) |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
674 for event in _apply_directives(stream, ctxt, directives): |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
675 yield event |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
676 ctxt.pop() |
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 def __repr__(self): |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
679 return '<%s "%s">' % (self.__class__.__name__, |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
680 '; '.join(['%s = %s' % (name, expr.source) |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
681 for name, expr in self.vars])) |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
682 |
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
683 |
1 | 684 class Template(object): |
685 """Can parse a template and transform it into the corresponding output | |
686 based on context data. | |
687 """ | |
61 | 688 NAMESPACE = Namespace('http://markup.edgewall.org/') |
1 | 689 |
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
|
690 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
|
691 SUB = StreamEventKind('SUB') # a "subprogram" |
10
c5890ef863ba
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
692 |
1 | 693 directives = [('def', DefDirective), |
694 ('match', MatchDirective), | |
120 | 695 ('when', WhenDirective), |
696 ('otherwise', OtherwiseDirective), | |
1 | 697 ('for', ForDirective), |
698 ('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
|
699 ('choose', ChooseDirective), |
104
e9259920db05
Added `py:with` directive based on Jonas' patch in #17.
cmlenz
parents:
101
diff
changeset
|
700 ('with', WithDirective), |
1 | 701 ('replace', ReplaceDirective), |
702 ('content', ContentDirective), | |
703 ('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
|
704 ('strip', StripDirective)] |
1 | 705 _dir_by_name = dict(directives) |
706 _dir_order = [directive[1] for directive in directives] | |
707 | |
21
eca77129518a
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
708 def __init__(self, source, basedir=None, filename=None): |
1 | 709 """Initialize a template from either a string or a file-like object.""" |
710 if isinstance(source, basestring): | |
711 self.source = StringIO(source) | |
712 else: | |
713 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
|
714 self.basedir = basedir |
172
4b4e80b2b0b5
Fix for #30 (trouble using `py:def`inside a match template)
cmlenz
parents:
166
diff
changeset
|
715 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
|
716 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
|
717 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
|
718 else: |
172
4b4e80b2b0b5
Fix for #30 (trouble using `py:def`inside a match template)
cmlenz
parents:
166
diff
changeset
|
719 self.filepath = None |
1 | 720 |
23
00835401c8cc
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
721 self.filters = [] |
1 | 722 self.parse() |
723 | |
724 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
|
725 return '<%s "%s">' % (self.__class__.__name__, self.filename) |
1 | 726 |
727 def parse(self): | |
728 """Parse the template. | |
729 | |
730 The parsing stage parses the XML template and constructs a list of | |
731 directives that will be executed in the render stage. The input is | |
732 split up into literal output (markup that does not depend on the | |
733 context data) and actual directives (commands or variable | |
734 substitution). | |
735 """ | |
736 stream = [] # list of events of the "compiled" template | |
737 dirmap = {} # temporary mapping of directives to elements | |
738 ns_prefix = {} | |
739 depth = 0 | |
740 | |
21
eca77129518a
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
741 for kind, data, pos in XMLParser(self.source, filename=self.filename): |
1 | 742 |
69 | 743 if kind is START_NS: |
1 | 744 # Strip out the namespace declaration for template directives |
745 prefix, uri = data | |
746 if uri == self.NAMESPACE: | |
747 ns_prefix[prefix] = uri | |
748 else: | |
749 stream.append((kind, data, pos)) | |
750 | |
69 | 751 elif kind is END_NS: |
1 | 752 if data in ns_prefix: |
753 del ns_prefix[data] | |
754 else: | |
755 stream.append((kind, data, pos)) | |
756 | |
69 | 757 elif kind is START: |
1 | 758 # Record any directive attributes in start tags |
759 tag, attrib = data | |
760 directives = [] | |
65
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
761 strip = False |
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
762 |
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
763 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
|
764 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
|
765 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
|
766 raise BadDirectiveError(tag, pos[0], pos[1]) |
66
822089ae65ce
Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents:
65
diff
changeset
|
767 value = attrib.get(getattr(cls, 'ATTRIBUTE', None), '') |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
768 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
|
769 strip = True |
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
770 |
1 | 771 new_attrib = [] |
772 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
|
773 if name in self.NAMESPACE: |
1 | 774 cls = self._dir_by_name.get(name.localname) |
775 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
|
776 raise BadDirectiveError(name, pos[0], pos[1]) |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
777 directives.append(cls(value, *pos)) |
1 | 778 else: |
75
c3c26300a46d
Empty attributes in templates were being stripped out. Thanks to Jonas for the patch.
cmlenz
parents:
74
diff
changeset
|
779 if value: |
c3c26300a46d
Empty attributes in templates were being stripped out. Thanks to Jonas for the patch.
cmlenz
parents:
74
diff
changeset
|
780 value = list(self._interpolate(value, *pos)) |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
781 if len(value) == 1 and value[0][0] is TEXT: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
782 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
|
783 else: |
c3c26300a46d
Empty attributes in templates were being stripped out. Thanks to Jonas for the patch.
cmlenz
parents:
74
diff
changeset
|
784 value = [(TEXT, u'', pos)] |
1 | 785 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
|
786 |
1 | 787 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
|
788 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
|
789 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
|
790 dirmap[(depth, tag)] = (directives, len(stream), strip) |
1 | 791 |
792 stream.append((kind, (tag, Attributes(new_attrib)), pos)) | |
793 depth += 1 | |
794 | |
69 | 795 elif kind is END: |
1 | 796 depth -= 1 |
797 stream.append((kind, data, pos)) | |
798 | |
799 # If there have have directive attributes with the corresponding | |
800 # start tag, move the events inbetween into a "subprogram" | |
801 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
|
802 directives, start_offset, strip = dirmap.pop((depth, data)) |
1 | 803 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
|
804 if strip: |
5c024cf58ecb
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
805 substream = substream[1:-1] |
69 | 806 stream[start_offset:] = [(SUB, (directives, substream), |
807 pos)] | |
1 | 808 |
69 | 809 elif kind is TEXT: |
1 | 810 for kind, data, pos in self._interpolate(data, *pos): |
811 stream.append((kind, data, pos)) | |
812 | |
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
|
813 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
|
814 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
|
815 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
|
816 |
1 | 817 else: |
818 stream.append((kind, data, pos)) | |
819 | |
820 self.stream = stream | |
821 | |
822 _FULL_EXPR_RE = re.compile(r'(?<!\$)\$\{(.+?)\}') | |
823 _SHORT_EXPR_RE = re.compile(r'(?<!\$)\$([a-zA-Z][a-zA-Z0-9_\.]*)') | |
824 | |
21
eca77129518a
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
825 def _interpolate(cls, text, filename=None, lineno=-1, offset=-1): |
1 | 826 """Parse the given string and extract expressions. |
827 | |
828 This method returns a list containing both literal text and `Expression` | |
829 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
|
830 |
1 | 831 @param text: the text to parse |
832 @param lineno: the line number at which the text was found (optional) | |
833 @param offset: the column number at which the text starts in the source | |
834 (optional) | |
835 """ | |
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
|
836 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
|
837 offset=offset): |
1 | 838 for idx, group in enumerate(patterns.pop(0).split(text)): |
839 if idx % 2: | |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
840 try: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
841 yield EXPR, Expression(group, 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
|
842 (filename, lineno, offset) |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
843 except SyntaxError, err: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
844 raise TemplateSyntaxError(err, filename, lineno, |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
845 offset + (err.offset or 0)) |
1 | 846 elif group: |
847 if patterns: | |
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
|
848 for result in _interpolate(group, patterns[:]): |
1 | 849 yield result |
850 else: | |
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
|
851 yield TEXT, group.replace('$$', '$'), \ |
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
|
852 (filename, lineno, offset) |
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
|
853 if '\n' in group: |
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
|
854 lines = group.splitlines() |
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
|
855 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
|
856 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
|
857 else: |
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
|
858 offset += len(group) |
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
|
859 return _interpolate(text, [cls._FULL_EXPR_RE, cls._SHORT_EXPR_RE]) |
1 | 860 _interpolate = classmethod(_interpolate) |
861 | |
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
|
862 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
|
863 """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
|
864 |
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
|
865 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
|
866 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
|
867 |
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
|
868 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
|
869 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
|
870 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
|
871 |
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
|
872 @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
|
873 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
|
874 """ |
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
|
875 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
|
876 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
|
877 ctxt = args[0] |
173 | 878 if ctxt is None: |
879 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
|
880 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
|
881 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
|
882 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
|
883 |
69 | 884 stream = self.stream |
885 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
|
886 stream = filter_(iter(stream), ctxt) |
3bc4778787c5
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
887 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
|
888 |
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
|
889 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
|
890 """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
|
891 `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
|
892 """ |
172
4b4e80b2b0b5
Fix for #30 (trouble using `py:def`inside a match template)
cmlenz
parents:
166
diff
changeset
|
893 filters = (self._eval, self._match, self._flatten) |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
894 |
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
|
895 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
|
896 |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
897 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
|
898 # 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
|
899 # 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
|
900 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
|
901 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
|
902 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
|
903 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
|
904 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
|
905 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
|
906 values = [] |
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
|
907 for subkind, subdata, subpos in substream: |
69 | 908 if subkind 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
|
909 values.append(subdata.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
|
910 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
|
911 values.append(subdata) |
48
06c642ba2b08
convert the result of expressions in attributes to strings so that values like ints are output correctly
mgood
parents:
44
diff
changeset
|
912 value = [unicode(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
|
913 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
|
914 continue |
23
00835401c8cc
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
915 new_attrib.append((name, u''.join(value))) |
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 yield kind, (tag, Attributes(new_attrib)), 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
|
917 |
69 | 918 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
|
919 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
|
920 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
|
921 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
|
922 |
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
|
923 # 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
|
924 # 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
|
925 # 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
|
926 if isinstance(result, basestring): |
69 | 927 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
|
928 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
|
929 # 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
|
930 # 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
|
931 try: |
111
8a4d9064f363
Some fixes and more unit tests for the XPath engine.
cmlenz
parents:
104
diff
changeset
|
932 substream = _ensure(result) |
81
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
933 for filter_ in filters: |
77
f1aa49c759b2
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
934 substream = filter_(substream, ctxt) |
f1aa49c759b2
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
935 for event in substream: |
35
3bc4778787c5
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
936 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
|
937 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
|
938 # 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
|
939 # through |
69 | 940 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
|
941 |
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
|
942 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
|
943 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
|
944 |
23
00835401c8cc
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
945 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
|
946 """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
|
947 for kind, data, pos in stream: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
948 if kind is SUB: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
949 # 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
|
950 # events to which those directives should be applied |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
951 directives, substream = data |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
952 substream = _apply_directives(substream, ctxt, directives) |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
953 for filter_ in (self._eval, self._match, self._flatten): |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
954 substream = filter_(substream, ctxt) |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
955 for event in substream: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
956 yield event |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
957 else: |
cc034182061e
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
958 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
|
959 |
36
57d607f25484
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
960 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
|
961 """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
|
962 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
|
963 """ |
36
57d607f25484
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
964 if match_templates is None: |
57d607f25484
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
965 match_templates = ctxt._match_templates |
57d607f25484
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
966 |
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
|
967 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
|
968 |
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 # 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
|
970 # 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
|
971 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
|
972 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
|
973 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
|
974 |
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
|
975 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
|
976 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
|
977 |
116 | 978 if test(kind, data, pos) 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
|
979 # 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
|
980 # 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
|
981 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
|
982 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
|
983 while depth > 0: |
73 | 984 kind, data, pos = stream.next() |
985 if kind is START: | |
986 depth += 1 | |
987 elif kind is END: | |
988 depth -= 1 | |
989 content.append((kind, data, pos)) | |
990 test(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 |
23
00835401c8cc
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
992 content = list(self._flatten(content, ctxt)) |
95
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
993 select = lambda path: Stream(content).select(path) |
7d6426183a90
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
994 ctxt.push(dict(select=select)) |
36
57d607f25484
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
995 |
78
fa4bafcbe4c7
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
996 template = _apply_directives(template, ctxt, directives) |
69 | 997 for event in self._match(self._eval(template, ctxt), |
998 ctxt, match_templates[:idx] + | |
999 match_templates[idx + 1:]): | |
35
3bc4778787c5
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
1000 yield event |
116 | 1001 |
35
3bc4778787c5
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
1002 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
|
1003 break |
69 | 1004 |
1005 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
|
1006 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
|
1007 |
1 | 1008 |
69 | 1009 EXPR = Template.EXPR |
1010 SUB = Template.SUB | |
1011 | |
1012 | |
1 | 1013 class TemplateLoader(object): |
1014 """Responsible for loading templates from files on the specified search | |
1015 path. | |
1016 | |
1017 >>> import tempfile | |
1018 >>> fd, path = tempfile.mkstemp(suffix='.html', prefix='template') | |
1019 >>> os.write(fd, '<p>$var</p>') | |
1020 11 | |
1021 >>> os.close(fd) | |
1022 | |
1023 The template loader accepts a list of directory paths that are then used | |
1024 when searching for template files, in the given order: | |
1025 | |
1026 >>> loader = TemplateLoader([os.path.dirname(path)]) | |
1027 | |
1028 The `load()` method first checks the template cache whether the requested | |
1029 template has already been loaded. If not, it attempts to locate the | |
1030 template file, and returns the corresponding `Template` object: | |
1031 | |
1032 >>> template = loader.load(os.path.basename(path)) | |
1033 >>> isinstance(template, Template) | |
1034 True | |
1035 | |
1036 Template instances are cached: requesting a template with the same name | |
1037 results in the same instance being returned: | |
1038 | |
1039 >>> loader.load(os.path.basename(path)) is template | |
1040 True | |
152
064ba1078f92
Add some tests for relative template includes (see #27).
cmlenz
parents:
150
diff
changeset
|
1041 |
064ba1078f92
Add some tests for relative template includes (see #27).
cmlenz
parents:
150
diff
changeset
|
1042 >>> os.remove(path) |
1 | 1043 """ |
1044 def __init__(self, search_path=None, auto_reload=False): | |
1045 """Create the template laoder. | |
1046 | |
1047 @param search_path: a list of absolute path names that should be | |
1048 searched for template files | |
1049 @param auto_reload: whether to check the last modification time of | |
1050 template files, and reload them if they have changed | |
1051 """ | |
1052 self.search_path = search_path | |
1053 if self.search_path is None: | |
1054 self.search_path = [] | |
1055 self.auto_reload = auto_reload | |
1056 self._cache = {} | |
1057 self._mtime = {} | |
1058 | |
21
eca77129518a
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1059 def load(self, filename, relative_to=None): |
1 | 1060 """Load the template with the given name. |
1061 | |
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
|
1062 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
|
1063 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
|
1064 name is an absolute path, the search path is not bypassed. |
1 | 1065 |
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
|
1066 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
|
1067 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
|
1068 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
|
1069 |
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
|
1070 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
|
1071 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
|
1072 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
|
1073 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
|
1074 changed since the last parse.) |
1 | 1075 |
21
eca77129518a
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1076 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
|
1077 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
|
1078 |
1 | 1079 @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
|
1080 @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
|
1081 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
|
1082 directly |
1 | 1083 """ |
69 | 1084 from markup.filters import IncludeFilter |
1085 | |
21
eca77129518a
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1086 if relative_to: |
153 | 1087 filename = os.path.join(os.path.dirname(relative_to), filename) |
1 | 1088 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
|
1089 |
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
|
1090 # First check the cache to avoid reparsing the same file |
1 | 1091 try: |
1092 tmpl = self._cache[filename] | |
1093 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
|
1094 os.path.getmtime(tmpl.filepath) == self._mtime[filename]: |
1 | 1095 return tmpl |
1096 except KeyError: | |
1097 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
|
1098 |
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 # 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
|
1100 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
|
1101 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
|
1102 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
|
1103 |
176
7efcbf6b1cf2
Fix control flow for error message when template search path is empty.
cmlenz
parents:
175
diff
changeset
|
1104 if not search_path: |
7efcbf6b1cf2
Fix control flow for error message when template search path is empty.
cmlenz
parents:
175
diff
changeset
|
1105 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
|
1106 |
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
|
1107 for dirname in search_path: |
1 | 1108 filepath = os.path.join(dirname, filename) |
1109 try: | |
133
b9a0031d4bbb
Minor cleanup and performance improvement for the builder module.
cmlenz
parents:
120
diff
changeset
|
1110 fileobj = open(filepath, 'U') |
1 | 1111 try: |
21
eca77129518a
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1112 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
|
1113 tmpl.filters.append(IncludeFilter(self)) |
1 | 1114 finally: |
1115 fileobj.close() | |
1116 self._cache[filename] = tmpl | |
1117 self._mtime[filename] = os.path.getmtime(filepath) | |
1118 return tmpl | |
1119 except IOError: | |
1120 continue | |
175 | 1121 |
1 | 1122 raise TemplateNotFound(filename, self.search_path) |