genshi/mirror: markup/template.py comparison

comparison markup/template.py @ 69:c40a5dcd2b55 trunk

A couple of minor performance improvements.

author	cmlenz
date	Mon, 10 Jul 2006 17:37:01 +0000
parents	59eb24184e9c
children	dd73921530e8

comparison

equal deleted inserted replaced

-:e7f91e75b0e1
+:c40a5dcd2b55
 import posixpath
 import re
 from StringIO import StringIO
 from markup.core import Attributes, Namespace, Stream, StreamEventKind
+from markup.core import START, END, START_NS, END_NS, TEXT
 from markup.eval import Expression
-from markup.input import HTML, XMLParser, XML
+from markup.input import XMLParser
 from markup.path import Path
 __all__ = ['Context', 'BadDirectiveError', 'TemplateError',
 'TemplateSyntaxError', 'TemplateNotFound', 'Template',
 'TemplateLoader']
 def __call__(self, stream, ctxt, directives):
 def _generate():
 kind, data, pos = stream.next()
 if kind is Stream.START:
 yield kind, data, pos # emit start tag
-yield Template.EXPR, self.expr, pos
+yield EXPR, self.expr, pos
 previous = stream.next()
 for event in stream:
 previous = event
 if previous is not None:
 yield previous
 if args:
 scope[name] = args.pop(0)
 else:
 scope[name] = kwargs.pop(name, self.defaults.get(name))
 ctxt.push(**scope)
-stream = self._apply_directives(self.stream, ctxt, self.directives)
+for event in self._apply_directives(self.stream, ctxt, self.directives):
-for event in stream:
 yield event
 ctxt.pop()
 class ForDirective(Directive):
 """
 __slots__ = []
 def __call__(self, stream, ctxt, directives):
 kind, data, pos = stream.next()
-yield Template.EXPR, self.expr, pos
+yield EXPR, self.expr, pos
 class StripDirective(Directive):
 """Implementation of the `py:strip` template directive.
 ns_prefix = {}
 depth = 0
 for kind, data, pos in XMLParser(self.source, filename=self.filename):
-if kind is Stream.START_NS:
+if kind is START_NS:
 # Strip out the namespace declaration for template directives
 prefix, uri = data
 if uri == self.NAMESPACE:
 ns_prefix[prefix] = uri
 else:
 stream.append((kind, data, pos))
-elif kind is Stream.END_NS:
+elif kind is END_NS:
 if data in ns_prefix:
 del ns_prefix[data]
 else:
 stream.append((kind, data, pos))
-elif kind is Stream.START:
+elif kind is START:
 # Record any directive attributes in start tags
 tag, attrib = data
 directives = []
 strip = False
 dirmap[(depth, tag)] = (directives, len(stream), strip)
 stream.append((kind, (tag, Attributes(new_attrib)), pos))
 depth += 1
-elif kind is Stream.END:
+elif kind is END:
 depth -= 1
 stream.append((kind, data, pos))
 # If there have have directive attributes with the corresponding
 # start tag, move the events inbetween into a "subprogram"
 if (depth, data) in dirmap:
 directives, start_offset, strip = dirmap.pop((depth, data))
 substream = stream[start_offset:]
 if strip:
 substream = substream[1:-1]
-stream[start_offset:] = [(Template.SUB,
+stream[start_offset:] = [(SUB, (directives, substream),
-(directives, substream), pos)]
+pos)]
-elif kind is Stream.TEXT:
+elif kind is TEXT:
 for kind, data, pos in self._interpolate(data, *pos):
 stream.append((kind, data, pos))
 else:
 stream.append((kind, data, pos))
 """
 patterns = [Template._FULL_EXPR_RE, Template._SHORT_EXPR_RE]
 def _interpolate(text):
 for idx, group in enumerate(patterns.pop(0).split(text)):
 if idx % 2:
-yield Template.EXPR, Expression(group), (lineno, offset)
+yield EXPR, Expression(group), (lineno, offset)
 elif group:
 if patterns:
 for result in _interpolate(group):
 yield result
 else:
-yield Stream.TEXT, group.replace('$$', '$'), \
+yield TEXT, group.replace('$$', '$'), (filename, lineno,
-(filename, lineno, offset)
+offset)
 return _interpolate(text)
 _interpolate = classmethod(_interpolate)
 def generate(self, ctxt=None):
 """Apply the template to the given context data.
 if ctxt is None:
 ctxt = Context()
 if not hasattr(ctxt, '_match_templates'):
 ctxt._match_templates = []
-stream = self._flatten(self._match(self._eval(self.stream, ctxt), ctxt),
+stream = self.stream
-ctxt)
+for filter_ in [self._eval, self._match, self._flatten] + self.filters:
-for filter_ in self.filters:
 stream = filter_(iter(stream), ctxt)
 return Stream(stream)
 def _eval(self, stream, ctxt=None):
 """Internal stream filter that evaluates any expressions in `START` and
 `TEXT` events.
 """
 for kind, data, pos in stream:
