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