rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/email/test/test_email_codecs.py

@@ -0,0 +1,68 @@
+# Copyright (C) 2002 Python Software Foundation
+# email package unit tests for (optional) Asian codecs
+
+import unittest
+from test.test_support import run_unittest
+
+from email.test.test_email import TestEmailBase
+from email.Charset import Charset
+from email.Header import Header, decode_header
+
+# See if we have the Japanese codecs package installed
+try:
+    unicode('foo', 'japanese.iso-2022-jp')
+except LookupError:
+    # Different in Python 2.3
+    from test_support import TestSkipped
+    raise TestSkipped, 'Optional Japanese codecs not installed'
+
+
+
+class TestEmailAsianCodecs(TestEmailBase):
+    def test_japanese_codecs(self):
+        eq = self.ndiffAssertEqual
+        j = Charset("euc-jp")
+        g = Charset("iso-8859-1")
+        h = Header("Hello World!")
+        jhello = '\xa5\xcf\xa5\xed\xa1\xbc\xa5\xef\xa1\xbc\xa5\xeb\xa5\xc9\xa1\xaa'
+        ghello = 'Gr\xfc\xdf Gott!'
+        h.append(jhello, j)
+        h.append(ghello, g)
+        # BAW: This used to -- and maybe should -- fold the two iso-8859-1
+        # chunks into a single encoded word.  However it doesn't violate the
+        # standard to have them as two encoded chunks and maybe it's
+        # reasonable <wink> for each .append() call to result in a separate
+        # encoded word.
+        eq(h.encode(), """\
+Hello World! =?iso-2022-jp?b?GyRCJU8lbSE8JW8hPCVrJUkhKhsoQg==?=
+ =?iso-8859-1?q?Gr=FC=DF?= =?iso-8859-1?q?_Gott!?=""")
+        eq(decode_header(h.encode()),
+           [('Hello World!', None),
+            ('\x1b$B%O%m!<%o!<%k%I!*\x1b(B', 'iso-2022-jp'),
+            ('Gr\xfc\xdf Gott!', 'iso-8859-1')])
+        long = 'test-ja \xa4\xd8\xc5\xea\xb9\xc6\xa4\xb5\xa4\xec\xa4\xbf\xa5\xe1\xa1\xbc\xa5\xeb\xa4\xcf\xbb\xca\xb2\xf1\xbc\xd4\xa4\xce\xbe\xb5\xc7\xa7\xa4\xf2\xc2\xd4\xa4\xc3\xa4\xc6\xa4\xa4\xa4\xde\xa4\xb9'
+        h = Header(long, j, header_name="Subject")
+        # test a very long header
+        enc = h.encode()
+        # TK: splitting point may differ by codec design and/or Header encoding
+        eq(enc , """\
+=?iso-2022-jp?b?dGVzdC1qYSAbJEIkWEVqOUYkNSRsJD8lYSE8JWskTztKGyhC?=
+ =?iso-2022-jp?b?GyRCMnE8VCROPjVHJyRyQlQkQyRGJCQkXiQ5GyhC?=""")
+        # TK: full decode comparison
+        eq(h.__unicode__().encode('euc-jp'), long)
+
+
+
+def suite():
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(TestEmailAsianCodecs))
+    return suite
+
+
+def test_main():
+    run_unittest(TestEmailAsianCodecs)
+
+
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='suite')

data/lib/rubyfox/server/data/lib/Lib/email/test/test_email_torture.py

