1

#

     2

# minixsv, Release 0.3

     3

# file: xmlifbase.py

     4

#

     5

# abstract XML interface class

     6

#

     7

# history:

     8

# 2004-09-09 rl   created

     9

# 2004-09-22 rl   XML interface classes completely re-designed

    10

# 2004-09-23 rl   added filename and line number support

    11

# 2004-09-29 rl   URL processing added

    12

# 2004-10-01 rl   URL processing improved

    13

# 2004-10-03 rl   xPath processing moved from pyxsval.py

    14

# 2004-10-12 rl   XML text processing added

    15

#

    16

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

    17

#

    18

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

    19

# The minixsv XML schema validator is

    20

#

    21

# Copyright (c) 2004 by Roland Leuthe

    22

#

    23

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

    24

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

    25

# and will comply with the following terms and conditions:

    26

#

    27

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

    28

# its associated documentation for any purpose and without fee is

    29

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

    30

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

    31

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

    32

# the author not be used in advertising or publicity

    33

# pertaining to distribution of the software without specific, written

    34

# prior permission.

    35

#

    36

# THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

    37

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

    38

# ABILITY AND FITNESS.  IN NO EVENT SHALL THE AUTHOR

    39

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

    40

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

    41

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

    42

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

    43

# OF THIS SOFTWARE.

    44

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

    45

    46

    47

import string

    48

import os

    49

import re

    50

import urllib

    51

import urlparse

    52

    53

    54

_reSplitUrlApplication = re.compile (r"(file|http|ftp|gopher):(.+)") # "file:///d:\test.xml" => "file" + "///d:\test.xml"

    55

    56

    57

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

    58

# define XML interface base class

    59

# All not implemented methods have to be overloaded by the derived class!!

    60

#

    61

    62

