rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/macpath.py

@@ -0,0 +1,242 @@
+"""Pathname and path-related operations for the Macintosh."""
+
+import os
+from stat import *
+
+__all__ = ["normcase","isabs","join","splitdrive","split","splitext",
+           "basename","dirname","commonprefix","getsize","getmtime",
+           "getatime","islink","exists","isdir","isfile",
+           "walk","expanduser","expandvars","normpath","abspath",
+           "realpath"]
+
+# Normalize the case of a pathname.  Dummy in Posix, but <s>.lower() here.
+
+def normcase(path):
+    return path.lower()
+
+
+def isabs(s):
+    """Return true if a path is absolute.
+    On the Mac, relative paths begin with a colon,
+    but as a special case, paths with no colons at all are also relative.
+    Anything else is absolute (the string up to the first colon is the
+    volume name)."""
+
+    return ':' in s and s[0] != ':'
+
+
+def join(s, *p):
+    path = s
+    for t in p:
+        if (not s) or isabs(t):
+            path = t
+            continue
+        if t[:1] == ':':
+            t = t[1:]
+        if ':' not in path:
+            path = ':' + path
+        if path[-1:] != ':':
+            path = path + ':'
+        path = path + t
+    return path
+
+
+def split(s):
+    """Split a pathname into two parts: the directory leading up to the final
+    bit, and the basename (the filename, without colons, in that directory).
+    The result (s, t) is such that join(s, t) yields the original argument."""
+
+    if ':' not in s: return '', s
+    colon = 0
+    for i in range(len(s)):
+        if s[i] == ':': colon = i + 1
+    path, file = s[:colon-1], s[colon:]
+    if path and not ':' in path:
+        path = path + ':'
+    return path, file
+
+
+def splitext(p):
+    """Split a path into root and extension.
+    The extension is everything starting at the last dot in the last
+    pathname component; the root is everything before that.
+    It is always true that root + ext == p."""
+
+    root, ext = '', ''
+    for c in p:
+        if c == ':':
+            root, ext = root + ext + c, ''
+        elif c == '.':
+            if ext:
+                root, ext = root + ext, c
+            else:
+                ext = c
+        elif ext:
+            ext = ext + c
+        else:
+            root = root + c
+    return root, ext
+
+
+def splitdrive(p):
+    """Split a pathname into a drive specification and the rest of the
+    path.  Useful on DOS/Windows/NT; on the Mac, the drive is always
+    empty (don't use the volume name -- it doesn't have the same
+    syntactic and semantic oddities as DOS drive letters, such as there
+    being a separate current directory per drive)."""
+
+    return '', p
+
+
+# Short interfaces to split()
+
+def dirname(s): return split(s)[0]
+def basename(s): return split(s)[1]
+
+def ismount(s):
+	if not isabs(s):
+		return False
+	components = split(s)
+	return len(components) == 2 and components[1] == ''
+
+def isdir(s):
+    """Return true if the pathname refers to an existing directory."""
+
+    try:
+        st = os.stat(s)
+    except os.error:
+        return 0
+    return S_ISDIR(st[ST_MODE])
+
+
+# Get size, mtime, atime of files.
+
+def getsize(filename):
+    """Return the size of a file, reported by os.stat()."""
+    st = os.stat(filename)
+    return st[ST_SIZE]
+
+def getmtime(filename):
+    """Return the last modification time of a file, reported by os.stat()."""
+    st = os.stat(filename)
+    return st[ST_MTIME]
+
+def getatime(filename):
+    """Return the last access time of a file, reported by os.stat()."""
+    st = os.stat(filename)
+    return st[ST_ATIME]
+
+
+def islink(s):
+    """Return true if the pathname refers to a symbolic link.
+    Always false on the Mac, until we understand Aliases.)"""
+
+    return 0
+
+
+def isfile(s):
+    """Return true if the pathname refers to an existing regular file."""
+
+    try:
+        st = os.stat(s)
+    except os.error:
+        return 0
+    return S_ISREG(st[ST_MODE])
+
+
+def exists(s):
+    """Return true if the pathname refers to an existing file or directory."""
+
+    try:
+        st = os.stat(s)
+    except os.error:
+        return 0
+    return 1
+
+# Return the longest prefix of all list elements.
+
+def commonprefix(m):
+    "Given a list of pathnames, returns the longest common leading component"
+    if not m: return ''
+    prefix = m[0]
+    for item in m:
+        for i in range(len(prefix)):
+            if prefix[:i+1] != item[:i+1]:
+                prefix = prefix[:i]
+                if i == 0: return ''
+                break
+    return prefix
+
+def expandvars(path):
+    """Dummy to retain interface-compatibility with other operating systems."""
+    return path
+
+
+def expanduser(path):
+    """Dummy to retain interface-compatibility with other operating systems."""
+    return path
+
+norm_error = 'macpath.norm_error: path cannot be normalized'
+
+def normpath(s):
+    """Normalize a pathname.  Will return the same result for
+    equivalent paths."""
+
+    if ":" not in s:
+        return ":"+s
+
+    comps = s.split(":")
+    i = 1
+    while i < len(comps)-1:
+        if comps[i] == "" and comps[i-1] != "":
+            if i > 1:
+                del comps[i-1:i+1]
+                i = i - 1
+            else:
+                # best way to handle this is to raise an exception
+                raise norm_error, 'Cannot use :: immediately after volume name'
+        else:
+            i = i + 1
+
+    s = ":".join(comps)
+
+    # remove trailing ":" except for ":" and "Volume:"
+    if s[-1] == ":" and len(comps) > 2 and s != ":"*len(s):
+        s = s[:-1]
+    return s
+
+
+def walk(top, func, arg):
+    """Directory tree walk with callback function.
+
+    For each directory in the directory tree rooted at top (including top
+    itself, but excluding '.' and '..'), call func(arg, dirname, fnames).
+    dirname is the name of the directory, and fnames a list of the names of
+    the files and subdirectories in dirname (excluding '.' and '..').  func
+    may modify the fnames list in-place (e.g. via del or slice assignment),
+    and walk will only recurse into the subdirectories whose names remain in
+    fnames; this can be used to implement a filter, or to impose a specific
+    order of visiting.  No semantics are defined for, or required of, arg,
+    beyond that arg is always passed to func.  It can be used, e.g., to pass
+    a filename pattern, or a mutable object designed to accumulate
+    statistics.  Passing None for arg is common."""
+
+    try:
+        names = os.listdir(top)
+    except os.error:
+        return
+    func(arg, top, names)
+    for name in names:
+        name = join(top, name)
+        if isdir(name):
+            walk(name, func, arg)
+
+
+def abspath(path):
+    """Return an absolute path."""
+    if not isabs(path):
+        path = join(os.getcwd(), path)
+    return normpath(path)
+
+# realpath is a no-op on systems without islink support
+realpath = abspath