@@ -0,0 +1,136 @@
+# Copyright (C) 2002 Python Software Foundation
+#
+# A torture test of the email package.  This should not be run as part of the
+# standard Python test suite since it requires several meg of email messages
+# collected in the wild.  These source messages are not checked into the
+# Python distro, but are available as part of the standalone email package at
+# http://sf.net/projects/mimelib
+
+import sys
+import os
+import unittest
+from cStringIO import StringIO
+from types import ListType
+
+from email.test.test_email import TestEmailBase
+from test.test_support import TestSkipped
+
+import email
+from email import __file__ as testfile
+from email.Iterators import _structure
+
+def openfile(filename):
+    from os.path import join, dirname, abspath
+    path = abspath(join(dirname(testfile), os.pardir, 'moredata', filename))
+    return open(path, 'r')
+
+# Prevent this test from running in the Python distro
+try:
+    openfile('crispin-torture.txt')
+except IOError:
+    raise TestSkipped
+
+
+
+class TortureBase(TestEmailBase):
+    def _msgobj(self, filename):
+        fp = openfile(filename)
+        try:
+            msg = email.message_from_file(fp)
+        finally:
+            fp.close()
+        return msg
+
+
+
+class TestCrispinTorture(TortureBase):
+    # Mark Crispin's torture test from the SquirrelMail project
+    def test_mondo_message(self):
+        eq = self.assertEqual
+        neq = self.ndiffAssertEqual
+        msg = self._msgobj('crispin-torture.txt')
+        payload = msg.get_payload()
+        eq(type(payload), ListType)
+        eq(len(payload), 12)
+        eq(msg.preamble, None)
+        eq(msg.epilogue, '\n\n')
+        # Probably the best way to verify the message is parsed correctly is to
+        # dump its structure and compare it against the known structure.
+        fp = StringIO()
+        _structure(msg, fp=fp)
+        neq(fp.getvalue(), """\
+multipart/mixed
+    text/plain
+    message/rfc822
+        multipart/alternative
+            text/plain
+            multipart/mixed
+                text/richtext
+            application/andrew-inset
+    message/rfc822
+        audio/basic
+    audio/basic
+    image/pbm
+    message/rfc822
+        multipart/mixed
+            multipart/mixed
+                text/plain
+                audio/x-sun
+            multipart/mixed
+                image/gif
+                image/gif
+                application/x-be2
+                application/atomicmail
+            audio/x-sun
+    message/rfc822
+        multipart/mixed
+            text/plain
+            image/pgm
+            text/plain
+    message/rfc822
+        multipart/mixed
+            text/plain
+            image/pbm
+    message/rfc822
+        application/postscript
+    image/gif
+    message/rfc822
+        multipart/mixed
+            audio/basic
+            audio/basic
+    message/rfc822
+        multipart/mixed
+            application/postscript
+            text/plain
+            message/rfc822
+                multipart/mixed
+                    text/plain
+                    multipart/parallel
+                        image/gif
+                        audio/basic
+                    application/atomicmail
+                    message/rfc822
+                        audio/x-sun
+""")
+
+
+def _testclasses():
+    mod = sys.modules[__name__]
+    return [getattr(mod, name) for name in dir(mod) if name.startswith('Test')]
+
+
+def suite():
+    suite = unittest.TestSuite()
+    for testclass in _testclasses():
+        suite.addTest(unittest.makeSuite(testclass))
+    return suite
+
+
+def test_main():
+    for testclass in _testclasses():
+        test_support.run_unittest(testclass)
+
+
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='suite')

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

@@ -0,0 +1,97 @@
+""" Standard "encodings" Package
+
+    Standard Python encoding modules are stored in this package
+    directory.
+
+    Codec modules must have names corresponding to standard lower-case
+    encoding names with hyphens mapped to underscores, e.g. 'utf-8' is
+    implemented by the module 'utf_8.py'.
+
+    Each codec module must export the following interface:
+
+    * getregentry() -> (encoder, decoder, stream_reader, stream_writer)
+    The getregentry() API must return callable objects which adhere to
+    the Python Codec Interface Standard.
+
+    In addition, a module may optionally also define the following
+    APIs which are then used by the package's codec search function:
+
+    * getaliases() -> sequence of encoding name strings to use as aliases
+
+    Alias names returned by getaliases() must be standard encoding
+    names as defined above (lower-case, hyphens converted to
+    underscores).
+
+Written by Marc-Andre Lemburg (mal@lemburg.com).
+
+(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
+
+"""#"
+
+import codecs,aliases,exceptions
+
+_cache = {}
+_unknown = '--unknown--'
+
+class CodecRegistryError(exceptions.LookupError,
+                         exceptions.SystemError):
+    pass
+
+def search_function(encoding):
+    
+    # Cache lookup
+    entry = _cache.get(encoding,_unknown)
+    if entry is not _unknown:
+        return entry
+
+    # Import the module
+    modname = encoding.replace('-', '_')
+    modname = aliases.aliases.get(modname,modname)
+    try:
+        mod = __import__(modname,globals(),locals(),'*')
+    except ImportError,why:
+        # cache misses
+        _cache[encoding] = None
+        return None
+
+    try:
+        getregentry = mod.getregentry
+    except AttributeError:
+        # Not a codec module
+        _cache[encoding] = None
+        return None
+    
+    # Now ask the module for the registry entry
+    try:
+        entry = tuple(getregentry())
+    except AttributeError:
+        entry = ()
+    if len(entry) != 4:
+        raise CodecRegistryError,\
+              'module "%s" (%s) failed to register' % \
+              (mod.__name__, mod.__file__)
+    for obj in entry:
+        if not callable(obj):
+            raise CodecRegistryError,\
+                  'incompatible codecs in module "%s" (%s)' % \
+                  (mod.__name__, mod.__file__)
+
+    # Cache the codec registry entry
+    _cache[encoding] = entry
+
+    # Register its aliases (without overwriting previously registered
+    # aliases)
+    try:
+        codecaliases = mod.getaliases()
+    except AttributeError:
+        pass
+    else:
+        for alias in codecaliases:
+            if not aliases.aliases.has_key(alias):
+                aliases.aliases[alias] = modname
+
+    # Return the registry entry
+    return entry
+
+# Register the search_function in the Python codec registry
+codecs.register(search_function)

