genshi/mirror: markup/template.py comparison

comparison markup/template.py @ 50:d3842cd76e92 trunk

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.

author	cmlenz
date	Tue, 04 Jul 2006 08:37:25 +0000
parents	a5d585dd38c4
children	b2383634ec04

comparison

equal deleted inserted replaced

-:6d1f79b2f7ef
+:d3842cd76e92
 __slots__ = ['expr']
 def __init__(self, value):
 self.expr = value and Expression(value) or None
-def __call__(self, stream, ctxt):
+def __call__(self, stream, ctxt, directives=None):
 raise NotImplementedError
 def __repr__(self):
 expr = ''
 if self.expr is not None:
 >>> print tmpl.generate(ctxt)
 <ul>
 <li>Bar</li>
 </ul>
 """
-def __call__(self, stream, ctxt):
+__slots__ = []
+def __call__(self, stream, ctxt, directives=None):
 kind, (tag, attrib), pos  = stream.next()
 attrs = self.expr.evaluate(ctxt)
 if attrs:
 attrib = Attributes(attrib[:])
 if not isinstance(attrs, list): # assume it's a dict
 >>> print tmpl.generate(ctxt)
 <ul>
 <li>Bye</li>
 </ul>
 """
-def __call__(self, stream, ctxt):
+__slots__ = []
-kind, data, pos = stream.next()
-if kind is Stream.START:
+def __call__(self, stream, ctxt, directives):
-yield kind, data, pos # emit start tag
+def generate():
-yield Template.EXPR, self.expr, pos
+kind, data, pos = stream.next()
-previous = stream.next()
+if kind is Stream.START:
-for event in stream:
+yield kind, data, pos # emit start tag
-previous = event
+yield Template.EXPR, self.expr, pos
-if previous is not None:
+previous = stream.next()
-yield previous
+for event in stream:
+previous = event
+if previous is not None:
+yield previous
+output = generate()
+if directives:
+output = directives[0](output, ctxt, directives[1:])
+return output
 class DefDirective(Directive):
 """Implementation of the `py:def` template directive.
 <p class="message">
 hello, world!
 </p>
 </div>
 """
-__slots__ = ['name', 'args', 'defaults', 'stream']
+__slots__ = ['name', 'args', 'defaults', 'stream', 'directives']
 def __init__(self, args):
 Directive.__init__(self, None)
 ast = compiler.parse(args, 'eval').node
 self.args = []
 self.defaults[arg.name] = arg.expr.value
 else:
 self.args.append(arg.name)
 else:
 self.name = ast.name
-self.stream = []
+self.stream, self.directives = [], []
-def __call__(self, stream, ctxt):
+def __call__(self, stream, ctxt, directives):
 self.stream = list(stream)
+self.directives = directives
 ctxt[self.name] = lambda *args, **kwargs: self._exec(ctxt, *args,
 **kwargs)
 return []
 def _exec(self, ctxt, *args, **kwargs):
 if args:
 scope[name] = args.pop(0)
 else:
 scope[name] = kwargs.pop(name, self.defaults.get(name))
 ctxt.push(**scope)
-for event in self.stream:
+stream = iter(self.stream)
+if self.directives:
+stream = self.directives[0](stream, ctxt, self.directives[1:])
+for event in stream:
 yield event
 ctxt.pop()
 class ForDirective(Directive):
 def __init__(self, value):
 targets, value = value.split(' in ', 1)
 self.targets = [str(name.strip()) for name in targets.split(',')]
 Directive.__init__(self, value)
-def __call__(self, stream, ctxt):
+def __call__(self, stream, ctxt, directives):
 iterable = self.expr.evaluate(ctxt) or []
 if iterable is not None:
 stream = list(stream)
 for item in iter(iterable):
 if len(self.targets) == 1:
 item = [item]
 scope = {}
 for idx, name in enumerate(self.targets):
 scope[name] = item[idx]
 ctxt.push(**scope)
+if directives:
+stream = list(directives[0](iter(stream), ctxt,
+directives[1:]))
 for event in stream:
 yield event
 ctxt.pop()
 def __repr__(self):
 >>> print tmpl.generate(ctxt)
 <div>
 <b>Hello</b>
 </div>
 """
-def __call__(self, stream, ctxt):
+__slots__ = []
+def __call__(self, stream, ctxt, directives):
 if self.expr.evaluate(ctxt):
+if directives:
+stream = directives[0](stream, ctxt, directives[1:])
 return stream
 return []
 class MatchDirective(Directive):
 def __init__(self, value):
 Directive.__init__(self, None)
 self.path = Path(value)
 self.stream = []
-def __call__(self, stream, ctxt):
+def __call__(self, stream, ctxt, directives):
 self.stream = list(stream)
 ctxt._match_templates.append((self.path.test(ignore_context=True),
-self.path, self.stream))
+self.path, self.stream, directives))
 return []
 def __repr__(self):
 return '<%s "%s">' % (self.__class__.__name__, self.path.source)
 >>> print tmpl.generate(ctxt)
 <div>
 Bye
 </div>
 """
