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