Project

General

Profile

1
# XML DOM tree manipulation
2

    
3
import cgi
4
from HTMLParser import HTMLParser
5
from xml.dom import Node
6
import xml.dom.minidom
7

    
8
import strings
9

    
10
def escape(str_):
11
    return strings.to_unicode(cgi.escape(str_, True)).encode('ascii',
12
        'xmlcharrefreplace')
13

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

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

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

    
20
def is_empty(node): return node.firstChild == None
21

    
22
class NodeElemIter:
23
    def __init__(self, node): self.child = node.firstChild
24
    
25
    def __iter__(self): return self
26
    
27
    def curr(self):
28
        while self.child != None:
29
            if self.child.nodeType == Node.ELEMENT_NODE: return self.child
30
            self.child = self.child.nextSibling
31
        raise StopIteration
32
    
33
    def next(self):
34
        child = self.curr()
35
        self.child = self.child.nextSibling
36
        return child
37

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

    
40
class NodeElemReverseIter:
41
    def __init__(self, node): self.child = node.lastChild
42
    
43
    def __iter__(self): return self
44
    
45
    def curr(self):
46
        while self.child != None:
47
            if self.child.nodeType == Node.ELEMENT_NODE: return self.child
48
            self.child = self.child.previousSibling
49
        raise StopIteration
50
    
51
    def next(self):
52
        child = self.curr()
53
        self.child = self.child.previousSibling
54
        return child
55

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

    
58
class NodeParentIter:
59
    def __init__(self, node): self.node = node
60
    
61
    def __iter__(self): return self
62
    
63
    def curr(self):
64
        if self.node != None and self.node.nodeType == Node.ELEMENT_NODE:
65
            return self.node
66
        raise StopIteration
67
    
68
    def next(self):
69
        node = self.curr()
70
        self.node = self.node.parentNode
71
        return node
72

    
73
def is_text(node):
74
    for child in NodeElemIter(node): return False # has an element node
75
    return True
76

    
77
def value(node):
78
    if node.firstChild != None: return node.firstChild.nodeValue
79
    else: return node.nodeValue
80

    
81
def set_value(node, value):
82
    if node.nodeType == Node.ELEMENT_NODE:
83
        node.appendChild(node.ownerDocument.createTextNode(value))
84
    else: node.nodeValue = value
85

    
86
class NodeTextEntryIter:
87
    def __init__(self, node): self.iter_ = NodeElemIter(node)
88
    
89
    def __iter__(self): return self
90
    
91
    def curr(self):
92
        while True:
93
            child = self.iter_.curr()
94
            if is_text(child): return (child.tagName, value(child))
95
            self.iter_.next()
96
    
97
    def next(self):
98
        entry = self.curr()
99
        self.iter_.next()
100
        return entry
101

    
102
def set_child(node, name, value):
103
    '''Note: does not remove any existing child of the same name'''
104
    child = node.ownerDocument.createElement(name)
105
    set_value(child, value)
106
    node.appendChild(child)
107

    
108
def replace(old_node, new_node):
109
    old_node.parentNode.replaceChild(new_node, old_node) # note order reversed
110

    
111
def replace_with_text(node, str_):
112
    replace(node, node.ownerDocument.createTextNode(str_))
113

    
114
def by_tag_name(node, name, last_only=False):
115
    '''last_only optimization returns last matching node'''
116
    children = []
117
    for child in NodeElemReverseIter(node):
118
        if child.tagName == name:
119
            children.append(child)
120
            if last_only: break
121
    return children
122

    
123
def create_doc(root='_'):
124
    return xml.dom.minidom.getDOMImplementation().createDocument(None, root,
125
        None)
126

    
127
def writexml(writer, node): node.writexml(writer, addindent='    ', newl='\n')
128

    
129
# xml.dom.minidom modifications
130

    
131
def _write_data(writer, data): writer.write(escape(data))
132

    
133
xml.dom.minidom._write_data = _write_data
134

    
135
_writexml_orig = xml.dom.minidom.Element.writexml
136

    
137
def _writexml(self, writer, indent="", addindent="", newl=""):
138
    if self.firstChild != None and self.firstChild.nextSibling == None\
139
    and self.firstChild.nodeType == Node.TEXT_NODE: # a single text node
140
        writer.write(indent+'<'+self.tagName)
141
        for attr_idx in xrange(self.attributes.length):
142
            attr = self.attributes.item(attr_idx)
143
            writer.write(' '+attr.name+'='+escape(attr.value))
144
        writer.write('>'+escape(value(self))+'</'+self.tagName+'>'+newl)
145
    else: _writexml_orig(self, writer, indent, addindent, newl)
146

    
147
xml.dom.minidom.Element.writexml = _writexml
148

    
149
xml.dom.minidom.Node.__str__ = lambda self: self.toxml()
(9-9/11)