genshi/genshi-test: genshi/template/directives.py comparison

comparison genshi/template/directives.py @ 830:de82830f8816 experimental-inline

inline branch: synced with trunk@1038.

author	cmlenz
date	Fri, 13 Mar 2009 20:04:26 +0000
parents	abb1f1d2f4f3
children	09cc3627654c

comparison

equal deleted inserted replaced

-:eb8aa8690480
+:de82830f8816
 def __init__(self, value, template=None, namespaces=None, lineno=-1,
 offset=-1):
 self.expr = self._parse_expr(value, template, lineno, offset)
+@classmethod
 def attach(cls, template, stream, value, namespaces, pos):
 """Called after the template stream has been completely parsed.
 :param template: the `Template` object
 :param stream: the event stream associated with the directive
 class, and gets added to the list of directives applied to the substream
 at runtime. `stream` is an event stream that replaces the original
 stream associated with the directive.
 """
 return cls(value, template, namespaces, *pos[1:]), stream
-attach = classmethod(attach)
 def __call__(self, stream, directives, ctxt, **vars):
 """Apply the directive to the given stream.
 :param stream: the event stream
 expr = ''
 if getattr(self, 'expr', None) is not None:
 expr = ' "%s"' % self.expr.source
 return '<%s%s>' % (self.__class__.__name__, expr)
+@classmethod
 def _parse_expr(cls, expr, template, lineno=-1, offset=-1):
 """Parses the given expression, raising a useful error message when a
 syntax error is encountered.
 """
 try:
 except SyntaxError, err:
 err.msg += ' in expression "%s" of "%s" directive' % (expr,
 cls.tagname)
 raise TemplateSyntaxError(err, template.filepath, lineno,
 offset + (err.offset or 0))
-_parse_expr = classmethod(_parse_expr)
 def _assignment(ast):
 """Takes the AST representation of an assignment, and returns a
 function that applies the assignment of a given value to a dictionary.
 __slots__ = []
 def __call__(self, stream, directives, ctxt, **vars):
 def _generate():
 kind, (tag, attrib), pos  = stream.next()
-attrs = _eval_expr(self.expr, ctxt, **vars)
+attrs = _eval_expr(self.expr, ctxt, vars)
 if attrs:
 if isinstance(attrs, Stream):
 try:
 attrs = iter(attrs).next()
 except StopIteration:
 in attrs if val is not None]
 yield kind, (tag, attrib), pos
 for event in stream:
 yield event
-return _apply_directives(_generate(), directives, ctxt, **vars)
+return _apply_directives(_generate(), directives, ctxt, vars)
 class ContentDirective(Directive):
 """Implementation of the ``py:content`` template directive.
 <li>Bye</li>
 </ul>
 """
 __slots__ = []
+@classmethod
 def attach(cls, template, stream, value, namespaces, pos):
 if type(value) is dict:
 raise TemplateSyntaxError('The content directive can not be used '
 'as an element', template.filepath,
 *pos[1:])
 expr = cls._parse_expr(value, template, *pos[1:])
 return None, [stream[0], (EXPR, expr, pos),  stream[-1]]
