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