class XmlInterfaceBase:

    63

    64

    def __init__(self, verbose):

    65

        self.verbose = verbose

    66

        pass

    67

    68

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

    69

    #  calls the parser for 'file'

    70

    #  returns the respective XML tree for the parsed XML file

    71

    #  'file' may be a file path or an URI

    72

    73

    def parse (self, file, baseUrl):

    74

        raise NotImplementedError

    75

    76

    77

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

    78

    #  calls the parser for 'text'

    79

    #  returns the respective XML tree for the parsed XML text string

    80

    81

    def parseString (self, text):

    82

        raise NotImplementedError

    83

    84

    85

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

    86

    #  calls the parser for 'file' and processes all include directives

    87

    #  returns the respective XML tree wrapper for the parsed XML file

    88

    89

    def extParse (self, file, baseUrl):

    90

        treeWrapper = self.parse (file, baseUrl)

    91

        return self._expandIncludes (treeWrapper)

    92

    93

    def _expandIncludes (self, treeWrapper):

    94

        rootNodeWrapper = treeWrapper.getRootNode()

    95

        nsAlias  = self.extractNamespaceAlias(rootNodeWrapper.getTagName())

    96

    97

        for includeNodeWrapper in rootNodeWrapper.getChildrenNS(nsAlias, "include"):

    98

            includeUrl = includeNodeWrapper.getAttribute("schemaLocation")

    99

            if self.verbose:

   100

                print "including %s..." %(includeUrl)

   101

            treeWrapper.insertSubtree (includeNodeWrapper, includeUrl, rootNodeWrapper.getAbsUrl())

   102

            rootNodeWrapper.removeChild (includeNodeWrapper)

   103

        return treeWrapper

   104

   105

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

   106

    #  calls the parser for 'file' and processes all include directives

   107

    #  returns the respective XML tree wrapper for the parsed XML file

   108

   109

    def extParseString (self, text):

   110

        treeWrapper = self.parseString (text)

   111

        return self._expandIncludes (treeWrapper)

   112

   113

   114

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

   115

    #  returns namespace part of given 'ncName'

   116

   117

    def extractNamespaceAlias (self, ncName):

   118

        namespaceAlias, localName = self._splitNamespaceLocalName (ncName)

   119

        return namespaceAlias

   120

   121

   122

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

   123

    #  returns local tag name of given 'ncName'

   124

   125

    def extractLocalName (self, ncName):

   126

        namespaceAlias, localName = self._splitNamespaceLocalName (ncName)

   127

        return localName

   128

   129

   130

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

   131

    #  add namespace alias to localName

   132

   133

    def addNamespaceAlias (self, namespaceAlias, localName):

   134

        if namespaceAlias != "":

   135

            return namespaceAlias + localName

   136

        else:

   137

            return localName

   138

   139

   140

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

   141

    # PRIVATE methods

   142

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

   143

   144

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

   145

    #  convert input parameter 'file' into a valid URL

   146

   147

    def _convertToUrl (self, file):

   148

        matchObject = _reSplitUrlApplication.match(file)

   149

        if matchObject:

   150

            # given file is an absolute URL

   151

            if matchObject.group(1) == 'file':

   152

                path = re.sub(':', '|', matchObject.group(2)) # replace ':' by '|' in the path string

   153

                url = "file:" + path

   154

            else:

   155

                url = file

   156

        elif not os.path.isabs(file):

   157

            # given file is a relative URL

   158

            url = file

   159

        else:

   160

            # given file is not a valid URL => treated as local filename

   161

            url = "file:" + urllib.pathname2url (file)

   162

   163

        return url

   164

   165

    def _convertToAbsUrl (self, url, baseUrl):

   166

        application = urlparse.urlsplit(url)[0]

   167

        if application == '':

   168

            if baseUrl != "":

   169

                url = urlparse.urljoin (baseUrl, url)

   170

            else:

   171

                url = "file:" + urllib.pathname2url (os.path.join(os.getcwd(), url))

   172

        return url

   173

   174

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

   175

    #  split 'ncName' into namespace and local name

   176

   177

    def _splitNamespaceLocalName (self, ncName):

   178

        namespaceAlias = None

   179

   180

        namespaceEndIndex = string.find (ncName, '}')

   181

        if namespaceEndIndex != -1:

   182

            namespaceAlias = ncName[:namespaceEndIndex+1]

   183

            localName      = ncName[namespaceEndIndex+1:]

   184

        else:

   185

            namespaceEndIndex = string.find (ncName, ':')

   186

            if namespaceEndIndex != -1:

   187

                namespaceAlias = ncName[:namespaceEndIndex+1]

   188

                localName      = ncName[namespaceEndIndex+1:]

   189

            else:

   190

                namespaceAlias = ""

   191

                localName      = ncName

   192

        return namespaceAlias, localName

   193

   194

   195

   196

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

   197

# define tree wrapper base class

   198

# All not implemented methods have to be overloaded by the derived class!!

   199

#

   200

   201

class TreeWrapperBase:

   202

   203

    def __init__(self, xmlIf, tree):

   204

        self.xmlIf        = xmlIf

   205

        self.tree         = tree

   206

   207

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

   208

    #  includes the given XML/XSD file 'file' into the XML tree 'tree'

   209

    #  before 'nextSibling' ('nextSibling' is not removed!)

   210

    #  returns the extended XML tree (containing included XML/XSD file)

   211

    #

   212

    #  Note: Root tag of 'tree' and 'file' must match!

   213

   214

    def insertSubtree (self, nextSibling, file, baseUrl):

   215

        raise NotImplementedError

   216

   217

   218

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

   219

    #  returns root node of given XML tree 'tree'

   220

   221

    def getRootNode (self):

   222

        raise NotImplementedError

   223

   224

   225

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

   226

    #  returns 'tree' of given XML tree

   227

   228

    def getTree (self):

   229

        return self.tree

   230

   231

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

   232

# define node wrapper base class

   233

# All not implemented methods have to be overloaded by the derived class!!

   234

#

   235

   236