-attach = classmethod(attach)
 class DefDirective(Directive):
 """Implementation of the ``py:def`` template directive.
 if getattr(ast, 'kwargs', None):
 self.dstar_args = ast.kwargs.id
 else:
 self.name = ast.id
+@classmethod
 def attach(cls, template, stream, value, namespaces, pos):
 if type(value) is dict:
 value = value.get('function')
 return super(DefDirective, cls).attach(template, stream, value,
 namespaces, pos)
-attach = classmethod(attach)
 def __call__(self, stream, directives, ctxt, **vars):
 stream = list(stream)
 def function(*args, **kwargs):
 scope[name] = args.pop(0)
 else:
 if name in kwargs:
 val = kwargs.pop(name)
 else:
-val = _eval_expr(self.defaults.get(name), ctxt, **vars)
+val = _eval_expr(self.defaults.get(name), ctxt, vars)
 scope[name] = val
 if not self.star_args is None:
 scope[self.star_args] = args
 if not self.dstar_args is None:
 scope[self.dstar_args] = kwargs
 ctxt.push(scope)
-for event in _apply_directives(stream, directives, ctxt, **vars):
+for event in _apply_directives(stream, directives, ctxt, vars):
 yield event
 ctxt.pop()
 function.__name__ = self.name
 # Store the function reference in the bottom context frame so that it
 self.assign = _assignment(self.target)
 value = 'iter(%s)' % value.strip()
 self.filename = template.filepath
 Directive.__init__(self, value, template, namespaces, lineno, offset)
+@classmethod
 def attach(cls, template, stream, value, namespaces, pos):
 if type(value) is dict:
 value = value.get('each')
 return super(ForDirective, cls).attach(template, stream, value,
 namespaces, pos)
-attach = classmethod(attach)
+def __call__(self, stream, directives, ctxt, **vars):
-def __call__(self, stream, directives, ctxt, **vars):
+iterable = _eval_expr(self.expr, ctxt, vars)
-iterable = _eval_expr(self.expr, ctxt, **vars)
 if iterable is None:
 return
 assign = self.assign
 scope = {}
 stream = list(stream)
 for item in iterable:
 assign(scope, item)
 ctxt.push(scope)
-for event in _apply_directives(stream, directives, ctxt, **vars):
+for event in _apply_directives(stream, directives, ctxt, vars):
 yield event
 ctxt.pop()
 def __repr__(self):
 return '<%s>' % self.__class__.__name__
 <b>Hello</b>
 </div>
 """
 __slots__ = []
+@classmethod
 def attach(cls, template, stream, value, namespaces, pos):
 if type(value) is dict:
 value = value.get('test')
 return super(IfDirective, cls).attach(template, stream, value,
 namespaces, pos)
-attach = classmethod(attach)
+def __call__(self, stream, directives, ctxt, **vars):
-def __call__(self, stream, directives, ctxt, **vars):
+value = _eval_expr(self.expr, ctxt, vars)
-value = _eval_expr(self.expr, ctxt, **vars)
 if value:
-return _apply_directives(stream, directives, ctxt, **vars)
+return _apply_directives(stream, directives, ctxt, vars)
 return []
 class MatchDirective(Directive):
 """Implementation of the ``py:match`` template directive.
 Directive.__init__(self, None, template, namespaces, lineno, offset)
 self.path = Path(value, template.filepath, lineno)
 self.namespaces = namespaces or {}
 self.hints = hints or ()
+@classmethod
 def attach(cls, template, stream, value, namespaces, pos):
 hints = []
 if type(value) is dict:
 if value.get('buffer', '').lower() == 'false':
 hints.append('not_buffered')
 if value.get('recursive', '').lower() == 'false':
 hints.append('not_recursive')
 value = value.get('path')
 return cls(value, template, frozenset(hints), namespaces, *pos[1:]), \
 stream
-attach = classmethod(attach)
 def __call__(self, stream, directives, ctxt, **vars):
 ctxt._match_templates.append((self.path.test(ignore_context=True),
 self.path, list(stream), self.hints,
 self.namespaces, directives))
 Bye
 </div>
 """
 __slots__ = []
+@classmethod
 def attach(cls, template, stream, value, namespaces, pos):
 if type(value) is dict:
 value = value.get('value')
 if not value:
 raise TemplateSyntaxError('missing value for "replace" directive',
 template.filepath, *pos[1:])
 expr = cls._parse_expr(value, template, *pos[1:])
 return None, [(EXPR, expr, pos)]
-attach = classmethod(attach)
 class StripDirective(Directive):
 """Implementation of the ``py:strip`` template directive.
 """
 __slots__ = []
 def __call__(self, stream, directives, ctxt, **vars):
 def _generate():
-if _eval_expr(self.expr, ctxt, **vars):
+if _eval_expr(self.expr, ctxt, vars):
 stream.next() # skip start tag
 previous = stream.next()
 for event in stream:
 yield previous
 previous = event
 else:
 for event in stream:
 yield event
-return _apply_directives(_generate(), directives, ctxt, **vars)
+return _apply_directives(_generate(), directives, ctxt, vars)
+@classmethod
 def attach(cls, template, stream, value, namespaces, pos):
 if not value:
 return None, stream[1:-1]
 return super(StripDirective, cls).attach(template, stream, value,
 namespaces, pos)
