diff -r 000000000000 -r b622defdfd98 minixsv/xsvalBase.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/minixsv/xsvalBase.py Wed Jan 31 16:31:39 2007 +0100 @@ -0,0 +1,602 @@ +# +# minixsv, Release 0.3 +# file: xsvalBase.py +# +# XML schema validator base class +# +# history: +# 2004-10-07 rl created +# +# Copyright (c) 2004 by Roland Leuthe. All rights reserved. +# +# -------------------------------------------------------------------- +# The minixsv XML schema validator is +# +# Copyright (c) 2004 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. +# -------------------------------------------------------------------- + +from xsvalErrorHandler import * +import xsvalSimpleTypes + +########################################################### +# Validator class for validating one input file against one XML schema file + +class XsValBase: + + def __init__(self, xmlIf, errorHandler): + self.xmlIf = xmlIf + self.errorHandler = errorHandler + + self._raiseError = self.errorHandler.raiseError + self._addError = self.errorHandler.addError + self._addWarning = self.errorHandler.addWarning + + self.checkKeyrefList = [] + + + ######################################## + # validate inputTree against xsdTree + # + def validate (self, inputTree, xsdTree): + self.inputTree = inputTree + self.xsdTree = xsdTree + + self.xsdRoot = self.xsdTree.getRootNode() + self.xsdNSAlias = self.xmlIf.extractNamespaceAlias(self.xsdRoot.getTagName()) + self.inputRoot = self.inputTree.getRootNode() + self.inputNSAlias = self.xmlIf.extractNamespaceAlias(self.inputRoot.getTagName()) + + self.simpleTypeVal = xsvalSimpleTypes.XsSimpleTypeVal(self) + + self._setupLookupTables() + + inputRootTagName = self.inputRoot.getTagName() + inputRootLocalName = self.inputRoot.getLocalName() + if self.xsdElementDict.has_key(inputRootLocalName): + # start recursive schema validation + try: + self._checkElementTag (self.xsdElementDict[inputRootLocalName], inputRootTagName, (self.inputRoot,), 0) + except TagException, errInst: + self._addError (errInst.errstr, errInst.node, errInst.endTag) + + # validate keyrefs + for inputElement, keyrefNode in self.checkKeyrefList: + self._checkKeyRefConstraint (keyrefNode, inputElement) + else: + self._raiseError ("Used root tag %s not found in schema file!" %(inputRootTagName), self.inputRoot) + + + ######################################## + # setup lookup dictionaries used during validation + # + def _setupLookupTables (self): + # retrieve all elements + self.xsdElementDict = {} + for xsdTypeNode in self.xsdRoot.getChildrenNS(self.xsdNSAlias, "element"): + self.xsdElementDict[xsdTypeNode.getAttribute("name")] = xsdTypeNode + + # retrieve all type definitions (complex and simple types) + self.xsdTypeDict = {} + for xsdTypeNode in self.xsdRoot.getChildrenNS(self.xsdNSAlias, "complexType"): + self.xsdTypeDict[xsdTypeNode.getAttribute("name")] = xsdTypeNode + + for xsdTypeNode in self.xsdRoot.getChildrenNS(self.xsdNSAlias, "simpleType"): + self.xsdTypeDict[xsdTypeNode.getAttribute("name")] = xsdTypeNode + + # retrieve all group definitions + self.xsdGroupDict = {} + for xsdTypeNode in self.xsdRoot.getChildrenNS(self.xsdNSAlias, "group"): + self.xsdGroupDict[xsdTypeNode.getAttribute("name")] = xsdTypeNode + + # retrieve all attribute group definitions + self.xsdAttributeGroupDict = {} + for xsdTypeNode in self.xsdRoot.getChildrenNS(self.xsdNSAlias, "attributeGroup"): + self.xsdAttributeGroupDict[xsdTypeNode.getAttribute("name")] = xsdTypeNode + + # retrieve all identity constraints + self.xsdIdentityConstrDict = {} + for identConstrTagName in ("unique", "key", "keyref"): + identConstrNodeList = self.xsdRoot.getElementsByTagNameNS (self.xsdNSAlias, identConstrTagName) + for identConstrNode in identConstrNodeList: + identConstrName = identConstrNode.getAttribute("name") + if not self.xsdIdentityConstrDict.has_key(identConstrName): + self.xsdIdentityConstrDict[identConstrName] = {"Node": identConstrNode, "ValueDict":{}} + else: + self._raiseError ("Duplicate identity constraint name '%s' found in schema definition!" %(identConstrName), identConstrNode) + + + ######################################## + # validate inputElement against complexType node + # + def _checkComplexTypeTag (self, xsdParentElementNode, xsdElement, inputElement, inputElementChildIndex, usedAsBaseType=None): + baseTypeAttributes = {"__SPECIAL_ATTRS__":{}} + if xsdParentElementNode.getAttribute ("nillable") == "true": + baseTypeAttributes["__SPECIAL_ATTRS__"]["nil"] = "xsd:boolean" + + complexContentElement = xsdElement.getFirstChildNS(self.xsdNSAlias, "complexContent") + if complexContentElement != None: + inputElementChildIndex, baseTypeAttributes = self._checkComplexContentTag (xsdParentElementNode, complexContentElement, inputElement, inputElementChildIndex, usedAsBaseType, baseTypeAttributes) + else: + inputElementChildIndex, baseTypeAttributes = self._checkComplexTypeContent (xsdElement, inputElement, inputElementChildIndex, usedAsBaseType, baseTypeAttributes) + return inputElementChildIndex, baseTypeAttributes + + def _checkComplexContentTag (self, xsdParentElementNode, xsdElement, inputElement, inputElementChildIndex, usedAsBaseType, baseTypeAttributes): + extensionElement = xsdElement.getFirstChildNS(self.xsdNSAlias, "extension") + if extensionElement != None: + inputElementChildIndex, baseTypeAttributes = self._checkExtensionComplexContent (xsdParentElementNode, extensionElement, inputElement, inputElementChildIndex, usedAsBaseType, baseTypeAttributes) + else: + restrictionElement = xsdElement.getFirstChildNS(self.xsdNSAlias, "restriction") + if restrictionElement != None: + inputElementChildIndex, baseTypeAttributes = self._checkRestrictionComplexContent (xsdParentElementNode, restrictionElement, inputElement, inputElementChildIndex, usedAsBaseType, baseTypeAttributes) + return inputElementChildIndex, baseTypeAttributes + + def _checkExtensionComplexContent (self, xsdParentElementNode, xsdElement, inputElement, inputElementChildIndex, usedAsBaseType, baseTypeAttributes): + baseType = self.xmlIf.extractLocalName(xsdElement.getAttribute("base")) + inputElementChildIndex, baseTypeAttributes = self._checkComplexTypeTag (xsdParentElementNode, self.xsdTypeDict[baseType], inputElement, inputElementChildIndex, "extension") + + inputElementChildIndex, baseTypeAttributes = self._checkComplexTypeContent (xsdElement, inputElement, inputElementChildIndex, usedAsBaseType, baseTypeAttributes) + return inputElementChildIndex, baseTypeAttributes + + def _checkRestrictionComplexContent (self, xsdParentElementNode, xsdElement, inputElement, inputElementChildIndex, usedAsBaseType, baseTypeAttributes): + # first check against base type (retrieve only the base type attributes) + baseType = self.xmlIf.extractLocalName(xsdElement.getAttribute("base")) + inputElementChildIndex, baseTypeAttributes = self._checkComplexTypeTag (xsdParentElementNode, self.xsdTypeDict[baseType], inputElement, inputElementChildIndex, "restriction") + + # then check input against derived complex type + inputElementChildIndex, baseTypeAttributes = self._checkComplexTypeContent (xsdElement, inputElement, inputElementChildIndex, usedAsBaseType, baseTypeAttributes) + return inputElementChildIndex, baseTypeAttributes + + def _checkComplexTypeContent (self, xsdElement, inputElement, inputElementChildIndex, usedAsBaseType, baseTypeAttributes): + inputTagName = inputElement.getTagName() + childTags = inputElement.getChildren() + if usedAsBaseType in (None, "extension"): + validChildTags = xsdElement.getChildren() + for validChildTag in validChildTags: + if validChildTag.getLocalName() not in ("attribute", "attributeGroup", "anyAttribute"): + inputElementChildIndex = self._checkParticle (validChildTag, inputElement, childTags, inputElementChildIndex) + + if usedAsBaseType == None and inputElementChildIndex < len (childTags): + self._addError ("Unexpected child tag '%s' in tag '%s' found!" %(childTags[inputElementChildIndex].getTagName(), inputTagName), childTags[inputElementChildIndex]) + + if usedAsBaseType in (None,): + self._checkAttributeTags (xsdElement, inputElement, baseTypeAttributes) + + if usedAsBaseType in ("restriction", "extension"): + validAttributes = xsdElement.getChildrenNS(self.xsdNSAlias, "attribute") + for validAttrGroup in xsdElement.getChildrenNS(self.xsdNSAlias, "attributeGroup"): + attributeGroupRef = self.xmlIf.extractLocalName(validAttrGroup.getAttribute("ref")) + validAttributes.extend (self.xsdAttributeGroupDict[attributeGroupRef].getChildrenNS(self.xsdNSAlias, "attribute")) + for validAttribute in validAttributes: + baseTypeAttributes[validAttribute.getAttribute("name")] = validAttribute + return inputElementChildIndex, baseTypeAttributes + + + ######################################## + # validate inputNodeList against xsdNode + # + def _checkList (self, elementMethod, xsdNode, inputParentNode, inputNodeList, currIndex): + if not xsdNode.hasAttribute("minOccurs"): + xsdNode.setAttribute("minOccurs", "1") # default + if not xsdNode.hasAttribute("maxOccurs"): + xsdNode.setAttribute("maxOccurs", "1") # default + + minOccurs = string.atoi(xsdNode.getAttribute("minOccurs")) + maxOccurs = -1 + if xsdNode.getAttribute("maxOccurs") != "unbounded": + maxOccurs = string.atoi(xsdNode.getAttribute("maxOccurs")) + occurs = 0 + while maxOccurs == -1 or occurs < maxOccurs: + try: + newIndex = elementMethod (xsdNode, inputParentNode, inputNodeList, currIndex) + occurs += 1 + if newIndex > currIndex: + currIndex = newIndex + else: + break # no suitable element found + except TagException, errInst: + break + + if occurs == 0 and minOccurs > 0: + raise errInst + elif occurs < minOccurs: + expInputTagName = xsdNode.getAttribute("name") + if expInputTagName == None: + expInputTagName = self.xmlIf.extractLocalName(xsdNode.getAttribute("ref")) + + errInst.errstr = "Minimum number (%d) of child tags '%s' in tag '%s' not available (only %d)!" %(minOccurs, expInputTagName, inputParentNode.getTagName(), occurs) + raise errInst + + return currIndex + + ######################################## + # validate inputNode against element node + # + def _checkElementTag (self, xsdNode, inputParentNode, inputNodeList, currIndex): + if xsdNode.hasAttribute("ref"): + refAttr = self.xmlIf.extractLocalName(xsdNode.getAttribute("ref")) + currIndex = self._checkElementTag (self.xsdElementDict[refAttr], inputParentNode, inputNodeList, currIndex) + + else: + nameAttr = xsdNode.getAttribute ("name") + if currIndex >= len (inputNodeList): + raise TagException ("Missing child tag '%s' in tag '%s'!" %(nameAttr, inputParentNode.getTagName()), inputParentNode, 1) + + inputNode = inputNodeList[currIndex] + if nameAttr != inputNode.getLocalName(): + raise TagException ("Missing child tag '%s' in tag '%s'!" %(nameAttr, inputParentNode.getTagName()), inputNode, 0) + + simpleType = None + complexTypeNode = xsdNode.getFirstChildNS (self.xsdNSAlias, "complexType") + simpleTypeNode = xsdNode.getFirstChildNS (self.xsdNSAlias, "simpleType") + if xsdNode.hasAttribute("type"): + typeAttr = xsdNode.getAttribute ("type") + localTypeAttr = self.xmlIf.extractLocalName(typeAttr) + if self.xsdTypeDict.has_key (localTypeAttr) and self.xsdTypeDict[localTypeAttr].getLocalName() == "complexType": + complexTypeNode = self.xsdTypeDict[localTypeAttr] + else: + simpleType = typeAttr + + if complexTypeNode != None: + try: + self._checkComplexTypeTag (xsdNode, complexTypeNode, inputNode, 0) + except TagException, errInst: + self._addError (errInst.errstr, errInst.node, errInst.endTag) + else: + try: + simpleTypeReturnDict = {} + if simpleTypeNode != None: + self.simpleTypeVal.checkSimpleTypeDef (simpleTypeNode, inputNode.getTagName(), inputNode.getElementValue(), simpleTypeReturnDict) + elif simpleType != None: + self.simpleTypeVal.checkSimpleType (inputNode.getTagName(), simpleType, inputNode.getElementValue(), simpleTypeReturnDict) + # TODO: What to check if np type is specified for the element? + + if simpleTypeReturnDict.has_key("adaptedAttrValue"): + inputNode.setElementValue(simpleTypeReturnDict["adaptedAttrValue"]) + + except xsvalSimpleTypes.SimpleTypeError, errstr: + self._addError (str(errstr), inputNode) + + currIndex += 1 + + # check unique attributes and keys + childUniqueDefList = xsdNode.getChildrenNS (self.xsdNSAlias, "unique") + for childUniqueDef in childUniqueDefList: + self._checkIdentityConstraint (childUniqueDef, inputNode, "unique") + + childKeyDefList = xsdNode.getChildrenNS (self.xsdNSAlias, "key") + for childKeyDef in childKeyDefList: + self._checkIdentityConstraint (childKeyDef, inputNode, "key") + + childKeyrefDefList = xsdNode.getChildrenNS (self.xsdNSAlias, "keyref") + for childKeyrefDef in childKeyrefDefList: + self.checkKeyrefList.append ((inputNode, childKeyrefDef)) + + return currIndex + + + ######################################## + # validate inputNode against sequence node + # + def _checkSequenceTag (self, xsdNode, inputParentNode, inputNodeList, currIndex): + for xsdChildNode in xsdNode.getChildren(): + currIndex = self._checkParticle (xsdChildNode, inputParentNode, inputNodeList, currIndex) + return currIndex + + ######################################## + # validate inputNode against choice node + # + def _checkChoiceTag (self, xsdNode, inputParentNode, inputNodeList, currIndex): + for xsdChildNode in xsdNode.getChildren(): + try: + currIndex = self._checkParticle (xsdChildNode, inputParentNode, inputNodeList, currIndex) + break + except TagException, errInst: + pass + else: + if currIndex < len(inputNodeList): + currNode = inputNodeList[currIndex] + endTag = 0 + else: + currNode = inputParentNode + endTag = 1 + raise TagException ("No suitable child tag for choice found!", currNode, endTag) + + return currIndex + + ######################################## + # validate inputNode against group node + # + def _checkGroupTag (self, xsdNode, inputParentNode, inputNodeList, currIndex): + if xsdNode.hasAttribute("ref"): + refAttr = self.xmlIf.extractLocalName(xsdNode.getAttribute("ref")) + currIndex = self._checkGroupTag (self.xsdGroupDict[refAttr], inputParentNode, inputNodeList, currIndex) + else: + for xsdChildNode in xsdNode.getChildren(): + currIndex = self._checkParticle (xsdChildNode, inputParentNode, inputNodeList, currIndex) + return currIndex + + ######################################## + # validate inputNode against all node + # + def _checkAllTag (self, xsdNode, inputParentNode, inputNodeList, currIndex): + oldIndex = currIndex + xsdChildDict = {} + for xsdChildNode in xsdNode.getChildren(): + xsdChildDict[xsdChildNode] = 0 + while currIndex < len(inputNodeList): + currNode = inputNodeList[currIndex] + for xsdChildNode in xsdChildDict.keys(): + try: + newIndex = self._checkParticle (xsdChildNode, inputParentNode, inputNodeList, currIndex) + except TagException, errInst: + continue + + if xsdChildDict[xsdChildNode] == 0: + xsdChildDict[xsdChildNode] = 1 + currIndex = newIndex + break + else: + raise TagException ("Ambiguous child tag '%s' found in all-group!" %(currNode.getTagName()), currNode) + else: + raise TagException ("Unexpected child tag '%s' for all-group found!" %(currNode.getTagName()), currNode) + + for xsdChildNode, occurs in xsdChildDict.items(): + if xsdChildNode.getAttribute("minOccurs") != "0" and occurs == 0: + raise TagException ("Child tag '%s' missing in all-group (%s)" %(xsdChildNode.getAttribute("name"), inputParentNode.getTagName()), inputNodeList[oldIndex]) + + return currIndex + + + ######################################## + # validate inputNode against any node + # + def _checkAnyTag (self, xsdNode, inputParentNode, inputNodeList, currIndex): + processContents = xsdNode.getAttribute("processContents") + if processContents == "skip": + pass + elif processContents == "lax": + # TODO: Was muss hier gecheckt werden? + pass + elif processContents == "strict": + # TODO: Was muss hier gecheckt werden? + pass + + if currIndex < len(inputNodeList): + currIndex = currIndex + 1 + + return currIndex + + ######################################## + # validate inputNode against particle + # + def _checkParticle (self, xsdNode, inputParentNode, inputNodeList, currIndex): + xsdTagName = xsdNode.getTagName() + if xsdTagName == self.xsdNSAlias + "element": + currIndex = self._checkList (self._checkElementTag, xsdNode, inputParentNode, inputNodeList, currIndex) + elif xsdTagName == self.xsdNSAlias + "choice": + currIndex = self._checkList (self._checkChoiceTag, xsdNode, inputParentNode, inputNodeList, currIndex) + elif xsdTagName == self.xsdNSAlias + "sequence": + currIndex = self._checkList (self._checkSequenceTag, xsdNode, inputParentNode, inputNodeList, currIndex) + elif xsdTagName == self.xsdNSAlias + "group": + currIndex = self._checkList (self._checkGroupTag, xsdNode, inputParentNode, inputNodeList, currIndex) + elif xsdTagName == self.xsdNSAlias + "all": + currIndex = self._checkList (self._checkAllTag, xsdNode, inputParentNode, inputNodeList, currIndex) + elif xsdTagName == self.xsdNSAlias + "any": + currIndex = self._checkList (self._checkAnyTag, xsdNode, inputParentNode, inputNodeList, currIndex) + elif xsdTagName == self.xsdNSAlias + "annotation": + pass # nothing to check + else: + self._addError ("Internal error: Invalid tag %s found!" %(xsdTagName)) + return currIndex + + + ######################################## + # validate attributes of inputNode against complexType node + # + def _checkAttributeTags (self, xsdNode, inputNode, validAttrDict): + validAttributes = xsdNode.getChildrenNS(self.xsdNSAlias, "attribute") + for validAttrGroup in xsdNode.getChildrenNS(self.xsdNSAlias, "attributeGroup"): + attributeGroupRef = self.xmlIf.extractLocalName(validAttrGroup.getAttribute("ref")) + validAttributes.extend (self.xsdAttributeGroupDict[attributeGroupRef].getChildrenNS(self.xsdNSAlias, "attribute")) + for validAttribute in validAttributes: + if validAttribute.hasAttribute("name"): + keyAttr = validAttribute.getAttribute("name") + else: + keyAttr = self.xmlIf.extractLocalName(validAttribute.getAttribute("ref")) + validAttrDict[keyAttr] = validAttribute + + inputAttrDict = {} + for iAttrName, iAttrValue in inputNode.getAttributeDict().items(): + if self.xmlIf.extractNamespaceAlias (iAttrName) != "xmlns:" and iAttrName != "xmlns": + inputAttrDict[self.xmlIf.extractLocalName(iAttrName)] = iAttrValue + + for attrKey, validAttribute in validAttrDict.items(): + # handle special attributes, e.g. xsi:nil + if attrKey == "__SPECIAL_ATTRS__": + for specialAttrName, specialAttrType in validAttribute.items(): + if inputAttrDict.has_key(specialAttrName): + simpleTypeReturnDict = {} + try: + self.simpleTypeVal.checkSimpleType (specialAttrName, specialAttrType, inputAttrDict[specialAttrName], simpleTypeReturnDict) + except xsvalSimpleTypes.SimpleTypeError, errstr: + self._addError (str(errstr), inputNode) + + del inputAttrDict[specialAttrName] + continue + + attrDict = validAttribute.getAttributeDict() + if attrDict.has_key("ref"): + # TODO: What to do here?? + attrRef = self.xmlIf.extractLocalName(attrDict["ref"]) + if inputAttrDict.has_key(attrRef): + del inputAttrDict[attrRef] + else: + attrName = attrDict["name"] + if not attrDict.has_key("use"): + attrDict["use"] = "optional" + + if inputAttrDict.has_key(attrName): + del inputAttrDict[attrName] + else: + if attrDict["use"] == "required": + self._addError ("Attribute '%s' is missing for tag %s!" %(attrName, inputNode.getTagName()), inputNode) + elif attrDict["use"] == "optional": + if attrDict.has_key("default"): + inputNode.setAttribute(attrName, attrDict["default"]) + if attrDict.has_key("fixed"): + if inputNode.getAttribute(attrName) != attrDict["fixed"]: + self._addError ("Attribute '%s' must have fixed value '%s'!" %(attrName, attrDict["fixed"]), inputNode) + + if inputNode.hasAttribute(attrName): + if attrDict["use"] == "prohibited": + self._addError ("Attribute '%s' is prohibited in this context!" %(attrName), inputNode) + else: + attributeValue = inputNode.getAttribute(attrName) + try: + simpleTypeReturnDict = {} + if attrDict.has_key("type"): + self.simpleTypeVal.checkSimpleType (attrName, attrDict["type"], attributeValue, simpleTypeReturnDict) + else: + typedefNode = validAttribute.getFirstChildNS(self.xsdNSAlias, "simpleType") + if typedefNode != None: + self.simpleTypeVal.checkSimpleTypeDef (typedefNode, attrName, attributeValue, simpleTypeReturnDict) + else: + pass # default if no type attribute is specified + + if simpleTypeReturnDict.has_key("adaptedAttrValue"): + inputNode.setAttribute(attrName, simpleTypeReturnDict["adaptedAttrValue"]) + + except xsvalSimpleTypes.SimpleTypeError, errstr: + self._addError (str(errstr), inputNode) + + for inputAttribute in inputAttrDict.keys(): + # TODO: adapt for using namespaces!! + if self.xmlIf.extractLocalName(inputAttribute) in ("noNamespaceSchemaLocation", "schemaLocation"): + del inputAttrDict[inputAttribute] + + for inputAttribute in inputAttrDict.keys(): + if inputAttribute == "nil": + self._addError ("Tag '%s' hasn't been defined as nillable!" %(inputNode.getTagName()), inputNode) + else: + self._addError ("Unexpected attribute '%s' in Tag '%s'!" %(inputAttribute, inputNode.getTagName()), inputNode) + + + ######################################## + # validate unique and key definition + # + def _checkIdentityConstraint (self, identityConstrNode, inputElement, isKey): + identConstrName = identityConstrNode.getAttribute ("name") + selectorXPathNode = identityConstrNode.getFirstChildNS (self.xsdNSAlias, "selector") + selectorNodeList, dummy = self._getXPath (inputElement, selectorXPathNode.getAttribute("xpath"), self.inputNSAlias) + + valueDict = {} + for selectorNode in selectorNodeList: + fieldXPathNodeList = identityConstrNode.getChildrenNS (self.xsdNSAlias, "field") + keyValue = [] + for fieldXPathNode in fieldXPathNodeList: + fieldXPath = fieldXPathNode.getAttribute("xpath") + fieldNodeList, fieldAttributeList = self._getXPath (selectorNode, fieldXPath, self.inputNSAlias, isKey) + if len(fieldNodeList) > 1 or len(fieldAttributeList) > 1: + self._addError ("The field xPath of identity constraint '%s' must evaluate to exactly 0 or 1 node!" %(identConstrName), fieldXPathNode) + return + + # TODO: unique and key check currently only on string base + for fieldNode in fieldNodeList: + keyValue.append (fieldNode.getElementValue ()) + + for attrValue in fieldAttributeList: + keyValue.append (attrValue) + + if keyValue != []: + keyValue = tuple(keyValue) + if not valueDict.has_key (keyValue): + valueDict[keyValue] = 1 + self.xsdIdentityConstrDict[identConstrName]["ValueDict"][keyValue] = 1 + else: + self._addError ("Duplicate identity constraint values '%s' found for identity contraint '%s'!" %(keyValue, identConstrName), selectorNode) + + ######################################## + # validate unique and key definition + # + def _checkKeyRefConstraint (self, keyrefNode, inputElement): + keyRefName = keyrefNode.getAttribute ("name") + keyReference = keyrefNode.getAttribute ("refer") + if not self.xsdIdentityConstrDict.has_key (keyReference): + self._addError ("keyref refers unknown key '%s'!" %(keyReference), keyrefNode) + return + + selectorXPathNode = keyrefNode.getFirstChildNS (self.xsdNSAlias, "selector") + selectorNodeList, dummy = self._getXPath (inputElement, selectorXPathNode.getAttribute("xpath"), self.inputNSAlias) + + for selectorNode in selectorNodeList: + fieldXPathNodeList = keyrefNode.getChildrenNS(self.xsdNSAlias, "field") + keyValue = [] + for fieldXPathNode in fieldXPathNodeList: + fieldXPath = fieldXPathNode.getAttribute("xpath") + fieldNodeList, fieldAttributeList = self._getXPath (selectorNode, fieldXPath, self.inputNSAlias, "keyref") + if len(fieldNodeList) > 1 or len(fieldAttributeList) > 1: + self._addError ("The field xPath of keyref '%s' must evaluate to exactly 0 or 1 node!" %(keyRefName), fieldXPathNode) + return + + # TODO: unique and key check currently only on string base + for fieldNode in fieldNodeList: + keyValue.append(fieldNode.getElementValue()) + + for attrValue in fieldAttributeList: + keyValue.append(attrValue) + + keyValue = tuple(keyValue) + if not self.xsdIdentityConstrDict[keyReference]["ValueDict"].has_key (keyValue): + self._addError ("Element value '%s' does not match key type '%s'!" %(keyValue, keyReference), selectorNode) + + ######################################## + # retrieve nodes/attributes specified by given xPath + # + def _getXPath (self, node, xPath, defaultNamespace, identityConstraint=None): + try: + nodeList, attributeList = node.getXPathList (xPath, defaultNamespace) + except IOError, errstr: + self._addError (errstr, node) + nodeList = attributeList = [] + + if nodeList == [] and attributeList == []: + if identityConstraint == "key": + self.errorHandler.addError ("Key is missing! XPath = '%s'!" %(xPath), node) + elif identityConstraint in ("unique", "keyref"): + self.errorHandler.addWarning ("Identity constraint is missing! XPath = '%s'!" %(xPath), node) + + return nodeList, attributeList + + +######################################## +# define own exception for XML schema validation errors +# +class TagException (StandardError): + def __init__ (self, errstr="", node=None, endTag=0): + self.node = node + self.errstr = errstr + self.endTag = endTag + StandardError.__init__(self) +