def __init__(self, namespace=None):
"""Create the factory, optionally bound to the given namespace.
:param namespace: the namespace URI for any created elements, or `None`
for no namespace
"""
if namespace and not isinstance(namespace, Namespace):
namespace = Namespace(namespace)
self.namespace = namespace
def test_pickle(self):
ns = Namespace('http://www.example.org/namespace')
buf = BytesIO()
pickle.dump(ns, buf, 2)
buf.seek(0)
unpickled = pickle.load(buf)
self.assertEquals("Namespace('http://www.example.org/namespace')",
repr(unpickled))
self.assertEquals('http://www.example.org/namespace', unpickled.uri)
def _rewrite_stream(stream, directives, ctxt, vars, bind):
stream = list(stream)
mutable_attrs = {}
for control_attribute in directives:
control_attribute.inject(mutable_attrs, ctxt, vars)
kind, (tagname, attrs), pos = stream[0]
if len(stream) == 2:
contents = None
else:
contents = _simplify_stream(stream[1:-1], ctxt, vars)
existing_attributes = {}
for qname, value in attrs:
if qname.namespace is None:
if not isinstance(value, unicode):
value = _simplify_stream(value, ctxt, vars)
attrs |= ((qname, value), )
existing_attributes[qname.localname] = qname
mutable_attrs[qname.localname] = value
try:
render_context = ctxt['flatland_render_context']
except KeyError:
ctxt['flatland_render_context'] = render_context = Context()
new_contents = transform(tagname.localname, mutable_attrs, contents,
render_context, bind)
if new_contents is None:
new_contents = ()
elif isinstance(new_contents, unicode):
new_contents = [(TEXT, new_contents, (None, -1, -1))]
pairs = sorted(mutable_attrs.iteritems(), key=_attribute_sort_key)
for attribute_name, value in pairs:
if attribute_name in existing_attributes:
qname = existing_attributes.pop(attribute_name)
else:
qname = QName(attribute_name)
attrs |= ((qname, value), )
for qname in existing_attributes.values():
attrs -= qname
stream[0] = (kind, (tagname, attrs), pos)
if new_contents and tagname.localname == u'select' and bind is not None:
if tagname.namespace:
sub_tag = Namespace(tagname.namespace).option
else: # pragma: nocover
sub_tag = QName('option')
new_contents = _bind_unbound_tags(new_contents, sub_tag, bind)
if new_contents:
stream[1:-1] = new_contents
return iter(stream)
class ChildRemover(TagListener):
"""Sample TagListener implementation that discards all children from
matching nodes."""
NAMESPACE = Namespace(u'http://code.discorporate.us/child-remover')
def inspect(self, event, context):
if event[0] is not START:
return False
kind, (tag, attributes), pos = event
if tag in self.NAMESPACE:
return (self.start, self.end)
else:
for attr, value in attributes:
if attr in self.NAMESPACE:
return (default_start, self.end)
return False
def end(self, start, event, stream, context, history):
"""I remove all children."""
# fixme: guessed missing symbol, cover w/ tests
return start, self.end, None
def _extract_includes(self, stream):
streams = [[]] # stacked lists of events of the "compiled" template
prefixes = {}
fallbacks = []
includes = []
xinclude_ns = Namespace(self.XINCLUDE_NAMESPACE)
for kind, data, pos in stream:
stream = streams[-1]
if kind is START:
# Record any directive attributes in start tags
tag, attrs = data
if tag in xinclude_ns:
if tag.localname == 'include':
include_href = attrs.get('href')
if not include_href:
raise TemplateSyntaxError(
'Include misses required '
'attribute "href"', self.filepath, *pos[1:])
includes.append((include_href, attrs.get('parse')))
streams.append([])
elif tag.localname == 'fallback':
streams.append([])
fallbacks.append(streams[-1])
else:
stream.append((kind, (tag, attrs), pos))
elif kind is END:
if fallbacks and data == xinclude_ns['fallback']:
assert streams.pop() is fallbacks[-1]
elif data == xinclude_ns['include']:
fallback = None
if len(fallbacks) == len(includes):
fallback = fallbacks.pop()
streams.pop() # discard anything between the include tags
# and the fallback element
stream = streams[-1]
href, parse = includes.pop()
try:
cls = {
'xml': MarkupTemplate,
'text': NewTextTemplate
}.get(parse) or self.__class__
except KeyError:
raise TemplateSyntaxError(
'Invalid value for "parse" '
'attribute of include', self.filepath, *pos[1:])
stream.append((INCLUDE, (href, cls, fallback), pos))
else:
stream.append((kind, data, pos))
elif kind is START_NS and data[1] == xinclude_ns:
# Strip out the XInclude namespace
prefixes[data[0]] = data[1]
elif kind is END_NS and data in prefixes:
prefixes.pop(data)
else:
stream.append((kind, data, pos))
assert len(streams) == 1
return streams[0]
def test_repr_eval_non_ascii(self):
ns = Namespace('http://www.example.org/nämespäcé')
self.assertEqual(eval(repr(ns)), ns)
def test_repr_eval(self):
ns = Namespace('http://www.example.org/namespace')
self.assertEqual(eval(repr(ns)), ns)
def test_repr(self):
self.assertEqual("Namespace('http://www.example.org/namespace')",
repr(Namespace('http://www.example.org/namespace')))
import os
import re
from types import FunctionType
from genshi.core import Attrs, Namespace, QName, START, END, TEXT, \
XML_NAMESPACE, _ensure, StreamEventKind
from genshi.template.eval import _ast
from genshi.template.base import DirectiveFactory, EXPR, SUB, _apply_directives
from genshi.template.directives import Directive, StripDirective
from genshi.template.markup import MarkupTemplate, EXEC
from genshi.compat import IS_PYTHON2
__all__ = ['Translator', 'extract']
__docformat__ = 'restructuredtext en'
I18N_NAMESPACE = Namespace('http://genshi.edgewall.org/i18n')
MSGBUF = StreamEventKind('MSGBUF')
SUB_START = StreamEventKind('SUB_START')
SUB_END = StreamEventKind('SUB_END')
GETTEXT_FUNCTIONS = ('_', 'gettext', 'ngettext', 'dgettext', 'dngettext',
'ugettext', 'ungettext')
class I18NDirective(Directive):
"""Simple interface for i18n directives to support messages extraction."""
def __call__(self, stream, directives, ctxt, **vars):
return _apply_directives(stream, directives, ctxt, vars)
from genshi.template.base import (
DirectiveFactory,
EXPR,
SUB,
TemplateSyntaxError,
_eval_expr,
)
from genshi.template.eval import Expression
from genshi.template.directives import Directive
from genshi.template.interpolation import interpolate
from flatland.out.generic import transform, Context
__all__ = ('setup', )
NS = Namespace(u'http://ns.discorporate.us/flatland/genshi')
_static_attribute_order = [u'type', u'name', u'value']
_to_context = {}
for key in (u'auto-name', u'auto-value', u'auto-domid', u'auto-for',
u'auto-tabindex', u'auto-filter', u'domid-format'):
_to_context[key] = key.replace(u'-', u'_')
_bind_qname = NS.bind
def setup(template):
"""Register the flatland directives with a template.
:param template: a `Template` instance