Ticket #160: NamespaceFlattener.py

class NamespaceFlattener(object):
    r"""Output stream filter that removes namespace information from the stream,
    instead adding namespace attributes and prefixes as needed.
    
    :param prefixes: optional mapping of namespace URIs to prefixes
    
    >>> from genshi.input import XML
    >>> xml = XML('''<doc xmlns="NS1" xmlns:two="NS2">
    ...   <two:item/>
    ... </doc>''')
    >>> for kind, data, pos in NamespaceFlattener()(xml):
    ...     print kind, repr(data)
    START (u'doc', Attrs([(u'xmlns', u'NS1'), (u'xmlns:two', u'NS2')]))
    TEXT u'\n  '
    START (u'two:item', Attrs())
    END u'two:item'
    TEXT u'\n'
    END u'doc'
    """

    def __init__(self, prefixes=None):
        self.prefixes = {XML_NAMESPACE.uri: 'xml'}
        if prefixes is not None:
            self.prefixes.update(prefixes)

    def __call__(self, stream):
        # The XML document (given by the stream) can be thought of as consisting of nested elements.
        # Namespaces introduced by one element apply to all its children, and therefore current
        # namespace scope can be represented by a stack of namespace declarations.

        class _NamespaceStackFrame(object):
            def __init__(self, prefix = None, uri = None):
                # Prefix -> URI and URI -> prefix mappings for all namespaces introduced by this stack frame
                self.prefixes = {}
                self.uris = {}
                # True if namespaces introduced by this stack frame have not yet been emitted as xmlns attributes
                self.pending = True
                
            def add(self, prefix, uri):
                """Add prefix/uri mapping to this stack frame"""
                # You can't change prefix/uri mapping for an existing prefix or URI in the same stack frame
                assert not uri in self.prefixes and not prefix in self.uris
                self.prefixes[uri] = prefix
                self.uris[prefix] = uri

        def _add_ns(prefix, uri):
            stack[-1].add(prefix, uri)
            
        def _push_ns(prefix, uri):
            stack.append(_NamespaceStackFrame())
            stack[-1].add(prefix, uri)
            
        def _pop_ns():
            stack.pop()
            
        def _get_prefix(uri):
            for f in reversed(stack):
                prefix = f.prefixes.get(uri)
                if prefix != None:
                    return prefix
                    
            return None
        
        def _new_prefix():
            index = 1
            while True:
                yield 'ns%d' % index
                index += 1
        _new_prefix = _new_prefix().next
            
        def _make_nsattr(prefix, uri):
            return prefix and u'xmlns:%s' % prefix or u'xmlns', uri
            
        def _qualify(prefix, tag):
            return prefix and u'%s:%s' % (prefix, tag) or tag
            
        # Start off with a single, empty stack frame
        stack = [_NamespaceStackFrame()]

        # Initialize the stack with namespaces given to the constructor
        for uri, prefix in self.prefixes.iteritems():
            _add_ns(prefix, uri)
            
        # Don't emit xmlns attributes for namespaces given in our constructor (make them implicit)
        stack[-1].pending = False
            
        for kind, data, pos in stream:
            if kind is START_NS:
                # Beginning of explicit namespace scope. Push a new stack frame for it
                prefix, uri = data
                _push_ns(prefix, uri)
                
            elif kind is END_NS:
                # End of explicit namespace scope. Pop its stack frame
                _pop_ns()
            
            elif kind is START or kind is EMPTY:
                # Beginning of namespace scope derived from an element. 
                # An element introduces at least one namespace (for its tag),
                # but may also introduce additional namespaces for its attributes

                tag, attrs = data
                tagname = tag.localname
                tagns = tag.namespace

                # Has the tag's namespace already been assigned a prefix in this scope?
                prefix = _get_prefix(tagns)
                if prefix is None:
                    # No? Treat the tag's namespace as the default namespace for this scope
                    prefix = ''
                _push_ns(prefix, tagns)
                
                tagname = _qualify(prefix, tagname)

                # Rewrite the element's attributes
                newattrs = []
                
                for attr, value in attrs:
                    attrname = attr.localname
                    attrns = attr.namespace

                    # Has the attribute's namespace already been assigned a prefix in this scope?
                    attrprefix = _get_prefix(attrns)
                    if attrprefix is None:
                        # No? Make one up
                        attrprefix = _new_prefix()
                    # Add the attribute's namespace prefix to the current scope
                    _add_ns(attrprefix, attrns)
                        
                    attrname = _qualify(attrprefix, attrname)
                    
                    newattrs.append((attrname, value))

                # Divide all namespaces active in this scope according to whether their xmlns attribute declaration
                # has already been emitted (comitted) in this scope or not (pending)
                pending = {}
                committed = {}
                for f in stack:
                    if f.pending:
                        pending.update(f.uris)
                        # In the process, mark all namespaces in this scope as committed, because we are about to write out
                        # the xmlns declaration for the ones that are still pending at this point in time
                        f.pending = False
                    else:
                        committed.update(f.uris)

                # Compose the xmlns declarations for pending namespaces
                nsattrs = [_make_nsattr(prefix, uri) for prefix, uri in pending.iteritems() if committed.get(prefix) != uri]
                yield kind, (tagname, newattrs + nsattrs), pos

                # If this is an empty tag, there will be no matching END event, so we pop the current stack frame
                if kind is EMPTY:
                    _pop_ns()
                    
            elif kind is END:
                # Tag scope is ending, pop its stack frame
                tagname = data.localname
                tagns = data.namespace

                prefix = _get_prefix(tagns)
                tagname = _qualify(prefix, tagname)

                yield kind, tagname, pos
                _pop_ns()
            
            else:
                yield kind, data, pos