data/lib/rubyfox/server/data/lib/Lib/encodings/aliases.py

@@ -0,0 +1,115 @@
+""" Encoding Aliases Support
+
+    This module is used by the encodings package search function to
+    map encodings names to module names.
+
+    Note that the search function converts the encoding names to lower
+    case and replaces hyphens with underscores *before* performing the
+    lookup.
+
+"""
+aliases = {
+
+    # Latin-1
+    'latin': 'latin_1',
+    'latin1': 'latin_1',
+    
+    # UTF-7
+    'utf7': 'utf_7',
+    'u7': 'utf_7',
+    
+    # UTF-8
+    'utf': 'utf_8',
+    'utf8': 'utf_8',
+    'u8': 'utf_8',
+    'utf8@ucs2': 'utf_8',
+    'utf8@ucs4': 'utf_8',
+    
+    # UTF-16
+    'utf16': 'utf_16',
+    'u16': 'utf_16',
+    'utf_16be': 'utf_16_be',
+    'utf_16le': 'utf_16_le',
+    'unicodebigunmarked': 'utf_16_be',
+    'unicodelittleunmarked': 'utf_16_le',
+
+    # ASCII
+    'us_ascii': 'ascii',
+    'ansi_x3.4_1968': 'ascii', # used on Linux
+    'ansi_x3_4_1968': 'ascii', # used on BSD?
+    '646': 'ascii',            # used on Solaris
+
+    # EBCDIC
+    'ebcdic_cp_us': 'cp037',
+    'ibm039': 'cp037',
+    'ibm1140': 'cp1140',
+    
+    # ISO
+    '8859': 'latin_1',
+    'iso8859': 'latin_1',
+    'iso8859_1': 'latin_1',
+    'iso_8859_1': 'latin_1',
+    'iso_8859_10': 'iso8859_10',
+    'iso_8859_13': 'iso8859_13',
+    'iso_8859_14': 'iso8859_14',
+    'iso_8859_15': 'iso8859_15',
+    'iso_8859_2': 'iso8859_2',
+    'iso_8859_3': 'iso8859_3',
+    'iso_8859_4': 'iso8859_4',
+    'iso_8859_5': 'iso8859_5',
+    'iso_8859_6': 'iso8859_6',
+    'iso_8859_7': 'iso8859_7',
+    'iso_8859_8': 'iso8859_8',
+    'iso_8859_9': 'iso8859_9',
+
+    # Mac
+    'maclatin2': 'mac_latin2',
+    'maccentraleurope': 'mac_latin2',
+    'maccyrillic': 'mac_cyrillic',
+    'macgreek': 'mac_greek',
+    'maciceland': 'mac_iceland',
+    'macroman': 'mac_roman',
+    'macturkish': 'mac_turkish',
+
+    # Windows
+    'windows_1251': 'cp1251',
+    'windows_1252': 'cp1252',
+    'windows_1254': 'cp1254',
+    'windows_1255': 'cp1255',
+    'windows_1256': 'cp1256',
+    'windows_1257': 'cp1257',
+    'windows_1258': 'cp1258',
+
+    # MBCS
+    'dbcs': 'mbcs',
+
+    # Code pages
+    '437': 'cp437',
+
+    # CJK
+    #
+    # The codecs for these encodings are not distributed with the
+    # Python core, but are included here for reference, since the
+    # locale module relies on having these aliases available.
+    #
+    'jis_7': 'jis_7',
+    'iso_2022_jp': 'jis_7',
+    'ujis': 'euc_jp',
+    'ajec': 'euc_jp',
+    'eucjp': 'euc_jp',
+    'tis260': 'tactis',
+    'sjis': 'shift_jis',
+
+    # Content transfer/compression encodings
+    'rot13': 'rot_13',
+    'base64': 'base64_codec',
+    'base_64': 'base64_codec',
+    'zlib': 'zlib_codec',
+    'zip': 'zlib_codec',
+    'hex': 'hex_codec',
+    'uu': 'uu_codec',
+    'quopri': 'quopri_codec',
+    'quotedprintable': 'quopri_codec',
+    'quoted_printable': 'quopri_codec',
+
+}