-if kind is Stream.START:
+if kind is START:
 # Attributes may still contain expressions in start tags at
 # this point, so do some evaluation
 tag, attrib = data
 new_attrib = []
 for name, substream in attrib:
 if isinstance(substream, basestring):
 value = substream
 else:
 values = []
 for subkind, subdata, subpos in substream:
-if subkind is Template.EXPR:
+if subkind is EXPR:
 values.append(subdata.evaluate(ctxt))
 else:
 values.append(subdata)
 value = [unicode(x) for x in values if x is not None]
 if not value:
 continue
 new_attrib.append((name, u''.join(value)))
 yield kind, (tag, Attributes(new_attrib)), pos
-elif kind is Template.EXPR:
+elif kind is EXPR:
 result = data.evaluate(ctxt)
 if result is None:
 continue
 # First check for a string, otherwise the iterable test below
 # succeeds, and the string will be chopped up into individual
 # characters
 if isinstance(result, basestring):
-yield Stream.TEXT, result, pos
+yield TEXT, result, pos
 else:
 # Test if the expression evaluated to an iterable, in which
 # case we yield the individual items
 try:
 for event in self._match(self._eval(iter(result), ctxt),
 ctxt):
 yield event
 except TypeError:
 # Neither a string nor an iterable, so just pass it
 # through
-yield Stream.TEXT, unicode(result), pos
+yield TEXT, unicode(result), pos
 else:
 yield kind, data, pos
 def _flatten(self, stream, ctxt=None):
 """Internal stream filter that expands `SUB` events in the stream."""
 try:
 for kind, data, pos in stream:
-if kind is Template.SUB:
+if kind is SUB:
 # This event is a list of directives and a list of nested
 # events to which those directives should be applied
 directives, substream = data
-substream = directives[0](iter(substream), ctxt, directives[1:])
+if directives:
-substream = self._match(self._eval(substream, ctxt), ctxt)
+substream = directives[0](iter(substream), ctxt,
-for event in self._flatten(substream, ctxt):
+directives[1:])
+for filter_ in (self._eval, self._match, self._flatten):
+substream = filter_(substream, ctxt)
+for event in substream:
 yield event
 continue
 else:
 yield kind, data, pos
 except SyntaxError, err:
-raise TemplateSyntaxError(err, self.filename, pos[1],
+raise TemplateSyntaxError(err, pos[0], pos[1],
 pos[2] + (err.offset or 0))
 def _match(self, stream, ctxt=None, match_templates=None):
 """Internal stream filter that applies any defined match templates
 to the stream.
 for kind, data, pos in stream:
 # We (currently) only care about start and end events for matching
 # We might care about namespace events in the future, though
-if kind not in (Stream.START, Stream.END):
+if kind not in (START, END):
 yield kind, data, pos
 continue
 for idx, (test, path, template, directives) in \
 enumerate(match_templates):
 # Consume and store all events until an end event
 # corresponding to this start event is encountered
 content = [(kind, data, pos)]
 depth = 1
 while depth > 0:
-event = stream.next()
+ev = stream.next()
-if event[0] is Stream.START:
+depth += {START: 1, END: -1}.get(ev[0], 0)
-depth += 1
+content.append(ev)
-elif event[0] is Stream.END:
+test(*ev)
-depth -= 1
-content.append(event)
-# enable the path to keep track of the stream state
-test(*event)
 content = list(self._flatten(content, ctxt))
 ctxt.push(select=lambda path: Stream(content).select(path))
 if directives:
 template = directives[0](iter(template), ctxt,
 directives[1:])
-template = self._match(self._eval(iter(template), ctxt),
+for event in self._match(self._eval(template, ctxt),
 ctxt, match_templates[:idx] +
-match_templates[idx + 1:])
+match_templates[idx + 1:]):
-for event in template:
 yield event
 ctxt.pop()
 break
-else:
+else: # no matches
 yield kind, data, pos
+EXPR = Template.EXPR
+SUB = Template.SUB
 class TemplateLoader(object):
 """Responsible for loading templates from files on the specified search
 path.
 @param filename: the relative path of the template file to load
 @param relative_to: the filename of the template from which the new
 template is being loaded, or `None` if the template is being loaded
 directly
 """
+from markup.filters import IncludeFilter
 if relative_to:
 filename = posixpath.join(posixpath.dirname(relative_to), filename)
 filename = os.path.normpath(filename)
 # First check the cache to avoid reparsing the same file
 for dirname in search_path:
 filepath = os.path.join(dirname, filename)
 try:
 fileobj = file(filepath, 'rt')
 try:
-from markup.filters import IncludeFilter
 tmpl = Template(fileobj, basedir=dirname, filename=filename)
 tmpl.filters.append(IncludeFilter(self))
 finally:
 fileobj.close()
 self._cache[filename] = tmpl

Mercurial > genshi > mirror

comparison markup/template.py @ 69:c40a5dcd2b55 trunk