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

comparison genshi/template/base.py @ 902:09cc3627654c experimental-inline

Sync `experimental/inline` branch with [source:trunk@1126].

author	cmlenz
date	Fri, 23 Apr 2010 21:08:26 +0000
parents	de82830f8816
children

comparison

equal deleted inserted replaced

-:de82830f8816
+:09cc3627654c
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2006-2008 Edgewall Software
+# Copyright (C) 2006-2010 Edgewall Software
 # All rights reserved.
 #
 # This software is licensed as described in the file COPYING, which
 # you should have received as part of this distribution. The terms
 # are also available at http://genshi.edgewall.org/wiki/License.
 :since: version 0.6
 """
 __metaclass__ = DirectiveFactoryMeta
 directives = []
-"""A list of `(name, cls)` tuples that define the set of directives
+"""A list of ``(name, cls)`` tuples that define the set of directives
 provided by this factory.
 """
-def compare_directives(self):
-"""Return a function that takes two directive classes and compares
-them to determine their relative ordering.
-"""
-def _get_index(cls):
-if cls in self._dir_order:
-return self._dir_order.index(cls)
-return 0
-return lambda a, b: cmp(_get_index(a[0]), _get_index(b[0]))
 def get_directive(self, name):
 """Return the directive class for the given name.
 :param name: the directive name as used in the template
 :return: the directive class
 :see: `Directive`
 """
 return self._dir_by_name.get(name)
+def get_directive_index(self, dir_cls):
+"""Return a key for the given directive class that should be used to
+sort it among other directives on the same `SUB` event.
+The default implementation simply returns the index of the directive in
+the `directives` list.
+:param dir_cls: the directive class
+:return: the sort key
+"""
+if dir_cls in self._dir_order:
+return self._dir_order.index(dir_cls)
+return len(self._dir_order)
 class Template(DirectiveFactory):
 """Abstract template base class.
 self.filename = filename
 self.loader = loader
 self.lookup = lookup
 self.allow_exec = allow_exec
 self._init_filters()
+self._init_loader()
 self._module = None
 self._prepared = False
 if isinstance(source, basestring):
 source = StringIO(source)
 def __setstate__(self, state):
 self.__dict__ = state
 self._init_filters()
 def __repr__(self):
-return '<%s "%s">' % (self.__class__.__name__, self.filename)
+return '<%s "%s">' % (type(self).__name__, self.filename)
 def _init_filters(self):
-self.filters = [self._flatten]
+self.filters = [self._flatten, self._include]
-if self.loader:
-self.filters.append(self._include)
+def _init_loader(self):
+if self.loader is None:
+from genshi.template.loader import TemplateLoader
+if self.filename:
+if self.filepath != self.filename:
+basedir = os.path.normpath(self.filepath)[:-len(
+os.path.normpath(self.filename))
+]
+else:
+basedir = os.path.dirname(self.filename)
+else:
+basedir = '.'
+self.loader = TemplateLoader([os.path.abspath(basedir)])
 @property
 def stream(self):
 if not self._prepared:
 self._stream = list(self._prepare(self._stream))
 for kind, data, pos in stream:
 if kind is SUB:
 directives = []
 substream = data[1]
-for cls, value, namespaces, pos in data[0]:
+for _, cls, value, namespaces, pos in sorted(data[0]):
 directive, substream = cls.attach(self, substream, value,
 namespaces, pos)
 if directive:
 directives.append(directive)
 substream = self._prepare(substream)
 return Stream(stream, self.serializer)
 def _flatten(self, stream, ctxt, **vars):
 number_conv = self._number_conv
+stack = []
-for kind, data, pos in stream:
+push = stack.append
+pop = stack.pop
-if kind is START and data[1]:
+stream = iter(stream)
-# Attributes may still contain expressions in start tags at
-# this point, so do some evaluation
+while 1:
-tag, attrs = data
+for kind, data, pos in stream:
-new_attrs = []
-for name, value in attrs:
+if kind is START and data[1]:
-if type(value) is list: # this is an interpolated string
+# Attributes may still contain expressions in start tags at
-values = [event[1]
+# this point, so do some evaluation
-for event in self._flatten(value, ctxt, **vars)
+tag, attrs = data
-if event[0] is TEXT and event[1] is not None
+new_attrs = []
-]
+for name, value in attrs:
-if not values:
+if type(value) is list: # this is an interpolated string
-continue
+values = [event[1]
-value = u''.join(values)
+for event in self._flatten(value, ctxt, **vars)
-new_attrs.append((name, value))
+if event[0] is TEXT and event[1] is not None
-yield kind, (tag, Attrs(new_attrs)), pos
+]
+if not values:
-elif kind is EXPR:
+continue
-result = _eval_expr(data, ctxt, vars)
+value = ''.join(values)
-if result is not None:
+new_attrs.append((name, value))
-# First check for a string, otherwise the iterable test
+yield kind, (tag, Attrs(new_attrs)), pos
-# below succeeds, and the string will be chopped up into
-# individual characters
+elif kind is EXPR:
-if isinstance(result, basestring):
+result = _eval_expr(data, ctxt, vars)
-yield TEXT, result, pos
+if result is not None:
-elif isinstance(result, (int, float, long)):
+# First check for a string, otherwise the iterable test
-yield TEXT, number_conv(result), pos
+# below succeeds, and the string will be chopped up into
-elif hasattr(result, '__iter__'):
+# individual characters
-for event in self._flatten(_ensure(result), ctxt,
+if isinstance(result, basestring):
-**vars):
+yield TEXT, result, pos
-yield event
+elif isinstance(result, (int, float, long)):
-else:
+yield TEXT, number_conv(result), pos
-yield TEXT, unicode(result), pos
+elif hasattr(result, '__iter__'):
+push(stream)
-elif kind is EXEC:
+stream = _ensure(result)
-_exec_suite(data, ctxt, vars)
+break
+else:
-elif kind is SUB:
+yield TEXT, unicode(result), pos
-# This event is a list of directives and a list of nested
-# events to which those directives should be applied
+elif kind is SUB:
-substream = _apply_directives(data[1], data[0], ctxt, vars)
+# This event is a list of directives and a list of nested
-for event in self._flatten(substream, ctxt, **vars):
+# events to which those directives should be applied
-yield event
+push(stream)
+stream = _apply_directives(data[1], data[0], ctxt, vars)
+break
+elif kind is EXEC:
+_exec_suite(data, ctxt, vars)
+else:
+yield kind, data, pos
 else:
-yield kind, data, pos
+if not stack:
+break
+stream = pop()
 def _include(self, stream, ctxt, **vars):
 """Internal stream filter that performs inclusion of external
 template files.
 """
 parts = []
 for subkind, subdata, subpos in self._flatten(href, ctxt,
 **vars):
 if subkind is TEXT:
 parts.append(subdata)
-href = u''.join([x for x in parts if x is not None])
+href = ''.join([x for x in parts if x is not None])
 try:
 tmpl = self.loader.load(href, relative_to=event[2][0],
 cls=cls or self.__class__)
 for event in tmpl.generate(ctxt, **vars):
 yield event

Mercurial > genshi > genshi-test

comparison genshi/template/base.py @ 902:09cc3627654c experimental-inline