# # genxmlif, Release 0.9.0 # file: xmlifDom.py # # XML interface base class for Python DOM implementations # # history: # 2005-04-25 rl created # 2007-07-02 rl complete re-design, internal wrapper # for DOM trees and elements introduced # 2008-07-01 rl Limited support of XInclude added # # Copyright (c) 2005-2008 by Roland Leuthe. All rights reserved. # # -------------------------------------------------------------------- # The generic XML interface is # # Copyright (c) 2005-2008 by Roland Leuthe # # By obtaining, using, and/or copying this software and/or its # associated documentation, you agree that you have read, understood, # and will comply with the following terms and conditions: # # Permission to use, copy, modify, and distribute this software and # its associated documentation for any purpose and without fee is # hereby granted, provided that the above copyright notice appears in # all copies, and that both that copyright notice and this permission # notice appear in supporting documentation, and that the name of # the author not be used in advertising or publicity # pertaining to distribution of the software without specific, written # prior permission. # # THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD # TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- # ABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR # BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY # DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, # WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS # ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # -------------------------------------------------------------------- import string import copy import urllib from types import TupleType from xml.dom import Node, getDOMImplementation, XMLNS_NAMESPACE from genxmlif import XINC_NAMESPACE, GenXmlIfError from xmlifUtils import nsNameToQName, processWhitespaceAction, collapseString, NsNameTupleFactory, convertToAbsUrl from xmlifBase import XmlIfBuilderExtensionBase from xmlifApi import XmlInterfaceBase class XmlInterfaceDom (XmlInterfaceBase): """Derived interface class for handling of DOM parsers. For description of the interface methods see xmlifbase.py. """ def xInclude (self, elementWrapper, baseUrl, ownerDoc): filePath = elementWrapper.getFilePath() for childElementWrapper in elementWrapper.getChildren(): line = childElementWrapper.getStartLineNumber() if childElementWrapper.getNsName() == (XINC_NAMESPACE, "include"): href = childElementWrapper["href"] parse = childElementWrapper.getAttributeOrDefault ("parse", "xml") encoding = childElementWrapper.getAttribute ("encoding") if self.verbose: print "Xinclude: %s" %href try: if parse == "xml": subTreeWrapper = self.parse (href, baseUrl, ownerDoc) elementWrapper.replaceChildBySubtree (childElementWrapper, subTreeWrapper) elif parse == "text": absUrl = convertToAbsUrl (href, baseUrl) fp = urllib.urlopen (absUrl) data = fp.read() if encoding: data = data.decode(encoding) newTextNode = ownerDoc.xmlIfExtCreateTextNode(data) elementWrapper.element.element.insertBefore (newTextNode, childElementWrapper.element.element) elementWrapper.removeChild (childElementWrapper) fp.close() else: raise GenXmlIfError, "%s: line %s: XIncludeError: Invalid 'parse' Attribut: '%s'" %(filePath, line, parse) except IOError, errInst: raise GenXmlIfError, "%s: line %s: IOError: %s" %(filePath, line, str(errInst)) elif childElementWrapper.getNsName() == (XINC_NAMESPACE, "fallback"): raise GenXmlIfError, "%s: line %s: XIncludeError: xi:fallback tag must be child of xi:include" %(filePath, line) else: self.xInclude(childElementWrapper, baseUrl, ownerDoc) class InternalDomTreeWrapper: """Internal wrapper for a DOM Document class. """ def __init__ (self, document): self.document = document def xmlIfExtGetRootNode (self): domNode = self.document if domNode.nodeType == Node.DOCUMENT_NODE: return domNode.documentElement.xmlIfExtInternalWrapper elif domNode.nodeType == Node.DOCUMENT_FRAGMENT_NODE: for node in domNode.childNodes: if node.nodeType == Node.ELEMENT_NODE: return node.xmlIfExtInternalWrapper else: return None else: return None def xmlIfExtCreateElement (self, nsName, attributeDict, curNs): elementNode = self.document.createElementNS (nsName[0], nsName[1]) intElementWrapper = self.internalElementWrapperClass(elementNode, self) for attrName, attrValue in attributeDict.items(): intElementWrapper.xmlIfExtSetAttribute (NsNameTupleFactory(attrName), attrValue, curNs) return intElementWrapper def xmlIfExtCreateTextNode (self, data): return self.document.createTextNode(data) def xmlIfExtImportNode (self, node): return self.document.importNode (node, 0) def xmlIfExtCloneTree (self, rootElementCopy): domImpl = getDOMImplementation() # documentCopy = domImpl.createDocument(rootElementCopy.xmlIfExtGetNamespaceURI(), rootElementCopy.xmlIfExtGetTagName(), None) documentCopy = domImpl.createDocument(None, None, None) # documentCopy = copy.copy(self.document) documentCopy.documentElement = rootElementCopy.element return self.__class__(documentCopy) ######################################################### # Internal Wrapper class for a Dom Element class class InternalDomElementWrapper: """Internal Wrapper for a Dom Element class. """ def __init__ (self, element, internalDomTreeWrapper): self.element = element element.xmlIfExtInternalWrapper = self self.internalDomTreeWrapper = internalDomTreeWrapper def xmlIfExtUnlink (self): self.xmlIfExtElementWrapper = None def xmlIfExtCloneNode (self): nodeCopy = self.__class__(self.element.cloneNode(deep=0), self.internalDomTreeWrapper) for childTextNode in self.__xmlIfExtGetChildTextNodes(): childTextNodeCopy = childTextNode.cloneNode(0) nodeCopy.element.appendChild (childTextNodeCopy) # for nsAttrName, attrValue in self.xmlIfExtGetAttributeDict().items(): # nodeCopy.xmlIfExtSetAttribute(nsAttrName, attrValue, self.xmlIfExtElementWrapper.getCurrentNamespaces()) return nodeCopy def xmlIfExtGetTagName (self): return self.element.tagName def xmlIfExtGetNamespaceURI (self): return self.element.namespaceURI def xmlIfExtGetParentNode (self): parentNode = self.element.parentNode if parentNode.nodeType == Node.ELEMENT_NODE: return self.element.parentNode.xmlIfExtInternalWrapper else: return None def xmlIfExtSetParentNode (self, parentElement): pass # nothing to do since parent is provided by DOM interface def xmlIfExtGetChildren (self, tagFilter=None): # TODO: Handle also wildcard tagFilter = (namespace, None) children = filter (lambda e: (e.nodeType == Node.ELEMENT_NODE) and # - only ELEMENTs (tagFilter == None or (e.namespaceURI == tagFilter[0] and e.localName == tagFilter[1])), # - if tagFilter given --> check self.element.childNodes ) # from element's nodes return map(lambda element: element.xmlIfExtInternalWrapper, children) def xmlIfExtGetFirstChild (self, tagFilter=None): children = self.xmlIfExtGetChildren (tagFilter) if children != []: return children[0] else: None def xmlIfExtGetElementsByTagName (self, tagFilter=('*','*')): elementList = self.element.getElementsByTagNameNS( tagFilter[0], tagFilter[1] ) return map( lambda element: element.xmlIfExtInternalWrapper, elementList ) def xmlIfExtGetIterator (self, tagFilter=('*','*')): elementList = [] if tagFilter in (('*','*'), (self.element.namespaceURI, self.element.localName)): elementList.append(self.element) elementList.extend(self.element.getElementsByTagNameNS( tagFilter[0], tagFilter[1] )) return map( lambda element: element.xmlIfExtInternalWrapper, elementList ) def xmlIfExtAppendChild (self, childElement): self.element.appendChild (childElement.element) def xmlIfExtInsertBefore (self, childElement, refChildElement): self.element.insertBefore (childElement.element, refChildElement.element) def xmlIfExtRemoveChild (self, childElement): self.element.removeChild (childElement.element) def xmlIfExtInsertSubtree (self, refChildElement, subTree, insertSubTreeRootNode): if insertSubTreeRootNode: childElementList = [subTree.xmlIfExtGetRootNode(),] else: childElementList = subTree.xmlIfExtGetRootNode().xmlIfExtGetChildren() for childElement in childElementList: if refChildElement != None: self.element.insertBefore(childElement.element, refChildElement.element) else: self.element.appendChild(childElement.element) def xmlIfExtGetAttributeDict (self): attribDict = {} for nsAttrName, attrNodeOrValue in self.element.attributes.items(): attribDict[NsNameTupleFactory(nsAttrName)] = attrNodeOrValue.nodeValue return attribDict def xmlIfExtGetAttribute (self, nsAttrName): if self.element.attributes.has_key (nsAttrName): return self.element.getAttributeNS (nsAttrName[0], nsAttrName[1]) elif nsAttrName[1] == "xmlns" and self.element.attributes.has_key(nsAttrName[1]): # workaround for minidom for correct access of xmlns attribute return self.element.getAttribute (nsAttrName[1]) else: return None def xmlIfExtSetAttribute (self, nsAttrName, attributeValue, curNs): if nsAttrName[0] != None: qName = nsNameToQName (nsAttrName, curNs) else: qName = nsAttrName[1] self.element.setAttributeNS (nsAttrName[0], qName, attributeValue) def xmlIfExtRemoveAttribute (self, nsAttrName): self.element.removeAttributeNS (nsAttrName[0], nsAttrName[1]) def xmlIfExtGetElementValueFragments (self, ignoreEmtpyStringFragments): elementValueList = [] for childTextNode in self.__xmlIfExtGetChildTextNodes(): elementValueList.append(childTextNode.data) if ignoreEmtpyStringFragments: elementValueList = filter (lambda s: collapseString(s) != "", elementValueList) if elementValueList == []: elementValueList = ["",] return elementValueList def xmlIfExtGetElementText (self): elementTextList = ["",] if self.element.childNodes != []: for childNode in self.element.childNodes: if childNode.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE): elementTextList.append (childNode.data) else: break return "".join(elementTextList) def xmlIfExtGetElementTailText (self): tailTextList = ["",] nextSib = self.element.nextSibling while nextSib: if nextSib.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE): tailTextList.append (nextSib.data) nextSib = nextSib.nextSibling else: break return "".join(tailTextList) def xmlIfExtSetElementValue (self, elementValue): if self.__xmlIfExtGetChildTextNodes() == []: textNode = self.internalDomTreeWrapper.xmlIfExtCreateTextNode (elementValue) self.element.appendChild (textNode) else: self.__xmlIfExtGetChildTextNodes()[0].data = elementValue if len (self.__xmlIfExtGetChildTextNodes()) > 1: for textNode in self.__xmlIfExtGetChildTextNodes()[1:]: textNode.data = "" def xmlIfExtProcessWsElementValue (self, wsAction): textNodes = self.__xmlIfExtGetChildTextNodes() if len(textNodes) == 1: textNodes[0].data = processWhitespaceAction (textNodes[0].data, wsAction) elif len(textNodes) > 1: textNodes[0].data = processWhitespaceAction (textNodes[0].data, wsAction, rstrip=0) lstrip = 0 if len(textNodes[0].data) > 0 and textNodes[0].data[-1] == " ": lstrip = 1 for textNode in textNodes[1:-1]: textNode.data = processWhitespaceAction (textNode.data, wsAction, lstrip, rstrip=0) if len(textNode.data) > 0 and textNode.data[-1] == " ": lstrip = 1 else: lstrip = 0 textNodes[-1].data = processWhitespaceAction (textNodes[-1].data, wsAction, lstrip) ############################################################### # PRIVATE methods ############################################################### def __xmlIfExtGetChildTextNodes ( self ): """Return list of TEXT nodes.""" return filter (lambda e: ( e.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE) ), # - only TEXT-NODES self.element.childNodes) # from element's child nodes class XmlIfBuilderExtensionDom (XmlIfBuilderExtensionBase): """XmlIf builder extension class for DOM parsers.""" pass