genshi/mirror: markup/template.py annotate

annotate markup/template.py @ 173:128005041637 trunk

Fix for #33.

author	cmlenz
date	Sun, 20 Aug 2006 11:35:46 +0000
parents	ff4f0d89eef7
children	7f96149f28d5

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

Mercurial > genshi > mirror

annotate markup/template.py @ 173:128005041637 trunk