WIP-pyshapelib-bramz/test/xmlsupport.py

# Copyright (C) 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""XML support code for the test cases"""

import sys
import os
from StringIO import StringIO
import xml.sax
import xml.sax.handler
from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException

import support

try:
    import pyRXP
except ImportError:
    pyRXP = None

class ValidationTest:

    """Mix-in class for tests that want to check for validity of XML data"""

    # If true, at least one test case tried to validate XML data but
    # couldn't because PyRXP is not available
    validation_attempt_ignored = False

    def validate_data(self, data):
        """Validate the XML data"""
        if pyRXP is not None:
            parser = pyRXP.Parser()
            try:
                parser.parse(data, eoCB = self.rxp_eo_cb)
            except pyRXP.error, val:
                raise AssertionError, str(val), sys.exc_info()[2]
        else:
            ValidationTest.validation_attempt_ignored = True

    def rxp_eo_cb(self, filename):
        """Resolve an eternal entity

        In the Thuban test cases the only external entities that have to
        be resolved are the DTDs which now live in the resource
        directory. So, interpret any filename relative to that
        directory.
        """
        return os.path.join(support.resource_dir(), "XML", filename)


#
# Classes and functions to convert XML to a normalized list
# representation for comparisons
#

class SaxEventLister(xml.sax.handler.ContentHandler):

    """Create a normalized list representation containing the SAX events

    The normalization includes the following

     - The attribute dictionary of a staertElement event is converted to
       a sorted list of (key, value) pairs

     - ID and IDREF attribute values are normalized in such a way that
       two documents that only use different values for IDs can still
       lead to the same normalized representation.

       The implementation of this feature assumes that all IDs are
       defined before they are used. The normalized ID values are of the
       form 'D<NUM>' where <NUM> is a counter starting with 0, so the
       first ID value will become 'D0', the second 'D1', etc.

       Which attributes are IDs or IDREFS is defined with the
       correspoding constructor arguments.
    """

    def __init__(self, ids = (), idrefs = ()):
        """Initialize the SaxEventLister

        The ids and idrefs parameters should be lists of (element, attr)
        pairs where name is the name of an attribute as passed to the
        startElementNS method and attr is the name of an attribute as
        used in the mapping passed to startElementNS, so both name and
        attr usually must include the namespace.
        """
        self.eventlist = []
        self.ids = ids
        self.idrefs = idrefs
        self.idremap = {}

    def startElementNS(self, name, qname, attrs):
        items = attrs.items()
        items.sort()
        for i, (attr, value) in zip(range(len(items)), items):
            #print '++++'
            #print self.idremap
            #print name, attr, value
            if (name, attr) in self.ids:
                newid = len(self.idremap)
                self.idremap[value] = "D" + str(newid)
                value = self.idremap[value]
            elif (name, attr) in self.idrefs:
                value = self.idremap[value]
            items[i] = (attr, value)
            #print name, attr, value
        self.eventlist.append(("start", name, items))

    def endElementNS(self, name, qname):
        self.eventlist.append(("end", name))


def sax_eventlist(data = None, filename = None,
                  ids = (), idrefs = ()):
    """Return a list of SAX event generated for a given XML source

    The xml source may either be a string with the actual XML, in which
    case it should be given as the keyword argument data or the name of
    an xml file given as the keyword argument filename
    """
    if filename is not None:
        data = open(filename).read()
    handler = SaxEventLister(ids = ids, idrefs = idrefs)
    parser = make_parser()
    parser.setContentHandler(handler)
    parser.setErrorHandler(ErrorHandler())
    parser.setFeature(xml.sax.handler.feature_namespaces, 1)

    #
    # see comment at the end of Thuban/Model/load.py
    #
    try:
        parser.setFeature(xml.sax.handler.feature_validation, 0)
        parser.setFeature(xml.sax.handler.feature_external_ges, 0)
        parser.setFeature(xml.sax.handler.feature_external_pes, 0)
    except SAXNotRecognizedException:
        pass

    inpsrc = xml.sax.InputSource()
    inpsrc.setByteStream(StringIO(data))
    parser.parse(inpsrc)

    return handler.eventlist


def print_summary_message():
    """Print a summary message about validation tests

    Currently simply print a message about pyRXP not being available if
    a test case's attempt to validate XML was ignored because of that.
    """
    if ValidationTest.validation_attempt_ignored:
        print "XML validation attempts ignored because pyRXP is not available"
