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