Lib/xml/dom/expatbuilder.py

   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)