data/lib/rubyfox/server/data/lib/Lib/encodings/ascii.py

@@ -0,0 +1,35 @@
+""" Python 'ascii' Codec
+
+
+Written by Marc-Andre Lemburg (mal@lemburg.com).
+
+(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
+
+"""
+import codecs
+
+### Codec APIs
+
+class Codec(codecs.Codec):
+
+    # Note: Binding these as C functions will result in the class not
+    # converting them to methods. This is intended.
+    encode = codecs.ascii_encode
+    decode = codecs.ascii_decode
+
+class StreamWriter(Codec,codecs.StreamWriter):
+    pass
+        
+class StreamReader(Codec,codecs.StreamReader):
+    pass
+
+class StreamConverter(StreamWriter,StreamReader):
+
+    encode = codecs.ascii_decode
+    decode = codecs.ascii_encode
+
+### encodings module API
+
+def getregentry():
+
+    return (Codec.encode,Codec.decode,StreamReader,StreamWriter)

data/lib/rubyfox/server/data/lib/Lib/encodings/base64_codec.py

@@ -0,0 +1,62 @@
+""" Python 'base64_codec' Codec - base64 content transfer encoding
+
+    Unlike most of the other codecs which target Unicode, this codec
+    will return Python string objects for both encode and decode.
+
+    Written by Marc-Andre Lemburg (mal@lemburg.com).
+
+"""
+import codecs, base64
+
+### Codec APIs
+
+def base64_encode(input,errors='strict'):
+
+    """ Encodes the object input and returns a tuple (output
+        object, length consumed).
+
+        errors defines the error handling to apply. It defaults to
+        'strict' handling which is the only currently supported
+        error handling for this codec.
+
+    """
+    assert errors == 'strict'
+    output = base64.encodestring(input)
+    return (output, len(input))
+
+def base64_decode(input,errors='strict'):
+
+    """ Decodes the object input and returns a tuple (output
+        object, length consumed).
+
+        input must be an object which provides the bf_getreadbuf
+        buffer slot. Python strings, buffer objects and memory
+        mapped files are examples of objects providing this slot.
+
+        errors defines the error handling to apply. It defaults to
+        'strict' handling which is the only currently supported
+        error handling for this codec.
+
+    """
+    assert errors == 'strict'
+    output = base64.decodestring(input)
+    return (output, len(input))
+
+class Codec(codecs.Codec):
+
+    def encode(self, input,errors='strict'):
+        return base64_encode(input,errors)
+    def decode(self, input,errors='strict'):
+        return base64_decode(input,errors)
+
+class StreamWriter(Codec,codecs.StreamWriter):
+    pass
+        
+class StreamReader(Codec,codecs.StreamReader):
+    pass
+
+### encodings module API
+
+def getregentry():
+
+    return (base64_encode,base64_decode,StreamReader,StreamWriter)

data/lib/rubyfox/server/data/lib/Lib/encodings/charmap.py

@@ -0,0 +1,51 @@
+""" Generic Python Character Mapping Codec.
+
+    Use this codec directly rather than through the automatic
+    conversion mechanisms supplied by unicode() and .encode().
+    
+
+Written by Marc-Andre Lemburg (mal@lemburg.com).
+
+(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
+
+"""#"
+
+import codecs
+
+### Codec APIs
+
+class Codec(codecs.Codec):
+
+    # Note: Binding these as C functions will result in the class not
+    # converting them to methods. This is intended.
+    encode = codecs.charmap_encode
+    decode = codecs.charmap_decode
+
+class StreamWriter(Codec,codecs.StreamWriter):
+
+    def __init__(self,stream,errors='strict',mapping=None):
+
+        codecs.StreamWriter.__init__(self,stream,errors)
+        self.mapping = mapping
+
+    def encode(self,input,errors='strict'):
+
+        return Codec.encode(input,errors,self.mapping)
+        
+class StreamReader(Codec,codecs.StreamReader):
+
+    def __init__(self,stream,errors='strict',mapping=None):
+
+        codecs.StreamReader.__init__(self,strict,errors)
+        self.mapping = mapping
+
+    def decode(self,input,errors='strict'):
+
+        return Codec.decode(input,errors,self.mapping)
+
+### encodings module API
+
+def getregentry():
+
+    return (Codec.encode,Codec.decode,StreamReader,StreamWriter)
+