Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | """Facility to use the Expat parser to load a minidom instance |
2 | from a string or file. | |
3 | ||
4 | This avoids all the overhead of SAX and pulldom to gain performance. | |
5 | """ | |
6 | ||
7 | # Warning! | |
8 | # | |
9 | # This module is tightly bound to the implementation details of the | |
10 | # minidom DOM and can't be used with other DOM implementations. This | |
11 | # is due, in part, to a lack of appropriate methods in the DOM (there is | |
12 | # no way to create Entity and Notation nodes via the DOM Level 2 | |
13 | # interface), and for performance. The later is the cause of some fairly | |
14 | # cryptic code. | |
15 | # | |
16 | # Performance hacks: | |
17 | # | |
18 | # - .character_data_handler() has an extra case in which continuing | |
19 | # data is appended to an existing Text node; this can be a | |
20 | # speedup since pyexpat can break up character data into multiple | |
21 | # callbacks even though we set the buffer_text attribute on the | |
22 | # parser. This also gives us the advantage that we don't need a | |
23 | # separate normalization pass. | |
24 | # | |
25 | # - Determining that a node exists is done using an identity comparison | |
26 | # with None rather than a truth test; this avoids searching for and | |
27 | # calling any methods on the node object if it exists. (A rather | |
28 | # nice speedup is achieved this way as well!) | |
29 | ||
30 | from xml.dom import xmlbuilder, minidom, Node | |
31 | from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE | |
32 | from xml.parsers import expat | |
33 | from xml.dom.minidom import _append_child, _set_attribute_node | |
34 | from xml.dom.NodeFilter import NodeFilter | |
35 | ||
36 | from xml.dom.minicompat import * | |
37 | ||
38 | TEXT_NODE = Node.TEXT_NODE | |
39 | CDATA_SECTION_NODE = Node.CDATA_SECTION_NODE | |
40 | DOCUMENT_NODE = Node.DOCUMENT_NODE | |
41 | ||
42 | FILTER_ACCEPT = xmlbuilder.DOMBuilderFilter.FILTER_ACCEPT | |
43 | FILTER_REJECT = xmlbuilder.DOMBuilderFilter.FILTER_REJECT | |
44 | FILTER_SKIP = xmlbuilder.DOMBuilderFilter.FILTER_SKIP | |
45 | FILTER_INTERRUPT = xmlbuilder.DOMBuilderFilter.FILTER_INTERRUPT | |
46 | ||
47 | theDOMImplementation = minidom.getDOMImplementation() | |
48 | ||
49 | # Expat typename -> TypeInfo | |
50 | _typeinfo_map = { | |
51 | "CDATA": minidom.TypeInfo(None, "cdata"), | |
52 | "ENUM": minidom.TypeInfo(None, "enumeration"), | |
53 | "ENTITY": minidom.TypeInfo(None, "entity"), | |
54 | "ENTITIES": minidom.TypeInfo(None, "entities"), | |
55 | "ID": minidom.TypeInfo(None, "id"), | |
56 | "IDREF": minidom.TypeInfo(None, "idref"), | |
57 | "IDREFS": minidom.TypeInfo(None, "idrefs"), | |
58 | "NMTOKEN": minidom.TypeInfo(None, "nmtoken"), | |
59 | "NMTOKENS": minidom.TypeInfo(None, "nmtokens"), | |
60 | } | |
61 | ||
62 | class ElementInfo(NewStyle): | |
63 | __slots__ = '_attr_info', '_model', 'tagName' | |
64 | ||
65 | def __init__(self, tagName, model=None): | |
66 | self.tagName = tagName | |
67 | self._attr_info = [] | |
68 | self._model = model | |
69 | ||
70 | def __getstate__(self): | |
71 | return self._attr_info, self._model, self.tagName | |
72 | ||
73 | def __setstate__(self, state): | |
74 | self._attr_info, self._model, self.tagName = state | |
75 | ||
76 | def getAttributeType(self, aname): | |
77 | for info in self._attr_info: | |
78 | if info[1] == aname: | |
79 | t = info[-2] | |
80 | if t[0] == "(": | |
81 | return _typeinfo_map["ENUM"] | |
82 | else: | |
83 | return _typeinfo_map[info[-2]] | |
84 | return minidom._no_type | |
85 | ||
86 | def getAttributeTypeNS(self, namespaceURI, localName): | |
87 | return minidom._no_type | |
88 | ||
89 | def isElementContent(self): | |
90 | if self._model: | |
91 | type = self._model[0] | |
92 | return type not in (expat.model.XML_CTYPE_ANY, | |
93 | expat.model.XML_CTYPE_MIXED) | |
94 | else: | |
95 | return False | |
96 | ||
97 | def isEmpty(self): | |
98 | if self._model: | |
99 | return self._model[0] == expat.model.XML_CTYPE_EMPTY | |
100 | else: | |
101 | return False | |
102 | ||
103 | def isId(self, aname): | |
104 | for info in self._attr_info: | |
105 | if info[1] == aname: | |
106 | return info[-2] == "ID" | |
107 | return False | |
108 | ||
109 | def isIdNS(self, euri, ename, auri, aname): | |
110 | # not sure this is meaningful | |
111 | return self.isId((auri, aname)) | |
112 | ||
113 | def _intern(builder, s): | |
114 | return builder._intern_setdefault(s, s) | |
115 | ||
116 | def _parse_ns_name(builder, name): | |
117 | assert ' ' in name | |
118 | parts = name.split(' ') | |
119 | intern = builder._intern_setdefault | |
120 | if len(parts) == 3: | |
121 | uri, localname, prefix = parts | |
122 | prefix = intern(prefix, prefix) | |
123 | qname = "%s:%s" % (prefix, localname) | |
124 | qname = intern(qname, qname) | |
125 | localname = intern(localname, localname) | |
126 | else: | |
127 | uri, localname = parts | |
128 | prefix = EMPTY_PREFIX | |
129 | qname = localname = intern(localname, localname) | |
130 | return intern(uri, uri), localname, prefix, qname | |
131 | ||
132 | ||
133 | class ExpatBuilder: | |
134 | """Document builder that uses Expat to build a ParsedXML.DOM document | |
135 | instance.""" | |
136 | ||
137 | def __init__(self, options=None): | |
138 | if options is None: | |
139 | options = xmlbuilder.Options() | |
140 | self._options = options | |
141 | if self._options.filter is not None: | |
142 | self._filter = FilterVisibilityController(self._options.filter) | |
143 | else: | |
144 | self._filter = None | |
145 | # This *really* doesn't do anything in this case, so | |
146 | # override it with something fast & minimal. | |
147 | self._finish_start_element = id | |
148 | self._parser = None | |
149 | self.reset() | |
150 | ||
151 | def createParser(self): | |
152 | """Create a new parser object.""" | |
153 | return expat.ParserCreate() | |
154 | ||
155 | def getParser(self): | |
156 | """Return the parser object, creating a new one if needed.""" | |
157 | if not self._parser: | |
158 | self._parser = self.createParser() | |
159 | self._intern_setdefault = self._parser.intern.setdefault | |
160 | self._parser.buffer_text = True | |
161 | self._parser.ordered_attributes = True | |
162 | self._parser.specified_attributes = True | |
163 | self.install(self._parser) | |
164 | return self._parser | |
165 | ||
166 | def reset(self): | |
167 | """Free all data structures used during DOM construction.""" | |
168 | self.document = theDOMImplementation.createDocument( | |
169 | EMPTY_NAMESPACE, None, None) | |
170 | self.curNode = self.document | |
171 | self._elem_info = self.document._elem_info | |
172 | self._cdata = False | |
173 | ||
174 | def install(self, parser): | |
175 | """Install the callbacks needed to build the DOM into the parser.""" | |
176 | # This creates circular references! | |
177 | parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler | |
178 | parser.StartElementHandler = self.first_element_handler | |
179 | parser.EndElementHandler = self.end_element_handler | |
180 | parser.ProcessingInstructionHandler = self.pi_handler | |
181 | if self._options.entities: | |
182 | parser.EntityDeclHandler = self.entity_decl_handler | |
183 | parser.NotationDeclHandler = self.notation_decl_handler | |
184 | if self._options.comments: | |
185 | parser.CommentHandler = self.comment_handler | |
186 | if self._options.cdata_sections: | |
187 | parser.StartCdataSectionHandler = self.start_cdata_section_handler | |
188 | parser.EndCdataSectionHandler = self.end_cdata_section_handler | |
189 | parser.CharacterDataHandler = self.character_data_handler_cdata | |
190 | else: | |
191 | parser.CharacterDataHandler = self.character_data_handler | |
192 | parser.ExternalEntityRefHandler = self.external_entity_ref_handler | |
193 | parser.XmlDeclHandler = self.xml_decl_handler | |
194 | parser.ElementDeclHandler = self.element_decl_handler | |
195 | parser.AttlistDeclHandler = self.attlist_decl_handler | |
196 | ||
197 | def parseFile(self, file): | |
198 | """Parse a document from a file object, returning the document | |
199 | node.""" | |
200 | parser = self.getParser() | |
201 | first_buffer = True | |
202 | try: | |
203 | while 1: | |
204 | buffer = file.read(16*1024) | |
205 | if not buffer: | |
206 | break | |
207 | parser.Parse(buffer, 0) | |
208 | if first_buffer and self.document.documentElement: | |
209 | self._setup_subset(buffer) | |
210 | first_buffer = False | |
211 | parser.Parse("", True) | |
212 | except ParseEscape: | |
213 | pass | |
214 | doc = self.document | |
215 | self.reset() | |
216 | self._parser = None | |
217 | return doc | |
218 | ||
219 | def parseString(self, string): | |
220 | """Parse a document from a string, returning the document node.""" | |
221 | parser = self.getParser() | |
222 | try: | |
223 | parser.Parse(string, True) | |
224 | self._setup_subset(string) | |
225 | except ParseEscape: | |
226 | pass | |
227 | doc = self.document | |
228 | self.reset() | |
229 | self._parser = None | |
230 | return doc | |
231 | ||
232 | def _setup_subset(self, buffer): | |
233 | """Load the internal subset if there might be one.""" | |
234 | if self.document.doctype: | |
235 | extractor = InternalSubsetExtractor() | |
236 | extractor.parseString(buffer) | |
237 | subset = extractor.getSubset() | |
238 | self.document.doctype.internalSubset = subset | |
239 | ||
240 | def start_doctype_decl_handler(self, doctypeName, systemId, publicId, | |
241 | has_internal_subset): | |
242 | doctype = self.document.implementation.createDocumentType( | |
243 | doctypeName, publicId, systemId) | |
244 | doctype.ownerDocument = self.document | |
245 | self.document.childNodes.append(doctype) | |
246 | self.document.doctype = doctype | |
247 | if self._filter and self._filter.acceptNode(doctype) == FILTER_REJECT: | |
248 | self.document.doctype = None | |
249 | del self.document.childNodes[-1] | |
250 | doctype = None | |
251 | self._parser.EntityDeclHandler = None | |
252 | self._parser.NotationDeclHandler = None | |
253 | if has_internal_subset: | |
254 | if doctype is not None: | |
255 | doctype.entities._seq = [] | |
256 | doctype.notations._seq = [] | |
257 | self._parser.CommentHandler = None | |
258 | self._parser.ProcessingInstructionHandler = None | |
259 | self._parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler | |
260 | ||
261 | def end_doctype_decl_handler(self): | |
262 | if self._options.comments: | |
263 | self._parser.CommentHandler = self.comment_handler | |
264 | self._parser.ProcessingInstructionHandler = self.pi_handler | |
265 | if not (self._elem_info or self._filter): | |
266 | self._finish_end_element = id | |
267 | ||
268 | def pi_handler(self, target, data): | |
269 | node = self.document.createProcessingInstruction(target, data) | |
270 | _append_child(self.curNode, node) | |
271 | if self._filter and self._filter.acceptNode(node) == FILTER_REJECT: | |
272 | self.curNode.removeChild(node) | |
273 | ||
274 | def character_data_handler_cdata(self, data): | |
275 | childNodes = self.curNode.childNodes | |
276 | if self._cdata: | |
277 | if ( self._cdata_continue | |
278 | and childNodes[-1].nodeType == CDATA_SECTION_NODE): | |
279 | childNodes[-1].appendData(data) | |
280 | return | |
281 | node = self.document.createCDATASection(data) | |
282 | self._cdata_continue = True | |
283 | elif childNodes and childNodes[-1].nodeType == TEXT_NODE: | |
284 | node = childNodes[-1] | |
285 | value = node.data + data | |
286 | d = node.__dict__ | |
287 | d['data'] = d['nodeValue'] = value | |
288 | return | |
289 | else: | |
290 | node = minidom.Text() | |
291 | d = node.__dict__ | |
292 | d['data'] = d['nodeValue'] = data | |
293 | d['ownerDocument'] = self.document | |
294 | _append_child(self.curNode, node) | |
295 | ||
296 | def character_data_handler(self, data): | |
297 | childNodes = self.curNode.childNodes | |
298 | if childNodes and childNodes[-1].nodeType == TEXT_NODE: | |
299 | node = childNodes[-1] | |
300 | d = node.__dict__ | |
301 | d['data'] = d['nodeValue'] = node.data + data | |
302 | return | |
303 | node = minidom.Text() | |
304 | d = node.__dict__ | |
305 | d['data'] = d['nodeValue'] = node.data + data | |
306 | d['ownerDocument'] = self.document | |
307 | _append_child(self.curNode, node) | |
308 | ||
309 | def entity_decl_handler(self, entityName, is_parameter_entity, value, | |
310 | base, systemId, publicId, notationName): | |
311 | if is_parameter_entity: | |
312 | # we don't care about parameter entities for the DOM | |
313 | return | |
314 | if not self._options.entities: | |
315 | return | |
316 | node = self.document._create_entity(entityName, publicId, | |
317 | systemId, notationName) | |
318 | if value is not None: | |
319 | # internal entity | |
320 | # node *should* be readonly, but we'll cheat | |
321 | child = self.document.createTextNode(value) | |
322 | node.childNodes.append(child) | |
323 | self.document.doctype.entities._seq.append(node) | |
324 | if self._filter and self._filter.acceptNode(node) == FILTER_REJECT: | |
325 | del self.document.doctype.entities._seq[-1] | |
326 | ||
327 | def notation_decl_handler(self, notationName, base, systemId, publicId): | |
328 | node = self.document._create_notation(notationName, publicId, systemId) | |
329 | self.document.doctype.notations._seq.append(node) | |
330 | if self._filter and self._filter.acceptNode(node) == FILTER_ACCEPT: | |
331 | del self.document.doctype.notations._seq[-1] | |
332 | ||
333 | def comment_handler(self, data): | |
334 | node = self.document.createComment(data) | |
335 | _append_child(self.curNode, node) | |
336 | if self._filter and self._filter.acceptNode(node) == FILTER_REJECT: | |
337 | self.curNode.removeChild(node) | |
338 | ||
339 | def start_cdata_section_handler(self): | |
340 | self._cdata = True | |
341 | self._cdata_continue = False | |
342 | ||
343 | def end_cdata_section_handler(self): | |
344 | self._cdata = False | |
345 | self._cdata_continue = False | |
346 | ||
347 | def external_entity_ref_handler(self, context, base, systemId, publicId): | |
348 | return 1 | |
349 | ||
350 | def first_element_handler(self, name, attributes): | |
351 | if self._filter is None and not self._elem_info: | |
352 | self._finish_end_element = id | |
353 | self.getParser().StartElementHandler = self.start_element_handler | |
354 | self.start_element_handler(name, attributes) | |
355 | ||
356 | def start_element_handler(self, name, attributes): | |
357 | node = self.document.createElement(name) | |
358 | _append_child(self.curNode, node) | |
359 | self.curNode = node | |
360 | ||
361 | if attributes: | |
362 | for i in range(0, len(attributes), 2): | |
363 | a = minidom.Attr(attributes[i], EMPTY_NAMESPACE, | |
364 | None, EMPTY_PREFIX) | |
365 | value = attributes[i+1] | |
366 | d = a.childNodes[0].__dict__ | |
367 | d['data'] = d['nodeValue'] = value | |
368 | d = a.__dict__ | |
369 | d['value'] = d['nodeValue'] = value | |
370 | d['ownerDocument'] = self.document | |
371 | _set_attribute_node(node, a) | |
372 | ||
373 | if node is not self.document.documentElement: | |
374 | self._finish_start_element(node) | |
375 | ||
376 | def _finish_start_element(self, node): | |
377 | if self._filter: | |
378 | # To be general, we'd have to call isSameNode(), but this | |
379 | # is sufficient for minidom: | |
380 | if node is self.document.documentElement: | |
381 | return | |
382 | filt = self._filter.startContainer(node) | |
383 | if filt == FILTER_REJECT: | |
384 | # ignore this node & all descendents | |
385 | Rejecter(self) | |
386 | elif filt == FILTER_SKIP: | |
387 | # ignore this node, but make it's children become | |
388 | # children of the parent node | |
389 | Skipper(self) | |
390 | else: | |
391 | return | |
392 | self.curNode = node.parentNode | |
393 | node.parentNode.removeChild(node) | |
394 | node.unlink() | |
395 | ||
396 | # If this ever changes, Namespaces.end_element_handler() needs to | |
397 | # be changed to match. | |
398 | # | |
399 | def end_element_handler(self, name): | |
400 | curNode = self.curNode | |
401 | self.curNode = curNode.parentNode | |
402 | self._finish_end_element(curNode) | |
403 | ||
404 | def _finish_end_element(self, curNode): | |
405 | info = self._elem_info.get(curNode.tagName) | |
406 | if info: | |
407 | self._handle_white_text_nodes(curNode, info) | |
408 | if self._filter: | |
409 | if curNode is self.document.documentElement: | |
410 | return | |
411 | if self._filter.acceptNode(curNode) == FILTER_REJECT: | |
412 | self.curNode.removeChild(curNode) | |
413 | curNode.unlink() | |
414 | ||
415 | def _handle_white_text_nodes(self, node, info): | |
416 | if (self._options.whitespace_in_element_content | |
417 | or not info.isElementContent()): | |
418 | return | |
419 | ||
420 | # We have element type information and should remove ignorable | |
421 | # whitespace; identify for text nodes which contain only | |
422 | # whitespace. | |
423 | L = [] | |
424 | for child in node.childNodes: | |
425 | if child.nodeType == TEXT_NODE and not child.data.strip(): | |
426 | L.append(child) | |
427 | ||
428 | # Remove ignorable whitespace from the tree. | |
429 | for child in L: | |
430 | node.removeChild(child) | |
431 | ||
432 | def element_decl_handler(self, name, model): | |
433 | info = self._elem_info.get(name) | |
434 | if info is None: | |
435 | self._elem_info[name] = ElementInfo(name, model) | |
436 | else: | |
437 | assert info._model is None | |
438 | info._model = model | |
439 | ||
440 | def attlist_decl_handler(self, elem, name, type, default, required): | |
441 | info = self._elem_info.get(elem) | |
442 | if info is None: | |
443 | info = ElementInfo(elem) | |
444 | self._elem_info[elem] = info | |
445 | info._attr_info.append( | |
446 | [None, name, None, None, default, 0, type, required]) | |
447 | ||
448 | def xml_decl_handler(self, version, encoding, standalone): | |
449 | self.document.version = version | |
450 | self.document.encoding = encoding | |
451 | # This is still a little ugly, thanks to the pyexpat API. ;-( | |
452 | if standalone >= 0: | |
453 | if standalone: | |
454 | self.document.standalone = True | |
455 | else: | |
456 | self.document.standalone = False | |
457 | ||
458 | ||
459 | # Don't include FILTER_INTERRUPT, since that's checked separately | |
460 | # where allowed. | |
461 | _ALLOWED_FILTER_RETURNS = (FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP) | |
462 | ||
463 | class FilterVisibilityController(NewStyle): | |
464 | """Wrapper around a DOMBuilderFilter which implements the checks | |
465 | to make the whatToShow filter attribute work.""" | |
466 | ||
467 | __slots__ = 'filter', | |
468 | ||
469 | def __init__(self, filter): | |
470 | self.filter = filter | |
471 | ||
472 | def startContainer(self, node): | |
473 | mask = self._nodetype_mask[node.nodeType] | |
474 | if self.filter.whatToShow & mask: | |
475 | val = self.filter.startContainer(node) | |
476 | if val == FILTER_INTERRUPT: | |
477 | raise ParseEscape | |
478 | if val not in _ALLOWED_FILTER_RETURNS: | |
479 | raise ValueError, \ | |
480 | "startContainer() returned illegal value: " + repr(val) | |
481 | return val | |
482 | else: | |
483 | return FILTER_ACCEPT | |
484 | ||
485 | def acceptNode(self, node): | |
486 | mask = self._nodetype_mask[node.nodeType] | |
487 | if self.filter.whatToShow & mask: | |
488 | val = self.filter.acceptNode(node) | |
489 | if val == FILTER_INTERRUPT: | |
490 | raise ParseEscape | |
491 | if val == FILTER_SKIP: | |
492 | # move all child nodes to the parent, and remove this node | |
493 | parent = node.parentNode | |
494 | for child in node.childNodes[:]: | |
495 | parent.appendChild(child) | |
496 | # node is handled by the caller | |
497 | return FILTER_REJECT | |
498 | if val not in _ALLOWED_FILTER_RETURNS: | |
499 | raise ValueError, \ | |
500 | "acceptNode() returned illegal value: " + repr(val) | |
501 | return val | |
502 | else: | |
503 | return FILTER_ACCEPT | |
504 | ||
505 | _nodetype_mask = { | |
506 | Node.ELEMENT_NODE: NodeFilter.SHOW_ELEMENT, | |
507 | Node.ATTRIBUTE_NODE: NodeFilter.SHOW_ATTRIBUTE, | |
508 | Node.TEXT_NODE: NodeFilter.SHOW_TEXT, | |
509 | Node.CDATA_SECTION_NODE: NodeFilter.SHOW_CDATA_SECTION, | |
510 | Node.ENTITY_REFERENCE_NODE: NodeFilter.SHOW_ENTITY_REFERENCE, | |
511 | Node.ENTITY_NODE: NodeFilter.SHOW_ENTITY, | |
512 | Node.PROCESSING_INSTRUCTION_NODE: NodeFilter.SHOW_PROCESSING_INSTRUCTION, | |
513 | Node.COMMENT_NODE: NodeFilter.SHOW_COMMENT, | |
514 | Node.DOCUMENT_NODE: NodeFilter.SHOW_DOCUMENT, | |
515 | Node.DOCUMENT_TYPE_NODE: NodeFilter.SHOW_DOCUMENT_TYPE, | |
516 | Node.DOCUMENT_FRAGMENT_NODE: NodeFilter.SHOW_DOCUMENT_FRAGMENT, | |
517 | Node.NOTATION_NODE: NodeFilter.SHOW_NOTATION, | |
518 | } | |
519 | ||
520 | ||
521 | class FilterCrutch(NewStyle): | |
522 | __slots__ = '_builder', '_level', '_old_start', '_old_end' | |
523 | ||
524 | def __init__(self, builder): | |
525 | self._level = 0 | |
526 | self._builder = builder | |
527 | parser = builder._parser | |
528 | self._old_start = parser.StartElementHandler | |
529 | self._old_end = parser.EndElementHandler | |
530 | parser.StartElementHandler = self.start_element_handler | |
531 | parser.EndElementHandler = self.end_element_handler | |
532 | ||
533 | class Rejecter(FilterCrutch): | |
534 | __slots__ = () | |
535 | ||
536 | def __init__(self, builder): | |
537 | FilterCrutch.__init__(self, builder) | |
538 | parser = builder._parser | |
539 | for name in ("ProcessingInstructionHandler", | |
540 | "CommentHandler", | |
541 | "CharacterDataHandler", | |
542 | "StartCdataSectionHandler", | |
543 | "EndCdataSectionHandler", | |
544 | "ExternalEntityRefHandler", | |
545 | ): | |
546 | setattr(parser, name, None) | |
547 | ||
548 | def start_element_handler(self, *args): | |
549 | self._level = self._level + 1 | |
550 | ||
551 | def end_element_handler(self, *args): | |
552 | if self._level == 0: | |
553 | # restore the old handlers | |
554 | parser = self._builder._parser | |
555 | self._builder.install(parser) | |
556 | parser.StartElementHandler = self._old_start | |
557 | parser.EndElementHandler = self._old_end | |
558 | else: | |
559 | self._level = self._level - 1 | |
560 | ||
561 | class Skipper(FilterCrutch): | |
562 | __slots__ = () | |
563 | ||
564 | def start_element_handler(self, *args): | |
565 | node = self._builder.curNode | |
566 | self._old_start(*args) | |
567 | if self._builder.curNode is not node: | |
568 | self._level = self._level + 1 | |
569 | ||
570 | def end_element_handler(self, *args): | |
571 | if self._level == 0: | |
572 | # We're popping back out of the node we're skipping, so we | |
573 | # shouldn't need to do anything but reset the handlers. | |
574 | self._builder._parser.StartElementHandler = self._old_start | |
575 | self._builder._parser.EndElementHandler = self._old_end | |
576 | self._builder = None | |
577 | else: | |
578 | self._level = self._level - 1 | |
579 | self._old_end(*args) | |
580 | ||
581 | ||
582 | # framework document used by the fragment builder. | |
583 | # Takes a string for the doctype, subset string, and namespace attrs string. | |
584 | ||
585 | _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID = \ | |
586 | "http://xml.python.org/entities/fragment-builder/internal" | |
587 | ||
588 | _FRAGMENT_BUILDER_TEMPLATE = ( | |
589 | '''\ | |
590 | <!DOCTYPE wrapper | |
591 | %%s [ | |
592 | <!ENTITY fragment-builder-internal | |
593 | SYSTEM "%s"> | |
594 | %%s | |
595 | ]> | |
596 | <wrapper %%s | |
597 | >&fragment-builder-internal;</wrapper>''' | |
598 | % _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID) | |
599 | ||
600 | ||
601 | class FragmentBuilder(ExpatBuilder): | |
602 | """Builder which constructs document fragments given XML source | |
603 | text and a context node. | |
604 | ||
605 | The context node is expected to provide information about the | |
606 | namespace declarations which are in scope at the start of the | |
607 | fragment. | |
608 | """ | |
609 | ||
610 | def __init__(self, context, options=None): | |
611 | if context.nodeType == DOCUMENT_NODE: | |
612 | self.originalDocument = context | |
613 | self.context = context | |
614 | else: | |
615 | self.originalDocument = context.ownerDocument | |
616 | self.context = context | |
617 | ExpatBuilder.__init__(self, options) | |
618 | ||
619 | def reset(self): | |
620 | ExpatBuilder.reset(self) | |
621 | self.fragment = None | |
622 | ||
623 | def parseFile(self, file): | |
624 | """Parse a document fragment from a file object, returning the | |
625 | fragment node.""" | |
626 | return self.parseString(file.read()) | |
627 | ||
628 | def parseString(self, string): | |
629 | """Parse a document fragment from a string, returning the | |
630 | fragment node.""" | |
631 | self._source = string | |
632 | parser = self.getParser() | |
633 | doctype = self.originalDocument.doctype | |
634 | ident = "" | |
635 | if doctype: | |
636 | subset = doctype.internalSubset or self._getDeclarations() | |
637 | if doctype.publicId: | |
638 | ident = ('PUBLIC "%s" "%s"' | |
639 | % (doctype.publicId, doctype.systemId)) | |
640 | elif doctype.systemId: | |
641 | ident = 'SYSTEM "%s"' % doctype.systemId | |
642 | else: | |
643 | subset = "" | |
644 | nsattrs = self._getNSattrs() # get ns decls from node's ancestors | |
645 | document = _FRAGMENT_BUILDER_TEMPLATE % (ident, subset, nsattrs) | |
646 | try: | |
647 | parser.Parse(document, 1) | |
648 | except: | |
649 | self.reset() | |
650 | raise | |
651 | fragment = self.fragment | |
652 | self.reset() | |
653 | ## self._parser = None | |
654 | return fragment | |
655 | ||
656 | def _getDeclarations(self): | |
657 | """Re-create the internal subset from the DocumentType node. | |
658 | ||
659 | This is only needed if we don't already have the | |
660 | internalSubset as a string. | |
661 | """ | |
662 | doctype = self.context.ownerDocument.doctype | |
663 | s = "" | |
664 | if doctype: | |
665 | for i in range(doctype.notations.length): | |
666 | notation = doctype.notations.item(i) | |
667 | if s: | |
668 | s = s + "\n " | |
669 | s = "%s<!NOTATION %s" % (s, notation.nodeName) | |
670 | if notation.publicId: | |
671 | s = '%s PUBLIC "%s"\n "%s">' \ | |
672 | % (s, notation.publicId, notation.systemId) | |
673 | else: | |
674 | s = '%s SYSTEM "%s">' % (s, notation.systemId) | |
675 | for i in range(doctype.entities.length): | |
676 | entity = doctype.entities.item(i) | |
677 | if s: | |
678 | s = s + "\n " | |
679 | s = "%s<!ENTITY %s" % (s, entity.nodeName) | |
680 | if entity.publicId: | |
681 | s = '%s PUBLIC "%s"\n "%s"' \ | |
682 | % (s, entity.publicId, entity.systemId) | |
683 | elif entity.systemId: | |
684 | s = '%s SYSTEM "%s"' % (s, entity.systemId) | |
685 | else: | |
686 | s = '%s "%s"' % (s, entity.firstChild.data) | |
687 | if entity.notationName: | |
688 | s = "%s NOTATION %s" % (s, entity.notationName) | |
689 | s = s + ">" | |
690 | return s | |
691 | ||
692 | def _getNSattrs(self): | |
693 | return "" | |
694 | ||
695 | def external_entity_ref_handler(self, context, base, systemId, publicId): | |
696 | if systemId == _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID: | |
697 | # this entref is the one that we made to put the subtree | |
698 | # in; all of our given input is parsed in here. | |
699 | old_document = self.document | |
700 | old_cur_node = self.curNode | |
701 | parser = self._parser.ExternalEntityParserCreate(context) | |
702 | # put the real document back, parse into the fragment to return | |
703 | self.document = self.originalDocument | |
704 | self.fragment = self.document.createDocumentFragment() | |
705 | self.curNode = self.fragment | |
706 | try: | |
707 | parser.Parse(self._source, 1) | |
708 | finally: | |
709 | self.curNode = old_cur_node | |
710 | self.document = old_document | |
711 | self._source = None | |
712 | return -1 | |
713 | else: | |
714 | return ExpatBuilder.external_entity_ref_handler( | |
715 | self, context, base, systemId, publicId) | |
716 | ||
717 | ||
718 | class Namespaces: | |
719 | """Mix-in class for builders; adds support for namespaces.""" | |
720 | ||
721 | def _initNamespaces(self): | |
722 | # list of (prefix, uri) ns declarations. Namespace attrs are | |
723 | # constructed from this and added to the element's attrs. | |
724 | self._ns_ordered_prefixes = [] | |
725 | ||
726 | def createParser(self): | |
727 | """Create a new namespace-handling parser.""" | |
728 | parser = expat.ParserCreate(namespace_separator=" ") | |
729 | parser.namespace_prefixes = True | |
730 | return parser | |
731 | ||
732 | def install(self, parser): | |
733 | """Insert the namespace-handlers onto the parser.""" | |
734 | ExpatBuilder.install(self, parser) | |
735 | if self._options.namespace_declarations: | |
736 | parser.StartNamespaceDeclHandler = ( | |
737 | self.start_namespace_decl_handler) | |
738 | ||
739 | def start_namespace_decl_handler(self, prefix, uri): | |
740 | """Push this namespace declaration on our storage.""" | |
741 | self._ns_ordered_prefixes.append((prefix, uri)) | |
742 | ||
743 | def start_element_handler(self, name, attributes): | |
744 | if ' ' in name: | |
745 | uri, localname, prefix, qname = _parse_ns_name(self, name) | |
746 | else: | |
747 | uri = EMPTY_NAMESPACE | |
748 | qname = name | |
749 | localname = None | |
750 | prefix = EMPTY_PREFIX | |
751 | node = minidom.Element(qname, uri, prefix, localname) | |
752 | node.ownerDocument = self.document | |
753 | _append_child(self.curNode, node) | |
754 | self.curNode = node | |
755 | ||
756 | if self._ns_ordered_prefixes: | |
757 | for prefix, uri in self._ns_ordered_prefixes: | |
758 | if prefix: | |
759 | a = minidom.Attr(_intern(self, 'xmlns:' + prefix), | |
760 | XMLNS_NAMESPACE, prefix, "xmlns") | |
761 | else: | |
762 | a = minidom.Attr("xmlns", XMLNS_NAMESPACE, | |
763 | "xmlns", EMPTY_PREFIX) | |
764 | d = a.childNodes[0].__dict__ | |
765 | d['data'] = d['nodeValue'] = uri | |
766 | d = a.__dict__ | |
767 | d['value'] = d['nodeValue'] = uri | |
768 | d['ownerDocument'] = self.document | |
769 | _set_attribute_node(node, a) | |
770 | del self._ns_ordered_prefixes[:] | |
771 | ||
772 | if attributes: | |
773 | _attrs = node._attrs | |
774 | _attrsNS = node._attrsNS | |
775 | for i in range(0, len(attributes), 2): | |
776 | aname = attributes[i] | |
777 | value = attributes[i+1] | |
778 | if ' ' in aname: | |
779 | uri, localname, prefix, qname = _parse_ns_name(self, aname) | |
780 | a = minidom.Attr(qname, uri, localname, prefix) | |
781 | _attrs[qname] = a | |
782 | _attrsNS[(uri, localname)] = a | |
783 | else: | |
784 | a = minidom.Attr(aname, EMPTY_NAMESPACE, | |
785 | aname, EMPTY_PREFIX) | |
786 | _attrs[aname] = a | |
787 | _attrsNS[(EMPTY_NAMESPACE, aname)] = a | |
788 | d = a.childNodes[0].__dict__ | |
789 | d['data'] = d['nodeValue'] = value | |
790 | d = a.__dict__ | |
791 | d['ownerDocument'] = self.document | |
792 | d['value'] = d['nodeValue'] = value | |
793 | d['ownerElement'] = node | |
794 | ||
795 | if __debug__: | |
796 | # This only adds some asserts to the original | |
797 | # end_element_handler(), so we only define this when -O is not | |
798 | # used. If changing one, be sure to check the other to see if | |
799 | # it needs to be changed as well. | |
800 | # | |
801 | def end_element_handler(self, name): | |
802 | curNode = self.curNode | |
803 | if ' ' in name: | |
804 | uri, localname, prefix, qname = _parse_ns_name(self, name) | |
805 | assert (curNode.namespaceURI == uri | |
806 | and curNode.localName == localname | |
807 | and curNode.prefix == prefix), \ | |
808 | "element stack messed up! (namespace)" | |
809 | else: | |
810 | assert curNode.nodeName == name, \ | |
811 | "element stack messed up - bad nodeName" | |
812 | assert curNode.namespaceURI == EMPTY_NAMESPACE, \ | |
813 | "element stack messed up - bad namespaceURI" | |
814 | self.curNode = curNode.parentNode | |
815 | self._finish_end_element(curNode) | |
816 | ||
817 | ||
818 | class ExpatBuilderNS(Namespaces, ExpatBuilder): | |
819 | """Document builder that supports namespaces.""" | |
820 | ||
821 | def reset(self): | |
822 | ExpatBuilder.reset(self) | |
823 | self._initNamespaces() | |
824 | ||
825 | ||
826 | class FragmentBuilderNS(Namespaces, FragmentBuilder): | |
827 | """Fragment builder that supports namespaces.""" | |
828 | ||
829 | def reset(self): | |
830 | FragmentBuilder.reset(self) | |
831 | self._initNamespaces() | |
832 | ||
833 | def _getNSattrs(self): | |
834 | """Return string of namespace attributes from this element and | |
835 | ancestors.""" | |
836 | # XXX This needs to be re-written to walk the ancestors of the | |
837 | # context to build up the namespace information from | |
838 | # declarations, elements, and attributes found in context. | |
839 | # Otherwise we have to store a bunch more data on the DOM | |
840 | # (though that *might* be more reliable -- not clear). | |
841 | attrs = "" | |
842 | context = self.context | |
843 | L = [] | |
844 | while context: | |
845 | if hasattr(context, '_ns_prefix_uri'): | |
846 | for prefix, uri in context._ns_prefix_uri.items(): | |
847 | # add every new NS decl from context to L and attrs string | |
848 | if prefix in L: | |
849 | continue | |
850 | L.append(prefix) | |
851 | if prefix: | |
852 | declname = "xmlns:" + prefix | |
853 | else: | |
854 | declname = "xmlns" | |
855 | if attrs: | |
856 | attrs = "%s\n %s='%s'" % (attrs, declname, uri) | |
857 | else: | |
858 | attrs = " %s='%s'" % (declname, uri) | |
859 | context = context.parentNode | |
860 | return attrs | |
861 | ||
862 | ||
863 | class ParseEscape(Exception): | |
864 | """Exception raised to short-circuit parsing in InternalSubsetExtractor.""" | |
865 | pass | |
866 | ||
867 | class InternalSubsetExtractor(ExpatBuilder): | |
868 | """XML processor which can rip out the internal document type subset.""" | |
869 | ||
870 | subset = None | |
871 | ||
872 | def getSubset(self): | |
873 | """Return the internal subset as a string.""" | |
874 | return self.subset | |
875 | ||
876 | def parseFile(self, file): | |
877 | try: | |
878 | ExpatBuilder.parseFile(self, file) | |
879 | except ParseEscape: | |
880 | pass | |
881 | ||
882 | def parseString(self, string): | |
883 | try: | |
884 | ExpatBuilder.parseString(self, string) | |
885 | except ParseEscape: | |
886 | pass | |
887 | ||
888 | def install(self, parser): | |
889 | parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler | |
890 | parser.StartElementHandler = self.start_element_handler | |
891 | ||
892 | def start_doctype_decl_handler(self, name, publicId, systemId, | |
893 | has_internal_subset): | |
894 | if has_internal_subset: | |
895 | parser = self.getParser() | |
896 | self.subset = [] | |
897 | parser.DefaultHandler = self.subset.append | |
898 | parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler | |
899 | else: | |
900 | raise ParseEscape() | |
901 | ||
902 | def end_doctype_decl_handler(self): | |
903 | s = ''.join(self.subset).replace('\r\n', '\n').replace('\r', '\n') | |
904 | self.subset = s | |
905 | raise ParseEscape() | |
906 | ||
907 | def start_element_handler(self, name, attrs): | |
908 | raise ParseEscape() | |
909 | ||
910 | ||
911 | def parse(file, namespaces=1): | |
912 | """Parse a document, returning the resulting Document node. | |
913 | ||
914 | 'file' may be either a file name or an open file object. | |
915 | """ | |
916 | if namespaces: | |
917 | builder = ExpatBuilderNS() | |
918 | else: | |
919 | builder = ExpatBuilder() | |
920 | ||
921 | if isinstance(file, StringTypes): | |
922 | fp = open(file, 'rb') | |
923 | try: | |
924 | result = builder.parseFile(fp) | |
925 | finally: | |
926 | fp.close() | |
927 | else: | |
928 | result = builder.parseFile(file) | |
929 | return result | |
930 | ||
931 | ||
932 | def parseString(string, namespaces=1): | |
933 | """Parse a document from a string, returning the resulting | |
934 | Document node. | |
935 | """ | |
936 | if namespaces: | |
937 | builder = ExpatBuilderNS() | |
938 | else: | |
939 | builder = ExpatBuilder() | |
940 | return builder.parseString(string) | |
941 | ||
942 | ||
943 | def parseFragment(file, context, namespaces=1): | |
944 | """Parse a fragment of a document, given the context from which it | |
945 | was originally extracted. context should be the parent of the | |
946 | node(s) which are in the fragment. | |
947 | ||
948 | 'file' may be either a file name or an open file object. | |
949 | """ | |
950 | if namespaces: | |
951 | builder = FragmentBuilderNS(context) | |
952 | else: | |
953 | builder = FragmentBuilder(context) | |
954 | ||
955 | if isinstance(file, StringTypes): | |
956 | fp = open(file, 'rb') | |
957 | try: | |
958 | result = builder.parseFile(fp) | |
959 | finally: | |
960 | fp.close() | |
961 | else: | |
962 | result = builder.parseFile(file) | |
963 | return result | |
964 | ||
965 | ||
966 | def parseFragmentString(string, context, namespaces=1): | |
967 | """Parse a fragment of a document from a string, given the context | |
968 | from which it was originally extracted. context should be the | |
969 | parent of the node(s) which are in the fragment. | |
970 | """ | |
971 | if namespaces: | |
972 | builder = FragmentBuilderNS(context) | |
973 | else: | |
974 | builder = FragmentBuilder(context) | |
975 | return builder.parseString(string) | |
976 | ||
977 | ||
978 | def makeBuilder(options): | |
979 | """Create a builder based on an Options object.""" | |
980 | if options.namespaces: | |
981 | return ExpatBuilderNS(options) | |
982 | else: | |
983 | return ExpatBuilder(options) |