Mercurial > genshi > genshi-test
annotate markup/template.py @ 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.
Also, output filters are now applied in the `Stream.serialize()` method instead of by the `Template.generate()` method, which just makes more sense.
author | cmlenz |
---|---|
date | Sun, 18 Jun 2006 22:33:33 +0000 |
parents | 76b5d4b189e6 |
children | 4cbebb15a834 |
rev | line source |
---|---|
1 | 1 # -*- coding: utf-8 -*- |
2 # | |
3 # Copyright (C) 2006 Christopher Lenz | |
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 | |
8 # are also available at http://trac.edgewall.com/license.html. | |
9 # | |
10 # This software consists of voluntary contributions made by many | |
11 # individuals. For the exact contribution history, see the revision | |
12 # history and logs, available at http://projects.edgewall.com/trac/. | |
13 | |
14 """Template engine that is compatible with Kid (http://kid.lesscode.org) to a | |
15 certain extent. | |
16 | |
17 Differences include: | |
18 * No generation of Python code for a template; the template is "interpreted" | |
19 * No support for <?python ?> processing instructions | |
20 * Expressions are evaluated in a more flexible manner, meaning you can use e.g. | |
21 attribute access notation to access items in a dictionary, etc | |
22 * Use of XInclude and match templates instead of Kid's py:extends/py:layout | |
23 directives | |
24 * Real (thread-safe) search path support | |
25 * No dependency on ElementTree (due to the lack of pos info) | |
26 * The original pos of parse events is kept throughout the processing | |
27 pipeline, so that errors can be tracked back to a specific line/column in | |
28 the template file | |
29 * py:match directives use (basic) XPath expressions to match against input | |
30 nodes, making match templates more powerful while keeping the syntax simple | |
31 | |
32 Todo items: | |
33 * Improved error reporting | |
34 * Support for using directives as elements and not just as attributes, reducing | |
35 the need for wrapper elements with py:strip="" | |
36 * Support for py:choose/py:when/py:otherwise (similar to XSLT) | |
37 * Support for list comprehensions and generator expressions in expressions | |
38 | |
39 Random thoughts: | |
40 * Is there any need to support py:extends and/or py:layout? | |
41 * Could we generate byte code from expressions? | |
42 """ | |
43 | |
44 import compiler | |
45 import os | |
46 import re | |
47 from StringIO import StringIO | |
48 | |
10
c5890ef863ba
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
49 from markup.core import Attributes, Stream, StreamEventKind |
1 | 50 from markup.eval import Expression |
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
|
51 from markup.filters import IncludeFilter |
1 | 52 from markup.input import HTML, XMLParser, XML |
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
|
53 from markup.path import Path |
1 | 54 |
55 __all__ = ['Context', 'BadDirectiveError', 'TemplateError', | |
56 'TemplateSyntaxError', 'TemplateNotFound', 'Template', | |
57 'TemplateLoader'] | |
58 | |
59 | |
60 class TemplateError(Exception): | |
61 """Base exception class for errors related to template processing.""" | |
62 | |
63 | |
64 class TemplateSyntaxError(TemplateError): | |
65 """Exception raised when an expression in a template causes a Python syntax | |
66 error.""" | |
67 | |
68 def __init__(self, message, filename='<string>', lineno=-1, offset=-1): | |
69 if isinstance(message, SyntaxError) and message.lineno is not None: | |
70 message = str(message).replace(' (line %d)' % message.lineno, '') | |
71 TemplateError.__init__(self, message) | |
72 self.filename = filename | |
73 self.lineno = lineno | |
74 self.offset = offset | |
75 | |
76 | |
77 class BadDirectiveError(TemplateSyntaxError): | |
78 """Exception raised when an unknown directive is encountered when parsing | |
79 a template. | |
80 | |
81 An unknown directive is any attribute using the namespace for directives, | |
82 with a local name that doesn't match any registered directive. | |
83 """ | |
84 | |
85 def __init__(self, name, filename='<string>', lineno=-1): | |
86 TemplateSyntaxError.__init__(self, 'Bad directive "%s"' % name.localname, | |
87 filename, lineno) | |
88 | |
89 | |
90 class TemplateNotFound(TemplateError): | |
91 """Exception raised when a specific template file could not be found.""" | |
92 | |
93 def __init__(self, name, search_path): | |
94 TemplateError.__init__(self, 'Template "%s" not found' % name) | |
95 self.search_path = search_path | |
96 | |
97 | |
98 class Context(object): | |
99 """A container for template input data. | |
100 | |
101 A context provides a stack of scopes. Template directives such as loops can | |
102 push a new scope on the stack with data that should only be available | |
103 inside the loop. When the loop terminates, that scope can get popped off | |
104 the stack again. | |
105 | |
106 >>> ctxt = Context(one='foo', other=1) | |
107 >>> ctxt.get('one') | |
108 'foo' | |
109 >>> ctxt.get('other') | |
110 1 | |
111 >>> ctxt.push(one='frost') | |
112 >>> ctxt.get('one') | |
113 'frost' | |
114 >>> ctxt.get('other') | |
115 1 | |
116 >>> ctxt.pop() | |
117 >>> ctxt.get('one') | |
118 'foo' | |
119 """ | |
120 | |
121 def __init__(self, **data): | |
122 self.stack = [data] | |
123 | |
124 def __getitem__(self, key): | |
125 """Get a variable's value, starting at the current context and going | |
126 upward. | |
127 """ | |
128 return self.get(key) | |
129 | |
130 def __repr__(self): | |
131 return repr(self.stack) | |
132 | |
133 def __setitem__(self, key, value): | |
134 """Set a variable in the current context.""" | |
135 self.stack[0][key] = value | |
136 | |
137 def get(self, key): | |
138 for frame in self.stack: | |
139 if key in frame: | |
140 return frame[key] | |
141 | |
142 def push(self, **data): | |
143 self.stack.insert(0, data) | |
144 | |
145 def pop(self): | |
146 assert self.stack, 'Pop from empty context stack' | |
147 self.stack.pop(0) | |
148 | |
149 | |
150 class Directive(object): | |
151 """Abstract base class for template directives. | |
152 | |
153 A directive is basically a callable that takes two parameters: `ctxt` is | |
154 the template data context, and `stream` is an iterable over the events that | |
155 the directive applies to. | |
156 | |
157 Directives can be "anonymous" or "registered". Registered directives can be | |
158 applied by the template author using an XML attribute with the | |
159 corresponding name in the template. Such directives should be subclasses of | |
160 this base class that can be instantiated with two parameters: `template` | |
161 is the `Template` instance, and `value` is the value of the directive | |
162 attribute. | |
163 | |
164 Anonymous directives are simply functions conforming to the protocol | |
165 described above, and can only be applied programmatically (for example by | |
166 template filters). | |
167 """ | |
168 __slots__ = ['expr'] | |
169 | |
170 def __init__(self, template, value, pos): | |
171 self.expr = value and Expression(value) or None | |
172 | |
173 def __call__(self, stream, ctxt): | |
174 raise NotImplementedError | |
175 | |
176 def __repr__(self): | |
177 expr = '' | |
178 if self.expr is not None: | |
179 expr = ' "%s"' % self.expr.source | |
180 return '<%s%s>' % (self.__class__.__name__, expr) | |
181 | |
182 | |
183 class AttrsDirective(Directive): | |
184 """Implementation of the `py:attrs` template directive. | |
185 | |
186 The value of the `py:attrs` attribute should be a dictionary. The keys and | |
187 values of that dictionary will be added as attributes to the element: | |
188 | |
189 >>> ctxt = Context(foo={'class': 'collapse'}) | |
190 >>> tmpl = Template('''<ul xmlns:py="http://purl.org/kid/ns#"> | |
191 ... <li py:attrs="foo">Bar</li> | |
192 ... </ul>''') | |
193 >>> print tmpl.generate(ctxt) | |
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 | |
201 >>> ctxt = Context(foo=None) | |
202 >>> print tmpl.generate(ctxt) | |
203 <ul> | |
204 <li>Bar</li> | |
205 </ul> | |
206 """ | |
207 def __call__(self, stream, ctxt): | |
208 kind, (tag, attrib), pos = stream.next() | |
209 attrs = self.expr.evaluate(ctxt) | |
210 if attrs: | |
5
1add946decb8
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
211 attrib = Attributes(attrib[:]) |
1add946decb8
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
212 if not isinstance(attrs, list): # assume it's a dict |
1add946decb8
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
213 attrs = attrs.items() |
1add946decb8
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
214 for name, value in attrs: |
1add946decb8
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
215 if value is None: |
1add946decb8
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
216 attrib.remove(name) |
1add946decb8
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
217 else: |
1add946decb8
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
218 attrib.set(name, unicode(value).strip()) |
1add946decb8
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
219 yield kind, (tag, attrib), pos |
1 | 220 for event in stream: |
221 yield event | |
222 | |
223 | |
224 class ContentDirective(Directive): | |
225 """Implementation of the `py:content` template directive. | |
226 | |
227 This directive replaces the content of the element with the result of | |
228 evaluating the value of the `py:content` attribute: | |
229 | |
230 >>> ctxt = Context(bar='Bye') | |
231 >>> tmpl = Template('''<ul xmlns:py="http://purl.org/kid/ns#"> | |
232 ... <li py:content="bar">Hello</li> | |
233 ... </ul>''') | |
234 >>> print tmpl.generate(ctxt) | |
235 <ul> | |
236 <li>Bye</li> | |
237 </ul> | |
238 """ | |
239 def __call__(self, stream, ctxt): | |
240 kind, data, pos = stream.next() | |
241 if kind is Stream.START: | |
242 yield kind, data, pos # emit start tag | |
10
c5890ef863ba
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
243 yield Template.EXPR, self.expr, pos |
6 | 244 previous = stream.next() |
245 for event in stream: | |
246 previous = event | |
10
c5890ef863ba
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
247 if previous is not None: |
c5890ef863ba
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
248 yield previous |
1 | 249 |
250 | |
251 class DefDirective(Directive): | |
252 """Implementation of the `py:def` template directive. | |
253 | |
254 This directive can be used to create "Named Template Functions", which | |
255 are template snippets that are not actually output during normal | |
256 processing, but rather can be expanded from expressions in other places | |
257 in the template. | |
258 | |
259 A named template function can be used just like a normal Python function | |
260 from template expressions: | |
261 | |
262 >>> ctxt = Context(bar='Bye') | |
263 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
264 ... <p py:def="echo(greeting, name='world')" class="message"> | |
265 ... ${greeting}, ${name}! | |
266 ... </p> | |
267 ... ${echo('hi', name='you')} | |
268 ... </div>''') | |
269 >>> print tmpl.generate(ctxt) | |
270 <div> | |
271 <p class="message"> | |
272 hi, you! | |
273 </p> | |
274 </div> | |
275 | |
276 >>> ctxt = Context(bar='Bye') | |
277 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
278 ... <p py:def="echo(greeting, name='world')" class="message"> | |
279 ... ${greeting}, ${name}! | |
280 ... </p> | |
281 ... <div py:replace="echo('hello')"></div> | |
282 ... </div>''') | |
283 >>> print tmpl.generate(ctxt) | |
284 <div> | |
285 <p class="message"> | |
286 hello, world! | |
287 </p> | |
288 </div> | |
289 """ | |
290 __slots__ = ['name', 'args', 'defaults', 'stream'] | |
291 | |
292 def __init__(self, template, args, pos): | |
293 Directive.__init__(self, template, None, pos) | |
294 ast = compiler.parse(args, 'eval').node | |
295 self.args = [] | |
296 self.defaults = {} | |
297 if isinstance(ast, compiler.ast.CallFunc): | |
298 self.name = ast.node.name | |
299 for arg in ast.args: | |
300 if isinstance(arg, compiler.ast.Keyword): | |
301 self.args.append(arg.name) | |
302 self.defaults[arg.name] = arg.expr.value | |
303 else: | |
304 self.args.append(arg.name) | |
305 else: | |
306 self.name = ast.name | |
307 self.stream = [] | |
308 | |
309 def __call__(self, stream, ctxt): | |
310 self.stream = list(stream) | |
311 ctxt[self.name] = lambda *args, **kwargs: self._exec(ctxt, *args, | |
312 **kwargs) | |
313 return [] | |
314 | |
315 def _exec(self, ctxt, *args, **kwargs): | |
316 scope = {} | |
317 args = list(args) # make mutable | |
318 for name in self.args: | |
319 if args: | |
320 scope[name] = args.pop(0) | |
321 else: | |
322 scope[name] = kwargs.pop(name, self.defaults.get(name)) | |
323 ctxt.push(**scope) | |
324 for event in self.stream: | |
325 yield event | |
326 ctxt.pop() | |
327 | |
328 | |
329 class ForDirective(Directive): | |
330 """Implementation of the `py:for` template directive. | |
331 | |
332 >>> ctxt = Context(items=[1, 2, 3]) | |
333 >>> tmpl = Template('''<ul xmlns:py="http://purl.org/kid/ns#"> | |
334 ... <li py:for="item in items">${item}</li> | |
335 ... </ul>''') | |
336 >>> print tmpl.generate(ctxt) | |
337 <ul> | |
338 <li>1</li><li>2</li><li>3</li> | |
339 </ul> | |
340 """ | |
341 __slots__ = ['targets'] | |
342 | |
343 def __init__(self, template, value, pos): | |
344 targets, expr_source = value.split(' in ', 1) | |
345 self.targets = [str(name.strip()) for name in targets.split(',')] | |
346 Directive.__init__(self, template, expr_source, pos) | |
347 | |
348 def __call__(self, stream, ctxt): | |
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
|
349 iterable = self.expr.evaluate(ctxt) or [] |
1 | 350 if iterable is not None: |
351 stream = list(stream) | |
352 for item in iter(iterable): | |
353 if len(self.targets) == 1: | |
354 item = [item] | |
355 scope = {} | |
356 for idx, name in enumerate(self.targets): | |
357 scope[name] = item[idx] | |
358 ctxt.push(**scope) | |
359 for event in stream: | |
360 yield event | |
361 ctxt.pop() | |
362 | |
363 def __repr__(self): | |
364 return '<%s "%s in %s">' % (self.__class__.__name__, | |
365 ', '.join(self.targets), self.expr.source) | |
366 | |
367 | |
368 class IfDirective(Directive): | |
369 """Implementation of the `py:if` template directive. | |
370 | |
371 >>> ctxt = Context(foo=True, bar='Hello') | |
372 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
373 ... <b py:if="foo">${bar}</b> | |
374 ... </div>''') | |
375 >>> print tmpl.generate(ctxt) | |
376 <div> | |
377 <b>Hello</b> | |
378 </div> | |
379 """ | |
380 def __call__(self, stream, ctxt): | |
381 if self.expr.evaluate(ctxt): | |
382 return stream | |
383 return [] | |
384 | |
385 | |
386 class MatchDirective(Directive): | |
387 """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
|
388 |
1 | 389 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> |
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
|
390 ... <span py:match="greeting"> |
1 | 391 ... Hello ${select('@name')} |
392 ... </span> | |
393 ... <greeting name="Dude" /> | |
394 ... </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
|
395 >>> print tmpl.generate() |
1 | 396 <div> |
397 <span> | |
398 Hello Dude | |
399 </span> | |
400 </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
|
401 |
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
|
402 A match template can produce the same kind of element that it matched |
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
|
403 without entering an infinite recursion: |
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
|
404 |
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
|
405 >>> tmpl = Template('''<doc xmlns:py="http://purl.org/kid/ns#"> |
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
|
406 ... <elem py:match="elem"> |
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
|
407 ... <div class="elem">${select('*/text()')}</div> |
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
|
408 ... </elem> |
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
|
409 ... <elem>Hey Joe</elem> |
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
|
410 ... </doc>''') |
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
|
411 >>> print tmpl.generate() |
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
|
412 <doc> |
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
|
413 <elem> |
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
|
414 <div class="elem">Hey Joe</div> |
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
|
415 </elem> |
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
|
416 </doc> |
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
|
417 |
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
|
418 Match directives are applied recursively, meaning that they are also |
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
|
419 applied to any content they may have produced themselves: |
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
|
420 |
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
|
421 >>> tmpl = Template('''<doc xmlns:py="http://purl.org/kid/ns#"> |
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
|
422 ... <elem py:match="elem"> |
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
|
423 ... <div class="elem"> |
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
|
424 ... ${select('*/*')} |
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
|
425 ... </div> |
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
|
426 ... </elem> |
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
|
427 ... <elem> |
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
|
428 ... <subelem> |
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
|
429 ... <elem/> |
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 ... </subelem> |
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
|
431 ... </elem> |
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
|
432 ... </doc>''') |
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
|
433 >>> print tmpl.generate() |
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
|
434 <doc> |
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
|
435 <elem> |
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
|
436 <div class="elem"> |
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 <subelem> |
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
|
438 <elem> |
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
|
439 <div class="elem"> |
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
|
440 </div> |
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
|
441 </elem> |
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
|
442 </subelem> |
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
|
443 </div> |
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
|
444 </elem> |
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
|
445 </doc> |
1 | 446 """ |
447 __slots__ = ['path', 'stream'] | |
448 | |
449 def __init__(self, template, value, pos): | |
450 Directive.__init__(self, template, None, pos) | |
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
|
451 self.path = Path(value) |
1 | 452 self.stream = [] |
453 | |
454 def __call__(self, stream, ctxt): | |
455 self.stream = list(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
|
456 ctxt._match_templates.append((self.path.test(), self.path, self.stream)) |
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 | |
466 >>> ctxt = Context(bar='Bye') | |
467 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
468 ... <span py:replace="bar">Hello</span> | |
469 ... </div>''') | |
470 >>> print tmpl.generate(ctxt) | |
471 <div> | |
472 Bye | |
473 </div> | |
474 | |
475 This directive is equivalent to `py:content` combined with `py:strip`, | |
476 providing a less verbose way to achieve the same effect: | |
477 | |
478 >>> ctxt = Context(bar='Bye') | |
479 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
480 ... <span py:content="bar" py:strip="">Hello</span> | |
481 ... </div>''') | |
482 >>> print tmpl.generate(ctxt) | |
483 <div> | |
484 Bye | |
485 </div> | |
486 """ | |
487 def __call__(self, stream, ctxt): | |
488 kind, data, pos = stream.next() | |
10
c5890ef863ba
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
489 yield Template.EXPR, self.expr, pos |
1 | 490 |
491 | |
492 class StripDirective(Directive): | |
493 """Implementation of the `py:strip` template directive. | |
494 | |
495 When the value of the `py:strip` attribute evaluates to `True`, the element | |
496 is stripped from the output | |
497 | |
498 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
499 ... <div py:strip="True"><b>foo</b></div> | |
500 ... </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
|
501 >>> print tmpl.generate() |
1 | 502 <div> |
503 <b>foo</b> | |
504 </div> | |
505 | |
506 On the other hand, when the attribute evaluates to `False`, the element is | |
507 not stripped: | |
508 | |
509 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
510 ... <div py:strip="False"><b>foo</b></div> | |
511 ... </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
|
512 >>> print tmpl.generate() |
1 | 513 <div> |
514 <div><b>foo</b></div> | |
515 </div> | |
516 | |
517 Leaving the attribute value empty is equivalent to a truth value: | |
518 | |
519 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
520 ... <div py:strip=""><b>foo</b></div> | |
521 ... </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
|
522 >>> print tmpl.generate() |
1 | 523 <div> |
524 <b>foo</b> | |
525 </div> | |
526 | |
527 This directive is particulary interesting for named template functions or | |
528 match templates that do not generate a top-level element: | |
529 | |
530 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
531 ... <div py:def="echo(what)" py:strip=""> | |
532 ... <b>${what}</b> | |
533 ... </div> | |
534 ... ${echo('foo')} | |
535 ... </div>''') | |
14
76b5d4b189e6
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
536 >>> print tmpl.generate() |
1 | 537 <div> |
538 <b>foo</b> | |
539 </div> | |
540 """ | |
541 def __call__(self, stream, ctxt): | |
542 if self.expr: | |
543 strip = self.expr.evaluate(ctxt) | |
544 else: | |
545 strip = True | |
546 if strip: | |
547 stream.next() # skip start tag | |
548 previous = stream.next() | |
549 for event in stream: | |
550 yield previous | |
551 previous = event | |
552 else: | |
553 for event in stream: | |
554 yield event | |
555 | |
556 | |
557 class Template(object): | |
558 """Can parse a template and transform it into the corresponding output | |
559 based on context data. | |
560 """ | |
561 NAMESPACE = 'http://purl.org/kid/ns#' | |
562 | |
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
|
563 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
|
564 SUB = StreamEventKind('SUB') # a "subprogram" |
10
c5890ef863ba
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
565 |
1 | 566 directives = [('def', DefDirective), |
567 ('match', MatchDirective), | |
568 ('for', ForDirective), | |
569 ('if', IfDirective), | |
570 ('replace', ReplaceDirective), | |
571 ('content', ContentDirective), | |
572 ('attrs', AttrsDirective), | |
573 ('strip', StripDirective)] | |
574 _dir_by_name = dict(directives) | |
575 _dir_order = [directive[1] for directive in directives] | |
576 | |
577 def __init__(self, source, filename=None): | |
578 """Initialize a template from either a string or a file-like object.""" | |
579 if isinstance(source, basestring): | |
580 self.source = StringIO(source) | |
581 else: | |
582 self.source = source | |
583 self.filename = filename or '<string>' | |
584 | |
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
|
585 self.filters = [self._eval, self._match] |
1 | 586 self.parse() |
587 | |
588 def __repr__(self): | |
589 return '<%s "%s">' % (self.__class__.__name__, | |
590 os.path.basename(self.filename)) | |
591 | |
592 def parse(self): | |
593 """Parse the template. | |
594 | |
595 The parsing stage parses the XML template and constructs a list of | |
596 directives that will be executed in the render stage. The input is | |
597 split up into literal output (markup that does not depend on the | |
598 context data) and actual directives (commands or variable | |
599 substitution). | |
600 """ | |
601 stream = [] # list of events of the "compiled" template | |
602 dirmap = {} # temporary mapping of directives to elements | |
603 ns_prefix = {} | |
604 depth = 0 | |
605 | |
606 for kind, data, pos in XMLParser(self.source): | |
607 | |
608 if kind is Stream.START_NS: | |
609 # Strip out the namespace declaration for template directives | |
610 prefix, uri = data | |
611 if uri == self.NAMESPACE: | |
612 ns_prefix[prefix] = uri | |
613 else: | |
614 stream.append((kind, data, pos)) | |
615 | |
616 elif kind is Stream.END_NS: | |
617 if data in ns_prefix: | |
618 del ns_prefix[data] | |
619 else: | |
620 stream.append((kind, data, pos)) | |
621 | |
622 elif kind is Stream.START: | |
623 # Record any directive attributes in start tags | |
624 tag, attrib = data | |
625 directives = [] | |
626 new_attrib = [] | |
627 for name, value in attrib: | |
628 if name.namespace == self.NAMESPACE: | |
629 cls = self._dir_by_name.get(name.localname) | |
630 if cls is None: | |
631 raise BadDirectiveError(name, self.filename, pos[0]) | |
632 else: | |
633 directives.append(cls(self, value, pos)) | |
634 else: | |
635 value = list(self._interpolate(value, *pos)) | |
636 new_attrib.append((name, value)) | |
637 if directives: | |
638 directives.sort(lambda a, b: cmp(self._dir_order.index(a.__class__), | |
639 self._dir_order.index(b.__class__))) | |
640 dirmap[(depth, tag)] = (directives, len(stream)) | |
641 | |
642 stream.append((kind, (tag, Attributes(new_attrib)), pos)) | |
643 depth += 1 | |
644 | |
645 elif kind is Stream.END: | |
646 depth -= 1 | |
647 stream.append((kind, data, pos)) | |
648 | |
649 # If there have have directive attributes with the corresponding | |
650 # start tag, move the events inbetween into a "subprogram" | |
651 if (depth, data) in dirmap: | |
652 directives, start_offset = dirmap.pop((depth, data)) | |
653 substream = stream[start_offset:] | |
10
c5890ef863ba
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
654 stream[start_offset:] = [(Template.SUB, |
1 | 655 (directives, substream), pos)] |
656 | |
657 elif kind is Stream.TEXT: | |
658 for kind, data, pos in self._interpolate(data, *pos): | |
659 stream.append((kind, data, pos)) | |
660 | |
661 else: | |
662 stream.append((kind, data, pos)) | |
663 | |
664 self.stream = stream | |
665 | |
666 _FULL_EXPR_RE = re.compile(r'(?<!\$)\$\{(.+?)\}') | |
667 _SHORT_EXPR_RE = re.compile(r'(?<!\$)\$([a-zA-Z][a-zA-Z0-9_\.]*)') | |
668 | |
669 def _interpolate(cls, text, lineno=-1, offset=-1): | |
670 """Parse the given string and extract expressions. | |
671 | |
672 This method returns a list containing both literal text and `Expression` | |
673 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
|
674 |
1 | 675 @param text: the text to parse |
676 @param lineno: the line number at which the text was found (optional) | |
677 @param offset: the column number at which the text starts in the source | |
678 (optional) | |
679 """ | |
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
|
680 patterns = [Template._FULL_EXPR_RE, Template._SHORT_EXPR_RE] |
1 | 681 def _interpolate(text): |
682 for idx, group in enumerate(patterns.pop(0).split(text)): | |
683 if idx % 2: | |
10
c5890ef863ba
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
684 yield Template.EXPR, Expression(group), (lineno, offset) |
1 | 685 elif group: |
686 if patterns: | |
687 for result in _interpolate(group): | |
688 yield result | |
689 else: | |
690 yield Stream.TEXT, group.replace('$$', '$'), \ | |
691 (lineno, offset) | |
692 return _interpolate(text) | |
693 _interpolate = classmethod(_interpolate) | |
694 | |
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
|
695 def generate(self, ctxt=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
|
696 """Transform the template based on the given context 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
|
697 if ctxt 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
|
698 ctxt = Context() |
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
|
699 if not hasattr(ctxt, '_match_templates'): |
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
|
700 ctxt._match_templates = [] |
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
|
701 |
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
|
702 return Stream(self._flatten(self.stream, 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
|
703 |
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
|
704 def _eval(self, stream, ctxt=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
|
705 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
|
706 |
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
|
707 if kind is Stream.START: |
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
|
708 # 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
|
709 # 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
|
710 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
|
711 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
|
712 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
|
713 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
|
714 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
|
715 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
|
716 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
|
717 for subkind, subdata, subpos in 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
|
718 if subkind is Template.EXPR: |
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
|
719 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
|
720 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
|
721 values.append(subdata) |
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
|
722 value = filter(lambda x: x is not None, 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
|
723 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
|
724 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
|
725 new_attrib.append((name, ''.join(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
|
726 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
|
727 |
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
|
728 elif kind is Template.EXPR: |
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
|
729 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
|
730 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
|
731 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
|
732 |
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
|
733 # 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
|
734 # 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
|
735 # 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
|
736 if isinstance(result, 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
|
737 yield Stream.TEXT, result, 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
|
738 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
|
739 # 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
|
740 # 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
|
741 try: |
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
|
742 yield (Template.SUB, ([], iter(result)), 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
|
743 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
|
744 # 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
|
745 # through |
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
|
746 yield Stream.TEXT, unicode(result), 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
|
747 |
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
|
748 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
|
749 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
|
750 |
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
|
751 def _flatten(self, stream, ctxt=None, apply_filters=True): |
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
|
752 if apply_filters: |
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
|
753 for filter_ in self.filters: |
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
|
754 stream = filter_(iter(stream), 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
|
755 try: |
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
|
756 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
|
757 if kind is Template.SUB: |
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
|
758 # This event is a list of directives and a list of |
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
|
759 # nested events to which those directives should be |
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
|
760 # applied |
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
|
761 directives, substream = 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
|
762 directives.reverse() |
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
|
763 for directive in directives: |
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
|
764 substream = directive(iter(substream), 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
|
765 for event in self._flatten(substream, 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
|
766 yield 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
|
767 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
|
768 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
|
769 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
|
770 except SyntaxError, err: |
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
|
771 raise TemplateSyntaxError(err, self.filename, pos[0], |
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
|
772 pos[1] + (err.offset or 0)) |
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
|
773 |
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
|
774 def _match(self, stream, ctxt=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
|
775 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
|
776 |
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
|
777 # 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
|
778 # We might care about namespace events in the future, though |
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
|
779 if kind not in (Stream.START, Stream.END): |
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
|
780 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
|
781 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
|
782 |
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
|
783 for idx, (test, path, template) in enumerate(ctxt._match_templates): |
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
|
784 if (kind, data, pos) in template[::len(template)]: |
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
|
785 # This is the event this match template produced itself, so |
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
|
786 # matching it again would result in an infinite loop |
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
|
787 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
|
788 |
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
|
789 result = test(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
|
790 |
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
|
791 if result: |
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
|
792 # 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
|
793 # 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
|
794 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
|
795 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
|
796 while depth > 0: |
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
|
797 event = stream.next() |
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
|
798 if event[0] is Stream.START: |
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
|
799 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
|
800 elif event[0] is Stream.END: |
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
|
801 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
|
802 content.append(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
|
803 |
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
|
804 # enable the path to keep track of the stream state |
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
|
805 test(*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
|
806 |
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
|
807 content = list(self._flatten(content, ctxt, apply_filters=False)) |
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
|
808 |
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
|
809 def _apply(stream, 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
|
810 stream = list(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
|
811 ctxt.push(select=lambda path: Stream(stream).select(path)) |
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
|
812 for event in template: |
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
|
813 yield 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
|
814 ctxt.pop() |
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
|
815 |
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
|
816 yield (Template.SUB, |
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
|
817 ([lambda stream, ctxt: _apply(content, 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
|
818 []), content[0][-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
|
819 break |
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
|
820 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
|
821 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
|
822 |
1 | 823 |
824 class TemplateLoader(object): | |
825 """Responsible for loading templates from files on the specified search | |
826 path. | |
827 | |
828 >>> import tempfile | |
829 >>> fd, path = tempfile.mkstemp(suffix='.html', prefix='template') | |
830 >>> os.write(fd, '<p>$var</p>') | |
831 11 | |
832 >>> os.close(fd) | |
833 | |
834 The template loader accepts a list of directory paths that are then used | |
835 when searching for template files, in the given order: | |
836 | |
837 >>> loader = TemplateLoader([os.path.dirname(path)]) | |
838 | |
839 The `load()` method first checks the template cache whether the requested | |
840 template has already been loaded. If not, it attempts to locate the | |
841 template file, and returns the corresponding `Template` object: | |
842 | |
843 >>> template = loader.load(os.path.basename(path)) | |
844 >>> isinstance(template, Template) | |
845 True | |
846 | |
847 Template instances are cached: requesting a template with the same name | |
848 results in the same instance being returned: | |
849 | |
850 >>> loader.load(os.path.basename(path)) is template | |
851 True | |
852 """ | |
853 def __init__(self, search_path=None, auto_reload=False): | |
854 """Create the template laoder. | |
855 | |
856 @param search_path: a list of absolute path names that should be | |
857 searched for template files | |
858 @param auto_reload: whether to check the last modification time of | |
859 template files, and reload them if they have changed | |
860 """ | |
861 self.search_path = search_path | |
862 if self.search_path is None: | |
863 self.search_path = [] | |
864 self.auto_reload = auto_reload | |
865 self._cache = {} | |
866 self._mtime = {} | |
867 | |
868 def load(self, filename): | |
869 """Load the template with the given name. | |
870 | |
871 This method searches the search path trying to locate a template | |
872 matching the given name. If no such template is found, a | |
873 `TemplateNotFound` exception is raised. Otherwise, a `Template` object | |
874 representing the requested template is returned. | |
875 | |
876 Template searches are cached to avoid having to parse the same template | |
877 file more than once. Thus, subsequent calls of this method with the | |
878 same template file name will return the same `Template` object. | |
879 | |
880 @param filename: the relative path of the template file to load | |
881 """ | |
882 filename = os.path.normpath(filename) | |
883 try: | |
884 tmpl = self._cache[filename] | |
885 if not self.auto_reload or \ | |
886 os.path.getmtime(tmpl.filename) == self._mtime[filename]: | |
887 return tmpl | |
888 except KeyError: | |
889 pass | |
890 for dirname in self.search_path: | |
891 filepath = os.path.join(dirname, filename) | |
892 try: | |
893 fileobj = file(filepath, 'rt') | |
894 try: | |
895 tmpl = Template(fileobj, filename=filepath) | |
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
|
896 tmpl.filters.append(IncludeFilter(self)) |
1 | 897 finally: |
898 fileobj.close() | |
899 self._cache[filename] = tmpl | |
900 self._mtime[filename] = os.path.getmtime(filepath) | |
901 return tmpl | |
902 except IOError: | |
903 continue | |
904 raise TemplateNotFound(filename, self.search_path) |