0
|
1 |
#
|
|
2 |
# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
3 |
# All rights reserved.
|
|
4 |
# This component and the accompanying materials are made available
|
|
5 |
# under the terms of "Eclipse Public License v1.0"
|
|
6 |
# which accompanies this distribution, and is available
|
|
7 |
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
8 |
#
|
|
9 |
# Initial Contributors:
|
|
10 |
# Nokia Corporation - initial contribution.
|
|
11 |
#
|
|
12 |
# Contributors:
|
|
13 |
#
|
|
14 |
# Description:
|
|
15 |
#
|
|
16 |
|
|
17 |
from xml.parsers import expat
|
|
18 |
|
|
19 |
# Import ElementTree (should always be available)
|
|
20 |
try:
|
|
21 |
from elementtree import ElementTree
|
|
22 |
except ImportError:
|
|
23 |
from xml.etree import ElementTree
|
|
24 |
|
|
25 |
import exceptions
|
|
26 |
|
|
27 |
|
|
28 |
class ElementTreeBackendWrapperBase(object):
|
|
29 |
def get_module(self):
|
|
30 |
raise NotImplementedError()
|
|
31 |
|
|
32 |
def get_lineno(self, element):
|
|
33 |
raise NotImplementedError()
|
|
34 |
|
|
35 |
class ElementTreeBackendWrapper(ElementTreeBackendWrapperBase):
|
|
36 |
|
|
37 |
class CustomTreeBuilder(ElementTree.TreeBuilder):
|
|
38 |
"""
|
|
39 |
Custom TreeBuilder for ElementTree that records line numbers
|
|
40 |
of the elements.
|
|
41 |
"""
|
|
42 |
def start(self, tag, attrs):
|
|
43 |
elem = ElementTree.TreeBuilder.start(self, tag, attrs)
|
|
44 |
lineno = self._xmltreebuilder._parser.CurrentLineNumber
|
|
45 |
#print "Tag: %s, line: %r" % (tag, lineno)
|
|
46 |
elem.sourceline = lineno
|
|
47 |
return elem
|
|
48 |
|
|
49 |
def get_module(self):
|
|
50 |
return ElementTree
|
|
51 |
|
|
52 |
def fromstring(self, text):
|
|
53 |
try:
|
|
54 |
treebuilder = self.CustomTreeBuilder()
|
|
55 |
parser = ElementTree.XMLTreeBuilder(target=treebuilder)
|
|
56 |
treebuilder._xmltreebuilder = parser
|
|
57 |
parser.feed(text)
|
|
58 |
return parser.close()
|
|
59 |
except expat.ExpatError, e:
|
|
60 |
raise exceptions.XmlParseError(
|
|
61 |
"XML parse error on line %d: %s" % (e.lineno, e),
|
|
62 |
e.lineno, str(e))
|
|
63 |
|
|
64 |
def tostring(self, etree, encoding=None):
|
|
65 |
return ElementTree.tostring(etree, encoding)
|
|
66 |
|
|
67 |
def get_lineno(self, element):
|
|
68 |
return element.sourceline
|
|
69 |
|
|
70 |
|
|
71 |
class CElementTreeBackendWrapper(ElementTreeBackendWrapperBase):
|
|
72 |
def __init__(self):
|
|
73 |
try:
|
|
74 |
from cElementTree import cElementTree
|
|
75 |
except ImportError:
|
|
76 |
from xml.etree import cElementTree
|
|
77 |
|
|
78 |
self.cElementTree = cElementTree
|
|
79 |
|
|
80 |
def get_module(self):
|
|
81 |
return self.cElementTree
|
|
82 |
|
|
83 |
def fromstring(self, text):
|
|
84 |
try:
|
|
85 |
return self.cElementTree.fromstring(text)
|
|
86 |
except SyntaxError, e:
|
|
87 |
# cElementTree raises a SyntaxError, but does not set
|
|
88 |
# its lineno attribute, so look for the line number
|
|
89 |
# in the exception text
|
|
90 |
import re
|
|
91 |
match = re.search(r'line (\d+)\, column \d+$', str(e))
|
|
92 |
if match: lineno = int(match.group(1))
|
|
93 |
else: lineno = None
|
|
94 |
|
|
95 |
raise exceptions.XmlParseError(
|
|
96 |
"XML parse error on line %s: %s" % (lineno, e),
|
|
97 |
lineno, str(e))
|
|
98 |
|
|
99 |
def tostring(self, etree, encoding=None):
|
|
100 |
return self.cElementTree.tostring(etree, encoding)
|
|
101 |
|
|
102 |
def get_lineno(self, element):
|
|
103 |
# cElementTree does not support line numbers
|
|
104 |
return None
|
|
105 |
|
|
106 |
|
|
107 |
class LxmlBackendWrapper(ElementTreeBackendWrapperBase):
|
|
108 |
|
|
109 |
def __init__(self):
|
|
110 |
import lxml.etree
|
|
111 |
self.lxml = lxml
|
|
112 |
|
|
113 |
def get_module(self):
|
|
114 |
return self.lxml.etree
|
|
115 |
|
|
116 |
def fromstring(self, text):
|
|
117 |
try:
|
|
118 |
elem = self.lxml.etree.fromstring(text)
|
|
119 |
|
|
120 |
# lxml parses also comments, but ConE does not expect those,
|
|
121 |
# so remove them to prevent any errors on that account
|
|
122 |
def remove_comments(elem):
|
|
123 |
# Find the comments under this element
|
|
124 |
comments = []
|
|
125 |
for x in elem:
|
|
126 |
if isinstance(x, self.lxml.etree._Comment):
|
|
127 |
comments.append(x)
|
|
128 |
|
|
129 |
# Remove them
|
|
130 |
for c in comments:
|
|
131 |
elem.remove(c)
|
|
132 |
|
|
133 |
# Recurse to sub-elements
|
|
134 |
for subelem in elem:
|
|
135 |
remove_comments(subelem)
|
|
136 |
|
|
137 |
remove_comments(elem)
|
|
138 |
|
|
139 |
return elem
|
|
140 |
except self.lxml.etree.XMLSyntaxError, e:
|
|
141 |
raise exceptions.XmlParseError(
|
|
142 |
"XML parse error on line %d: %s" % (e.position[0], e),
|
|
143 |
e.position[0], str(e))
|
|
144 |
|
|
145 |
def tostring(self, etree, encoding=None):
|
|
146 |
return self.lxml.etree.tostring(etree, encoding=encoding)
|
|
147 |
|
|
148 |
def get_lineno(self, element):
|
|
149 |
return element.sourceline
|
|
150 |
|
|
151 |
# ============================================================================
|
|
152 |
#
|
|
153 |
# ============================================================================
|
|
154 |
|
|
155 |
class ElementTreeWrapper(object):
|
|
156 |
"""
|
|
157 |
ElementTree wrapper class for providing a unified interface to different
|
|
158 |
ElementTree implementations.
|
|
159 |
|
|
160 |
Currently supported are the pure Python ElementTree implementation,
|
|
161 |
cElementTree and lxml.etree
|
|
162 |
"""
|
|
163 |
BACKEND_ELEMENT_TREE = 'ElementTree'
|
|
164 |
BACKEND_C_ELEMENT_TREE = 'cElementTree'
|
|
165 |
BACKEND_LXML = 'lxml'
|
|
166 |
|
|
167 |
# Import order for the default back-end. The list is traversed
|
|
168 |
# top-down and the first back-end whose importing is successful is
|
|
169 |
# used as the default back-end
|
|
170 |
DEFAULT_BACKEND_IMPORT_ORDER = [BACKEND_C_ELEMENT_TREE,
|
|
171 |
BACKEND_ELEMENT_TREE]
|
|
172 |
|
|
173 |
_backend_mapping = {BACKEND_ELEMENT_TREE: ElementTreeBackendWrapper,
|
|
174 |
BACKEND_C_ELEMENT_TREE: CElementTreeBackendWrapper,
|
|
175 |
BACKEND_LXML: LxmlBackendWrapper}
|
|
176 |
|
|
177 |
_backend_id = None
|
|
178 |
_backend_wrapper = None
|
|
179 |
|
|
180 |
def get_backend_id(self):
|
|
181 |
"""
|
|
182 |
Return the ID of the currently used ElementTree back-end.
|
|
183 |
"""
|
|
184 |
# Make sure that the default back-end is set, so _backend_id
|
|
185 |
# will not be None
|
|
186 |
self._get_backend()
|
|
187 |
assert self._backend_id is not None
|
|
188 |
return self._backend_id
|
|
189 |
|
|
190 |
def set_backend_id(self, backend_id):
|
|
191 |
"""
|
|
192 |
Set the used ElementTree back-end by back-end ID.
|
|
193 |
"""
|
|
194 |
if backend_id not in self._backend_mapping:
|
|
195 |
raise ValueError("Invalid ElementTree back-end ID: %r" % backend_id)
|
|
196 |
|
|
197 |
if backend_id == self._backend_id:
|
|
198 |
return
|
|
199 |
|
|
200 |
backend_wrapper_class = self._backend_mapping[backend_id]
|
|
201 |
self._backend_wrapper = backend_wrapper_class()
|
|
202 |
self._backend_id = backend_id
|
|
203 |
|
|
204 |
def _get_backend(self):
|
|
205 |
"""
|
|
206 |
Return the currently set ElementTree back-end wrapper object.
|
|
207 |
"""
|
|
208 |
if self._backend_wrapper is None:
|
|
209 |
# Back-end not set, so set the default back-end.
|
|
210 |
# The default is the C version of ElementTree, but if that
|
|
211 |
# is not available, the pure Python version is used
|
|
212 |
for backend_id in self.DEFAULT_BACKEND_IMPORT_ORDER:
|
|
213 |
try:
|
|
214 |
self.set_backend_id(backend_id)
|
|
215 |
except ImportError:
|
|
216 |
pass
|
|
217 |
|
|
218 |
if self._backend_wrapper is None:
|
|
219 |
raise RuntimeError("Failed to set any ElementTree backend! Tried these: %r" % self.DEFAULT_BACKEND_IMPORT_ORDER)
|
|
220 |
|
|
221 |
return self._backend_wrapper
|
|
222 |
|
|
223 |
def get_lineno(self, element):
|
|
224 |
"""
|
|
225 |
Return the source line number of the given XML element.
|
|
226 |
|
|
227 |
Note that for the cElementTree parser this will always return
|
|
228 |
None, since that parser does not support line numbers.
|
|
229 |
"""
|
|
230 |
return self._get_backend().get_lineno(element)
|
|
231 |
|
|
232 |
def __getattribute__(self, attrname):
|
|
233 |
try:
|
|
234 |
# Try to get the attribute from this object (the top-level wrapper)
|
|
235 |
return object.__getattribute__(self, attrname)
|
|
236 |
except AttributeError:
|
|
237 |
# If not overridden here, try to get it from the back-end wrapper
|
|
238 |
backend = self._get_backend()
|
|
239 |
try:
|
|
240 |
return getattr(backend, attrname)
|
|
241 |
except AttributeError:
|
|
242 |
# Last resort: try to get it from the module
|
|
243 |
# the back-end wrapper wraps
|
|
244 |
backend_module = backend.get_module()
|
|
245 |
return getattr(backend_module, attrname)
|