Mercurial > genshi > mirror
annotate markup/template.py @ 95:2fe86a99947f trunk
Improve performance of push/pop operations on the context.
| author | cmlenz |
|---|---|
| date | Fri, 21 Jul 2006 11:35:56 +0000 |
| parents | 08d77c7725e2 |
| children | 5df0d81ac5d6 |
| rev | line source |
|---|---|
| 1 | 1 # -*- coding: utf-8 -*- |
| 2 # | |
|
66
59eb24184e9c
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
59eb24184e9c
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
59eb24184e9c
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
dd73921530e8
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: |
|
dd73921530e8
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 |
|
dd73921530e8
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: |
|
dd73921530e8
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): |
|
dd73921530e8
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) |
|
dd73921530e8
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
b4d17897d053
* 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
5420cfe42d36
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 |
|
89
80386d62814f
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
|
29 from markup.core import START, END, START_NS, END_NS, TEXT, COMMENT |
| 1 | 30 from markup.eval import Expression |
| 69 | 31 from markup.input import XMLParser |
|
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
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
2fe86a99947f
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
80 """Container for template input data. |
| 1 | 81 |
|
95
2fe86a99947f
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). |
|
2fe86a99947f
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
83 |
|
2fe86a99947f
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 |
|
2fe86a99947f
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 |
|
2fe86a99947f
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
2fe86a99947f
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
2fe86a99947f
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
dd73921530e8
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
2fe86a99947f
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
106 self.pop = self.frames.popleft |
|
2fe86a99947f
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
dd73921530e8
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
2fe86a99947f
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
113 """Set a variable in the current scope.""" |
|
70
dd73921530e8
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
2fe86a99947f
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 |
|
2fe86a99947f
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
118 upward. |
|
29
ab8703fa68b8
* 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
dd73921530e8
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
dd73921530e8
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
2fe86a99947f
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
125 def push(self, data): |
|
2fe86a99947f
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
2fe86a99947f
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
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
152 def __init__(self, value, filename=None, lineno=-1, offset=-1): |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
153 try: |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
154 self.expr = value and Expression(value, filename, lineno) or None |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
155 except SyntaxError, err: |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
156 raise TemplateSyntaxError(err, filename, lineno, |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
157 offset + (err.offset or 0)) |
| 1 | 158 |
|
53
512eb72dbb19
* 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
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
168 |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
169 def _apply_directives(stream, ctxt, directives): |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
170 if directives: |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
171 stream = directives[0](iter(stream), ctxt, directives[1:]) |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
172 return stream |
|
53
512eb72dbb19
* 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
d3842cd76e92
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__ = [] |
|
d3842cd76e92
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
512eb72dbb19
* 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): |
|
512eb72dbb19
* 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(): |
|
512eb72dbb19
* 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() |
|
512eb72dbb19
* 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) |
|
512eb72dbb19
* 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: |
|
512eb72dbb19
* 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
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
207 if isinstance(attrs, Stream): |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
208 try: |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
209 attrs = iter(attrs).next() |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
210 except StopIteration: |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
211 attrs = [] |
|
f5ec6d4a61e4
* 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
512eb72dbb19
* 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() |
|
512eb72dbb19
* 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: |
|
512eb72dbb19
* 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: |
|
512eb72dbb19
* 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) |
|
512eb72dbb19
* 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: |
|
512eb72dbb19
* 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()) |
|
512eb72dbb19
* 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 |
|
512eb72dbb19
* 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: |
|
512eb72dbb19
* 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
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
222 |
|
78
46fed54f23cd
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
d3842cd76e92
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__ = [] |
|
d3842cd76e92
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 |
|
d3842cd76e92
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
512eb72dbb19
* 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
d3842cd76e92
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() |
|
d3842cd76e92
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
|
246 if kind is Stream.START: |
|
d3842cd76e92
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
d3842cd76e92
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() |
|
d3842cd76e92
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: |
|
d3842cd76e92
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 |
|
d3842cd76e92
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: |
|
d3842cd76e92
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
1b874f032bde
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
46fed54f23cd
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
c835e81c50af
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
c835e81c50af
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
c835e81c50af
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 |
|
c835e81c50af
When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents:
89
diff
changeset
|
284 both when defining and when calling it: |
|
c835e81c50af
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
c835e81c50af
When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents:
89
diff
changeset
|
288 ... <p py:def="helloworld" class="message"> |
|
c835e81c50af
When an expression evaluates to a callable, it is called implicitly.
cmlenz
parents:
89
diff
changeset
|
289 ... Hello, world! |
| 1 | 290 ... </p> |
|
90
c835e81c50af
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
c835e81c50af
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
d3842cd76e92
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
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
302 ATTRIBUTE = 'function' |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
303 |
|
81
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
304 def __init__(self, args, filename=None, lineno=-1, offset=-1): |
|
d60486018004
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
d3842cd76e92
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
d3842cd76e92
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
d3842cd76e92
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
2fe86a99947f
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
336 ctxt.push(scope) |
|
78
46fed54f23cd
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
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
357 ATTRIBUTE = 'each' |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
358 |
|
81
d60486018004
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
ab8703fa68b8
* 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
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
362 Directive.__init__(self, value, filename, lineno, offset) |
| 1 | 363 |
|
50
d3842cd76e92
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
512eb72dbb19
* 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) |
| 1 | 366 if iterable is not None: |
|
93
08d77c7725e2
Minor bugfi x follow-up to [97]: don't yield the terminator event from the whitespace filter.
cmlenz
parents:
92
diff
changeset
|
367 scope = {} |
| 1 | 368 stream = list(stream) |
|
92
01d36818bb3d
More performance improvements... this time for whitespace normalization and template loops.
cmlenz
parents:
90
diff
changeset
|
369 targets = self.targets |
| 1 | 370 for item in iter(iterable): |
|
92
01d36818bb3d
More performance improvements... this time for whitespace normalization and template loops.
cmlenz
parents:
90
diff
changeset
|
371 if len(targets) == 1: |
|
01d36818bb3d
More performance improvements... this time for whitespace normalization and template loops.
cmlenz
parents:
90
diff
changeset
|
372 scope[targets[0]] = item |
|
01d36818bb3d
More performance improvements... this time for whitespace normalization and template loops.
cmlenz
parents:
90
diff
changeset
|
373 else: |
|
01d36818bb3d
More performance improvements... this time for whitespace normalization and template loops.
cmlenz
parents:
90
diff
changeset
|
374 for idx, name in enumerate(targets): |
|
01d36818bb3d
More performance improvements... this time for whitespace normalization and template loops.
cmlenz
parents:
90
diff
changeset
|
375 scope[name] = item[idx] |
|
95
2fe86a99947f
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
376 ctxt.push(scope) |
|
78
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
377 for event in _apply_directives(stream, ctxt, directives): |
| 1 | 378 yield event |
| 379 ctxt.pop() | |
| 380 | |
| 381 def __repr__(self): | |
| 382 return '<%s "%s in %s">' % (self.__class__.__name__, | |
| 383 ', '.join(self.targets), self.expr.source) | |
| 384 | |
| 385 | |
| 386 class IfDirective(Directive): | |
| 31 | 387 """Implementation of the `py:if` template directive for conditionally |
| 388 excluding elements from being output. | |
| 1 | 389 |
| 390 >>> ctxt = Context(foo=True, bar='Hello') | |
| 61 | 391 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
| 1 | 392 ... <b py:if="foo">${bar}</b> |
| 393 ... </div>''') | |
| 394 >>> print tmpl.generate(ctxt) | |
| 395 <div> | |
| 396 <b>Hello</b> | |
| 397 </div> | |
| 398 """ | |
|
50
d3842cd76e92
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
|
399 __slots__ = [] |
|
d3842cd76e92
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
|
400 |
|
65
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
401 ATTRIBUTE = 'test' |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
402 |
|
50
d3842cd76e92
Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives.
cmlenz
parents:
48
diff
changeset
|
403 def __call__(self, stream, ctxt, directives): |
| 1 | 404 if self.expr.evaluate(ctxt): |
|
78
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
405 return _apply_directives(stream, ctxt, directives) |
| 1 | 406 return [] |
| 407 | |
| 408 | |
| 409 class MatchDirective(Directive): | |
| 410 """Implementation of the `py:match` template directive. | |
|
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
411 |
| 61 | 412 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
413 ... <span py:match="greeting"> |
| 1 | 414 ... Hello ${select('@name')} |
| 415 ... </span> | |
| 416 ... <greeting name="Dude" /> | |
| 417 ... </div>''') | |
|
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
418 >>> print tmpl.generate() |
| 1 | 419 <div> |
| 420 <span> | |
| 421 Hello Dude | |
| 422 </span> | |
| 423 </div> | |
| 424 """ | |
| 425 __slots__ = ['path', 'stream'] | |
| 426 | |
|
65
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
427 ATTRIBUTE = 'path' |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
428 |
|
81
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
429 def __init__(self, value, filename=None, lineno=-1, offset=-1): |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
430 Directive.__init__(self, None, filename, lineno, offset) |
|
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
431 self.path = Path(value) |
| 1 | 432 self.stream = [] |
| 433 | |
|
50
d3842cd76e92
Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives.
cmlenz
parents:
48
diff
changeset
|
434 def __call__(self, stream, ctxt, directives): |
| 1 | 435 self.stream = list(stream) |
|
38
ee669cb9cccc
Fix for #2 (incorrect context node in path expressions). Still some paths that produce incorrect results, but the common case seems to work now.
cmlenz
parents:
37
diff
changeset
|
436 ctxt._match_templates.append((self.path.test(ignore_context=True), |
|
50
d3842cd76e92
Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives.
cmlenz
parents:
48
diff
changeset
|
437 self.path, self.stream, directives)) |
| 1 | 438 return [] |
| 439 | |
| 440 def __repr__(self): | |
|
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
441 return '<%s "%s">' % (self.__class__.__name__, self.path.source) |
| 1 | 442 |
| 443 | |
| 444 class ReplaceDirective(Directive): | |
| 445 """Implementation of the `py:replace` template directive. | |
| 446 | |
| 31 | 447 This directive replaces the element with the result of evaluating the |
| 448 value of the `py:replace` attribute: | |
| 449 | |
| 1 | 450 >>> ctxt = Context(bar='Bye') |
| 61 | 451 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
| 1 | 452 ... <span py:replace="bar">Hello</span> |
| 453 ... </div>''') | |
| 454 >>> print tmpl.generate(ctxt) | |
| 455 <div> | |
| 456 Bye | |
| 457 </div> | |
| 458 | |
| 459 This directive is equivalent to `py:content` combined with `py:strip`, | |
| 460 providing a less verbose way to achieve the same effect: | |
| 461 | |
| 462 >>> ctxt = Context(bar='Bye') | |
| 61 | 463 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
| 1 | 464 ... <span py:content="bar" py:strip="">Hello</span> |
| 465 ... </div>''') | |
| 466 >>> print tmpl.generate(ctxt) | |
| 467 <div> | |
| 468 Bye | |
| 469 </div> | |
| 470 """ | |
|
50
d3842cd76e92
Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives.
cmlenz
parents:
48
diff
changeset
|
471 __slots__ = [] |
|
d3842cd76e92
Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives.
cmlenz
parents:
48
diff
changeset
|
472 |
| 54 | 473 def __call__(self, stream, ctxt, directives): |
| 1 | 474 kind, data, pos = stream.next() |
| 69 | 475 yield EXPR, self.expr, pos |
| 1 | 476 |
| 477 | |
| 478 class StripDirective(Directive): | |
| 479 """Implementation of the `py:strip` template directive. | |
| 480 | |
| 481 When the value of the `py:strip` attribute evaluates to `True`, the element | |
| 482 is stripped from the output | |
| 483 | |
| 61 | 484 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
| 1 | 485 ... <div py:strip="True"><b>foo</b></div> |
| 486 ... </div>''') | |
|
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
487 >>> print tmpl.generate() |
| 1 | 488 <div> |
| 489 <b>foo</b> | |
| 490 </div> | |
| 491 | |
|
37
37557b8fb925
Moved some of the tests for the strip directive to a new unittest test case to not clutter up the documentation.
cmlenz
parents:
36
diff
changeset
|
492 Leaving the attribute value empty is equivalent to a truth value. |
| 1 | 493 |
| 494 This directive is particulary interesting for named template functions or | |
| 495 match templates that do not generate a top-level element: | |
| 496 | |
| 61 | 497 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/"> |
| 1 | 498 ... <div py:def="echo(what)" py:strip=""> |
| 499 ... <b>${what}</b> | |
| 500 ... </div> | |
| 501 ... ${echo('foo')} | |
| 502 ... </div>''') | |
|
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
503 >>> print tmpl.generate() |
| 1 | 504 <div> |
| 505 <b>foo</b> | |
| 506 </div> | |
| 507 """ | |
|
50
d3842cd76e92
Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives.
cmlenz
parents:
48
diff
changeset
|
508 __slots__ = [] |
|
d3842cd76e92
Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives.
cmlenz
parents:
48
diff
changeset
|
509 |
| 54 | 510 def __call__(self, stream, ctxt, directives): |
|
78
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
511 def _generate(): |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
512 if self.expr: |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
513 strip = self.expr.evaluate(ctxt) |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
514 else: |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
515 strip = True |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
516 if strip: |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
517 stream.next() # skip start tag |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
518 previous = stream.next() |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
519 for event in stream: |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
520 yield previous |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
521 previous = event |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
522 else: |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
523 for event in stream: |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
524 yield event |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
525 |
|
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
526 return _apply_directives(_generate(), ctxt, directives) |
| 1 | 527 |
| 528 | |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
529 class ChooseDirective(Directive): |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
530 """Implementation of the `py:choose` directive for conditionally selecting |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
531 one of several body elements to display. |
|
53
512eb72dbb19
* Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive.
cmlenz
parents:
51
diff
changeset
|
532 |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
533 If the `py:choose` expression is empty the expressions of nested `py:when` |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
534 directives are tested for truth. The first true `py:when` body is output. |
|
53
512eb72dbb19
* Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive.
cmlenz
parents:
51
diff
changeset
|
535 If no `py:when` directive is matched then the fallback directive |
|
512eb72dbb19
* Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive.
cmlenz
parents:
51
diff
changeset
|
536 `py:otherwise` will be used. |
|
512eb72dbb19
* Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive.
cmlenz
parents:
51
diff
changeset
|
537 |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
538 >>> ctxt = Context() |
| 61 | 539 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/" |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
540 ... py:choose=""> |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
541 ... <span py:when="0 == 1">0</span> |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
542 ... <span py:when="1 == 1">1</span> |
|
53
512eb72dbb19
* Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive.
cmlenz
parents:
51
diff
changeset
|
543 ... <span py:otherwise="">2</span> |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
544 ... </div>''') |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
545 >>> print tmpl.generate(ctxt) |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
546 <div> |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
547 <span>1</span> |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
548 </div> |
|
53
512eb72dbb19
* Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive.
cmlenz
parents:
51
diff
changeset
|
549 |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
550 If the `py:choose` directive contains an expression, the nested `py:when` |
|
53
512eb72dbb19
* Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive.
cmlenz
parents:
51
diff
changeset
|
551 directives are tested for equality to the `py:choose` expression: |
|
512eb72dbb19
* Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive.
cmlenz
parents:
51
diff
changeset
|
552 |
| 61 | 553 >>> tmpl = Template('''<div xmlns:py="http://markup.edgewall.org/" |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
554 ... py:choose="2"> |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
555 ... <span py:when="1">1</span> |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
556 ... <span py:when="2">2</span> |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
557 ... </div>''') |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
558 >>> print tmpl.generate(ctxt) |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
559 <div> |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
560 <span>2</span> |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
561 </div> |
|
53
512eb72dbb19
* Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive.
cmlenz
parents:
51
diff
changeset
|
562 |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
563 Behavior is undefined if a `py:choose` block contains content outside a |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
564 `py:when` or `py:otherwise` block. Behavior is also undefined if a |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
565 `py:otherwise` occurs before `py:when` blocks. |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
566 """ |
|
50
d3842cd76e92
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
|
567 __slots__ = ['matched', 'value'] |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
568 |
|
65
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
569 ATTRIBUTE = 'test' |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
570 |
|
53
512eb72dbb19
* Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive.
cmlenz
parents:
51
diff
changeset
|
571 def __call__(self, stream, ctxt, directives): |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
572 if self.expr: |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
573 self.value = self.expr.evaluate(ctxt) |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
574 self.matched = False |
|
95
2fe86a99947f
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
575 ctxt.push(dict(_choose=self)) |
|
78
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
576 for event in _apply_directives(stream, ctxt, directives): |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
577 yield event |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
578 ctxt.pop() |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
579 |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
580 |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
581 class WhenDirective(Directive): |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
582 """Implementation of the `py:when` directive for nesting in a parent with |
|
50
d3842cd76e92
Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives.
cmlenz
parents:
48
diff
changeset
|
583 the `py:choose` directive. |
|
d3842cd76e92
Fix the way multiple directives are applied to a single `SUB` in many cases by making the directives themselves responsible for applying any remaining directives.
cmlenz
parents:
48
diff
changeset
|
584 |
|
d3842cd76e92
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 See the documentation of `py:choose` for usage. |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
586 """ |
|
65
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
587 |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
588 ATTRIBUTE = 'test' |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
589 |
| 54 | 590 def __call__(self, stream, ctxt, directives): |
|
50
d3842cd76e92
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
|
591 choose = ctxt['_choose'] |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
592 if choose.matched: |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
593 return [] |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
594 value = self.expr.evaluate(ctxt) |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
595 try: |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
596 if value == choose.value: |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
597 choose.matched = True |
|
78
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
598 return _apply_directives(stream, ctxt, directives) |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
599 except AttributeError: |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
600 if value: |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
601 choose.matched = True |
|
78
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
602 return _apply_directives(stream, ctxt, directives) |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
603 return [] |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
604 |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
605 |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
606 class OtherwiseDirective(Directive): |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
607 """Implementation of the `py:otherwise` directive for nesting in a parent |
|
50
d3842cd76e92
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
|
608 with the `py:choose` directive. |
|
d3842cd76e92
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
|
609 |
|
d3842cd76e92
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 See the documentation of `py:choose` for usage. |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
611 """ |
| 54 | 612 def __call__(self, stream, ctxt, directives): |
|
50
d3842cd76e92
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
|
613 choose = ctxt['_choose'] |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
614 if choose.matched: |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
615 return [] |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
616 choose.matched = True |
|
78
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
617 return _apply_directives(stream, ctxt, directives) |
|
44
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
618 |
|
436e30c8420b
implement `py:choose/when/otherwise` directives for conditionally selecting one of several blocks
mgood
parents:
38
diff
changeset
|
619 |
| 1 | 620 class Template(object): |
| 621 """Can parse a template and transform it into the corresponding output | |
| 622 based on context data. | |
| 623 """ | |
| 61 | 624 NAMESPACE = Namespace('http://markup.edgewall.org/') |
| 1 | 625 |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
626 EXPR = StreamEventKind('EXPR') # an expression |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
627 SUB = StreamEventKind('SUB') # a "subprogram" |
|
10
f77f7a91aa46
Moved the template-specific stream event kinds into the template module.
cmlenz
parents:
6
diff
changeset
|
628 |
| 1 | 629 directives = [('def', DefDirective), |
| 630 ('match', MatchDirective), | |
| 631 ('for', ForDirective), | |
| 632 ('if', IfDirective), | |
|
50
d3842cd76e92
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
|
633 ('when', WhenDirective), |
|
d3842cd76e92
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
|
634 ('otherwise', OtherwiseDirective), |
|
53
512eb72dbb19
* Add helper function to let directives apply any remaining directives, and use that helper consistently in every directive.
cmlenz
parents:
51
diff
changeset
|
635 ('choose', ChooseDirective), |
| 1 | 636 ('replace', ReplaceDirective), |
| 637 ('content', ContentDirective), | |
| 638 ('attrs', AttrsDirective), | |
|
50
d3842cd76e92
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
|
639 ('strip', StripDirective)] |
| 1 | 640 _dir_by_name = dict(directives) |
| 641 _dir_order = [directive[1] for directive in directives] | |
| 642 | |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
643 def __init__(self, source, basedir=None, filename=None): |
| 1 | 644 """Initialize a template from either a string or a file-like object.""" |
| 645 if isinstance(source, basestring): | |
| 646 self.source = StringIO(source) | |
| 647 else: | |
| 648 self.source = source | |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
649 self.basedir = basedir |
| 1 | 650 self.filename = filename or '<string>' |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
651 if basedir and filename: |
|
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
652 self.filepath = os.path.join(basedir, filename) |
|
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
653 else: |
|
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
654 self.filepath = '<string>' |
| 1 | 655 |
|
23
d88358f719fa
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
656 self.filters = [] |
| 1 | 657 self.parse() |
| 658 | |
| 659 def __repr__(self): | |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
660 return '<%s "%s">' % (self.__class__.__name__, self.filename) |
| 1 | 661 |
| 662 def parse(self): | |
| 663 """Parse the template. | |
| 664 | |
| 665 The parsing stage parses the XML template and constructs a list of | |
| 666 directives that will be executed in the render stage. The input is | |
| 667 split up into literal output (markup that does not depend on the | |
| 668 context data) and actual directives (commands or variable | |
| 669 substitution). | |
| 670 """ | |
| 671 stream = [] # list of events of the "compiled" template | |
| 672 dirmap = {} # temporary mapping of directives to elements | |
| 673 ns_prefix = {} | |
| 674 depth = 0 | |
| 675 | |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
676 for kind, data, pos in XMLParser(self.source, filename=self.filename): |
| 1 | 677 |
| 69 | 678 if kind is START_NS: |
| 1 | 679 # Strip out the namespace declaration for template directives |
| 680 prefix, uri = data | |
| 681 if uri == self.NAMESPACE: | |
| 682 ns_prefix[prefix] = uri | |
| 683 else: | |
| 684 stream.append((kind, data, pos)) | |
| 685 | |
| 69 | 686 elif kind is END_NS: |
| 1 | 687 if data in ns_prefix: |
| 688 del ns_prefix[data] | |
| 689 else: | |
| 690 stream.append((kind, data, pos)) | |
| 691 | |
| 69 | 692 elif kind is START: |
| 1 | 693 # Record any directive attributes in start tags |
| 694 tag, attrib = data | |
| 695 directives = [] | |
|
65
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
696 strip = False |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
697 |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
698 if tag in self.NAMESPACE: |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
699 cls = self._dir_by_name.get(tag.localname) |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
700 if cls is None: |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
701 raise BadDirectiveError(tag, pos[0], pos[1]) |
|
66
59eb24184e9c
Switch copyright to Edgewall and URLs to markup.edgewall.org.
cmlenz
parents:
65
diff
changeset
|
702 value = attrib.get(getattr(cls, 'ATTRIBUTE', None), '') |
|
81
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
703 directives.append(cls(value, *pos)) |
|
65
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
704 strip = True |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
705 |
| 1 | 706 new_attrib = [] |
| 707 for name, value in attrib: | |
|
18
5420cfe42d36
Actually make use of the `markup.core.Namespace` class, and add a couple of doctests.
cmlenz
parents:
17
diff
changeset
|
708 if name in self.NAMESPACE: |
| 1 | 709 cls = self._dir_by_name.get(name.localname) |
| 710 if cls is None: | |
|
65
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
711 raise BadDirectiveError(name, pos[0], pos[1]) |
|
81
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
712 directives.append(cls(value, *pos)) |
| 1 | 713 else: |
|
75
3722696d0343
Empty attributes in templates were being stripped out. Thanks to Jonas for the patch.
cmlenz
parents:
74
diff
changeset
|
714 if value: |
|
3722696d0343
Empty attributes in templates were being stripped out. Thanks to Jonas for the patch.
cmlenz
parents:
74
diff
changeset
|
715 value = list(self._interpolate(value, *pos)) |
|
81
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
716 if len(value) == 1 and value[0][0] is TEXT: |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
717 value = value[0][1] |
|
75
3722696d0343
Empty attributes in templates were being stripped out. Thanks to Jonas for the patch.
cmlenz
parents:
74
diff
changeset
|
718 else: |
|
3722696d0343
Empty attributes in templates were being stripped out. Thanks to Jonas for the patch.
cmlenz
parents:
74
diff
changeset
|
719 value = [(TEXT, u'', pos)] |
| 1 | 720 new_attrib.append((name, value)) |
|
65
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
721 |
| 1 | 722 if directives: |
|
50
d3842cd76e92
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
|
723 directives.sort(lambda a, b: cmp(self._dir_order.index(a.__class__), |
|
d3842cd76e92
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
|
724 self._dir_order.index(b.__class__))) |
|
65
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
725 dirmap[(depth, tag)] = (directives, len(stream), strip) |
| 1 | 726 |
| 727 stream.append((kind, (tag, Attributes(new_attrib)), pos)) | |
| 728 depth += 1 | |
| 729 | |
| 69 | 730 elif kind is END: |
| 1 | 731 depth -= 1 |
| 732 stream.append((kind, data, pos)) | |
| 733 | |
| 734 # If there have have directive attributes with the corresponding | |
| 735 # start tag, move the events inbetween into a "subprogram" | |
| 736 if (depth, data) in dirmap: | |
|
65
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
737 directives, start_offset, strip = dirmap.pop((depth, data)) |
| 1 | 738 substream = stream[start_offset:] |
|
65
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
739 if strip: |
|
b3fdf93057ab
Support the use of directives as elements to reduce the need for using `py:strip`.
cmlenz
parents:
61
diff
changeset
|
740 substream = substream[1:-1] |
| 69 | 741 stream[start_offset:] = [(SUB, (directives, substream), |
| 742 pos)] | |
| 1 | 743 |
| 69 | 744 elif kind is TEXT: |
| 1 | 745 for kind, data, pos in self._interpolate(data, *pos): |
| 746 stream.append((kind, data, pos)) | |
| 747 | |
|
89
80386d62814f
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
|
748 elif kind is COMMENT: |
|
80386d62814f
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
|
749 if not data.lstrip().startswith('!'): |
|
80386d62814f
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
|
750 stream.append((kind, data, pos)) |
|
80386d62814f
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
|
751 |
| 1 | 752 else: |
| 753 stream.append((kind, data, pos)) | |
| 754 | |
| 755 self.stream = stream | |
| 756 | |
| 757 _FULL_EXPR_RE = re.compile(r'(?<!\$)\$\{(.+?)\}') | |
| 758 _SHORT_EXPR_RE = re.compile(r'(?<!\$)\$([a-zA-Z][a-zA-Z0-9_\.]*)') | |
| 759 | |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
760 def _interpolate(cls, text, filename=None, lineno=-1, offset=-1): |
| 1 | 761 """Parse the given string and extract expressions. |
| 762 | |
| 763 This method returns a list containing both literal text and `Expression` | |
| 764 objects. | |
|
14
c7d33e0c9839
The `<py:match>` directive now protects itself against simple infinite recursion (see MatchDirective), while still allowing recursion in general.
cmlenz
parents:
13
diff
changeset
|
765 |
| 1 | 766 @param text: the text to parse |
| 767 @param lineno: the line number at which the text was found (optional) | |
| 768 @param offset: the column number at which the text starts in the source | |
| 769 (optional) | |
| 770 """ | |
|
74
d54b5fd60b52
Fix expression interpolation where both shorthand notation and full notation are used inside a single text node. Thanks Jonas.
cmlenz
parents:
73
diff
changeset
|
771 def _interpolate(text, patterns): |
| 1 | 772 for idx, group in enumerate(patterns.pop(0).split(text)): |
| 773 if idx % 2: | |
|
81
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
774 try: |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
775 yield EXPR, Expression(group, filename, lineno), \ |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
776 (lineno, offset) |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
777 except SyntaxError, err: |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
778 raise TemplateSyntaxError(err, filename, lineno, |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
779 offset + (err.offset or 0)) |
| 1 | 780 elif group: |
| 781 if patterns: | |
|
74
d54b5fd60b52
Fix expression interpolation where both shorthand notation and full notation are used inside a single text node. Thanks Jonas.
cmlenz
parents:
73
diff
changeset
|
782 for result in _interpolate(group, patterns[:]): |
| 1 | 783 yield result |
| 784 else: | |
| 69 | 785 yield TEXT, group.replace('$$', '$'), (filename, lineno, |
| 786 offset) | |
|
74
d54b5fd60b52
Fix expression interpolation where both shorthand notation and full notation are used inside a single text node. Thanks Jonas.
cmlenz
parents:
73
diff
changeset
|
787 return _interpolate(text, [cls._FULL_EXPR_RE, cls._SHORT_EXPR_RE]) |
| 1 | 788 _interpolate = classmethod(_interpolate) |
| 789 | |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
790 def generate(self, ctxt=None): |
|
29
ab8703fa68b8
* 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
|
791 """Apply the template to the given context data. |
|
ab8703fa68b8
* 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
|
792 |
|
ab8703fa68b8
* 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
|
793 @param ctxt: a `Context` instance containing the data for the template |
|
ab8703fa68b8
* 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
|
794 @return: a markup event stream representing the result of applying |
|
ab8703fa68b8
* 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
|
795 the template to the context data. |
|
ab8703fa68b8
* 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
|
796 """ |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
797 if ctxt is None: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
798 ctxt = Context() |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
799 if not hasattr(ctxt, '_match_templates'): |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
800 ctxt._match_templates = [] |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
801 |
| 69 | 802 stream = self.stream |
| 803 for filter_ in [self._eval, self._match, self._flatten] + self.filters: | |
|
35
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
804 stream = filter_(iter(stream), ctxt) |
|
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
805 return Stream(stream) |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
806 |
|
77
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
807 def _ensure(self, stream, ctxt=None): |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
808 """Ensure that every item on the stream is actually a markup event.""" |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
809 for event in stream: |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
810 try: |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
811 kind, data, pos = event |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
812 except ValueError: |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
813 kind, data, pos = event.totuple() |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
814 yield kind, data, pos |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
815 |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
816 def _eval(self, stream, ctxt=None): |
|
29
ab8703fa68b8
* 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
|
817 """Internal stream filter that evaluates any expressions in `START` and |
|
ab8703fa68b8
* 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
|
818 `TEXT` events. |
|
ab8703fa68b8
* 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
|
819 """ |
|
81
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
820 filters = (self._ensure, self._eval, self._match) |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
821 |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
822 for kind, data, pos in stream: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
823 |
|
81
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
824 if kind is START and data[1]: |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
825 # Attributes may still contain expressions in start tags at |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
826 # this point, so do some evaluation |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
827 tag, attrib = data |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
828 new_attrib = [] |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
829 for name, substream in attrib: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
830 if isinstance(substream, basestring): |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
831 value = substream |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
832 else: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
833 values = [] |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
834 for subkind, subdata, subpos in substream: |
| 69 | 835 if subkind is EXPR: |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
836 values.append(subdata.evaluate(ctxt)) |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
837 else: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
838 values.append(subdata) |
|
48
a5d585dd38c4
convert the result of expressions in attributes to strings so that values like ints are output correctly
mgood
parents:
44
diff
changeset
|
839 value = [unicode(x) for x in values if x is not None] |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
840 if not value: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
841 continue |
|
23
d88358f719fa
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
842 new_attrib.append((name, u''.join(value))) |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
843 yield kind, (tag, Attributes(new_attrib)), pos |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
844 |
| 69 | 845 elif kind is EXPR: |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
846 result = data.evaluate(ctxt) |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
847 if result is None: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
848 continue |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
849 |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
850 # First check for a string, otherwise the iterable test below |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
851 # succeeds, and the string will be chopped up into individual |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
852 # characters |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
853 if isinstance(result, basestring): |
| 69 | 854 yield TEXT, result, pos |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
855 else: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
856 # Test if the expression evaluated to an iterable, in which |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
857 # case we yield the individual items |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
858 try: |
|
77
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
859 substream = iter(result) |
|
81
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
860 for filter_ in filters: |
|
77
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
861 substream = filter_(substream, ctxt) |
|
f5ec6d4a61e4
* Simplify implementation of the individual XPath tests (use closures instead of callable classes)
cmlenz
parents:
75
diff
changeset
|
862 for event in substream: |
|
35
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
863 yield event |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
864 except TypeError: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
865 # Neither a string nor an iterable, so just pass it |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
866 # through |
| 69 | 867 yield TEXT, unicode(result), pos |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
868 |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
869 else: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
870 yield kind, data, pos |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
871 |
|
23
d88358f719fa
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
872 def _flatten(self, stream, ctxt=None): |
|
29
ab8703fa68b8
* 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
|
873 """Internal stream filter that expands `SUB` events in the stream.""" |
|
81
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
874 for kind, data, pos in stream: |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
875 if kind is SUB: |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
876 # This event is a list of directives and a list of nested |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
877 # events to which those directives should be applied |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
878 directives, substream = data |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
879 substream = _apply_directives(substream, ctxt, directives) |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
880 for filter_ in (self._eval, self._match, self._flatten): |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
881 substream = filter_(substream, ctxt) |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
882 for event in substream: |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
883 yield event |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
884 else: |
|
d60486018004
Template expressions are now compiled to Python bytecode.
cmlenz
parents:
80
diff
changeset
|
885 yield kind, data, pos |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
886 |
|
36
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
887 def _match(self, stream, ctxt=None, match_templates=None): |
|
29
ab8703fa68b8
* 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
|
888 """Internal stream filter that applies any defined match templates |
|
ab8703fa68b8
* 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
|
889 to the stream. |
|
ab8703fa68b8
* 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
|
890 """ |
|
36
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
891 if match_templates is None: |
|
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
892 match_templates = ctxt._match_templates |
|
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
893 |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
894 for kind, data, pos in stream: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
895 |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
896 # We (currently) only care about start and end events for matching |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
897 # We might care about namespace events in the future, though |
|
92
01d36818bb3d
More performance improvements... this time for whitespace normalization and template loops.
cmlenz
parents:
90
diff
changeset
|
898 if not match_templates or kind not in (START, END): |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
899 yield kind, data, pos |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
900 continue |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
901 |
|
50
d3842cd76e92
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
|
902 for idx, (test, path, template, directives) in \ |
|
d3842cd76e92
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
|
903 enumerate(match_templates): |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
904 result = test(kind, data, pos) |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
905 |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
906 if result: |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
907 # Consume and store all events until an end event |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
908 # corresponding to this start event is encountered |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
909 content = [(kind, data, pos)] |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
910 depth = 1 |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
911 while depth > 0: |
| 73 | 912 kind, data, pos = stream.next() |
| 913 if kind is START: | |
| 914 depth += 1 | |
| 915 elif kind is END: | |
| 916 depth -= 1 | |
| 917 content.append((kind, data, pos)) | |
| 918 test(kind, data, pos) | |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
919 |
|
23
d88358f719fa
Separate match and eval filters from the include and user-supplied filters.
cmlenz
parents:
22
diff
changeset
|
920 content = list(self._flatten(content, ctxt)) |
|
95
2fe86a99947f
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
921 select = lambda path: Stream(content).select(path) |
|
2fe86a99947f
Improve performance of push/pop operations on the context.
cmlenz
parents:
93
diff
changeset
|
922 ctxt.push(dict(select=select)) |
|
36
ed370ebfa794
Fix for #7: match templates no longer process their own output.
cmlenz
parents:
35
diff
changeset
|
923 |
|
78
46fed54f23cd
Minor improvements to how directives are applied in template processing.
cmlenz
parents:
77
diff
changeset
|
924 template = _apply_directives(template, ctxt, directives) |
| 69 | 925 for event in self._match(self._eval(template, ctxt), |
| 926 ctxt, match_templates[:idx] + | |
| 927 match_templates[idx + 1:]): | |
|
35
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
928 yield event |
|
35b9e9318fb1
Simplify template processing model by removing dynamically generated `SUB` events.
cmlenz
parents:
31
diff
changeset
|
929 ctxt.pop() |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
930 |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
931 break |
| 69 | 932 |
| 933 else: # no matches | |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
934 yield kind, data, pos |
|
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
935 |
| 1 | 936 |
| 69 | 937 EXPR = Template.EXPR |
| 938 SUB = Template.SUB | |
| 939 | |
| 940 | |
| 1 | 941 class TemplateLoader(object): |
| 942 """Responsible for loading templates from files on the specified search | |
| 943 path. | |
| 944 | |
| 945 >>> import tempfile | |
| 946 >>> fd, path = tempfile.mkstemp(suffix='.html', prefix='template') | |
| 947 >>> os.write(fd, '<p>$var</p>') | |
| 948 11 | |
| 949 >>> os.close(fd) | |
| 950 | |
| 951 The template loader accepts a list of directory paths that are then used | |
| 952 when searching for template files, in the given order: | |
| 953 | |
| 954 >>> loader = TemplateLoader([os.path.dirname(path)]) | |
| 955 | |
| 956 The `load()` method first checks the template cache whether the requested | |
| 957 template has already been loaded. If not, it attempts to locate the | |
| 958 template file, and returns the corresponding `Template` object: | |
| 959 | |
| 960 >>> template = loader.load(os.path.basename(path)) | |
| 961 >>> isinstance(template, Template) | |
| 962 True | |
| 963 | |
| 964 Template instances are cached: requesting a template with the same name | |
| 965 results in the same instance being returned: | |
| 966 | |
| 967 >>> loader.load(os.path.basename(path)) is template | |
| 968 True | |
| 969 """ | |
| 970 def __init__(self, search_path=None, auto_reload=False): | |
| 971 """Create the template laoder. | |
| 972 | |
| 973 @param search_path: a list of absolute path names that should be | |
| 974 searched for template files | |
| 975 @param auto_reload: whether to check the last modification time of | |
| 976 template files, and reload them if they have changed | |
| 977 """ | |
| 978 self.search_path = search_path | |
| 979 if self.search_path is None: | |
| 980 self.search_path = [] | |
| 981 self.auto_reload = auto_reload | |
| 982 self._cache = {} | |
| 983 self._mtime = {} | |
| 984 | |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
985 def load(self, filename, relative_to=None): |
| 1 | 986 """Load the template with the given name. |
| 987 | |
|
22
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
988 If the `filename` parameter is relative, this method searches the search |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
989 path trying to locate a template matching the given name. If the file |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
990 name is an absolute path, the search path is not bypassed. |
| 1 | 991 |
|
22
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
992 If requested template is not found, a `TemplateNotFound` exception is |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
993 raised. Otherwise, a `Template` object is returned that represents the |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
994 parsed template. |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
995 |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
996 Template instances are cached to avoid having to parse the same |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
997 template file more than once. Thus, subsequent calls of this method |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
998 with the same template file name will return the same `Template` |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
999 object (unless the `auto_reload` option is enabled and the file was |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
1000 changed since the last parse.) |
| 1 | 1001 |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1002 If the `relative_to` parameter is provided, the `filename` is |
|
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1003 interpreted as being relative to that path. |
|
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1004 |
| 1 | 1005 @param filename: the relative path of the template file to load |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1006 @param relative_to: the filename of the template from which the new |
|
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1007 template is being loaded, or `None` if the template is being loaded |
|
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1008 directly |
| 1 | 1009 """ |
| 69 | 1010 from markup.filters import IncludeFilter |
| 1011 | |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1012 if relative_to: |
|
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1013 filename = posixpath.join(posixpath.dirname(relative_to), filename) |
| 1 | 1014 filename = os.path.normpath(filename) |
|
22
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
1015 |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
1016 # First check the cache to avoid reparsing the same file |
| 1 | 1017 try: |
| 1018 tmpl = self._cache[filename] | |
| 1019 if not self.auto_reload or \ | |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1020 os.path.getmtime(tmpl.filepath) == self._mtime[filename]: |
| 1 | 1021 return tmpl |
| 1022 except KeyError: | |
| 1023 pass | |
|
22
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
1024 |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
1025 # Bypass the search path if the filename is absolute |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
1026 search_path = self.search_path |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
1027 if os.path.isabs(filename): |
|
2483fe549959
Fix for the template engine plugin: the search path is now ignored if the requested template path is absolute.
cmlenz
parents:
21
diff
changeset
|
1028 search_path = [os.path.dirname(filename)] |
|
2483fe549959
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 |
|
2483fe549959
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 for dirname in search_path: |
| 1 | 1031 filepath = os.path.join(dirname, filename) |
| 1032 try: | |
| 1033 fileobj = file(filepath, 'rt') | |
| 1034 try: | |
|
21
b4d17897d053
* Include paths are now interpreted relative to the path of the including template. Closes #3.
cmlenz
parents:
18
diff
changeset
|
1035 tmpl = Template(fileobj, basedir=dirname, filename=filename) |
|
17
74cc70129d04
Refactoring to address #6: all match templates are now processed by a single filter, which means that match templates added by included templates are properly applied. A side effect of this refactoring is that `Context` objects may not be reused across multiple template processing runs.
cmlenz
parents:
14
diff
changeset
|
1036 tmpl.filters.append(IncludeFilter(self)) |
| 1 | 1037 finally: |
| 1038 fileobj.close() | |
| 1039 self._cache[filename] = tmpl | |
| 1040 self._mtime[filename] = os.path.getmtime(filepath) | |
| 1041 return tmpl | |
| 1042 except IOError: | |
| 1043 continue | |
| 1044 raise TemplateNotFound(filename, self.search_path) |