data/lib/rubyfox/server/data/lib/Lib/macurl2path.py

@@ -0,0 +1,95 @@
+"""Macintosh-specific module for conversion between pathnames and URLs.
+
+Do not import directly; use urllib instead."""
+
+import urllib
+import os
+
+__all__ = ["url2pathname","pathname2url"]
+
+def url2pathname(pathname):
+    "Convert /-delimited pathname to mac pathname"
+    #
+    # XXXX The .. handling should be fixed...
+    #
+    tp = urllib.splittype(pathname)[0]
+    if tp and tp != 'file':
+        raise RuntimeError, 'Cannot convert non-local URL to pathname'
+    # Turn starting /// into /, an empty hostname means current host
+    if pathname[:3] == '///':
+        pathname = pathname[2:]
+    elif pathname[:2] == '//':
+        raise RuntimeError, 'Cannot convert non-local URL to pathname'
+    components = pathname.split('/')
+    # Remove . and embedded ..
+    i = 0
+    while i < len(components):
+        if components[i] == '.':
+            del components[i]
+        elif components[i] == '..' and i > 0 and \
+                                  components[i-1] not in ('', '..'):
+            del components[i-1:i+1]
+            i = i-1
+        elif components[i] == '' and i > 0 and components[i-1] != '':
+            del components[i]
+        else:
+            i = i+1
+    if not components[0]:
+        # Absolute unix path, don't start with colon
+        rv = ':'.join(components[1:])
+    else:
+        # relative unix path, start with colon. First replace
+        # leading .. by empty strings (giving ::file)
+        i = 0
+        while i < len(components) and components[i] == '..':
+            components[i] = ''
+            i = i + 1
+        rv = ':' + ':'.join(components)
+    # and finally unquote slashes and other funny characters
+    return urllib.unquote(rv)
+
+def pathname2url(pathname):
+    "convert mac pathname to /-delimited pathname"
+    if '/' in pathname:
+        raise RuntimeError, "Cannot convert pathname containing slashes"
+    components = pathname.split(':')
+    # Remove empty first and/or last component
+    if components[0] == '':
+        del components[0]
+    if components[-1] == '':
+        del components[-1]
+    # Replace empty string ('::') by .. (will result in '/../' later)
+    for i in range(len(components)):
+        if components[i] == '':
+            components[i] = '..'
+    # Truncate names longer than 31 bytes
+    components = map(_pncomp2url, components)
+
+    if os.path.isabs(pathname):
+        return '/' + '/'.join(components)
+    else:
+        return '/'.join(components)
+
+def _pncomp2url(component):
+    component = urllib.quote(component[:31], safe='')  # We want to quote slashes
+    return component
+
+def test():
+    for url in ["index.html",
+                "bar/index.html",
+                "/foo/bar/index.html",
+                "/foo/bar/",
+                "/"]:
+        print `url`, '->', `url2pathname(url)`
+    for path in ["drive:",
+                 "drive:dir:",
+                 "drive:dir:file",
+                 "drive:file",
+                 "file",
+                 ":file",
+                 ":dir:",
+                 ":dir:file"]:
+        print `path`, '->', `pathname2url(path)`
+
+if __name__ == '__main__':
+    test()

