rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/xml/sax/drivers2/drv_javasax.py

@@ -0,0 +1,333 @@
+"""
+SAX driver for the Java SAX parsers. Can only be used in Jython.
+
+$Id: drv_javasax.py,v 1.5 2003/01/26 09:08:51 loewis Exp $
+"""
+
+# --- Initialization
+
+version = "0.10"
+revision = "$Revision: 1.5 $"
+
+import string
+from xml.sax import xmlreader, saxutils
+from xml.sax.handler import feature_namespaces, feature_namespace_prefixes
+from xml.sax import _exceptions
+
+# we only work in jython
+import sys
+if sys.platform[:4] != "java":
+    raise _exceptions.SAXReaderNotAvailable("drv_javasax not available in CPython", None)
+del sys
+
+# get the necessary Java SAX classes
+try:
+    from org.python.core import FilelikeInputStream
+    from org.xml.sax.helpers import XMLReaderFactory
+    from org.xml import sax as javasax
+except ImportError:
+    raise _exceptions.SAXReaderNotAvailable("SAX is not on the classpath", None)
+
+# get some JAXP stuff
+try:
+    from javax.xml.parsers import SAXParserFactory, ParserConfigurationException
+    factory = SAXParserFactory.newInstance()
+    jaxp = 1
+except ImportError:
+    jaxp = 0
+    
+from java.lang import String
+
+
+def _wrap_sax_exception(e):
+    return _exceptions.SAXParseException(e.message,
+					 e.exception,
+					 SimpleLocator(e.columnNumber,
+							      e.lineNumber,
+							      e.publicId,
+							      e.systemId))
+
+class JyErrorHandlerWrapper(javasax.ErrorHandler):
+    def __init__(self, err_handler):
+	self._err_handler = err_handler
+	
+    def error(self, exc):
+	self._err_handler.error(_wrap_sax_exception(exc))
+
+    def fatalError(self, exc):
+	self._err_handler.fatalError(_wrap_sax_exception(exc))
+
+    def warning(self, exc):
+	self._err_handler.warning(_wrap_sax_exception(exc))
+
+class JyInputSourceWrapper(javasax.InputSource):
+    def __init__(self, source):
+	if isinstance(source, str):
+	    javasax.InputSource.__init__(self, source)
+	elif hasattr(source, "read"):#file like object
+	    f = source
+	    javasax.InputSource.__init__(self, FilelikeInputStream(f))
+	    if hasattr(f, "name"):
+		self.setSystemId(f.name)
+	else:#xml.sax.xmlreader.InputSource object
+	    #Use byte stream constructor if possible so that Xerces won't attempt to open
+	    #the url at systemId unless it's really there
+	    if source.getByteStream():
+	        javasax.InputSource.__init__(self,
+					     FilelikeInputStream(source.getByteStream()))
+	    else:
+		javasax.InputSource.__init__(self)
+	    if source.getSystemId():
+		self.setSystemId(source.getSystemId())
+	    self.setPublicId(source.getPublicId())
+	    self.setEncoding(source.getEncoding())
+
+class JyEntityResolverWrapper(javasax.EntityResolver):
+    def __init__(self, entityResolver):
+	self._resolver = entityResolver
+
+    def resolveEntity(self, pubId, sysId):
+	return JyInputSourceWrapper(self._resolver.resolveEntity(pubId, sysId))
+
+class JyDTDHandlerWrapper(javasax.DTDHandler):
+    def __init__(self, dtdHandler):
+	self._handler = dtdHandler
+
+    def notationDecl(self, name, publicId, systemId):
+	self._handler.notationDecl(name, publicId, systemId)
+
+    def unparsedEntityDecl(self, name, publicId, systemId, notationName):
+	self._handler.unparsedEntityDecl(name, publicId, systemId, notationName)
+
+class SimpleLocator(xmlreader.Locator):
+    def __init__(self, colNum, lineNum, pubId, sysId):
+	self.colNum = colNum
+	self.lineNum = lineNum
+	self.pubId = pubId
+	self.sysId = sysId
+    
+    def getColumnNumber(self):
+        return self.colNum
+
+    def getLineNumber(self):
+        return self.lineNum
+
+    def getPublicId(self):
+        return self.pubId
+
+    def getSystemId(self):
+        return self.sysId
+
+# --- JavaSAXParser
+class JavaSAXParser(xmlreader.XMLReader, javasax.ContentHandler):
+    "SAX driver for the Java SAX parsers."
+
+    def __init__(self, jdriver = None):
+	xmlreader.XMLReader.__init__(self)
+        self._parser = create_java_parser(jdriver)
+        self._parser.setFeature(feature_namespaces, 0)
+	self._parser.setFeature(feature_namespace_prefixes, 0)
+        self._parser.setContentHandler(self)
+        self._nsattrs = AttributesNSImpl()
+        self._attrs = AttributesImpl()
+	self.setEntityResolver(self.getEntityResolver())
+	self.setErrorHandler(self.getErrorHandler())
+	self.setDTDHandler(self.getDTDHandler())
+
+    # XMLReader methods
+
+    def parse(self, source):
+        "Parse an XML document from a URL or an InputSource."
+        self._parser.parse(JyInputSourceWrapper(source))
+
+    def getFeature(self, name):
+        return self._parser.getFeature(name)
+
+    def setFeature(self, name, state):
+        self._parser.setFeature(name, state)
+
+    def getProperty(self, name):
+        return self._parser.getProperty(name)
+
+    def setProperty(self, name, value):
+        self._parser.setProperty(name, value)
+
+    def setEntityResolver(self, resolver):
+	self._parser.entityResolver = JyEntityResolverWrapper(resolver)
+	xmlreader.XMLReader.setEntityResolver(self, resolver)
+
+    def setErrorHandler(self, err_handler):
+	self._parser.errorHandler = JyErrorHandlerWrapper(err_handler)
+	xmlreader.XMLReader.setErrorHandler(self, err_handler)
+
+    def setDTDHandler(self, dtd_handler):
+	self._parser.setDTDHandler(JyDTDHandlerWrapper(dtd_handler))
+	xmlreader.XMLReader.setDTDHandler(self, dtd_handler)
+
+    # ContentHandler methods
+    def setDocumentLocator(self, locator):
+        self._cont_handler.setDocumentLocator(locator)
+
+    def startDocument(self):
+        self._cont_handler.startDocument()
+        self._namespaces = self._parser.getFeature(feature_namespaces)
+
+    def startElement(self, uri, lname, qname, attrs):
+        if self._namespaces:
+	    self._nsattrs._attrs = attrs
+            self._cont_handler.startElementNS((uri or None, lname), qname,
+                                              self._nsattrs)
+        else:
+	    self._attrs._attrs = attrs
+            self._cont_handler.startElement(qname, self._attrs)
+
+    def startPrefixMapping(self, prefix, uri):
+	self._cont_handler.startPrefixMapping(prefix, uri)
+
+    def characters(self, char, start, len):
+        self._cont_handler.characters(str(String(char, start, len)))
+
+    def ignorableWhitespace(self, char, start, len):
+        self._cont_handler.ignorableWhitespace(str(String(char, start, len)))
+
+    def endElement(self, uri, lname, qname):
+        if self._namespaces:
+            self._cont_handler.endElementNS((uri or None, lname), qname)
+        else:
+            self._cont_handler.endElement(qname)
+
+    def endPrefixMapping(self, prefix):
+	self._cont_handler.endPrefixMapping(prefix)
+
+    def endDocument(self):
+        self._cont_handler.endDocument()
+
+    def processingInstruction(self, target, data):
+        self._cont_handler.processingInstruction(target, data)
+
+class AttributesImpl:
+    def __init__(self, attrs = None):
+        self._attrs = attrs
+
+    def getLength(self):
+        return self._attrs.getLength()
+
+    def getType(self, name):
+        return self._attrs.getType(name)
+
+    def getValue(self, name):
+	value = self._attrs.getValue(name)
+        if value == None:
+            raise KeyError(name)
+        return value
+
+    def getNames(self):
+        return [self._attrs.getQName(index) for index in range(len(self))]
+
+    def getQNames(self):
+        return [self._attrs.getQName(index) for index in range(len(self))]
+
+    def getValueByQName(self, qname):
+	idx = self._attrs.getIndex(qname)
+	if idx == -1:
+	    raise KeyError, qname
+	return self._attrs.getValue(idx)
+
+    def getNameByQName(self, qname):
+	idx = self._attrs.getIndex(qname)
+	if idx == -1:
+	    raise KeyError, qname
+	return qname
+
+    def getQNameByName(self, name):
+	idx = self._attrs.getIndex(name)
+	if idx == -1:
+	    raise KeyError, name
+	return name
+
+    def __len__(self):
+        return self._attrs.getLength()
+
+    def __getitem__(self, name):
+        return self.getValue(name)
+
+    def keys(self):
+        return self.getNames()
+
+    def copy(self):
+        return self.__class__(self._attrs)
+
+    def items(self):
+        return [(name, self[name]) for name in self.getNames()]
+
+    def values(self):
+        return map(self.getValue, self.getNames())
+
+    def get(self, name, alt=None):
+	try:
+           return self.getValue(name)
+        except KeyError:
+            return alt
+
+    def has_key(self, name):
+	try:
+	    self.getValue(name)
+	    return True
+	except KeyError:
+	    return False
+
+# --- AttributesNSImpl
+
+class AttributesNSImpl(AttributesImpl):
+
+    def __init__(self, attrs=None):
+	AttributesImpl.__init__(self, attrs)
+
+    def getType(self, name):
+	return self._attrs.getType(name[0], name[1])
+
+    def getValue(self, name):
+	value = self._attrs.getValue(name[0], name[1])
+	if value == None:
+	    raise KeyError(name)
+	return value
+
+    def getNames(self):
+	names = []
+	for idx in range(len(self)):
+	    names.append((self._attrs.getURI(idx),
+			  self._attrs.getLocalName(idx)))
+	return names
+
+    def getNameByQName(self, qname):
+	idx = self._attrs.getIndex(qname)
+	if idx == -1:
+	    raise KeyError, qname
+	return (self._attrs.getURI(idx), self._attrs.getLocalName(idx))
+
+    def getQNameByName(self, name):
+	idx = self._attrs.getIndex(name[0], name[1])
+	if idx == -1:
+	    raise KeyError, name
+	return self._attrs.getQName(idx)
+
+    def getQNames(self):
+	return [self._attrs.getQName(idx) for idx in range(len(self))]
+
+# ---
+
+def create_java_parser(jdriver = None):
+    try:
+        if jdriver:
+            return XMLReaderFactory.createXMLReader(jdriver)
+        elif jaxp:
+            return factory.newSAXParser().getXMLReader()
+        else:
+            return XMLReaderFactory.createXMLReader()
+    except ParserConfigurationException, e:
+        raise _exceptions.SAXReaderNotAvailable(e.getMessage())
+    except javasax.SAXException, e:
+        raise _exceptions.SAXReaderNotAvailable(e.getMessage())
+
+def create_parser(jdriver = None):
+    return JavaSAXParser(jdriver)

