1

#

     2

# # minixsv, Release 0.3

     3

# file: xsvalSimpleTypes.py

     4

#

     5

# class for validation of XML schema simple types

     6

#

     7

# history:

     8

# 2004-09-09 rl   created

     9

#

    10

# Copyright (c) 2004 by Roland Leuthe.  All rights reserved.

    11

#

    12

# --------------------------------------------------------------------

    13

# The minixsv XML schema validator is

    14

#

    15

# Copyright (c) 2004 by Roland Leuthe

    16

#

    17

# By obtaining, using, and/or copying this software and/or its

    18

# associated documentation, you agree that you have read, understood,

    19

# and will comply with the following terms and conditions:

    20

#

    21

# Permission to use, copy, modify, and distribute this software and

    22

# its associated documentation for any purpose and without fee is

    23

# hereby granted, provided that the above copyright notice appears in

    24

# all copies, and that both that copyright notice and this permission

    25

# notice appear in supporting documentation, and that the name of

    26

# the author not be used in advertising or publicity

    27

# pertaining to distribution of the software without specific, written

    28

# prior permission.

    29

#

    30

# THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

    31

# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-

    32

# ABILITY AND FITNESS.  IN NO EVENT SHALL THE AUTHOR

    33

# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY

    34

# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

    35

# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS

    36

# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

    37

# OF THIS SOFTWARE.

    38

# --------------------------------------------------------------------

    39

    40

    41

import sys

    42

import string

    43

import re

    44

    45

    46

