Mercurial > genshi > mirror
annotate markup/template.py @ 48:a5d585dd38c4 trunk
convert the result of expressions in attributes to strings so that values like ints are output correctly
author | mgood |
---|---|
date | Tue, 04 Jul 2006 04:49:22 +0000 |
parents | 436e30c8420b |
children | d3842cd76e92 |
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 | |
27 | 8 # are also available at http://markup.cmlenz.net/wiki/License. |
1 | 9 # |
10 # This software consists of voluntary contributions made by many | |
11 # individuals. For the exact contribution history, see the revision | |
27 | 12 # history and logs, available at http://markup.cmlenz.net/log/. |
1 | 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 list comprehensions and generator expressions in expressions | |
37 | |
38 Random thoughts: | |
39 * Is there any need to support py:extends and/or py:layout? | |
40 * Could we generate byte code from expressions? | |
41 """ | |
42 | |
43 import compiler | |
44 import os | |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
45 import posixpath |
1 | 46 import re |
47 from StringIO import StringIO | |
48 | |
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
49 from markup.core import Attributes, Namespace, Stream, StreamEventKind |
1 | 50 from markup.eval import Expression |
51 from markup.input import HTML, XMLParser, XML | |
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
52 from markup.path import Path |
1 | 53 |
54 __all__ = ['Context', 'BadDirectiveError', 'TemplateError', | |
55 'TemplateSyntaxError', 'TemplateNotFound', 'Template', | |
56 'TemplateLoader'] | |
57 | |
58 | |
59 class TemplateError(Exception): | |
60 """Base exception class for errors related to template processing.""" | |
61 | |
62 | |
63 class TemplateSyntaxError(TemplateError): | |
64 """Exception raised when an expression in a template causes a Python syntax | |
65 error.""" | |
66 | |
67 def __init__(self, message, filename='<string>', lineno=-1, offset=-1): | |
68 if isinstance(message, SyntaxError) and message.lineno is not None: | |
69 message = str(message).replace(' (line %d)' % message.lineno, '') | |
70 TemplateError.__init__(self, message) | |
71 self.filename = filename | |
72 self.lineno = lineno | |
73 self.offset = offset | |
74 | |
75 | |
76 class BadDirectiveError(TemplateSyntaxError): | |
77 """Exception raised when an unknown directive is encountered when parsing | |
78 a template. | |
79 | |
80 An unknown directive is any attribute using the namespace for directives, | |
81 with a local name that doesn't match any registered directive. | |
82 """ | |
83 | |
84 def __init__(self, name, filename='<string>', lineno=-1): | |
85 TemplateSyntaxError.__init__(self, 'Bad directive "%s"' % name.localname, | |
86 filename, lineno) | |
87 | |
88 | |
89 class TemplateNotFound(TemplateError): | |
90 """Exception raised when a specific template file could not be found.""" | |
91 | |
92 def __init__(self, name, search_path): | |
93 TemplateError.__init__(self, 'Template "%s" not found' % name) | |
94 self.search_path = search_path | |
95 | |
96 | |
97 class Context(object): | |
98 """A container for template input data. | |
99 | |
100 A context provides a stack of scopes. Template directives such as loops can | |
101 push a new scope on the stack with data that should only be available | |
102 inside the loop. When the loop terminates, that scope can get popped off | |
103 the stack again. | |
104 | |
105 >>> ctxt = Context(one='foo', other=1) | |
106 >>> ctxt.get('one') | |
107 'foo' | |
108 >>> ctxt.get('other') | |
109 1 | |
110 >>> ctxt.push(one='frost') | |
111 >>> ctxt.get('one') | |
112 'frost' | |
113 >>> ctxt.get('other') | |
114 1 | |
115 >>> ctxt.pop() | |
116 >>> ctxt.get('one') | |
117 'foo' | |
118 """ | |
119 | |
120 def __init__(self, **data): | |
121 self.stack = [data] | |
122 | |
123 def __getitem__(self, key): | |
29
ab8703fa68b8
* 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
|
124 """Get a variable's value, starting at the current context frame and |
ab8703fa68b8
* 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
|
125 going upward. |
1 | 126 """ |
127 return self.get(key) | |
128 | |
129 def __repr__(self): | |
130 return repr(self.stack) | |
131 | |
132 def __setitem__(self, key, value): | |
133 """Set a variable in the current context.""" | |
134 self.stack[0][key] = value | |
135 | |
136 def get(self, key): | |
29
ab8703fa68b8
* 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
|
137 """Get a variable's value, starting at the current context frame and |
ab8703fa68b8
* 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
|
138 going upward. |
ab8703fa68b8
* 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
|
139 """ |
1 | 140 for frame in self.stack: |
141 if key in frame: | |
142 return frame[key] | |
143 | |
144 def push(self, **data): | |
29
ab8703fa68b8
* 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
|
145 """Push a new context frame on the stack.""" |
1 | 146 self.stack.insert(0, data) |
147 | |
148 def pop(self): | |
29
ab8703fa68b8
* 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
|
149 """Pop the top-most context frame from the stack. |
ab8703fa68b8
* 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
|
150 |
ab8703fa68b8
* 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
|
151 If the stack is empty, an `AssertionError` is raised. |
ab8703fa68b8
* 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
|
152 """ |
1 | 153 assert self.stack, 'Pop from empty context stack' |
154 self.stack.pop(0) | |
155 | |
156 | |
157 class Directive(object): | |
158 """Abstract base class for template directives. | |
159 | |
160 A directive is basically a callable that takes two parameters: `ctxt` is | |
161 the template data context, and `stream` is an iterable over the events that | |
162 the directive applies to. | |
163 | |
164 Directives can be "anonymous" or "registered". Registered directives can be | |
165 applied by the template author using an XML attribute with the | |
166 corresponding name in the template. Such directives should be subclasses of | |
31 | 167 this base class that can be instantiated with the value of the directive |
168 attribute as parameter. | |
1 | 169 |
170 Anonymous directives are simply functions conforming to the protocol | |
171 described above, and can only be applied programmatically (for example by | |
172 template filters). | |
173 """ | |
174 __slots__ = ['expr'] | |
175 | |
29
ab8703fa68b8
* 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
|
176 def __init__(self, value): |
1 | 177 self.expr = value and Expression(value) or None |
178 | |
179 def __call__(self, stream, ctxt): | |
180 raise NotImplementedError | |
181 | |
182 def __repr__(self): | |
183 expr = '' | |
184 if self.expr is not None: | |
185 expr = ' "%s"' % self.expr.source | |
186 return '<%s%s>' % (self.__class__.__name__, expr) | |
187 | |
188 | |
189 class AttrsDirective(Directive): | |
190 """Implementation of the `py:attrs` template directive. | |
191 | |
192 The value of the `py:attrs` attribute should be a dictionary. The keys and | |
193 values of that dictionary will be added as attributes to the element: | |
194 | |
195 >>> ctxt = Context(foo={'class': 'collapse'}) | |
196 >>> tmpl = Template('''<ul xmlns:py="http://purl.org/kid/ns#"> | |
197 ... <li py:attrs="foo">Bar</li> | |
198 ... </ul>''') | |
199 >>> print tmpl.generate(ctxt) | |
200 <ul> | |
201 <li class="collapse">Bar</li> | |
202 </ul> | |
203 | |
204 If the value evaluates to `None` (or any other non-truth value), no | |
205 attributes are added: | |
206 | |
207 >>> ctxt = Context(foo=None) | |
208 >>> print tmpl.generate(ctxt) | |
209 <ul> | |
210 <li>Bar</li> | |
211 </ul> | |
212 """ | |
213 def __call__(self, stream, ctxt): | |
214 kind, (tag, attrib), pos = stream.next() | |
215 attrs = self.expr.evaluate(ctxt) | |
216 if attrs: | |
5
dbb08edbc615
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 attrib = Attributes(attrib[:]) |
dbb08edbc615
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 if not isinstance(attrs, list): # assume it's a dict |
dbb08edbc615
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 attrs = attrs.items() |
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
220 for name, value in attrs: |
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
221 if value is None: |
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
222 attrib.remove(name) |
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
223 else: |
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
224 attrib.set(name, unicode(value).strip()) |
dbb08edbc615
Improved `py:attrs` directive so that it removes existing attributes if they evaluate to `None` (AFAICT matching Kid behavior).
cmlenz
parents:
1
diff
changeset
|
225 yield kind, (tag, attrib), pos |
1 | 226 for event in stream: |
227 yield event | |
228 | |
229 | |
230 class ContentDirective(Directive): | |
231 """Implementation of the `py:content` template directive. | |
232 | |
233 This directive replaces the content of the element with the result of | |
234 evaluating the value of the `py:content` attribute: | |
235 | |
236 >>> ctxt = Context(bar='Bye') | |
237 >>> tmpl = Template('''<ul xmlns:py="http://purl.org/kid/ns#"> | |
238 ... <li py:content="bar">Hello</li> | |
239 ... </ul>''') | |
240 >>> print tmpl.generate(ctxt) | |
241 <ul> | |
242 <li>Bye</li> | |
243 </ul> | |
244 """ | |
245 def __call__(self, stream, ctxt): | |
246 kind, data, pos = stream.next() | |
247 if kind is Stream.START: | |
248 yield kind, data, pos # emit start tag | |
10
f77f7a91aa46
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
249 yield Template.EXPR, self.expr, pos |
6 | 250 previous = stream.next() |
251 for event in stream: | |
252 previous = event | |
10
f77f7a91aa46
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
253 if previous is not None: |
f77f7a91aa46
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
254 yield previous |
1 | 255 |
256 | |
257 class DefDirective(Directive): | |
258 """Implementation of the `py:def` template directive. | |
259 | |
260 This directive can be used to create "Named Template Functions", which | |
261 are template snippets that are not actually output during normal | |
262 processing, but rather can be expanded from expressions in other places | |
263 in the template. | |
264 | |
265 A named template function can be used just like a normal Python function | |
266 from template expressions: | |
267 | |
268 >>> ctxt = Context(bar='Bye') | |
269 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
270 ... <p py:def="echo(greeting, name='world')" class="message"> | |
271 ... ${greeting}, ${name}! | |
272 ... </p> | |
273 ... ${echo('hi', name='you')} | |
274 ... </div>''') | |
275 >>> print tmpl.generate(ctxt) | |
276 <div> | |
277 <p class="message"> | |
278 hi, you! | |
279 </p> | |
280 </div> | |
281 | |
282 >>> ctxt = Context(bar='Bye') | |
283 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
284 ... <p py:def="echo(greeting, name='world')" class="message"> | |
285 ... ${greeting}, ${name}! | |
286 ... </p> | |
287 ... <div py:replace="echo('hello')"></div> | |
288 ... </div>''') | |
289 >>> print tmpl.generate(ctxt) | |
290 <div> | |
291 <p class="message"> | |
292 hello, world! | |
293 </p> | |
294 </div> | |
295 """ | |
296 __slots__ = ['name', 'args', 'defaults', 'stream'] | |
297 | |
29
ab8703fa68b8
* 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
|
298 def __init__(self, args): |
ab8703fa68b8
* 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
|
299 Directive.__init__(self, None) |
1 | 300 ast = compiler.parse(args, 'eval').node |
301 self.args = [] | |
302 self.defaults = {} | |
303 if isinstance(ast, compiler.ast.CallFunc): | |
304 self.name = ast.node.name | |
305 for arg in ast.args: | |
306 if isinstance(arg, compiler.ast.Keyword): | |
307 self.args.append(arg.name) | |
308 self.defaults[arg.name] = arg.expr.value | |
309 else: | |
310 self.args.append(arg.name) | |
311 else: | |
312 self.name = ast.name | |
313 self.stream = [] | |
314 | |
315 def __call__(self, stream, ctxt): | |
316 self.stream = list(stream) | |
317 ctxt[self.name] = lambda *args, **kwargs: self._exec(ctxt, *args, | |
318 **kwargs) | |
319 return [] | |
320 | |
321 def _exec(self, ctxt, *args, **kwargs): | |
322 scope = {} | |
323 args = list(args) # make mutable | |
324 for name in self.args: | |
325 if args: | |
326 scope[name] = args.pop(0) | |
327 else: | |
328 scope[name] = kwargs.pop(name, self.defaults.get(name)) | |
329 ctxt.push(**scope) | |
330 for event in self.stream: | |
331 yield event | |
332 ctxt.pop() | |
333 | |
334 | |
335 class ForDirective(Directive): | |
31 | 336 """Implementation of the `py:for` template directive for repeating an |
337 element based on an iterable in the context data. | |
1 | 338 |
339 >>> ctxt = Context(items=[1, 2, 3]) | |
340 >>> tmpl = Template('''<ul xmlns:py="http://purl.org/kid/ns#"> | |
341 ... <li py:for="item in items">${item}</li> | |
342 ... </ul>''') | |
343 >>> print tmpl.generate(ctxt) | |
344 <ul> | |
345 <li>1</li><li>2</li><li>3</li> | |
346 </ul> | |
347 """ | |
348 __slots__ = ['targets'] | |
349 | |
29
ab8703fa68b8
* 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
|
350 def __init__(self, value): |
ab8703fa68b8
* 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
|
351 targets, value = value.split(' in ', 1) |
1 | 352 self.targets = [str(name.strip()) for name in targets.split(',')] |
29
ab8703fa68b8
* 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
|
353 Directive.__init__(self, value) |
1 | 354 |
355 def __call__(self, stream, ctxt): | |
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
356 iterable = self.expr.evaluate(ctxt) or [] |
1 | 357 if iterable is not None: |
358 stream = list(stream) | |
359 for item in iter(iterable): | |
360 if len(self.targets) == 1: | |
361 item = [item] | |
362 scope = {} | |
363 for idx, name in enumerate(self.targets): | |
364 scope[name] = item[idx] | |
365 ctxt.push(**scope) | |
366 for event in stream: | |
367 yield event | |
368 ctxt.pop() | |
369 | |
370 def __repr__(self): | |
371 return '<%s "%s in %s">' % (self.__class__.__name__, | |
372 ', '.join(self.targets), self.expr.source) | |
373 | |
374 | |
375 class IfDirective(Directive): | |
31 | 376 """Implementation of the `py:if` template directive for conditionally |
377 excluding elements from being output. | |
1 | 378 |
379 >>> ctxt = Context(foo=True, bar='Hello') | |
380 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
381 ... <b py:if="foo">${bar}</b> | |
382 ... </div>''') | |
383 >>> print tmpl.generate(ctxt) | |
384 <div> | |
385 <b>Hello</b> | |
386 </div> | |
387 """ | |
388 def __call__(self, stream, ctxt): | |
389 if self.expr.evaluate(ctxt): | |
390 return stream | |
391 return [] | |
392 | |
393 | |
394 class MatchDirective(Directive): | |
395 """Implementation of the `py:match` template directive. | |
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
396 |
1 | 397 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
398 ... <span py:match="greeting"> |
1 | 399 ... Hello ${select('@name')} |
400 ... </span> | |
401 ... <greeting name="Dude" /> | |
402 ... </div>''') | |
14
c7d33e0c9839
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 >>> print tmpl.generate() |
1 | 404 <div> |
405 <span> | |
406 Hello Dude | |
407 </span> | |
408 </div> | |
409 """ | |
410 __slots__ = ['path', 'stream'] | |
411 | |
29
ab8703fa68b8
* 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
|
412 def __init__(self, value): |
ab8703fa68b8
* 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
|
413 Directive.__init__(self, None) |
14
c7d33e0c9839
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 self.path = Path(value) |
1 | 415 self.stream = [] |
416 | |
417 def __call__(self, stream, ctxt): | |
418 self.stream = list(stream) | |
38
ee669cb9cccc
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
|
419 ctxt._match_templates.append((self.path.test(ignore_context=True), |
ee669cb9cccc
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
|
420 self.path, self.stream)) |
1 | 421 return [] |
422 | |
423 def __repr__(self): | |
14
c7d33e0c9839
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 return '<%s "%s">' % (self.__class__.__name__, self.path.source) |
1 | 425 |
426 | |
427 class ReplaceDirective(Directive): | |
428 """Implementation of the `py:replace` template directive. | |
429 | |
31 | 430 This directive replaces the element with the result of evaluating the |
431 value of the `py:replace` attribute: | |
432 | |
1 | 433 >>> ctxt = Context(bar='Bye') |
434 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
435 ... <span py:replace="bar">Hello</span> | |
436 ... </div>''') | |
437 >>> print tmpl.generate(ctxt) | |
438 <div> | |
439 Bye | |
440 </div> | |
441 | |
442 This directive is equivalent to `py:content` combined with `py:strip`, | |
443 providing a less verbose way to achieve the same effect: | |
444 | |
445 >>> ctxt = Context(bar='Bye') | |
446 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
447 ... <span py:content="bar" py:strip="">Hello</span> | |
448 ... </div>''') | |
449 >>> print tmpl.generate(ctxt) | |
450 <div> | |
451 Bye | |
452 </div> | |
453 """ | |
454 def __call__(self, stream, ctxt): | |
455 kind, data, pos = stream.next() | |
10
f77f7a91aa46
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
456 yield Template.EXPR, self.expr, pos |
1 | 457 |
458 | |
459 class StripDirective(Directive): | |
460 """Implementation of the `py:strip` template directive. | |
461 | |
462 When the value of the `py:strip` attribute evaluates to `True`, the element | |
463 is stripped from the output | |
464 | |
465 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
466 ... <div py:strip="True"><b>foo</b></div> | |
467 ... </div>''') | |
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
468 >>> print tmpl.generate() |
1 | 469 <div> |
470 <b>foo</b> | |
471 </div> | |
472 | |
37
37557b8fb925
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
|
473 Leaving the attribute value empty is equivalent to a truth value. |
1 | 474 |
475 This directive is particulary interesting for named template functions or | |
476 match templates that do not generate a top-level element: | |
477 | |
478 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#"> | |
479 ... <div py:def="echo(what)" py:strip=""> | |
480 ... <b>${what}</b> | |
481 ... </div> | |
482 ... ${echo('foo')} | |
483 ... </div>''') | |
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
484 >>> print tmpl.generate() |
1 | 485 <div> |
486 <b>foo</b> | |
487 </div> | |
488 """ | |
489 def __call__(self, stream, ctxt): | |
490 if self.expr: | |
491 strip = self.expr.evaluate(ctxt) | |
492 else: | |
493 strip = True | |
494 if strip: | |
495 stream.next() # skip start tag | |
496 previous = stream.next() | |
497 for event in stream: | |
498 yield previous | |
499 previous = event | |
500 else: | |
501 for event in stream: | |
502 yield event | |
503 | |
504 | |
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
505 class ChooseDirective(Directive): |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
506 """Implementation of the `py:choose` directive for conditionally selecting |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
507 one of several body elements to display. |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
508 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
509 If the `py:choose` expression is empty the expressions of nested `py:when` |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
510 directives are tested for truth. The first true `py:when` body is output. |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
511 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
512 >>> ctxt = Context() |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
513 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#" |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
514 ... py:choose=""> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
515 ... <span py:when="0 == 1">0</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
516 ... <span py:when="1 == 1">1</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
517 ... </div>''') |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
518 >>> print tmpl.generate(ctxt) |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
519 <div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
520 <span>1</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
521 </div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
522 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
523 If multiple `py:when` bodies match only the first is output. |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
524 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#" |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
525 ... py:choose=""> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
526 ... <span py:when="1 == 1">1</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
527 ... <span py:when="2 == 2">2</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
528 ... </div>''') |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
529 >>> print tmpl.generate(ctxt) |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
530 <div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
531 <span>1</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
532 </div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
533 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
534 If the `py:choose` directive contains an expression, the nested `py:when` |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
535 directives are tested for equality to the `py:choose` expression. |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
536 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#" |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
537 ... py:choose="2"> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
538 ... <span py:when="1">1</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
539 ... <span py:when="2">2</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
540 ... </div>''') |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
541 >>> print tmpl.generate(ctxt) |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
542 <div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
543 <span>2</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
544 </div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
545 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
546 If no `py:when` directive is matched then the fallback directive |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
547 `py:otherwise` will be used. |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
548 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#" |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
549 ... py:choose=""> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
550 ... <span py:when="False">hidden</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
551 ... <span py:otherwise="">hello</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
552 ... </div>''') |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
553 >>> print tmpl.generate(ctxt) |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
554 <div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
555 <span>hello</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
556 </div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
557 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
558 `py:choose` blocks can be nested: |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
559 >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#" |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
560 ... py:choose="1"> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
561 ... <div py:when="1" py:choose="3"> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
562 ... <span py:when="2">2</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
563 ... <span py:when="3">3</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
564 ... </div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
565 ... </div>''') |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
566 >>> print tmpl.generate(ctxt) |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
567 <div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
568 <div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
569 <span>3</span> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
570 </div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
571 </div> |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
572 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
573 Behavior is undefined if a `py:choose` block contains content outside a |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
574 `py:when` or `py:otherwise` block. Behavior is also undefined if a |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
575 `py:otherwise` occurs before `py:when` blocks. |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
576 """ |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
577 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
578 def __call__(self, stream, ctxt): |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
579 if self.expr: |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
580 self.value = self.expr.evaluate(ctxt) |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
581 self.matched = False |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
582 ctxt.push(__choose=self) |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
583 for event in stream: |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
584 yield event |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
585 ctxt.pop() |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
586 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
587 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
588 class WhenDirective(Directive): |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
589 """Implementation of the `py:when` directive for nesting in a parent with |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
590 the `py:choose` directive. See the documentation of `py:choose` for |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
591 usage. |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
592 """ |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
593 def __call__(self, stream, ctxt): |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
594 choose = ctxt['__choose'] |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
595 if choose.matched: |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
596 return [] |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
597 value = self.expr.evaluate(ctxt) |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
598 try: |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
599 if value == choose.value: |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
600 choose.matched = True |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
601 return stream |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
602 except AttributeError: |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
603 if value: |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
604 choose.matched = True |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
605 return stream |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
606 return [] |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
607 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
608 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
609 class OtherwiseDirective(Directive): |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
610 """Implementation of the `py:otherwise` directive for nesting in a parent |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
611 with the `py:choose` directive. See the documentation of `py:choose` for |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
612 usage. |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
613 """ |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
614 def __call__(self, stream, ctxt): |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
615 choose = ctxt['__choose'] |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
616 if choose.matched: |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
617 return [] |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
618 choose.matched = True |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
619 return stream |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
620 |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
621 |
1 | 622 class Template(object): |
623 """Can parse a template and transform it into the corresponding output | |
624 based on context data. | |
625 """ | |
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
626 NAMESPACE = Namespace('http://purl.org/kid/ns#') |
1 | 627 |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
628 EXPR = StreamEventKind('EXPR') # an expression |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
629 SUB = StreamEventKind('SUB') # a "subprogram" |
10
f77f7a91aa46
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
630 |
1 | 631 directives = [('def', DefDirective), |
632 ('match', MatchDirective), | |
633 ('for', ForDirective), | |
634 ('if', IfDirective), | |
635 ('replace', ReplaceDirective), | |
636 ('content', ContentDirective), | |
637 ('attrs', AttrsDirective), | |
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
638 ('strip', StripDirective), |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
639 ('choose', ChooseDirective), |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
640 ('when', WhenDirective), |
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
641 ('otherwise', OtherwiseDirective)] |
1 | 642 _dir_by_name = dict(directives) |
643 _dir_order = [directive[1] for directive in directives] | |
644 | |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
645 def __init__(self, source, basedir=None, filename=None): |
1 | 646 """Initialize a template from either a string or a file-like object.""" |
647 if isinstance(source, basestring): | |
648 self.source = StringIO(source) | |
649 else: | |
650 self.source = source | |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
651 self.basedir = basedir |
1 | 652 self.filename = filename or '<string>' |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
653 if basedir and filename: |
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
654 self.filepath = os.path.join(basedir, filename) |
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
655 else: |
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
656 self.filepath = '<string>' |
1 | 657 |
23
d88358f719fa
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
658 self.filters = [] |
1 | 659 self.parse() |
660 | |
661 def __repr__(self): | |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
662 return '<%s "%s">' % (self.__class__.__name__, self.filename) |
1 | 663 |
664 def parse(self): | |
665 """Parse the template. | |
666 | |
667 The parsing stage parses the XML template and constructs a list of | |
668 directives that will be executed in the render stage. The input is | |
669 split up into literal output (markup that does not depend on the | |
670 context data) and actual directives (commands or variable | |
671 substitution). | |
672 """ | |
673 stream = [] # list of events of the "compiled" template | |
674 dirmap = {} # temporary mapping of directives to elements | |
675 ns_prefix = {} | |
676 depth = 0 | |
677 | |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
678 for kind, data, pos in XMLParser(self.source, filename=self.filename): |
1 | 679 |
680 if kind is Stream.START_NS: | |
681 # Strip out the namespace declaration for template directives | |
682 prefix, uri = data | |
683 if uri == self.NAMESPACE: | |
684 ns_prefix[prefix] = uri | |
685 else: | |
686 stream.append((kind, data, pos)) | |
687 | |
688 elif kind is Stream.END_NS: | |
689 if data in ns_prefix: | |
690 del ns_prefix[data] | |
691 else: | |
692 stream.append((kind, data, pos)) | |
693 | |
694 elif kind is Stream.START: | |
695 # Record any directive attributes in start tags | |
696 tag, attrib = data | |
697 directives = [] | |
698 new_attrib = [] | |
699 for name, value in attrib: | |
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
700 if name in self.NAMESPACE: |
1 | 701 cls = self._dir_by_name.get(name.localname) |
702 if cls is None: | |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
703 raise BadDirectiveError(name, self.filename, pos[1]) |
1 | 704 else: |
29
ab8703fa68b8
* 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
|
705 directives.append(cls(value)) |
1 | 706 else: |
707 value = list(self._interpolate(value, *pos)) | |
708 new_attrib.append((name, value)) | |
709 if directives: | |
31 | 710 directives.sort(lambda a, b: cmp(self._dir_order.index(b.__class__), |
711 self._dir_order.index(a.__class__))) | |
1 | 712 dirmap[(depth, tag)] = (directives, len(stream)) |
713 | |
714 stream.append((kind, (tag, Attributes(new_attrib)), pos)) | |
715 depth += 1 | |
716 | |
717 elif kind is Stream.END: | |
718 depth -= 1 | |
719 stream.append((kind, data, pos)) | |
720 | |
721 # If there have have directive attributes with the corresponding | |
722 # start tag, move the events inbetween into a "subprogram" | |
723 if (depth, data) in dirmap: | |
724 directives, start_offset = dirmap.pop((depth, data)) | |
725 substream = stream[start_offset:] | |
10
f77f7a91aa46
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
726 stream[start_offset:] = [(Template.SUB, |
1 | 727 (directives, substream), pos)] |
728 | |
729 elif kind is Stream.TEXT: | |
730 for kind, data, pos in self._interpolate(data, *pos): | |
731 stream.append((kind, data, pos)) | |
732 | |
733 else: | |
734 stream.append((kind, data, pos)) | |
735 | |
736 self.stream = stream | |
737 | |
738 _FULL_EXPR_RE = re.compile(r'(?<!\$)\$\{(.+?)\}') | |
739 _SHORT_EXPR_RE = re.compile(r'(?<!\$)\$([a-zA-Z][a-zA-Z0-9_\.]*)') | |
740 | |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
741 def _interpolate(cls, text, filename=None, lineno=-1, offset=-1): |
1 | 742 """Parse the given string and extract expressions. |
743 | |
744 This method returns a list containing both literal text and `Expression` | |
745 objects. | |
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
746 |
1 | 747 @param text: the text to parse |
748 @param lineno: the line number at which the text was found (optional) | |
749 @param offset: the column number at which the text starts in the source | |
750 (optional) | |
751 """ | |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 patterns = [Template._FULL_EXPR_RE, Template._SHORT_EXPR_RE] |
1 | 753 def _interpolate(text): |
754 for idx, group in enumerate(patterns.pop(0).split(text)): | |
755 if idx % 2: | |
10
f77f7a91aa46
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
756 yield Template.EXPR, Expression(group), (lineno, offset) |
1 | 757 elif group: |
758 if patterns: | |
759 for result in _interpolate(group): | |
760 yield result | |
761 else: | |
762 yield Stream.TEXT, group.replace('$$', '$'), \ | |
23
d88358f719fa
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
763 (filename, lineno, offset) |
1 | 764 return _interpolate(text) |
765 _interpolate = classmethod(_interpolate) | |
766 | |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 def generate(self, ctxt=None): |
29
ab8703fa68b8
* 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
|
768 """Apply the template to the given context data. |
ab8703fa68b8
* 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
|
769 |
ab8703fa68b8
* 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
|
770 @param ctxt: a `Context` instance containing the data for the template |
ab8703fa68b8
* 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
|
771 @return: a markup event stream representing the result of applying |
ab8703fa68b8
* 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
|
772 the template to the context data. |
ab8703fa68b8
* 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
|
773 """ |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 if ctxt is None: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 ctxt = Context() |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 if not hasattr(ctxt, '_match_templates'): |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 ctxt._match_templates = [] |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 |
35
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
779 stream = self._flatten(self._match(self._eval(self.stream, ctxt), ctxt), |
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
780 ctxt) |
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
781 for filter_ in self.filters: |
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
782 stream = filter_(iter(stream), ctxt) |
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
783 return Stream(stream) |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 def _eval(self, stream, ctxt=None): |
29
ab8703fa68b8
* 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
|
786 """Internal stream filter that evaluates any expressions in `START` and |
ab8703fa68b8
* 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
|
787 `TEXT` events. |
ab8703fa68b8
* 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
|
788 """ |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 for kind, data, pos in stream: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 kind is Stream.START: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 # Attributes may still contain expressions in start tags at |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 # this point, so do some evaluation |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 tag, attrib = data |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 new_attrib = [] |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 for name, substream in attrib: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 if isinstance(substream, basestring): |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 value = substream |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 else: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 values = [] |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 for subkind, subdata, subpos in substream: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 if subkind is Template.EXPR: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 values.append(subdata.evaluate(ctxt)) |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 else: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 values.append(subdata) |
48
a5d585dd38c4
convert the result of expressions in attributes to strings so that values like ints are output correctly
mgood
parents:
44
diff
changeset
|
806 value = [unicode(x) for x in values if x is not None] |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 if not value: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 continue |
23
d88358f719fa
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
809 new_attrib.append((name, u''.join(value))) |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 yield kind, (tag, Attributes(new_attrib)), pos |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 elif kind is Template.EXPR: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 result = data.evaluate(ctxt) |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 if result is None: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 continue |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 # First check for a string, otherwise the iterable test below |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 # succeeds, and the string will be chopped up into individual |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 # characters |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 if isinstance(result, basestring): |
23
d88358f719fa
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
821 yield Stream.TEXT, unicode(result), pos |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 else: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
823 # Test if the expression evaluated to an iterable, in which |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
824 # case we yield the individual items |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
825 try: |
35
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
826 for event in self._match(self._eval(iter(result), ctxt), |
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
827 ctxt): |
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
828 yield event |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
829 except TypeError: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
830 # Neither a string nor an iterable, so just pass it |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
831 # through |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
832 yield Stream.TEXT, unicode(result), pos |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
833 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
834 else: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
835 yield kind, data, pos |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
836 |
23
d88358f719fa
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
837 def _flatten(self, stream, ctxt=None): |
29
ab8703fa68b8
* 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
|
838 """Internal stream filter that expands `SUB` events in the stream.""" |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
839 try: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
840 for kind, data, pos in stream: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
841 if kind is Template.SUB: |
35
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
842 # This event is a list of directives and a list of nested |
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
843 # events to which those directives should be applied |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
844 directives, substream = data |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
845 for directive in directives: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
846 substream = directive(iter(substream), ctxt) |
23
d88358f719fa
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
847 substream = self._match(self._eval(substream, ctxt), ctxt) |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
848 for event in self._flatten(substream, ctxt): |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
849 yield event |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
850 continue |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
851 else: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
852 yield kind, data, pos |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
853 except SyntaxError, err: |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
854 raise TemplateSyntaxError(err, self.filename, pos[1], |
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
855 pos[2] + (err.offset or 0)) |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
856 |
36
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
857 def _match(self, stream, ctxt=None, match_templates=None): |
29
ab8703fa68b8
* 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
|
858 """Internal stream filter that applies any defined match templates |
ab8703fa68b8
* 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
|
859 to the stream. |
ab8703fa68b8
* 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
|
860 """ |
36
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
861 if match_templates is None: |
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
862 match_templates = ctxt._match_templates |
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
863 |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
864 for kind, data, pos in stream: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
865 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
866 # We (currently) only care about start and end events for matching |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
867 # We might care about namespace events in the future, though |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
868 if kind not in (Stream.START, Stream.END): |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
869 yield kind, data, pos |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
870 continue |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
871 |
36
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
872 for idx, (test, path, template) in enumerate(match_templates): |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
873 result = test(kind, data, pos) |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
874 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
875 if result: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
876 # Consume and store all events until an end event |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
877 # corresponding to this start event is encountered |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
878 content = [(kind, data, pos)] |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
879 depth = 1 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
880 while depth > 0: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
881 event = stream.next() |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
882 if event[0] is Stream.START: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 depth += 1 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
884 elif event[0] is Stream.END: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
885 depth -= 1 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
886 content.append(event) |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
887 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 # enable the path to keep track of the stream state |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 test(*event) |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
890 |
23
d88358f719fa
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
891 content = list(self._flatten(content, ctxt)) |
35
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
892 ctxt.push(select=lambda path: Stream(content).select(path)) |
36
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
893 |
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
894 template = self._match(self._eval(iter(template), ctxt), |
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
895 ctxt, match_templates[:idx] + |
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
896 match_templates[idx + 1:]) |
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
897 for event in template: |
35
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
898 yield event |
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
899 ctxt.pop() |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 break |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 else: |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 yield kind, data, pos |
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. 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 |
1 | 905 |
906 class TemplateLoader(object): | |
907 """Responsible for loading templates from files on the specified search | |
908 path. | |
909 | |
910 >>> import tempfile | |
911 >>> fd, path = tempfile.mkstemp(suffix='.html', prefix='template') | |
912 >>> os.write(fd, '<p>$var</p>') | |
913 11 | |
914 >>> os.close(fd) | |
915 | |
916 The template loader accepts a list of directory paths that are then used | |
917 when searching for template files, in the given order: | |
918 | |
919 >>> loader = TemplateLoader([os.path.dirname(path)]) | |
920 | |
921 The `load()` method first checks the template cache whether the requested | |
922 template has already been loaded. If not, it attempts to locate the | |
923 template file, and returns the corresponding `Template` object: | |
924 | |
925 >>> template = loader.load(os.path.basename(path)) | |
926 >>> isinstance(template, Template) | |
927 True | |
928 | |
929 Template instances are cached: requesting a template with the same name | |
930 results in the same instance being returned: | |
931 | |
932 >>> loader.load(os.path.basename(path)) is template | |
933 True | |
934 """ | |
935 def __init__(self, search_path=None, auto_reload=False): | |
936 """Create the template laoder. | |
937 | |
938 @param search_path: a list of absolute path names that should be | |
939 searched for template files | |
940 @param auto_reload: whether to check the last modification time of | |
941 template files, and reload them if they have changed | |
942 """ | |
943 self.search_path = search_path | |
944 if self.search_path is None: | |
945 self.search_path = [] | |
946 self.auto_reload = auto_reload | |
947 self._cache = {} | |
948 self._mtime = {} | |
949 | |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
950 def load(self, filename, relative_to=None): |
1 | 951 """Load the template with the given name. |
952 | |
22
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
953 If the `filename` parameter is relative, this method searches the search |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
954 path trying to locate a template matching the given name. If the file |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
955 name is an absolute path, the search path is not bypassed. |
1 | 956 |
22
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
957 If requested template is not found, a `TemplateNotFound` exception is |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
958 raised. Otherwise, a `Template` object is returned that represents the |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
959 parsed template. |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
960 |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
961 Template instances are cached to avoid having to parse the same |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
962 template file more than once. Thus, subsequent calls of this method |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
963 with the same template file name will return the same `Template` |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
964 object (unless the `auto_reload` option is enabled and the file was |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
965 changed since the last parse.) |
1 | 966 |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
967 If the `relative_to` parameter is provided, the `filename` is |
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
968 interpreted as being relative to that path. |
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
969 |
1 | 970 @param filename: the relative path of the template file to load |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
971 @param relative_to: the filename of the template from which the new |
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
972 template is being loaded, or `None` if the template is being loaded |
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
973 directly |
1 | 974 """ |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
975 if relative_to: |
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
976 filename = posixpath.join(posixpath.dirname(relative_to), filename) |
1 | 977 filename = os.path.normpath(filename) |
22
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
978 |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
979 # First check the cache to avoid reparsing the same file |
1 | 980 try: |
981 tmpl = self._cache[filename] | |
982 if not self.auto_reload or \ | |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
983 os.path.getmtime(tmpl.filepath) == self._mtime[filename]: |
1 | 984 return tmpl |
985 except KeyError: | |
986 pass | |
22
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
987 |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
988 # Bypass the search path if the filename is absolute |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
989 search_path = self.search_path |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
990 if os.path.isabs(filename): |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
991 search_path = [os.path.dirname(filename)] |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
992 |
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
993 for dirname in search_path: |
1 | 994 filepath = os.path.join(dirname, filename) |
995 try: | |
996 fileobj = file(filepath, 'rt') | |
997 try: | |
22
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
998 from markup.filters import IncludeFilter |
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
999 tmpl = Template(fileobj, basedir=dirname, filename=filename) |
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
1000 tmpl.filters.append(IncludeFilter(self)) |
1 | 1001 finally: |
1002 fileobj.close() | |
1003 self._cache[filename] = tmpl | |
1004 self._mtime[filename] = os.path.getmtime(filepath) | |
1005 return tmpl | |
1006 except IOError: | |
1007 continue | |
1008 raise TemplateNotFound(filename, self.search_path) |