data/lib/rubyfox/server/data/lib/Lib/xml/sax/handler.py

@@ -0,0 +1,345 @@
+"""
+This module contains the core classes of version 2.0 of SAX for Python.
+This file provides only default classes with absolutely minimum
+functionality, from which drivers and applications can be subclassed.
+
+Many of these classes are empty and are included only as documentation
+of the interfaces.
+
+$Id: handler.py,v 1.5 2002/02/14 08:09:36 loewis Exp $
+"""
+
+version = '2.0beta'
+
+#============================================================================
+#
+# HANDLER INTERFACES
+#
+#============================================================================
+
+# ===== ERRORHANDLER =====
+
+class ErrorHandler:
+    """Basic interface for SAX error handlers.
+
+    If you create an object that implements this interface, then
+    register the object with your XMLReader, the parser will call the
+    methods in your object to report all warnings and errors. There
+    are three levels of errors available: warnings, (possibly)
+    recoverable errors, and unrecoverable errors. All methods take a
+    SAXParseException as the only parameter."""
+
+    def error(self, exception):
+        "Handle a recoverable error."
+        raise exception
+
+    def fatalError(self, exception):
+        "Handle a non-recoverable error."
+        raise exception
+
+    def warning(self, exception):
+        "Handle a warning."
+        print exception
+
+
+# ===== CONTENTHANDLER =====
+
+class ContentHandler:
+    """Interface for receiving logical document content events.
+
+    This is the main callback interface in SAX, and the one most
+    important to applications. The order of events in this interface
+    mirrors the order of the information in the document."""
+
+    def __init__(self):
+        self._locator = None
+
+    def setDocumentLocator(self, locator):
+        """Called by the parser to give the application a locator for
+        locating the origin of document events.
+
+        SAX parsers are strongly encouraged (though not absolutely
+        required) to supply a locator: if it does so, it must supply
+        the locator to the application by invoking this method before
+        invoking any of the other methods in the DocumentHandler
+        interface.
+
+        The locator allows the application to determine the end
+        position of any document-related event, even if the parser is
+        not reporting an error. Typically, the application will use
+        this information for reporting its own errors (such as
+        character content that does not match an application's
+        business rules). The information returned by the locator is
+        probably not sufficient for use with a search engine.
+
+        Note that the locator will return correct information only
+        during the invocation of the events in this interface. The
+        application should not attempt to use it at any other time."""
+        self._locator = locator
+
+    def startDocument(self):
+        """Receive notification of the beginning of a document.
+
+        The SAX parser will invoke this method only once, before any
+        other methods in this interface or in DTDHandler (except for
+        setDocumentLocator)."""
+
+    def endDocument(self):
+        """Receive notification of the end of a document.
+
+        The SAX parser will invoke this method only once, and it will
+        be the last method invoked during the parse. The parser shall
+        not invoke this method until it has either abandoned parsing
+        (because of an unrecoverable error) or reached the end of
+        input."""
+
+    def startPrefixMapping(self, prefix, uri):
+        """Begin the scope of a prefix-URI Namespace mapping.
+
+        The information from this event is not necessary for normal
+        Namespace processing: the SAX XML reader will automatically
+        replace prefixes for element and attribute names when the
+        http://xml.org/sax/features/namespaces feature is true (the
+        default).
+
+        There are cases, however, when applications need to use
+        prefixes in character data or in attribute values, where they
+        cannot safely be expanded automatically; the
+        start/endPrefixMapping event supplies the information to the
+        application to expand prefixes in those contexts itself, if
+        necessary.
+
+        Note that start/endPrefixMapping events are not guaranteed to
+        be properly nested relative to each-other: all
+        startPrefixMapping events will occur before the corresponding
+        startElement event, and all endPrefixMapping events will occur
+        after the corresponding endElement event, but their order is
+        not guaranteed."""
+
+    def endPrefixMapping(self, prefix):
+        """End the scope of a prefix-URI mapping.
+
+        See startPrefixMapping for details. This event will always
+        occur after the corresponding endElement event, but the order
+        of endPrefixMapping events is not otherwise guaranteed."""
+
+    def startElement(self, name, attrs):
+        """Signals the start of an element in non-namespace mode.
+
+        The name parameter contains the raw XML 1.0 name of the
+        element type as a string and the attrs parameter holds an
+        instance of the Attributes class containing the attributes of
+        the element."""
+
+    def endElement(self, name):
+        """Signals the end of an element in non-namespace mode.
+
+        The name parameter contains the name of the element type, just
+        as with the startElement event."""
+
+    def startElementNS(self, name, qname, attrs):
+        """Signals the start of an element in namespace mode.
+
+        The name parameter contains the name of the element type as a
+        (uri, localname) tuple, the qname parameter the raw XML 1.0
+        name used in the source document, and the attrs parameter
+        holds an instance of the Attributes class containing the
+        attributes of the element.
+
+        The uri part of the name tuple is None for elements which have
+        no namespace."""
+
+    def endElementNS(self, name, qname):
+        """Signals the end of an element in namespace mode.
+
+        The name parameter contains the name of the element type, just
+        as with the startElementNS event."""
+
+    def characters(self, content):
+        """Receive notification of character data.
+
+        The Parser will call this method to report each chunk of
+        character data. SAX parsers may return all contiguous
+        character data in a single chunk, or they may split it into
+        several chunks; however, all of the characters in any single
+        event must come from the same external entity so that the
+        Locator provides useful information."""
+
+    def ignorableWhitespace(self, whitespace):
+        """Receive notification of ignorable whitespace in element content.
+
+        Validating Parsers must use this method to report each chunk
+        of ignorable whitespace (see the W3C XML 1.0 recommendation,
+        section 2.10): non-validating parsers may also use this method
+        if they are capable of parsing and using content models.
+
+        SAX parsers may return all contiguous whitespace in a single
+        chunk, or they may split it into several chunks; however, all
+        of the characters in any single event must come from the same
+        external entity, so that the Locator provides useful
+        information.
+
+        The application must not attempt to read from the array
+        outside of the specified range."""
+
+    def processingInstruction(self, target, data):
+        """Receive notification of a processing instruction.
+
+        The Parser will invoke this method once for each processing
+        instruction found: note that processing instructions may occur
+        before or after the main document element.
+
+        A SAX parser should never report an XML declaration (XML 1.0,
+        section 2.8) or a text declaration (XML 1.0, section 4.3.1)
+        using this method."""
+
+    def skippedEntity(self, name):
+        """Receive notification of a skipped entity.
+
+        The Parser will invoke this method once for each entity
+        skipped. Non-validating processors may skip entities if they
+        have not seen the declarations (because, for example, the
+        entity was declared in an external DTD subset). All processors
+        may skip external entities, depending on the values of the
+        http://xml.org/sax/features/external-general-entities and the
+        http://xml.org/sax/features/external-parameter-entities
+        properties."""
+
+
+# ===== DTDHandler =====
+
+class DTDHandler:
+    """Handle DTD events.
+
+    This interface specifies only those DTD events required for basic
+    parsing (unparsed entities and attributes)."""
+
+    def notationDecl(self, name, publicId, systemId):
+        "Handle a notation declaration event."
+
+    def unparsedEntityDecl(self, name, publicId, systemId, ndata):
+        "Handle an unparsed entity declaration event."
+
+
+# ===== ENTITYRESOLVER =====
+
+class EntityResolver:
+    """Basic interface for resolving entities. If you create an object
+    implementing this interface, then register the object with your
+    Parser, the parser will call the method in your object to
+    resolve all external entities. Note that DefaultHandler implements
+    this interface with the default behaviour."""
+
+    def resolveEntity(self, publicId, systemId):
+        """Resolve the system identifier of an entity and return either
+        the system identifier to read from as a string, or an InputSource
+        to read from."""
+        return systemId
+
+
+#============================================================================
+#
+# CORE FEATURES
+#
+#============================================================================
+
+feature_namespaces = "http://xml.org/sax/features/namespaces"
+# true: Perform Namespace processing (default).
+# false: Optionally do not perform Namespace processing
+#        (implies namespace-prefixes).
+# access: (parsing) read-only; (not parsing) read/write
+
+feature_namespace_prefixes = "http://xml.org/sax/features/namespace-prefixes"
+# true: Report the original prefixed names and attributes used for Namespace
+#       declarations.
+# false: Do not report attributes used for Namespace declarations, and
+#        optionally do not report original prefixed names (default).
+# access: (parsing) read-only; (not parsing) read/write
+
+feature_string_interning = "http://xml.org/sax/features/string-interning"
+# true: All element names, prefixes, attribute names, Namespace URIs, and
+#       local names are interned using the built-in intern function.
+# false: Names are not necessarily interned, although they may be (default).
+# access: (parsing) read-only; (not parsing) read/write
+
+feature_validation = "http://xml.org/sax/features/validation"
+# true: Report all validation errors (implies external-general-entities and
+#       external-parameter-entities).
+# false: Do not report validation errors.
+# access: (parsing) read-only; (not parsing) read/write
+
+feature_external_ges = "http://xml.org/sax/features/external-general-entities"
+# true: Include all external general (text) entities.
+# false: Do not include external general entities.
+# access: (parsing) read-only; (not parsing) read/write
+
+feature_external_pes = "http://xml.org/sax/features/external-parameter-entities"
+# true: Include all external parameter entities, including the external
+#       DTD subset.
+# false: Do not include any external parameter entities, even the external
+#        DTD subset.
+# access: (parsing) read-only; (not parsing) read/write
+
+all_features = [feature_namespaces,
+                feature_namespace_prefixes,
+                feature_string_interning,
+                feature_validation,
+                feature_external_ges,
+                feature_external_pes]
+
+
+#============================================================================
+#
+# CORE PROPERTIES
+#
+#============================================================================
+
+property_lexical_handler = "http://xml.org/sax/properties/lexical-handler"
+# data type: xml.sax.sax2lib.LexicalHandler
+# description: An optional extension handler for lexical events like comments.
+# access: read/write
+
+property_declaration_handler = "http://xml.org/sax/properties/declaration-handler"
+# data type: xml.sax.sax2lib.DeclHandler
+# description: An optional extension handler for DTD-related events other
+#              than notations and unparsed entities.
+# access: read/write
+
+property_dom_node = "http://xml.org/sax/properties/dom-node"
+# data type: org.w3c.dom.Node
+# description: When parsing, the current DOM node being visited if this is
+#              a DOM iterator; when not parsing, the root DOM node for
+#              iteration.
+# access: (parsing) read-only; (not parsing) read/write
+
+property_xml_string = "http://xml.org/sax/properties/xml-string"
+# data type: String
+# description: The literal string of characters that was the source for
+#              the current event.
+# access: read-only
+
+property_encoding = "http://www.python.org/sax/properties/encoding"
+# data type: String
+# description: The name of the encoding to assume for input data.
+# access: write: set the encoding, e.g. established by a higher-level
+#                protocol. May change during parsing (e.g. after
+#                processing a META tag)
+#         read:  return the current encoding (possibly established through
+#                auto-detection.
+# initial value: UTF-8 
+#
+
+property_interning_dict = "http://www.python.org/sax/properties/interning-dict"
+# data type: Dictionary
+# description: The dictionary used to intern common strings in the document
+# access: write: Request that the parser uses a specific dictionary, to
+#                allow interning across different documents
+#         read:  return the current interning dictionary, or None
+#
+
+all_properties = [property_lexical_handler,
+                  property_dom_node,
+                  property_declaration_handler,
+                  property_xml_string,
+                  property_encoding,
+                  property_interning_dict]