class XsSimpleTypeVal:

    47

    48

    def __init__ (self, parent):

    49

        self.parent = parent

    50

        self.xmlIf  = parent.xmlIf

    51

        self.xsdNSAlias = parent.xsdNSAlias

    52

        self.xsdTree    = parent.xsdTree

    53

    54

    55

    ########################################

    56

    # validate given value against simpleType

    57

    #

    58

    def checkSimpleType (self, attrName, typeName, attributeValue, returnDict):

    59

        localTypeName = self.xmlIf.extractLocalName(typeName)

    60

        if self.parent.xsdTypeDict.has_key(localTypeName):

    61

            typedefNode = self.parent.xsdTypeDict[localTypeName]

    62

            if typedefNode.getTagName () == self.xsdNSAlias + "simpleType":

    63

                self.checkSimpleTypeDef (typedefNode, attrName, attributeValue, returnDict)

    64

            else:

    65

                raise SimpleTypeError("Type '%s' must be simple type!" %(typeName))

    66

        else:

    67

            try:

    68

                validateBaseType (typeName, attributeValue, returnDict)

    69

            except BaseTypeError, errstr:

    70

                raise SimpleTypeError("Value of '%s' (%s) %s" %(attrName, attributeValue, errstr))

    71

    72

    73

    ########################################

    74

    # validate given value against simpleType node

    75

    #

    76

    def checkSimpleTypeDef (self, xsdElement, attrName, attributeValue, returnDict):

    77

        restrictionElement = xsdElement.getFirstChildNS(self.xsdNSAlias, "restriction")

    78

        listElement        = xsdElement.getFirstChildNS(self.xsdNSAlias, "list")

    79

        unionElement       = xsdElement.getFirstChildNS(self.xsdNSAlias, "union")

    80

        if restrictionElement != None:

    81

            self._checkRestrictionTag (restrictionElement, attrName, attributeValue, returnDict)

    82

        elif listElement != None:

    83

            self._checkListTag (listElement, attrName, attributeValue, returnDict)

    84

        elif unionElement != None:

    85

            self._checkUnionTag (unionElement, attrName, attributeValue, returnDict)

    86

    87

    ########################################

    88

    # validate given value against restriction node

    89

    #

    90

    def _checkRestrictionTag (self, xsdElement, attrName, attributeValue, returnDict):

    91

        # first check against base type

    92

        baseType = xsdElement.getAttribute("base")

    93

        if baseType != None:

    94

            self.checkSimpleType (attrName, baseType, attributeValue, returnDict)

    95

        else:

    96

            baseTypeNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "simpleType")

    97

            self.checkSimpleTypeDef (baseTypeNode, attrName, attributeValue, returnDict)

    98

    99

        minExcl = xsdElement.getFirstChildNS(self.xsdNSAlias, "minExclusive")

   100

        minIncl = xsdElement.getFirstChildNS(self.xsdNSAlias, "minInclusive")

   101

        maxExcl = xsdElement.getFirstChildNS(self.xsdNSAlias, "maxExclusive")

   102

        maxIncl = xsdElement.getFirstChildNS(self.xsdNSAlias, "maxInclusive")

   103

   104

        if minExcl != None:

   105

            minExclReturnDict = {}

   106

            minExclValue = minExcl.getAttribute("value")

   107

            self.checkSimpleType (attrName, baseType, minExclValue, minExclReturnDict)

   108

            if returnDict.has_key("orderedValue") and minExclReturnDict.has_key("orderedValue"):

   109

                if returnDict["orderedValue"] <= minExclReturnDict["orderedValue"]:

   110

                    raise SimpleTypeError ("Value of %s (%s) is <= minExclusive (%s)" %(attrName, attributeValue, minExclValue))

   111

        elif minIncl != None:

   112

            minInclReturnDict = {}

   113

            minInclValue = minIncl.getAttribute("value")

   114

            self.checkSimpleType (attrName, baseType, minInclValue, minInclReturnDict)

   115

            if returnDict.has_key("orderedValue") and minInclReturnDict.has_key("orderedValue"):

   116

                if returnDict["orderedValue"] < minInclReturnDict["orderedValue"]:

   117

                    raise SimpleTypeError ("Value of %s (%s) is < minInclusive (%s)" %(attrName, attributeValue, minInclValue))

   118

        if maxExcl != None:

   119

            maxExclReturnDict = {}

   120

            maxExclValue = maxExcl.getAttribute("value")

   121

            self.checkSimpleType (attrName, baseType, maxExclValue, maxExclReturnDict)

   122

            if returnDict.has_key("orderedValue") and maxExclReturnDict.has_key("orderedValue"):

   123

                if returnDict["orderedValue"] >= maxExclReturnDict["orderedValue"]:

   124

                    raise SimpleTypeError ("Value of %s (%s) is >= maxExclusive (%s)" %(attrName, attributeValue, maxExclValue))

   125

        elif maxIncl != None:

   126

            maxInclReturnDict = {}

   127

            maxInclValue = maxIncl.getAttribute("value")

   128

            self.checkSimpleType (attrName, baseType, maxInclValue, maxInclReturnDict)

   129

            if returnDict.has_key("orderedValue") and maxInclReturnDict.has_key("orderedValue"):

   130

                if returnDict["orderedValue"] > maxInclReturnDict["orderedValue"]:

   131

                    raise SimpleTypeError ("Value of %s (%s) is > maxInclusive (%s)" %(attrName, attributeValue, maxInclValue))

   132

   133

        totalDigitsNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "totalDigits")

   134

        if totalDigitsNode != None:

   135

            totalDigitsValue = totalDigitsNode.getAttribute("value")

   136

            if totalDigitsNode.getAttribute("fixed") == "true":

   137

                if len(re.findall("\d" ,attributeValue)) != string.atoi(totalDigitsValue):

   138

                    raise SimpleTypeError ("Total number of digits != %s for %s (%s)" %(totalDigitsValue, attrName, attributeValue))

   139

            else:

   140

                if len(re.findall("\d" ,attributeValue)) > string.atoi(totalDigitsValue):

   141

                    raise SimpleTypeError ("Total number of digits > %s for %s (%s)" %(totalDigitsValue, attrName, attributeValue))

   142

        fractionDigitsNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "fractionDigits")

   143

        if fractionDigitsNode != None:

   144

            fractionDigitsValue = fractionDigitsNode.getAttribute("value")

   145

            result = re.search("(?P<intDigits>\d+)(?P<dot>\.)(?P<fracDigits>\d+)" ,attributeValue)

   146

            if result != None:

   147

                numberOfFracDigits = len (result.group('fracDigits'))

   148

            else:

   149

                numberOfFracDigits = 0

   150

            if fractionDigitsNode.getAttribute("fixed") == "true" and numberOfFracDigits != string.atoi(fractionDigitsValue):

   151

                raise SimpleTypeError ("Fraction number of digits != %s for %s (%s)" %(fractionDigitsValue, attrName, attributeValue))

   152

            elif numberOfFracDigits > string.atoi(fractionDigitsValue):

   153

                raise SimpleTypeError ("Fraction number of digits > %s for %s (%s)" %(fractionDigitsValue, attrName, attributeValue))

   154

   155

        if returnDict.has_key("length"):            

   156

            lengthNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "length")

   157

            if lengthNode != None:

   158

                length = string.atoi(lengthNode.getAttribute("value"))

   159

                if returnDict["length"] != length:

   160

                    raise SimpleTypeError ("Length of %s (%s) must be %d!" %(attrName, attributeValue, length))

   161

            minLengthNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "minLength")

   162

            if minLengthNode != None:

   163

                minLength = string.atoi(minLengthNode.getAttribute("value"))

   164

                if returnDict["length"] < minLength:

   165

                    raise SimpleTypeError ("Length of %s (%s) must be >= %d!" %(attrName, attributeValue, minLength))

   166

            maxLengthNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "maxLength")

   167

            if maxLengthNode != None:

   168

                maxLength = string.atoi(maxLengthNode.getAttribute("value"))

   169

                if returnDict["length"] > maxLength:

   170

                    raise SimpleTypeError ("Length of %s (%s) must be <= %d!" %(attrName, attributeValue, maxLength))

   171

   172

        enumerationElementList = xsdElement.getChildrenNS(self.xsdNSAlias, "enumeration")

   173

        if enumerationElementList != []:

   174

            for enumeration in enumerationElementList:

   175

                if enumeration.getAttribute ("value") == attributeValue:

   176

                    break

   177

            else:

   178

                raise SimpleTypeError ("Enumeration value '%s' not allowed!" %(attributeValue))

   179

   180

        patternNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "pattern")

   181

        if patternNode != None:

   182

            rePattern = patternNode.getAttribute("value")

   183

            regexObj = re.match(rePattern, attributeValue)

   184

            if not regexObj or regexObj.end() != len(attributeValue):

   185

                raise SimpleTypeError ("Attribute value '%s' does not match pattern '%s'!" %(attributeValue, rePattern))                        

   186

   187

        whiteSpace = xsdElement.getFirstChildNS(self.xsdNSAlias, "whiteSpace")

   188

        if whiteSpace != None:

   189

            wsAction = whiteSpace.getAttribute("value")

   190

            if wsAction == "replace":

   191

                normalizedValue = self._normalizeString(attributeValue)

   192

                if normalizedValue != attributeValue:

   193

                    returnDict["adaptedAttrValue"] = normalizedValue

   194

            elif wsAction == "collapse":

   195

                collapsedValue = self._collapseString(attributeValue)

   196

                if collapsedValue != attributeValue:

   197

                    returnDict["adaptedAttrValue"] = collapsedValue

   198

   199

   200

    ########################################

   201

    # validate given value against list node

   202

    #

   203

    def _checkListTag (self, xsdElement, attrName, attributeValue, returnDict):

   204

        if attributeValue != "":

   205

            itemType = xsdElement.getAttribute ("itemType")

   206

            # substitute multiple whitespace characters by a single ' '

   207

            collapsedValue = self._collapseString(attributeValue)

   208

            if collapsedValue != attributeValue:

   209

                returnDict["adaptedAttrValue"] = collapsedValue

   210

   211

            # divide up attributeValue => store it into list

   212

            attributeList = string.split(collapsedValue, " ")

   213

            for attrValue in attributeList:

   214

                elementReturnDict = {}

   215

                if itemType != None:

   216

                    self.checkSimpleType (attrName, itemType, attrValue, elementReturnDict)

   217

                else:

   218

                    itemTypeNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "simpleType")

   219

                    self.checkSimpleTypeDef (itemTypeNode, attrName, attrValue, elementReturnDict)

   220

   221

            returnDict["length"] = len(attributeList)

   222

        else:

   223

            returnDict["length"] = 0

   224

   225

   226

    ########################################

   227

    # validate given value against union node

   228

    #

   229

    def _checkUnionTag (self, xsdElement, attrName, attributeValue, returnDict):

   230

        memberTypes = xsdElement.getAttribute ("memberTypes")

   231

        if memberTypes != None:

   232

            # substitute multiple whitespace characters by a single ' '

   233

            # divide up attributeValue => store it into list

   234

            for memberType in string.split(self._collapseString(memberTypes), " "):

   235

                try:

   236

                    self.checkSimpleType (attrName, memberType, attributeValue, returnDict)

   237

                    return

   238

                except SimpleTypeError, errstr:

   239

                    pass

   240

   241

        # memberTypes and additional type definitions is legal!

   242

        for childSimpleType in xsdElement.getChildrenNS(self.xsdNSAlias, "simpleType"):

   243

            try:

   244

                self.checkSimpleTypeDef (childSimpleType, attrName, attributeValue, returnDict)

   245

                return

   246

            except SimpleTypeError, errstr:

   247

                pass

   248

   249

        raise SimpleTypeError ("%s (%s) is no valid union member type (%s)!" %(attrName, attributeValue, memberTypes))

   250

   251

   252

    ########################################

   253

    # substitute multiple whitespace characters by a single ' '

   254

    #

   255

    def _collapseString (self, strValue):

   256

        return re.sub('\s+', ' ', strValue)

   257

   258

    ########################################

   259

    # substitute each whitespace characters by a single ' '

   260

    #

   261

    def _normalizeString (self, strValue):

   262

        return re.sub('\s', ' ', strValue)

   263

   264

   265

   266

   267

def validateBaseType (simpleType, attributeValue, returnDict):

   268

# TODO: Many base types are not completely defined by datatypes.xsd

   269

    simpleTypeDict = {"xsd:string":           _checkStringType,

   270

                      "xsd:hexBinary":        _checkHexBinaryType,

   271

                      "xsd:integer":          _checkIntegerType,

   272

                      "xsd:boolean":          _checkBooleanType,

   273

                      "xsd:QName":            _checkQNameType,

   274

                      }

   275

   276

    simpleType = string.replace(simpleType, "xs:", "xsd:")

   277

    if simpleTypeDict.has_key (simpleType):

   278

        simpleTypeDict[simpleType] (simpleType, attributeValue, returnDict)

   279

   280

    elif simpleType != "xsd:anySimpleType":

   281

        if simpleType in ("xsd:decimal", "xsd:float", "xsd:double", "xsd:base64Binary", "xsd:anyURI", "xsd:NOTATION",

   282

                            "xsd:duration", "xsd:dateTime", "xsd:time", "xsd:date", 

   283

                            "xsd:gYearMonth", "xsd:gMonthDay", "xsd:gYear", "xsd:gMonth", "xsd:gDay"):

   284

            print "INFO: Check of simple type '%s' currently not supported!" %(simpleType)

   285

        else:

   286

            # TODO: Fehler im XSD-File => Check muss an anderer Stelle erfolgen

   287

            raise BaseTypeError("uses unknown type '%s'!" %(simpleType))

   288

   289

   290

