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(object): 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 _append_child(self.document, 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(object): 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(object): 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=True): 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=True): 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=True): 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=True): 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) 984
