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