zeroinstall/injector/qdom.py

   1 """A quick DOM implementation.
   2
   3 Python's xml.dom is very slow. The xml.sax module is also slow (as it imports urllib2).
   4 This is our light-weight version.
   5 """
   6
   7 # Copyright (C) 2009, Thomas Leonard
   8 # See the README file for details, or visit http://0install.net.
   9
  10 from xml.parsers import expat
  11
  12 class Element(object):
  13         """An XML element.
  14         @ivar uri: the element's namespace
  15         @type uri: str
  16         @ivar name: the element's localName
  17         @type name: str
  18         @ivar attrs: the element's attributes (key is in the form [namespace " "] localName)
  19         @type attrs: {str: str}
  20         @ivar childNodes: children
  21         @type childNodes: [L{Element}]
  22         @ivar content: the text content
  23         @type content: str"""
  24         __slots__ = ['uri', 'name', 'attrs', 'childNodes', 'content']
  25         def __init__(self, uri, name, attrs):
  26                 self.uri = uri
  27                 self.name = name
  28                 self.attrs = attrs.copy()
  29                 self.content = None
  30                 self.childNodes = []
  31
  32         def __str__(self):
  33                 attrs = [n + '=' + self.attrs[n] for n in self.attrs]
  34                 start = '<{%s}%s %s' % (self.uri, self.name, ' '.join(attrs))
  35                 if self.childNodes:
  36                         return start + '>' + '\n'.join(map(str, self.childNodes)) + ('</%s>' % (self.name))
  37                 elif self.content:
  38                         return start + '>' + self.content + ('</%s>' % (self.name))
  39                 else:
  40                         return start + '/>'
  41
  42         def getAttribute(self, name):
  43                 return self.attrs.get(name, None)
  44
  45         def toDOM(self, doc, prefixes):
  46                 """Create a DOM Element for this qdom.Element.
  47                 @param doc: document to use to create the element
  48                 @return: the new element
  49                 """
  50                 elem = prefixes.createElementNS(doc, self.uri, self.name)
  51
  52                 for fullname, value in self.attrs.iteritems():
  53                         if ' ' in fullname:
  54                                 ns, localName = fullname.split(' ', 1)
  55                         else:
  56                                 ns, localName = None, fullname
  57                         prefixes.setAttributeNS(elem, ns, localName, value)
  58                 for child in self.childNodes:
  59                         elem.appendChild(child.toDOM(doc, prefixes))
  60                 if self.content:
  61                         elem.appendChild(doc.createTextNode(self.content))
  62                 return elem
  63
  64 class QSAXhandler:
  65         """SAXHandler that builds a tree of L{Element}s"""
  66         def __init__(self):
  67                 self.stack = []
  68
  69         def startElementNS(self, fullname, attrs):
  70                 split = fullname.split(' ', 1)
  71                 if len(split) == 2:
  72                         self.stack.append(Element(split[0], split[1], attrs))
  73                 else:
  74                         self.stack.append(Element(None, fullname, attrs))
  75                 self.contents = ''
  76
  77         def characters(self, data):
  78                 self.contents += data
  79
  80         def endElementNS(self, name):
  81                 contents = self.contents.strip()
  82                 self.stack[-1].content = contents
  83                 self.contents = ''
  84                 new = self.stack.pop()
  85                 if self.stack:
  86                         self.stack[-1].childNodes.append(new)
  87                 else:
  88                         self.doc = new
  89
  90 def parse(source):
  91         """Parse an XML stream into a tree of L{Element}s.
  92         @param source: data to parse
  93         @type source: file
  94         @return: the root
  95         @rtype: L{Element}"""
  96         handler = QSAXhandler()
  97         parser = expat.ParserCreate(namespace_separator = ' ')
  98
  99         parser.StartElementHandler = handler.startElementNS
 100         parser.EndElementHandler = handler.endElementNS
 101         parser.CharacterDataHandler = handler.characters
 102
 103         parser.ParseFile(source)
 104         return handler.doc
 105
 106 class Prefixes:
 107         """Keep track of namespace prefixes. Used when serialising a document.
 108         @since: 0.54
 109         """
 110         def __init__(self, default_ns):
 111                 self.prefixes = {}
 112                 self.default_ns = default_ns
 113
 114         def get(self, ns):
 115                 prefix = self.prefixes.get(ns, None)
 116                 if prefix:
 117                         return prefix
 118                 prefix = 'ns%d' % len(self.prefixes)
 119                 self.prefixes[ns] = prefix
 120                 return prefix
 121
 122         def setAttributeNS(self, elem, uri, localName, value):
 123                 if uri is None:
 124                         elem.setAttributeNS(None, localName, value)
 125                 else:
 126                         elem.setAttributeNS(uri, self.get(uri) + ':' + localName, value)
 127
 128         def createElementNS(self, doc, uri, localName):
 129                 if uri == self.default_ns:
 130                         return doc.createElementNS(uri, localName)
 131                 else:
 132                         return doc.createElementNS(uri, self.get(uri) + ':' + localName)