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 as minidom
7

    
8
import strings
9
import util
10

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

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

    
17
#####
18

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

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

    
23
#####
24

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

    
27
def has_one_child(node):
28
    return node.firstChild != None and node.firstChild.nextSibling == None
29

    
30
class NodeIter:
31
    def __init__(self, node): self.child = node.firstChild
32
    
33
    def __iter__(self): return self
34
    
35
    def curr(self):
36
        if self.child != None: return self.child
37
        raise StopIteration
38
    
39
    def next(self):
40
        child = self.curr()
41
        self.child = self.child.nextSibling
42
        return child
43

    
44
#####
45

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

    
48
def is_empty(node):
49
    for child in NodeIter(node):
50
        if not is_comment(child): return False
51
    return True
52

    
53
#####
54

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

    
57
class NodeElemIter:
58
    def __init__(self, node): self.child = node.firstChild
59
    
60
    def __iter__(self): return self
61
    
62
    def curr(self):
63
        while self.child != None:
64
            if is_elem(self.child): return self.child
65
            self.child = self.child.nextSibling
66
        raise StopIteration
67
    
68
    def next(self):
69
        child = self.curr()
70
        self.child = self.child.nextSibling
71
        return child
72

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

    
75
def has_elems(node):
76
    try: first_elem(node); return True
77
    except StopIteration: return False
78

    
79
class NodeElemReverseIter:
80
    def __init__(self, node): self.child = node.lastChild
81
    
82
    def __iter__(self): return self
83
    
84
    def curr(self):
85
        while self.child != None:
86
            if is_elem(self.child): return self.child
87
            self.child = self.child.previousSibling
88
        raise StopIteration
89
    
90
    def next(self):
91
        child = self.curr()
92
        self.child = self.child.previousSibling
93
        return child
94

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

    
97
class NodeParentIter:
98
    def __init__(self, node): self.node = node
99
    
100
    def __iter__(self): return self
101
    
102
    def curr(self):
103
        if self.node != None and is_elem(self.node): return self.node
104
        raise StopIteration
105
    
106
    def next(self):
107
        node = self.curr()
108
        self.node = self.node.parentNode
109
        return node
110

    
111
def is_simple(node):
112
    '''Whether every child recursively has no more than one child'''
113
    return (not is_elem(node) or is_completely_empty(node)
114
        or (has_one_child(node) and is_simple(node.firstChild)))
115

    
116
#####
117

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

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

    
122
def value(node):
123
    if node.firstChild != None: return node.firstChild.nodeValue
124
    else: return node.nodeValue
125

    
126
def set_value(node, value):
127
    if is_elem(node): node.appendChild(node.ownerDocument.createTextNode(value))
128
    else: node.nodeValue = value
129

    
130
class NodeTextEntryIter:
131
    def __init__(self, node): self.iter_ = NodeElemIter(node)
132
    
133
    def __iter__(self): return self
134
    
135
    def curr(self):
136
        child = self.iter_.curr()
137
        name = child.tagName
138
        if is_text(child): child = value(child)
139
        return (name, child)
140
    
141
    def next(self):
142
        entry = self.curr()
143
        self.iter_.next()
144
        return entry
145

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

    
148
class TextEntryOnlyIter(util.CheckedIter):
149
    def __init__(self, iterable):
150
        util.CheckedIter.__init__(self, is_text_node_entry, iterable)
151

    
152
#####
153

    
154
def set_child(node, name, value):
155
    '''Note: does not remove any existing child of the same name'''
156
    child = node.ownerDocument.createElement(name)
157
    set_value(child, value)
158
    node.appendChild(child)
159

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

    
162
def replace(old_node, new_node):
163
    old_node.parentNode.replaceChild(new_node, old_node) # note order reversed
164

    
165
def replace_with_text(node, new):
166
    if util.is_str(new): new = node.ownerDocument.createTextNode(new)
167
    replace(node, new)
168

    
169
#####
170

    
171
def by_tag_name(node, name, last_only=False):
172
    '''last_only optimization returns last matching node'''
173
    children = []
174
    for child in NodeElemReverseIter(node):
175
        if child.tagName == name:
176
            children.append(child)
177
            if last_only: break
178
    return children
179

    
180
#####
181

    
182
def create_doc(root='_'):
183
    return minidom.getDOMImplementation().createDocument(None, root, None)
184

    
185
#####
186

    
187
prettyxml_config = dict(addindent='    ', newl='\n')
188
toprettyxml_config = prettyxml_config.copy()
189
util.rename_key(toprettyxml_config, 'addindent', 'indent')
190

    
191
#####
192

    
193
# minidom modifications
194

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

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

    
199
minidom.Node.__str__ = lambda self: self.toprettyxml(**toprettyxml_config)
200

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

    
203
def __Node_clear(self):
204
    while not is_empty(self): self.pop()
205
minidom.Node.clear = __Node_clear
206

    
207
def __Element_write_opening(self, writer, indent='', addindent='', newl=''):
208
    writer.write(indent+'<'+self.tagName)
209
    for attr_idx in xrange(self.attributes.length):
210
        attr = self.attributes.item(attr_idx)
211
        writer.write(' '+attr.name+'='+escape(attr.value))
212
    writer.write('>'+newl)
213
minidom.Element.write_opening = __Element_write_opening
214

    
215
def __Element_write_closing(self, writer, indent='', addindent='', newl=''):
216
    writer.write('</'+self.tagName+'>'+newl)
217
minidom.Element.write_closing = __Element_write_closing
218

    
219
_writexml_orig = minidom.Element.writexml
220
def __Element_writexml(self, writer, indent='', addindent='', newl=''):
221
    if isinstance(indent, int): indent = addindent*indent
222
    if is_simple(self):
223
        writer.write(indent)
224
        _writexml_orig(self, writer)
225
        writer.write(newl)
226
    else: _writexml_orig(self, writer, indent, addindent, newl)
227
minidom.Element.writexml = __Element_writexml
228

    
229
def __Document_write_opening(self, writer, indent='', addindent='', newl='',
230
    encoding=None):
231
    xmlDecl = '<?xml version="1.0" '
232
    if encoding != None: xmlDecl += 'encoding="'+escape(encoding)+'"'
233
    xmlDecl += '?>'+newl
234
    writer.write(xmlDecl)
235
    assert has_one_child(self)
236
    assert is_elem(self.firstChild)
237
    self.firstChild.write_opening(writer, indent, addindent, newl)
238
minidom.Document.write_opening = __Document_write_opening
239

    
240
def __Document_write_closing(self, writer, indent='', addindent='', newl=''):
241
    self.firstChild.write_closing(writer, indent, addindent, newl)
242
minidom.Document.write_closing = __Document_write_closing
(11-11/13)