data/lib/rubyfox/server/data/lib/Lib/mailbox.py

@@ -0,0 +1,313 @@
+#! /usr/bin/env python
+
+"""Classes to handle Unix style, MMDF style, and MH style mailboxes."""
+
+
+import rfc822
+import os
+
+__all__ = ["UnixMailbox","MmdfMailbox","MHMailbox","Maildir","BabylMailbox",
+           "PortableUnixMailbox"]
+
+class _Mailbox:
+    def __init__(self, fp, factory=rfc822.Message):
+        self.fp = fp
+        self.seekp = 0
+        self.factory = factory
+
+    def __iter__(self):
+        return iter(self.next, None)
+
+    def next(self):
+        while 1:
+            self.fp.seek(self.seekp)
+            try:
+                self._search_start()
+            except EOFError:
+                self.seekp = self.fp.tell()
+                return None
+            start = self.fp.tell()
+            self._search_end()
+            self.seekp = stop = self.fp.tell()
+            if start != stop:
+                break
+        return self.factory(_Subfile(self.fp, start, stop))
+
+
+class _Subfile:
+    def __init__(self, fp, start, stop):
+        self.fp = fp
+        self.start = start
+        self.stop = stop
+        self.pos = self.start
+
+    def read(self, length = None):
+        if self.pos >= self.stop:
+            return ''
+        remaining = self.stop - self.pos
+        if length is None or length < 0:
+            length = remaining
+        elif length > remaining:
+            length = remaining
+        self.fp.seek(self.pos)
+        data = self.fp.read(length)
+        self.pos = self.fp.tell()
+        return data
+
+    def readline(self, length = None):
+        if self.pos >= self.stop:
+            return ''
+        if length is None:
+            length = self.stop - self.pos
+        self.fp.seek(self.pos)
+        data = self.fp.readline(length)
+        self.pos = self.fp.tell()
+        return data
+
+    def readlines(self, sizehint = -1):
+        lines = []
+        while 1:
+            line = self.readline()
+            if not line:
+                break
+            lines.append(line)
+            if sizehint >= 0:
+                sizehint = sizehint - len(line)
+                if sizehint <= 0:
+                    break
+        return lines
+
+    def tell(self):
+        return self.pos - self.start
+
+    def seek(self, pos, whence=0):
+        if whence == 0:
+            self.pos = self.start + pos
+        elif whence == 1:
+            self.pos = self.pos + pos
+        elif whence == 2:
+            self.pos = self.stop + pos
+
+    def close(self):
+        del self.fp
+
+
+# Recommended to use PortableUnixMailbox instead!
+class UnixMailbox(_Mailbox):
+    def _search_start(self):
+        while 1:
+            pos = self.fp.tell()
+            line = self.fp.readline()
+            if not line:
+                raise EOFError
+            if line[:5] == 'From ' and self._isrealfromline(line):
+                self.fp.seek(pos)
+                return
+
+    def _search_end(self):
+        self.fp.readline()      # Throw away header line
+        while 1:
+            pos = self.fp.tell()
+            line = self.fp.readline()
+            if not line:
+                return
+            if line[:5] == 'From ' and self._isrealfromline(line):
+                self.fp.seek(pos)
+                return
+
+    # An overridable mechanism to test for From-line-ness.  You can either
+    # specify a different regular expression or define a whole new
+    # _isrealfromline() method.  Note that this only gets called for lines
+    # starting with the 5 characters "From ".
+    #
+    # BAW: According to
+    #http://home.netscape.com/eng/mozilla/2.0/relnotes/demo/content-length.html
+    # the only portable, reliable way to find message delimiters in a BSD (i.e
+    # Unix mailbox) style folder is to search for "\n\nFrom .*\n", or at the
+    # beginning of the file, "^From .*\n".  While _fromlinepattern below seems
+    # like a good idea, in practice, there are too many variations for more
+    # strict parsing of the line to be completely accurate.
+    #
+    # _strict_isrealfromline() is the old version which tries to do stricter
+    # parsing of the From_ line.  _portable_isrealfromline() simply returns
+    # true, since it's never called if the line doesn't already start with
+    # "From ".
+    #
+    # This algorithm, and the way it interacts with _search_start() and
+    # _search_end() may not be completely correct, because it doesn't check
+    # that the two characters preceding "From " are \n\n or the beginning of
+    # the file.  Fixing this would require a more extensive rewrite than is
+    # necessary.  For convenience, we've added a StrictUnixMailbox class which
+    # uses the older, more strict _fromlinepattern regular expression.
+
+    _fromlinepattern = r"From \s*[^\s]+\s+\w\w\w\s+\w\w\w\s+\d?\d\s+" \
+                       r"\d?\d:\d\d(:\d\d)?(\s+[^\s]+)?\s+\d\d\d\d\s*$"
+    _regexp = None
+
+    def _strict_isrealfromline(self, line):
+        if not self._regexp:
+            import re
+            self._regexp = re.compile(self._fromlinepattern)
+        return self._regexp.match(line)
+
+    def _portable_isrealfromline(self, line):
+        return 1
+
+    _isrealfromline = _strict_isrealfromline
+
+
+class PortableUnixMailbox(UnixMailbox):
+    _isrealfromline = UnixMailbox._portable_isrealfromline
+
+
+class MmdfMailbox(_Mailbox):
+    def _search_start(self):
+        while 1:
+            line = self.fp.readline()
+            if not line:
+                raise EOFError
+            if line[:5] == '\001\001\001\001\n':
+                return
+
+    def _search_end(self):
+        while 1:
+            pos = self.fp.tell()
+            line = self.fp.readline()
+            if not line:
+                return
+            if line == '\001\001\001\001\n':
+                self.fp.seek(pos)
+                return
+
+
+class MHMailbox:
+    def __init__(self, dirname, factory=rfc822.Message):
+        import re
+        pat = re.compile('^[1-9][0-9]*$')
+        self.dirname = dirname
+        # the three following lines could be combined into:
+        # list = map(long, filter(pat.match, os.listdir(self.dirname)))
+        list = os.listdir(self.dirname)
+        list = filter(pat.match, list)
+        list = map(long, list)
+        list.sort()
+        # This only works in Python 1.6 or later;
+        # before that str() added 'L':
+        self.boxes = map(str, list)
+        self.factory = factory
+
+    def __iter__(self):
+        return iter(self.next, None)
+
+    def next(self):
+        if not self.boxes:
+            return None
+        fn = self.boxes[0]
+        del self.boxes[0]
+        fp = open(os.path.join(self.dirname, fn))
+        return self.factory(fp)
+
+
+class Maildir:
+    # Qmail directory mailbox
+
+    def __init__(self, dirname, factory=rfc822.Message):
+        self.dirname = dirname
+        self.factory = factory
+
+        # check for new mail
+        newdir = os.path.join(self.dirname, 'new')
+        boxes = [os.path.join(newdir, f)
+                 for f in os.listdir(newdir) if f[0] != '.']
+
+        # Now check for current mail in this maildir
+        curdir = os.path.join(self.dirname, 'cur')
+        boxes += [os.path.join(curdir, f)
+                  for f in os.listdir(curdir) if f[0] != '.']
+
+        self.boxes = boxes
+
+    def __iter__(self):
+        return iter(self.next, None)
+
+    def next(self):
+        if not self.boxes:
+            return None
+        fn = self.boxes[0]
+        del self.boxes[0]
+        fp = open(fn)
+        return self.factory(fp)
+
+
+class BabylMailbox(_Mailbox):
+    def _search_start(self):
+        while 1:
+            line = self.fp.readline()
+            if not line:
+                raise EOFError
+            if line == '*** EOOH ***\n':
+                return
+
+    def _search_end(self):
+        while 1:
+            pos = self.fp.tell()
+            line = self.fp.readline()
+            if not line:
+                return
+            if line == '\037\014\n':
+                self.fp.seek(pos)
+                return
+
+
+def _test():
+    import sys
+
+    args = sys.argv[1:]
+    if not args:
+        for key in 'MAILDIR', 'MAIL', 'LOGNAME', 'USER':
+            if os.environ.has_key(key):
+                mbox = os.environ[key]
+                break
+        else:
+            print "$MAIL, $LOGNAME nor $USER set -- who are you?"
+            return
+    else:
+        mbox = args[0]
+    if mbox[:1] == '+':
+        mbox = os.environ['HOME'] + '/Mail/' + mbox[1:]
+    elif not '/' in mbox:
+        mbox = '/usr/mail/' + mbox
+    if os.path.isdir(mbox):
+        if os.path.isdir(os.path.join(mbox, 'cur')):
+            mb = Maildir(mbox)
+        else:
+            mb = MHMailbox(mbox)
+    else:
+        fp = open(mbox, 'r')
+        mb = PortableUnixMailbox(fp)
+
+    msgs = []
+    while 1:
+        msg = mb.next()
+        if msg is None:
+            break
+        msgs.append(msg)
+        if len(args) <= 1:
+            msg.fp = None
+    if len(args) > 1:
+        num = int(args[1])
+        print 'Message %d body:'%num
+        msg = msgs[num-1]
+        msg.rewindbody()
+        sys.stdout.write(msg.fp.read())
+    else:
+        print 'Mailbox',mbox,'has',len(msgs),'messages:'
+        for msg in msgs:
+            f = msg.getheader('from') or ""
+            s = msg.getheader('subject') or ""
+            d = msg.getheader('date') or ""
+            print '-%20.20s   %20.20s   %-30.30s'%(f, d[5:], s)
+
+
+if __name__ == '__main__':
+    _test()