-attach = classmethod(attach)
 class ChooseDirective(Directive):
 """Implementation of the ``py:choose`` directive for conditionally selecting
 one of several body elements to display.
 ``py:when`` or ``py:otherwise`` block.  Behavior is also undefined if a
 ``py:otherwise`` occurs before ``py:when`` blocks.
 """
 __slots__ = ['matched', 'value']
+@classmethod
 def attach(cls, template, stream, value, namespaces, pos):
 if type(value) is dict:
 value = value.get('test')
 return super(ChooseDirective, cls).attach(template, stream, value,
 namespaces, pos)
-attach = classmethod(attach)
 def __call__(self, stream, directives, ctxt, **vars):
 info = [False, bool(self.expr), None]
 if self.expr:
-info[2] = _eval_expr(self.expr, ctxt, **vars)
+info[2] = _eval_expr(self.expr, ctxt, vars)
 ctxt._choice_stack.append(info)
-for event in _apply_directives(stream, directives, ctxt, **vars):
+for event in _apply_directives(stream, directives, ctxt, vars):
 yield event
 ctxt._choice_stack.pop()
 class WhenDirective(Directive):
 def __init__(self, value, template, namespaces=None, lineno=-1, offset=-1):
 Directive.__init__(self, value, template, namespaces, lineno, offset)
 self.filename = template.filepath
+@classmethod
 def attach(cls, template, stream, value, namespaces, pos):
 if type(value) is dict:
 value = value.get('test')
 return super(WhenDirective, cls).attach(template, stream, value,
 namespaces, pos)
-attach = classmethod(attach)
 def __call__(self, stream, directives, ctxt, **vars):
 info = ctxt._choice_stack and ctxt._choice_stack[-1]
 if not info:
 raise TemplateRuntimeError('"when" directives can only be used '
 'must have a test expression',
 self.filename, *stream.next()[2][1:])
 if info[1]:
 value = info[2]
 if self.expr:
-matched = value == _eval_expr(self.expr, ctxt, **vars)
+matched = value == _eval_expr(self.expr, ctxt, vars)
 else:
 matched = bool(value)
 else:
-matched = bool(_eval_expr(self.expr, ctxt, **vars))
+matched = bool(_eval_expr(self.expr, ctxt, vars))
 info[0] = matched
 if not matched:
 return []
-return _apply_directives(stream, directives, ctxt, **vars)
+return _apply_directives(stream, directives, ctxt, vars)
 class OtherwiseDirective(Directive):
 """Implementation of the ``py:otherwise`` directive for nesting in a parent
 with the ``py:choose`` directive.
 self.filename, *stream.next()[2][1:])
 if info[0]:
 return []
 info[0] = True
-return _apply_directives(stream, directives, ctxt, **vars)
+return _apply_directives(stream, directives, ctxt, vars)
 class WithDirective(Directive):
 """Implementation of the ``py:with`` template directive, which allows
 shorthand access to variables and expressions.
 err.msg += ' in expression "%s" of "%s" directive' % (value,
 self.tagname)
 raise TemplateSyntaxError(err, template.filepath, lineno,
 offset + (err.offset or 0))
+@classmethod
 def attach(cls, template, stream, value, namespaces, pos):
 if type(value) is dict:
 value = value.get('vars')
 return super(WithDirective, cls).attach(template, stream, value,
 namespaces, pos)
-attach = classmethod(attach)
 def __call__(self, stream, directives, ctxt, **vars):
 frame = {}
 ctxt.push(frame)
 for targets, expr in self.vars:
-value = _eval_expr(expr, ctxt, **vars)
+value = _eval_expr(expr, ctxt, vars)
 for _, assign in targets:
 assign(frame, value)
-for event in _apply_directives(stream, directives, ctxt, **vars):
+for event in _apply_directives(stream, directives, ctxt, vars):
 yield event
 ctxt.pop()
 def __repr__(self):
 return '<%s>' % (self.__class__.__name__)

Mercurial > genshi > genshi-test

comparison genshi/template/directives.py @ 830:de82830f8816 experimental-inline