def _checkStringType (simpleType, attributeValue, returnDict):

   291

    # all valid??

   292

    returnDict["length"] = len(attributeValue)

   293

   294

def _checkHexBinaryType (simpleType, attributeValue, returnDict):   

   295

    _checkIntegerRange (attributeValue, 16, 0, sys.maxint, returnDict)

   296

    returnDict["length"] = len(attributeValue)

   297

   298

def _checkIntegerType (simpleType, attributeValue, returnDict):

   299

    _checkIntegerRange (attributeValue, 10, -sys.maxint-1, sys.maxint, returnDict)

   300

   301

def _checkBooleanType (simpleType, attributeValue, returnDict):

   302

    if attributeValue not in ("true", "false", "1", "0"):

   303

        raise BaseTypeError("is not a boolean value!")

   304

   305

def _checkQNameType (simpleType, attributeValue, returnDict):

   306

    # TODO: fill

   307

    returnDict["length"] = len(attributeValue)

   308

   309

def _checkIntegerRange (attributeValue, base, minBase, maxBase, returnDict):

   310

    try:

   311

        value = string.atoi (attributeValue, base=base)

   312

    except:

   313

        if base == 16:

   314

            raise BaseTypeError("is not a hexadecimal value!")

   315

        else:

   316

            raise BaseTypeError("is not an integer!")

   317

   318

    if value < minBase or value > maxBase:

   319

        raise BaseTypeError("is out of range (%d..%d)!" %(minBase, maxBase))

   320

   321

    returnDict["orderedValue"] = value

   322

   323

   324

   325

########################################

   326

# define own exception for XML schema validation errors

   327

#

   328

class SimpleTypeError (StandardError):

   329

    pass

   330

   331

class BaseTypeError (StandardError):

   332

    pass