rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/xml/Uri.py

@@ -0,0 +1,380 @@
+# pylint: disable-msg=C0103
+#
+# backported code from 4Suite with slight modifications, started from r1.89 of
+# Ft/Lib/Uri.py, by syt@logilab.fr on 2005-02-09
+#
+# part if not all of this code should probably move to urlparse (or be used
+# to fix some existant functions in this module)
+#
+#
+# Copyright 2004 Fourthought, Inc. (USA).
+# Detailed license and copyright information: http://4suite.org/COPYRIGHT
+# Project home, documentation, distributions: http://4suite.org/
+import os.path
+import sys
+import re
+import urlparse, urllib, urllib2
+
+def UnsplitUriRef(uriRefSeq):
+    """should replace urlparse.urlunsplit
+    
+    Given a sequence as would be produced by SplitUriRef(), assembles and
+    returns a URI reference as a string.
+    """
+    if not isinstance(uriRefSeq, (tuple, list)):
+        raise TypeError("sequence expected, got %s" % type(uriRefSeq))
+    (scheme, authority, path, query, fragment) = uriRefSeq
+    uri = ''
+    if scheme is not None:
+        uri += scheme + ':'
+    if authority is not None:
+        uri += '//' + authority
+    uri += path
+    if query is not None:
+        uri += '?' + query
+    if fragment is not None:
+        uri += '#' + fragment
+    return uri
+
+SPLIT_URI_REF_PATTERN = re.compile(r"^(?:(?P<scheme>[^:/?#]+):)?(?://(?P<authority>[^/?#]*))?(?P<path>[^?#]*)(?:\?(?P<query>[^#]*))?(?:#(?P<fragment>.*))?$")
+
+def SplitUriRef(uriref):
+    """should replace urlparse.urlsplit
+    
+    Given a valid URI reference as a string, returns a tuple representing the
+    generic URI components, as per RFC 2396 appendix B. The tuple's structure
+    is (scheme, authority, path, query, fragment).
+
+    All values will be strings (possibly empty) or None if undefined.
+
+    Note that per rfc3986, there is no distinction between a path and
+    an "opaque part", as there was in RFC 2396.
+    """
+    # the pattern will match every possible string, so it's safe to
+    # assume there's a groupdict method to call.
+    g = SPLIT_URI_REF_PATTERN.match(uriref).groupdict()
+    scheme      = g['scheme']
+    authority   = g['authority']
+    path        = g['path']
+    query       = g['query']
+    fragment    = g['fragment']
+    return (scheme, authority, path, query, fragment)
+
+
+def Absolutize(uriRef, baseUri):
+    """
+    Resolves a URI reference to absolute form, effecting the result of RFC
+    3986 section 5. The URI reference is considered to be relative to the
+    given base URI.
+
+    It is the caller's responsibility to ensure that the base URI matches
+    the absolute-URI syntax rule of RFC 3986, and that its path component
+    does not contain '.' or '..' segments if the scheme is hierarchical.
+    Unexpected results may occur otherwise.
+
+    This function only conducts a minimal sanity check in order to determine
+    if relative resolution is possible: it raises a UriException if the base
+    URI does not have a scheme component. While it is true that the base URI
+    is irrelevant if the URI reference has a scheme, an exception is raised
+    in order to signal that the given string does not even come close to
+    meeting the criteria to be usable as a base URI.
+
+    It is the caller's responsibility to make a determination of whether the
+    URI reference constitutes a "same-document reference", as defined in RFC
+    2396 or RFC 3986. As per the spec, dereferencing a same-document
+    reference "should not" involve retrieval of a new representation of the
+    referenced resource. Note that the two specs have different definitions
+    of same-document reference: RFC 2396 says it is *only* the cases where the
+    reference is the empty string, or "#" followed by a fragment; RFC 3986
+    requires making a comparison of the base URI to the absolute form of the
+    reference (as is returned by the spec), minus its fragment component,
+    if any.
+
+    This function is similar to urlparse.urljoin() and urllib.basejoin().
+    Those functions, however, are (as of Python 2.3) outdated, buggy, and/or
+    designed to produce results acceptable for use with other core Python
+    libraries, rather than being earnest implementations of the relevant
+    specs. Their problems are most noticeable in their handling of
+    same-document references and 'file:' URIs, both being situations that
+    come up far too often to consider the functions reliable enough for
+    general use.
+    """
+    # Reasons to avoid using urllib.basejoin() and urlparse.urljoin():
+    # - Both are partial implementations of long-obsolete specs.
+    # - Both accept relative URLs as the base, which no spec allows.
+    # - urllib.basejoin() mishandles the '' and '..' references.
+    # - If the base URL uses a non-hierarchical or relative path,
+    #    or if the URL scheme is unrecognized, the result is not
+    #    always as expected (partly due to issues in RFC 1808).
+    # - If the authority component of a 'file' URI is empty,
+    #    the authority component is removed altogether. If it was
+    #    not present, an empty authority component is in the result.
+    # - '.' and '..' segments are not always collapsed as well as they
+    #    should be (partly due to issues in RFC 1808).
+    # - Effective Python 2.4, urllib.basejoin() *is* urlparse.urljoin(),
+    #    but urlparse.urljoin() is still based on RFC 1808.
+
+    # This procedure is based on the pseudocode in RFC 3986 sec. 5.2.
+    #
+    # ensure base URI is absolute
+    if not baseUri:
+        raise ValueError('baseUri is required and must be a non empty string')
+    if not IsAbsolute(baseUri):
+        raise ValueError('%r is not an absolute URI' % baseUri)
+    # shortcut for the simplest same-document reference cases
+    if uriRef == '' or uriRef[0] == '#':
+        return baseUri.split('#')[0] + uriRef
+    # ensure a clean slate
+    tScheme = tAuth = tPath = tQuery = None
+    # parse the reference into its components
+    (rScheme, rAuth, rPath, rQuery, rFrag) = SplitUriRef(uriRef)
+    # if the reference is absolute, eliminate '.' and '..' path segments
+    # and skip to the end
+    if rScheme is not None:
+        tScheme = rScheme
+        tAuth = rAuth
+        tPath = RemoveDotSegments(rPath)
+        tQuery = rQuery
+    else:
+        # the base URI's scheme, and possibly more, will be inherited
+        (bScheme, bAuth, bPath, bQuery, bFrag) = SplitUriRef(baseUri)
+        # if the reference is a net-path, just eliminate '.' and '..' path
+        # segments; no other changes needed.
+        if rAuth is not None:
+            tAuth = rAuth
+            tPath = RemoveDotSegments(rPath)
+            tQuery = rQuery
+        # if it's not a net-path, we need to inherit pieces of the base URI
+        else:
+            # use base URI's path if the reference's path is empty
+            if not rPath:
+                tPath = bPath
+                # use the reference's query, if any, or else the base URI's,
+                tQuery = rQuery is not None and rQuery or bQuery
+            # the reference's path is not empty
+            else:
+                # just use the reference's path if it's absolute
+                if rPath[0] == '/':
+                    tPath = RemoveDotSegments(rPath)
+                # merge the reference's relative path with the base URI's path
+                else:
+                    if bAuth is not None and not bPath:
+                        tPath = '/' + rPath
+                    else:
+                        tPath = bPath[:bPath.rfind('/')+1] + rPath
+                    tPath = RemoveDotSegments(tPath)
+                # use the reference's query
+                tQuery = rQuery
+            # since the reference isn't a net-path,
+            # use the authority from the base URI
+            tAuth = bAuth
+        # inherit the scheme from the base URI
+        tScheme = bScheme
+    # always use the reference's fragment (but no need to define another var)
+    #tFrag = rFrag
+
+    # now compose the target URI (RFC 3986 sec. 5.3)
+    return UnsplitUriRef((tScheme, tAuth, tPath, tQuery, rFrag))
+
+
+REG_NAME_HOST_PATTERN = re.compile(r"^(?:(?:[0-9A-Za-z\-_\.!~*'();&=+$,]|(?:%[0-9A-Fa-f]{2}))*)$")
+
+def MakeUrllibSafe(uriRef):
+    """
+    Makes the given RFC 3986-conformant URI reference safe for passing
+    to legacy urllib functions. The result may not be a valid URI.
+
+    As of Python 2.3.3, urllib.urlopen() does not fully support
+    internationalized domain names, it does not strip fragment components,
+    and on Windows, it expects file URIs to use '|' instead of ':' in the
+    path component corresponding to the drivespec. It also relies on
+    urllib.unquote(), which mishandles unicode arguments. This function
+    produces a URI reference that will work around these issues, although
+    the IDN workaround is limited to Python 2.3 only. May raise a
+    UnicodeEncodeError if the URI reference is Unicode and erroneously
+    contains non-ASCII characters.
+    """
+    # IDN support requires decoding any percent-encoded octets in the
+    # host part (if it's a reg-name) of the authority component, and when
+    # doing DNS lookups, applying IDNA encoding to that string first.
+    # As of Python 2.3, there is an IDNA codec, and the socket and httplib
+    # modules accept Unicode strings and apply IDNA encoding automatically
+    # where necessary. However, urllib.urlopen() has not yet been updated
+    # to do the same; it raises an exception if you give it a Unicode
+    # string, and does no conversion on non-Unicode strings, meaning you
+    # have to give it an IDNA string yourself. We will only support it on
+    # Python 2.3 and up.
+    #
+    # see if host is a reg-name, as opposed to IPv4 or IPv6 addr.
+    if isinstance(uriRef, unicode):
+        try:
+            uriRef = uriRef.encode('us-ascii') # parts of urllib are not unicode safe
+        except UnicodeError:
+            raise ValueError("uri %r must consist of ASCII characters." % uriRef)
+    (scheme, auth, path, query, frag) = urlparse.urlsplit(uriRef)
+    if auth and auth.find('@') > -1:
+        userinfo, hostport = auth.split('@')
+    else:
+        userinfo = None
+        hostport = auth
+    if hostport and hostport.find(':') > -1:
+        host, port = hostport.split(':')
+    else:
+        host = hostport
+        port = None
+    if host and REG_NAME_HOST_PATTERN.match(host):
+        # percent-encoded hostnames will always fail DNS lookups
+        host = urllib.unquote(host) #PercentDecode(host)
+        # IDNA-encode if possible.
+        # We shouldn't do this for schemes that don't need DNS lookup,
+        # but are there any (that you'd be calling urlopen for)?
+        if sys.version_info[0:2] >= (2, 3):
+            if isinstance(host, str):
+                host = host.decode('utf-8')
+            host = host.encode('idna')
+        # reassemble the authority with the new hostname
+        # (percent-decoded, and possibly IDNA-encoded)
+        auth = ''
+        if userinfo:
+            auth += userinfo + '@'
+        auth += host
+        if port:
+            auth += ':' + port
+
+    # On Windows, ensure that '|', not ':', is used in a drivespec.
+    if os.name == 'nt' and scheme == 'file':
+        path = path.replace(':', '|', 1)
+
+    # Note that we drop fragment, if any. See RFC 3986 sec. 3.5.
+    uri = urlparse.urlunsplit((scheme, auth, path, query, None))
+
+    return uri
+
+
+
+def BaseJoin(base, uriRef):
+    """
+    Merges a base URI reference with another URI reference, returning a
+    new URI reference.
+
+    It behaves exactly the same as Absolutize(), except the arguments
+    are reversed, and it accepts any URI reference (even a relative URI)
+    as the base URI. If the base has no scheme component, it is
+    evaluated as if it did, and then the scheme component of the result
+    is removed from the result, unless the uriRef had a scheme. Thus, if
+    neither argument has a scheme component, the result won't have one.
+
+    This function is named BaseJoin because it is very much like
+    urllib.basejoin(), but it follows the current rfc3986 algorithms
+    for path merging, dot segment elimination, and inheritance of query
+    and fragment components.
+
+    WARNING: This function exists for 2 reasons: (1) because of a need
+    within the 4Suite repository to perform URI reference absolutization
+    using base URIs that are stored (inappropriately) as absolute paths
+    in the subjects of statements in the RDF model, and (2) because of
+    a similar need to interpret relative repo paths in a 4Suite product
+    setup.xml file as being relative to a path that can be set outside
+    the document. When these needs go away, this function probably will,
+    too, so it is not advisable to use it.
+    """
+    if IsAbsolute(base):
+        return Absolutize(uriRef, base)
+    else:
+        dummyscheme = 'basejoin'
+        res = Absolutize(uriRef, '%s:%s' % (dummyscheme, base))
+        if IsAbsolute(uriRef):
+            # scheme will be inherited from uriRef
+            return res
+        else:
+            # no scheme in, no scheme out
+            return res[len(dummyscheme)+1:]
+
+
+def RemoveDotSegments(path):
+    """
+    Supports Absolutize() by implementing the remove_dot_segments function
+    described in RFC 3986 sec. 5.2.  It collapses most of the '.' and '..'
+    segments out of a path without eliminating empty segments. It is intended
+    to be used during the path merging process and may not give expected
+    results when used independently. Use NormalizePathSegments() or
+    NormalizePathSegmentsInUri() if more general normalization is desired.
+
+    semi-private because it is not for general use. I've implemented it
+    using two segment stacks, as alluded to in the spec, rather than the
+    explicit string-walking algorithm that would be too inefficient. (mbrown)
+    """
+    # return empty string if entire path is just "." or ".."
+    if path == '.' or path == '..':
+        return path[0:0] # preserves string type
+    # remove all "./" or "../" segments at the beginning
+    while path:
+        if path[:2] == './':
+            path = path[2:]
+        elif path[:3] == '../':
+            path = path[3:]
+        else:
+            break
+    # We need to keep track of whether there was a leading slash,
+    # because we're going to drop it in order to prevent our list of
+    # segments from having an ambiguous empty first item when we call
+    # split().
+    leading_slash = 0
+    if path[:1] == '/':
+        path = path[1:]
+        leading_slash = 1
+    # replace a trailing "/." with just "/"
+    if path[-2:] == '/.':
+        path = path[:-1]
+    # convert the segments into a list and process each segment in
+    # order from left to right.
+    segments = path.split('/')
+    keepers = []
+    segments.reverse()
+    while segments:
+        seg = segments.pop()
+        # '..' means drop the previous kept segment, if any.
+        # If none, and if the path is relative, then keep the '..'.
+        # If the '..' was the last segment, ensure
+        # that the result ends with '/'.
+        if seg == '..':
+            if keepers:
+                keepers.pop()
+            elif not leading_slash:
+                keepers.append(seg)
+            if not segments:
+                keepers.append('')
+        # ignore '.' segments and keep all others, even empty ones
+        elif seg != '.':
+            keepers.append(seg)
+    # reassemble the kept segments
+    return leading_slash * '/' + '/'.join(keepers)
+
+
+SCHEME_PATTERN = re.compile(r'([a-zA-Z][a-zA-Z0-9+\-.]*):')
+def GetScheme(uriRef):
+    """
+    Obtains, with optimum efficiency, just the scheme from a URI reference.
+    Returns a string, or if no scheme could be found, returns None.
+    """
+    # Using a regex seems to be the best option. Called 50,000 times on
+    # different URIs, on a 1.0-GHz PIII with FreeBSD 4.7 and Python
+    # 2.2.1, this method completed in 0.95s, and 0.05s if there was no
+    # scheme to find. By comparison,
+    #   urllib.splittype()[0] took 1.5s always;
+    #   Ft.Lib.Uri.SplitUriRef()[0] took 2.5s always;
+    #   urlparse.urlparse()[0] took 3.5s always.
+    m = SCHEME_PATTERN.match(uriRef)
+    if m is None:
+        return None
+    else:
+        return m.group(1)
+
+
+def IsAbsolute(identifier):
+    """
+    Given a string believed to be a URI or URI reference, tests that it is
+    absolute (as per RFC 2396), not relative -- i.e., that it has a scheme.
+    """
+    # We do it this way to avoid compiling another massive regex.
+    return GetScheme(identifier) is not None