class ElementWrapperBase:

   237

   238

    def __init__(self, xmlIf, treeWrapper, element):

   239

        self.xmlIf           = xmlIf

   240

        self.treeWrapper     = treeWrapper

   241

        self.element         = element

   242

   243

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

   244

    #  returns tag name of given XML node 'node'

   245

   246

    def getTagName (self):

   247

        raise NotImplementedError

   248

   249

   250

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

   251

    #  returns child element nodes (list) of given XML node 'node'

   252

    #  'filterTag' is optional, 'filterTag' = '*' must be supported

   253

   254

    def getChildren (self, filterTag=None):

   255

        raise NotImplementedError

   256

   257

   258

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

   259

    #  returns all descendants of node whose tag match 'tagName'

   260

    #  'filterTag' is optional, 'filterTag' = '*' must be supported

   261

   262

    def getElementsByTagName (self, filterTag=None):

   263

        raise NotImplementedError

   264

   265

   266

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

   267

    #  remove given child node from children of current node

   268

   269

    def removeChild (self, childNodeWrapper):

   270

        raise NotImplementedError

   271

   272

   273

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

   274

    #  returns dictionary with all attributes of this node

   275

   276

    def getAttributeDict (self):

   277

        raise NotImplementedError

   278

   279

   280

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

   281

    #  returns attribute value of given attributeName

   282

    #  or None if there is no suitable attribute

   283

   284

    def getAttribute (self, attributeName):

   285

        raise NotImplementedError

   286

   287

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

   288

    #  returns 1 if attribute 'attributeName' exists

   289

    #          0 if not

   290

   291

    def hasAttribute (self, attributeName):

   292

        raise NotImplementedError

   293

   294

   295

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

   296

    #  sets value of attribute 'attributeName' to 'attributeValue'

   297

    #  if the attribute does not yet exist, it will be created

   298

   299

    def setAttribute (self, attributeName, attributeValue):

   300

        raise NotImplementedError

   301

   302

   303

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

   304

    #  returns element value of this node

   305

   306

    def getElementValue (self):

   307

        raise NotImplementedError

   308

   309

   310

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

   311

    #  sets element value of this node to 'value'

   312

   313

    def setElementValue (self, value):

   314

        raise NotImplementedError

   315

   316

   317

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

   318

    #  returns local tag name of given XML node 'node' (without namespace)

   319

   320

    def getLocalName (self):

   321

        return self.xmlIf.extractLocalName (self.getTagName())

   322

   323

   324

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

   325

    #  returns namespace of tag name of given XML node 'node'

   326

   327

    def getNamespaceURI (self):

   328

        return extractNamespaceAlias (self.getTagName())

   329

   330

   331

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

   332

    #  returns child element nodes (list) of given XML node 'node'

   333

    #  'filterTag' (localTagName) is optional, 'filterTag' = '*' must be supported

   334

    #  'namespaceAlias' has to contain corresponding namespace

   335

   336

    def getChildrenNS (self, namespaceAlias, filterTag=None):

   337

        if not filterTag in (None, '*'):

   338

            filterTag = self.xmlIf.addNamespaceAlias(namespaceAlias, filterTag)

   339

        return self.getChildren(filterTag)

   340

   341

   342

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

   343

    #  returns first child element of given XML node 'node'

   344

    #  or None if there is no suitable child element

   345

    #  'filterTag' is optional, 'filterTag' = '*' must be supported

   346

   347

    def getFirstChild (self, filterTag=None):

   348

        children = self.getChildren(filterTag)

   349

        if children != []:

   350

            return children[0]

   351

        else:

   352

            return None

   353

   354

   355

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

   356

    #  returns first child element of given XML node 'node'

   357

    #  or None if there is no suitable child element

   358

    #  'filterTag' (localTagName) is optional, 'filterTag' = '*' must be supported

   359

    #  'namespaceAlias' has to contain corresponding namespace

   360

   361

    def getFirstChildNS (self, namespaceAlias, filterTag=None):

   362

        if not filterTag in (None, '*'):

   363

            filterTag = self.xmlIf.addNamespaceAlias(namespaceAlias, filterTag)

   364

        return self.getFirstChild(filterTag)

   365

   366

   367

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

   368

    #  returns all descendants of node whose tag match 'localName' of the given namespace

   369

    #  'filterTag' (localTagName) is optional, 'filterTag' = '*' must be supported

   370

    #  'namespaceAlias' has to contain corresponding namespace

   371

   372

    def getElementsByTagNameNS (self, namespaceAlias, filterTag=None):

   373

        if not filterTag in (None, '*'):

   374

            filterTag = self.xmlIf.addNamespaceAlias(namespaceAlias, filterTag)

   375

        return self.getElementsByTagName (filterTag)

   376

   377

   378

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

   379

    #  returns attribute if it exists or default value if not

   380

   381

    def getAttributeOrDefault (self, attributeName, default):

   382

        if self.hasAttribute (attributeName):

   383

            return self.getAttribute (attributeName)

   384

        else:

   385

            return default

   386

   387

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

   388

    #  returns the current start line number of the element node in the XML file

   389

   390

    def getStartLineNumber (self):

   391

        return self.element.startLineNumber

   392

   393

   394

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

   395

    #  returns the current end line number of the element node in the XML file

   396

   397

    def getEndLineNumber (self):

   398

        return self.element.endLineNumber

   399

   400

   401

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

   402

    #  returns the URL of the XML file the node belongs to

   403

   404

    def getUrl (self):

   405

        return self.element.url

   406

   407

    def getAbsUrl (self):

   408

        return self.element.absUrl

   409

   410

   411

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

   412

    #  returns the file path of the XML file the node belongs to

   413

   414

    def getFilePath (self):

   415

        return self.element.filePath

   416

   417

   418

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

   419

    # retrieve node list or attribute list for specified XPath

   420

   421

    def getXPathList (self, xPath, defaultNamespace):

   422

        selectedNodeList = []

   423

        selectedAttributeList = []

   424

        xPathList = string.split (xPath, "|")

   425

        for xRelPath in xPathList:

   426

            descendantOrSelf = 0

   427

            if xRelPath[:3] == ".//":

   428

                descendantOrSelf = 1

   429

                xRelPath = xRelPath[3:]

   430

            # no namespaces supported!

   431

            xPathLocalStepList = map(lambda xPath: self.xmlIf.extractLocalName(xPath), string.split (xRelPath, "/"))

   432

            childList = [self,]

   433

            isAttributeList = 0

   434

            for localStep in xPathLocalStepList:

   435

                stepChildList = []

   436

                if localStep == "":

   437

                    raise IOError ("Invalid xPath '%s'!" %(xRelPath))

   438

                elif localStep == ".":

   439

                    continue

   440

                elif localStep[0] == '@':

   441

                    for childNode in childList:

   442

                        attrName = localStep[1:]

   443

                        if attrName == '*':

   444

                            stepChildList.extend(childNode.getAttributeDict().values())

   445

                        elif childNode.hasAttribute(attrName):

   446

                            stepChildList.append (childNode.getAttribute(attrName))

   447

                    childList = stepChildList

   448

                    isAttributeList = 1

   449

                else:

   450

                    if descendantOrSelf:

   451

                        descendantOrSelf = 0

   452

                        stepChildList = self.getElementsByTagNameNS(defaultNamespace, localStep)

   453

                    else:

   454

                        for childNode in childList:

   455

                            stepChildList.extend (childNode.getChildrenNS(defaultNamespace, localStep))

   456

                    childList = stepChildList

   457

   458

            if isAttributeList:

   459

                selectedAttributeList.extend (childList)

   460

            else:

   461

                selectedNodeList.extend (childList)

   462

        return selectedNodeList, selectedAttributeList

   463

   464

   465