-def __call__(self, stream, ctxt):
+__slots__ = []
+def __call__(self, stream, ctxt, directives=None):
 kind, data, pos = stream.next()
 yield Template.EXPR, self.expr, pos
 class StripDirective(Directive):
 >>> print tmpl.generate()
 <div>
 <b>foo</b>
 </div>
 """
-def __call__(self, stream, ctxt):
+__slots__ = []
+def __call__(self, stream, ctxt, directives=None):
 if self.expr:
 strip = self.expr.evaluate(ctxt)
 else:
 strip = True
 if strip:
 Behavior is undefined if a `py:choose` block contains content outside a
 `py:when` or `py:otherwise` block.  Behavior is also undefined if a
 `py:otherwise` occurs before `py:when` blocks.
 """
+__slots__ = ['matched', 'value']
-def __call__(self, stream, ctxt):
+def __call__(self, stream, ctxt, directives=None):
 if self.expr:
 self.value = self.expr.evaluate(ctxt)
 self.matched = False
-ctxt.push(__choose=self)
+ctxt.push(_choose=self)
 for event in stream:
 yield event
 ctxt.pop()
 class WhenDirective(Directive):
 """Implementation of the `py:when` directive for nesting in a parent with
-the `py:choose` directive.  See the documentation of `py:choose` for
+the `py:choose` directive.
-usage.
-"""
+See the documentation of `py:choose` for usage.
-def __call__(self, stream, ctxt):
+"""
-choose = ctxt['__choose']
+def __call__(self, stream, ctxt, directives=None):
+choose = ctxt['_choose']
 if choose.matched:
 return []
 value = self.expr.evaluate(ctxt)
 try:
 if value == choose.value:
 return []
 class OtherwiseDirective(Directive):
 """Implementation of the `py:otherwise` directive for nesting in a parent
-with the `py:choose` directive.  See the documentation of `py:choose` for
+with the `py:choose` directive.
-usage.
-"""
+See the documentation of `py:choose` for usage.
-def __call__(self, stream, ctxt):
+"""
-choose = ctxt['__choose']
+def __call__(self, stream, ctxt, directives=None):
+choose = ctxt['_choose']
 if choose.matched:
 return []
 choose.matched = True
 return stream
 directives = [('def', DefDirective),
 ('match', MatchDirective),
 ('for', ForDirective),
 ('if', IfDirective),
+('choose', ChooseDirective),
+('when', WhenDirective),
+('otherwise', OtherwiseDirective),
 ('replace', ReplaceDirective),
 ('content', ContentDirective),
 ('attrs', AttrsDirective),
-('strip', StripDirective),
+('strip', StripDirective)]
-('choose', ChooseDirective),
-('when', WhenDirective),
-('otherwise', OtherwiseDirective)]
 _dir_by_name = dict(directives)
 _dir_order = [directive[1] for directive in directives]
 def __init__(self, source, basedir=None, filename=None):
 """Initialize a template from either a string or a file-like object."""
 directives.append(cls(value))
 else:
 value = list(self._interpolate(value, *pos))
 new_attrib.append((name, value))
 if directives:
-directives.sort(lambda a, b: cmp(self._dir_order.index(b.__class__),
+directives.sort(lambda a, b: cmp(self._dir_order.index(a.__class__),
-self._dir_order.index(a.__class__)))
+self._dir_order.index(b.__class__)))
 dirmap[(depth, tag)] = (directives, len(stream))
 stream.append((kind, (tag, Attributes(new_attrib)), pos))
 depth += 1
 for kind, data, pos in stream:
 if kind is Template.SUB:
 # This event is a list of directives and a list of nested
 # events to which those directives should be applied
 directives, substream = data
-for directive in directives:
+substream = directives[0](iter(substream), ctxt, directives[1:])
-substream = directive(iter(substream), ctxt)
 substream = self._match(self._eval(substream, ctxt), ctxt)
 for event in self._flatten(substream, ctxt):
 yield event
 continue
 else:
 # We might care about namespace events in the future, though
 if kind not in (Stream.START, Stream.END):
 yield kind, data, pos
 continue
-for idx, (test, path, template) in enumerate(match_templates):
+for idx, (test, path, template, directives) in \
+enumerate(match_templates):
 result = test(kind, data, pos)
 if result:
 # Consume and store all events until an end event
 # corresponding to this start event is encountered
 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),
 ctxt, match_templates[:idx] +
 match_templates[idx + 1:])
 for event in template:
 yield event

Mercurial > genshi > mirror

comparison markup/template.py @ 50:d3842cd76e92 trunk