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
#####
112

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

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

    
117
def value(node):
118
    if node.firstChild != None: return node.firstChild.nodeValue
119
    else: return node.nodeValue
120

    
121
def set_value(node, value):
122
    if is_elem(node): node.appendChild(node.ownerDocument.createTextNode(value))
123
    else: node.nodeValue = value
124

    
125
class NodeTextEntryIter:
126
    def __init__(self, node): self.iter_ = NodeElemIter(node)
127
    
128
    def __iter__(self): return self
129
    
130
    def curr(self):
131
        while True:
132
            child = self.iter_.curr()
133
            if is_text(child): return (child.tagName, value(child))
134
            self.iter_.next()
135
    
136
    def next(self):
137
        entry = self.curr()
138
        self.iter_.next()
139
        return entry
140

    
141
#####
142

    
143
def set_child(node, name, value):
144
    '''Note: does not remove any existing child of the same name'''
145
    child = node.ownerDocument.createElement(name)
146
    set_value(child, value)
147
    node.appendChild(child)
148

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

    
151
def replace(old_node, new_node):
152
    old_node.parentNode.replaceChild(new_node, old_node) # note order reversed
153

    
154
def replace_with_text(node, str_):
155
    replace(node, node.ownerDocument.createTextNode(str_))
156

    
157
#####
158

    
159
def by_tag_name(node, name, last_only=False):
160
    '''last_only optimization returns last matching node'''
161
    children = []
162
    for child in NodeElemReverseIter(node):
163
        if child.tagName == name:
164
            children.append(child)
165
            if last_only: break
166
    return children
167

    
168
#####
169

    
170
def create_doc(root='_'):
171
    return minidom.getDOMImplementation().createDocument(None, root, None)
172

    
173
#####
174

    
175
prettyxml_config = dict(addindent='    ', newl='\n')
176
toprettyxml_config = prettyxml_config.copy()
177
util.rename_key(toprettyxml_config, 'addindent', 'indent')
178

    
179
#####
180

    
181
# minidom modifications
182

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

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

    
187
minidom.Node.__str__ = lambda self: self.toprettyxml(**toprettyxml_config)
188

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

    
191
def __Node_clear(self):
192
    while not is_empty(self): self.pop()
193
minidom.Node.clear = __Node_clear
194

    
195
def __Element_write_opening(self, writer, indent='', addindent='', newl=''):
196
    writer.write(indent+'<'+self.tagName)
197
    for attr_idx in xrange(self.attributes.length):
198
        attr = self.attributes.item(attr_idx)
199
        writer.write(' '+attr.name+'='+escape(attr.value))
200
    writer.write('>'+newl)
201
minidom.Element.write_opening = __Element_write_opening
202

    
203
def __Element_write_closing(self, writer, indent='', addindent='', newl=''):
204
    writer.write('</'+self.tagName+'>'+newl)
205
minidom.Element.write_closing = __Element_write_closing
206

    
207
_writexml_orig = minidom.Element.writexml
208
def __Element_writexml(self, writer, indent='', addindent='', newl=''):
209
    if isinstance(indent, int): indent = addindent*indent
210
    if is_text(self):
211
        self.write_opening(writer, indent, addindent, '') # no newline
212
        writer.write(escape(value(self)))
213
        self.write_closing(writer, indent, addindent, newl)
214
    else: _writexml_orig(self, writer, indent, addindent, newl)
215
minidom.Element.writexml = __Element_writexml
216

    
217
def __Document_write_opening(self, writer, indent='', addindent='', newl='',
218
    encoding=None):
219
    xmlDecl = '<?xml version="1.0" '
220
    if encoding != None: xmlDecl += 'encoding="'+escape(encoding)+'"'
221
    xmlDecl += '?>'+newl
222
    writer.write(xmlDecl)
223
    assert has_one_child(self)
224
    assert is_elem(self.firstChild)
225
    self.firstChild.write_opening(writer, indent, addindent, newl)
226
minidom.Document.write_opening = __Document_write_opening
227

    
228
def __Document_write_closing(self, writer, indent='', addindent='', newl=''):
229
    self.firstChild.write_closing(writer, indent, addindent, newl)
230
minidom.Document.write_closing = __Document_write_closing
(9-9/11)