data/lib/rubyfox/server/data/lib/Lib/xml/__init__.py

@@ -0,0 +1,41 @@
+"""Core XML support for Jython.
+
+This package contains two sub-packages:
+
+dom -- The W3C Document Object Model.  This supports DOM Level 1 +
+       Namespaces.
+
+sax -- The Simple API for XML, developed by XML-Dev, led by David
+       Megginson and ported to Python by Lars Marius Garshol.  This
+       supports the SAX 2 API.
+
+"""
+
+__all__ = ['dom', 'sax']
+
+# When being checked-out without options, this has the form
+# "<dollar>Revision: x.y </dollar>"
+# When exported using -kv, it is "x.y".
+__version__ = "$Revision: 2920 $".split()[-2:][0]
+
+
+_MINIMUM_XMLPLUS_VERSION = (0, 8, 5)
+
+
+try:
+    import _xmlplus
+except ImportError:
+    pass
+else:
+    try:
+        v = _xmlplus.version_info
+    except AttributeError:
+        # _xmlplus is too old; ignore it
+        pass
+    else:
+        if v >= _MINIMUM_XMLPLUS_VERSION:
+            import sys
+            _xmlplus.__path__.extend(__path__)
+            sys.modules[__name__] = _xmlplus
+        else:
+            del v

data/lib/rubyfox/server/data/lib/Lib/xml/dom/MessageSource.py

@@ -0,0 +1,54 @@
+# DOMException
+from xml.dom import INDEX_SIZE_ERR, DOMSTRING_SIZE_ERR , HIERARCHY_REQUEST_ERR
+from xml.dom import WRONG_DOCUMENT_ERR, INVALID_CHARACTER_ERR, NO_DATA_ALLOWED_ERR
+from xml.dom import NO_MODIFICATION_ALLOWED_ERR, NOT_FOUND_ERR, NOT_SUPPORTED_ERR
+from xml.dom import INUSE_ATTRIBUTE_ERR, INVALID_STATE_ERR, SYNTAX_ERR
+from xml.dom import INVALID_MODIFICATION_ERR, NAMESPACE_ERR, INVALID_ACCESS_ERR
+from xml.dom import VALIDATION_ERR
+
+# EventException
+from xml.dom import UNSPECIFIED_EVENT_TYPE_ERR
+
+#Range Exceptions
+from xml.dom import BAD_BOUNDARYPOINTS_ERR
+from xml.dom import INVALID_NODE_TYPE_ERR
+
+# Fourthought Exceptions
+from xml.dom import XML_PARSE_ERR
+
+from xml.FtCore import get_translator
+
+_ = get_translator("dom")
+
+
+DOMExceptionStrings = {
+    INDEX_SIZE_ERR: _("Index error accessing NodeList or NamedNodeMap"),
+    DOMSTRING_SIZE_ERR: _("DOMString exceeds maximum size"),
+    HIERARCHY_REQUEST_ERR: _("Node manipulation results in invalid parent/child relationship."),
+    WRONG_DOCUMENT_ERR: _("Node is from a different document"),
+    INVALID_CHARACTER_ERR: _("Invalid or illegal character"),
+    NO_DATA_ALLOWED_ERR: _("Node does not support data"),
+    NO_MODIFICATION_ALLOWED_ERR: _("Attempt to modify a read-only object"),
+    NOT_FOUND_ERR: _("Node does not exist in this context"),
+    NOT_SUPPORTED_ERR: _("Object or operation not supported"),
+    INUSE_ATTRIBUTE_ERR: _("Attribute already in use by an element"),
+    INVALID_STATE_ERR: _("Object is not, or is no longer, usable"),
+    SYNTAX_ERR: _("Specified string is invalid or illegal"),
+    INVALID_MODIFICATION_ERR: _("Attempt to modify the type of a node"),
+    NAMESPACE_ERR: _("Invalid or illegal namespace operation"),
+    INVALID_ACCESS_ERR: _("Object does not support this operation or parameter"),
+    VALIDATION_ERR: _("Operation would invalidate partial validity constraint"),
+    }
+
+EventExceptionStrings = {
+    UNSPECIFIED_EVENT_TYPE_ERR : _("Uninitialized type in Event object"),
+    }
+
+FtExceptionStrings = {
+    XML_PARSE_ERR : _("XML parse error at line %d, column %d: %s"),
+    }
+
+RangeExceptionStrings = {
+    BAD_BOUNDARYPOINTS_ERR : _("Invalid Boundary Points specified for Range"),
+    INVALID_NODE_TYPE_ERR : _("Invalid Container Node")
+    }

data/lib/rubyfox/server/data/lib/Lib/xml/dom/NodeFilter.py

@@ -0,0 +1,27 @@
+# This is the Python mapping for interface NodeFilter from
+# DOM2-Traversal-Range. It contains only constants.
+
+class NodeFilter:
+    """
+    This is the DOM2 NodeFilter interface. It contains only constants.
+    """
+    FILTER_ACCEPT = 1
+    FILTER_REJECT = 2
+    FILTER_SKIP   = 3
+
+    SHOW_ALL                    = 0xFFFFFFFFL
+    SHOW_ELEMENT                = 0x00000001
+    SHOW_ATTRIBUTE              = 0x00000002
+    SHOW_TEXT                   = 0x00000004
+    SHOW_CDATA_SECTION          = 0x00000008
+    SHOW_ENTITY_REFERENCE       = 0x00000010
+    SHOW_ENTITY                 = 0x00000020
+    SHOW_PROCESSING_INSTRUCTION = 0x00000040
+    SHOW_COMMENT                = 0x00000080
+    SHOW_DOCUMENT               = 0x00000100
+    SHOW_DOCUMENT_TYPE          = 0x00000200
+    SHOW_DOCUMENT_FRAGMENT      = 0x00000400
+    SHOW_NOTATION               = 0x00000800
+
+    def acceptNode(self, node):
+        raise NotImplementedError