1	bh	1245	# Copyright (C) 2003 by Intevation GmbH
2			# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with the software for details.
7
8			"""XML support code for the test cases"""
9
10			import sys
11			import os
12	bh	1257	from StringIO import StringIO
13			import xml.sax
14			import xml.sax.handler
15			from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException
16
17	bh	1245	import support
18
19			try:
20			import pyRXP
21			except ImportError:
22			pyRXP = None
23
24			class ValidationTest:
25
26			"""Mix-in class for tests that want to check for validity of XML data"""
27
28			# If true, at least one test case tried to validate XML data but
29			# couldn't because PyRXP is not available
30			validation_attempt_ignored = False
31
32			def validate_data(self, data):
33			"""Validate the XML data"""
34			if pyRXP is not None:
35			parser = pyRXP.Parser()
36			try:
37			parser.parse(data, eoCB = self.rxp_eo_cb)
38			except pyRXP.error, val:
39			raise AssertionError, str(val), sys.exc_info()[2]
40			else:
41			ValidationTest.validation_attempt_ignored = True
42
43			def rxp_eo_cb(self, filename):
44			"""Resolve an eternal entity
45
46			In the Thuban test cases the only external entities that have to
47			be resolved are the DTDs which now live in the resource
48			directory. So, interpret any filename relative to that
49			directory.
50			"""
51			return os.path.join(support.resource_dir(), "XML", filename)
52
53
54	bh	1257	#
55			# Classes and functions to convert XML to a normalized list
56			# representation for comparisons
57			#
58	bh	1245
59	bh	1257	class SaxEventLister(xml.sax.handler.ContentHandler):
60
61			"""Create a normalized list representation containing the SAX events
62	bh	1268
63			The normalization includes the following
64
65			- The attribute dictionary of a staertElement event is converted to
66			a sorted list of (key, value) pairs
67
68			- ID and IDREF attribute values are normalized in such a way that
69			two documents that only use different values for IDs can still
70			lead to the same normalized representation.
71
72			The implementation of this feature assumes that all IDs are
73			defined before they are used. The normalized ID values are of the
74			form 'D<NUM>' where <NUM> is a counter starting with 0, so the
75			first ID value will become 'D0', the second 'D1', etc.
76
77			Which attributes are IDs or IDREFS is defined with the
78			correspoding constructor arguments.
79	bh	1257	"""
80
81	bh	1268	def __init__(self, ids = (), idrefs = ()):
82			"""Initialize the SaxEventLister
83
84			The ids and idrefs parameters should be lists of (element, attr)
85			pairs where name is the name of an attribute as passed to the
86			startElementNS method and attr is the name of an attribute as
87			used in the mapping passed to startElementNS, so both name and
88			attr usually must include the namespace.
89			"""
90	bh	1257	self.eventlist = []
91	bh	1268	self.ids = ids
92			self.idrefs = idrefs
93			self.idremap = {}
94	bh	1257
95			def startElementNS(self, name, qname, attrs):
96			items = attrs.items()
97			items.sort()
98	bh	1268	for i, (attr, value) in zip(range(len(items)), items):
99			#print '++++'
100			#print self.idremap
101			#print name, attr, value
102			if (name, attr) in self.ids:
103			newid = len(self.idremap)
104			self.idremap[value] = "D" + str(newid)
105			value = self.idremap[value]
106			elif (name, attr) in self.idrefs:
107			value = self.idremap[value]
108			items[i] = (attr, value)
109			#print name, attr, value
110	bh	1280	self.eventlist.append(("start", name, items))
111	bh	1257
112			def endElementNS(self, name, qname):
113	bh	1280	self.eventlist.append(("end", name))
114	bh	1257
115
116	bh	1268	def sax_eventlist(data = None, filename = None,
117			ids = (), idrefs = ()):
118	bh	1257	"""Return a list of SAX event generated for a given XML source
119
120			The xml source may either be a string with the actual XML, in which
121			case it should be given as the keyword argument data or the name of
122			an xml file given as the keyword argument filename
123			"""
124			if filename is not None:
125			data = open(filename).read()
126	bh	1268	handler = SaxEventLister(ids = ids, idrefs = idrefs)
127	bh	1257	parser = make_parser()
128			parser.setContentHandler(handler)
129			parser.setErrorHandler(ErrorHandler())
130			parser.setFeature(xml.sax.handler.feature_namespaces, 1)
131
132			#
133			# see comment at the end of Thuban/Model/load.py
134			#
135			try:
136			parser.setFeature(xml.sax.handler.feature_validation, 0)
137			parser.setFeature(xml.sax.handler.feature_external_ges, 0)
138			parser.setFeature(xml.sax.handler.feature_external_pes, 0)
139			except SAXNotRecognizedException:
140			pass
141
142			inpsrc = xml.sax.InputSource()
143			inpsrc.setByteStream(StringIO(data))
144			parser.parse(inpsrc)
145
146			return handler.eventlist
147
148
149	bh	1245	def print_summary_message():
150			"""Print a summary message about validation tests
151
152			Currently simply print a message about pyRXP not being available if
153			a test case's attempt to validate XML was ignored because of that.
154			"""
155			if ValidationTest.validation_attempt_ignored:
156			print "XML validation attempts ignored because pyRXP is not available"
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision