# XML DOM tree manipulation

import cgi

from HTMLParser import HTMLParser

from xml.dom import Node

import xml.dom.minidom as minidom

import strings

import util

##### Escaping input

def escape(str_):

    return strings.to_unicode(cgi.escape(str_, True)).encode('ascii',

        'xmlcharrefreplace')

def unescape(str_): return HTMLParser().unescape(str_)

##### IDs

def get_id(node): return node.getAttribute('id')

def set_id(node, id_): node.setAttribute('id', id_)

##### Element node contents

def is_elem(node): return node.nodeType == Node.ELEMENT_NODE

def is_completely_empty(node): return node.firstChild == None

def has_one_child(node):

    return node.firstChild != None and node.firstChild.nextSibling == None

def is_simple(node):

    '''Whether every child recursively has no more than one child'''

    return (not is_elem(node) or is_completely_empty(node)

        or (has_one_child(node) and is_simple(node.firstChild)))

class NodeIter:

    def __init__(self, node): self.child = node.firstChild

    def __iter__(self): return self

    def curr(self):

        if self.child != None: return self.child

        raise StopIteration

    def next(self):

        child = self.curr()

        self.child = self.child.nextSibling

        return child

##### Comments

def is_comment(node): return node.nodeType == Node.COMMENT_NODE

def is_empty(node):

    for child in NodeIter(node):

        if not is_comment(child): return False

    return True

##### Child nodes that are elements

class NodeElemIter:

    def __init__(self, node): self.child = node.firstChild

    def __iter__(self): return self

    def curr(self):

        while self.child != None:

            if is_elem(self.child): return self.child

            self.child = self.child.nextSibling

        raise StopIteration

    def next(self):

        child = self.curr()

        self.child = self.child.nextSibling

        return child

def first_elem(node): return NodeElemIter(node).next()

def has_elems(node):

    try: first_elem(node); return True

    except StopIteration: return False

class NodeElemReverseIter:

    def __init__(self, node): self.child = node.lastChild

    def __iter__(self): return self

    def curr(self):

        while self.child != None:

            if is_elem(self.child): return self.child

            self.child = self.child.previousSibling

        raise StopIteration

    def next(self):

        child = self.curr()

        self.child = self.child.previousSibling

        return child

def last_elem(node): return NodeElemReverseIter(node).next()

##### Parent nodes

class NodeParentIter:

    '''Does not treat the document object as the root node's parent, since it's

    not a true element node'''

    def __init__(self, node): self.node = node

    def __iter__(self): return self

    def curr(self):

        if self.node != None and is_elem(self.node): return self.node

        raise StopIteration

    def next(self):

        node = self.curr()

        self.node = self.node.parentNode

        return node

def parent(node):

    '''See NodeParentIter for special treatment of root node'''

    try: return NodeParentIter(node).next()

    except StopIteration: return None

##### Element nodes containing text

def is_text_node(node): return node.nodeType == Node.TEXT_NODE

def is_text(node): return has_one_child(node) and is_text_node(node.firstChild)

def value(node):

    if node.firstChild != None: return node.firstChild.nodeValue

    else: return node.nodeValue

def set_value(node, value):

    if is_elem(node): node.appendChild(node.ownerDocument.createTextNode(value))

    else: node.nodeValue = value

class NodeTextEntryIter:

    def __init__(self, node): self.iter_ = NodeElemIter(node)

    def __iter__(self): return self

    def curr(self):

        entry = self.iter_.curr()

        if is_text(entry): value_ = value(entry)

        elif is_empty(entry): value_ = None

        else:

            assert has_one_child(entry) # TODO: convert to an exception

            value_ = entry.firstChild

        return (entry.tagName, value_)

    def next(self):

        entry = self.curr()

        self.iter_.next()

        return entry

def is_text_node_entry(val): return util.is_str(val[1])

class TextEntryOnlyIter(util.CheckedIter):

    def __init__(self, iterable):

        util.CheckedIter.__init__(self, is_text_node_entry, iterable)

##### Modifying/replacing a node

def set_child(node, name, value):

    '''Note: does not remove any existing child of the same name'''

    child = node.ownerDocument.createElement(name)

    set_value(child, value)

    node.appendChild(child)

def remove(node): node.parentNode.removeChild(node)

def replace(old, new):

    '''@param new Node|None'''

    if new == None: old.parentNode.removeChild(old)

    else: old.parentNode.replaceChild(new, old) # note order reversed

def replace_with_text(node, new):

    if util.is_str(new): new = node.ownerDocument.createTextNode(new)

    replace(node, new)

##### Searching child nodes

def by_tag_name(node, name, last_only=False):

    '''last_only optimization returns last matching node'''

    children = []

    if last_only: iter_ = NodeElemReverseIter(node)

    else: iter_ = NodeElemIter(node)

    for child in iter_:

        if child.tagName == name:

            children.append(child)

            if last_only: break

    return children

##### XML documents

def create_doc(root='_'):

    return minidom.getDOMImplementation().createDocument(None, root, None)

##### Printing XML

prettyxml_config = dict(addindent='    ', newl='\n')

toprettyxml_config = prettyxml_config.copy()

util.rename_key(toprettyxml_config, 'addindent', 'indent')

##### minidom modifications

minidom._write_data = lambda writer, data: writer.write(escape(data))

minidom.Node.__iter__ = lambda self: NodeIter(self)

def __Node_str(self):

    return strings.remove_extra_newl(self.toprettyxml(**toprettyxml_config))

minidom.Node.__str__ = __Node_str

minidom.Node.__repr__ = __Node_str

minidom.Element.__repr__ = __Node_str

def __Attr_str(self): return self.name+'="'+escape(self.value)+'"'

minidom.Attr.__str__ = __Attr_str

minidom.Attr.__repr__ = __Attr_str

minidom.Node.pop = lambda self: self.removeChild(self.lastChild)

def __Node_clear(self):

    while not is_empty(self): self.pop()

minidom.Node.clear = __Node_clear

def __Element_write_opening(self, writer, indent='', addindent='', newl=''):

    writer.write(indent+'<'+self.tagName)

    for attr_idx in xrange(self.attributes.length):

        writer.write(' '+str(self.attributes.item(attr_idx)))

    writer.write('>'+newl)

minidom.Element.write_opening = __Element_write_opening

def __Element_write_closing(self, writer, indent='', addindent='', newl=''):

    writer.write('</'+self.tagName+'>'+newl)

minidom.Element.write_closing = __Element_write_closing

_writexml_orig = minidom.Element.writexml

def __Element_writexml(self, writer, indent='', addindent='', newl=''):

    if isinstance(indent, int): indent = addindent*indent

    if is_simple(self):

        writer.write(indent)

        _writexml_orig(self, writer)

        writer.write(newl)

    else: _writexml_orig(self, writer, indent, addindent, newl)

minidom.Element.writexml = __Element_writexml

def __Document_write_opening(self, writer, indent='', addindent='', newl='',

    encoding=None):

    xmlDecl = '<?xml version="1.0" '

    if encoding != None: xmlDecl += 'encoding="'+escape(encoding)+'"'

    xmlDecl += '?>'+newl

    writer.write(xmlDecl)

    assert has_one_child(self)

    assert is_elem(self.firstChild)

    self.firstChild.write_opening(writer, indent, addindent, newl)

minidom.Document.write_opening = __Document_write_opening

def __Document_write_closing(self, writer, indent='', addindent='', newl=''):

    self.firstChild.write_closing(writer, indent, addindent, newl)

minidom.Document.write_closing = __Document_write_closing