rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,209 @@
+"""A lexical analyzer class for simple shell-like syntaxes."""
+
+# Module and documentation by Eric S. Raymond, 21 Dec 1998
+# Input stacking and error message cleanup added by ESR, March 2000
+# push_source() and pop_source() made explicit by ESR, January 2001.
+
+import os.path
+import sys
+
+__all__ = ["shlex"]
+
+class shlex:
+    "A lexical analyzer class for simple shell-like syntaxes."
+    def __init__(self, instream=None, infile=None):
+        if instream:
+            self.instream = instream
+            self.infile = infile
+        else:
+            self.instream = sys.stdin
+            self.infile = None
+        self.commenters = '#'
+        self.wordchars = ('abcdfeghijklmnopqrstuvwxyz'
+                          'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_')
+        self.whitespace = ' \t\r\n'
+        self.quotes = '\'"'
+        self.state = ' '
+        self.pushback = []
+        self.lineno = 1
+        self.debug = 0
+        self.token = ''
+        self.filestack = []
+        self.source = None
+        if self.debug:
+            print 'shlex: reading from %s, line %d' \
+                  % (self.instream, self.lineno)
+
+    def push_token(self, tok):
+        "Push a token onto the stack popped by the get_token method"
+        if self.debug >= 1:
+            print "shlex: pushing token " + `tok`
+        self.pushback = [tok] + self.pushback
+
+    def push_source(self, newstream, newfile=None):
+        "Push an input source onto the lexer's input source stack."
+        self.filestack.insert(0, (self.infile, self.instream, self.lineno))
+        self.infile = newfile
+        self.instream = newstream
+        self.lineno = 1
+        if self.debug:
+            if newfile:
+                print 'shlex: pushing to file %s' % (self.infile,)
+            else:
+                print 'shlex: pushing to stream %s' % (self.instream,)
+
+    def pop_source(self):
+        "Pop the input source stack."
+        self.instream.close()
+        (self.infile, self.instream, self.lineno) = self.filestack[0]
+        self.filestack = self.filestack[1:]
+        if self.debug:
+            print 'shlex: popping to %s, line %d' \
+                  % (self.instream, self.lineno)
+        self.state = ' '
+
+    def get_token(self):
+        "Get a token from the input stream (or from stack if it's nonempty)"
+        if self.pushback:
+            tok = self.pushback[0]
+            self.pushback = self.pushback[1:]
+            if self.debug >= 1:
+                print "shlex: popping token " + `tok`
+            return tok
+        # No pushback.  Get a token.
+        raw = self.read_token()
+        # Handle inclusions
+        while raw == self.source:
+            spec = self.sourcehook(self.read_token())
+            if spec:
+                (newfile, newstream) = spec
+                self.push_source(newstream, newfile)
+            raw = self.get_token()
+        # Maybe we got EOF instead?
+        while raw == "":
+            if len(self.filestack) == 0:
+                return ""
+            else:
+                self.pop_source()
+                raw = self.get_token()
+         # Neither inclusion nor EOF
+        if self.debug >= 1:
+            if raw:
+                print "shlex: token=" + `raw`
+            else:
+                print "shlex: token=EOF"
+        return raw
+
+    def read_token(self):
+        "Read a token from the input stream (no pushback or inclusions)"
+        while 1:
+            nextchar = self.instream.read(1)
+            if nextchar == '\n':
+                self.lineno = self.lineno + 1
+            if self.debug >= 3:
+                print "shlex: in state", repr(self.state), \
+                      "I see character:", repr(nextchar)
+            if self.state is None:
+                self.token = ''        # past end of file
+                break
+            elif self.state == ' ':
+                if not nextchar:
+                    self.state = None  # end of file
+                    break
+                elif nextchar in self.whitespace:
+                    if self.debug >= 2:
+                        print "shlex: I see whitespace in whitespace state"
+                    if self.token:
+                        break   # emit current token
+                    else:
+                        continue
+                elif nextchar in self.commenters:
+                    self.instream.readline()
+                    self.lineno = self.lineno + 1
+                elif nextchar in self.wordchars:
+                    self.token = nextchar
+                    self.state = 'a'
+                elif nextchar in self.quotes:
+                    self.token = nextchar
+                    self.state = nextchar
+                else:
+                    self.token = nextchar
+                    if self.token:
+                        break   # emit current token
+                    else:
+                        continue
+            elif self.state in self.quotes:
+                self.token = self.token + nextchar
+                if nextchar == self.state:
+                    self.state = ' '
+                    break
+                elif not nextchar:      # end of file
+                    if self.debug >= 2:
+                        print "shlex: I see EOF in quotes state"
+                    # XXX what error should be raised here?
+                    raise ValueError, "No closing quotation"
+            elif self.state == 'a':
+                if not nextchar:
+                    self.state = None   # end of file
+                    break
+                elif nextchar in self.whitespace:
+                    if self.debug >= 2:
+                        print "shlex: I see whitespace in word state"
+                    self.state = ' '
+                    if self.token:
+                        break   # emit current token
+                    else:
+                        continue
+                elif nextchar in self.commenters:
+                    self.instream.readline()
+                    self.lineno = self.lineno + 1
+                elif nextchar in self.wordchars or nextchar in self.quotes:
+                    self.token = self.token + nextchar
+                else:
+                    self.pushback = [nextchar] + self.pushback
+                    if self.debug >= 2:
+                        print "shlex: I see punctuation in word state"
+                    self.state = ' '
+                    if self.token:
+                        break   # emit current token
+                    else:
+                        continue
+        result = self.token
+        self.token = ''
+        if self.debug > 1:
+            if result:
+                print "shlex: raw token=" + `result`
+            else:
+                print "shlex: raw token=EOF"
+        return result
+
+    def sourcehook(self, newfile):
+        "Hook called on a filename to be sourced."
+        if newfile[0] == '"':
+            newfile = newfile[1:-1]
+        # This implements cpp-like semantics for relative-path inclusion.
+        if type(self.infile) == type("") and not os.path.isabs(newfile):
+            newfile = os.path.join(os.path.dirname(self.infile), newfile)
+        return (newfile, open(newfile, "r"))
+
+    def error_leader(self, infile=None, lineno=None):
+        "Emit a C-compiler-like, Emacs-friendly error-message leader."
+        if not infile:
+            infile = self.infile
+        if not lineno:
+            lineno = self.lineno
+        return "\"%s\", line %d: " % (infile, lineno)
+
+
+if __name__ == '__main__':
+    if len(sys.argv) == 1:
+        lexer = shlex()
+    else:
+        file = sys.argv[1]
+        lexer = shlex(open(file), file)
+    while 1:
+        tt = lexer.get_token()
+        if tt:
+            print "Token: " + repr(tt)
+        else:
+            break

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

@@ -0,0 +1,138 @@
+"""Utility functions for copying files and directory trees.
+
+XXX The functions here don't copy the resource fork or other metadata on Mac.
+
+"""
+
+import os
+import sys
+import stat
+
+__all__ = ["copyfileobj","copyfile","copymode","copystat","copy","copy2",
+           "copytree","rmtree"]
+
+def copyfileobj(fsrc, fdst, length=16*1024):
+    """copy data from file-like object fsrc to file-like object fdst"""
+    while 1:
+        buf = fsrc.read(length)
+        if not buf:
+            break
+        fdst.write(buf)
+
+
+def copyfile(src, dst):
+    """Copy data from src to dst"""
+    fsrc = None
+    fdst = None
+    try:
+        fsrc = open(src, 'rb')
+        fdst = open(dst, 'wb')
+        copyfileobj(fsrc, fdst)
+    finally:
+        if fdst:
+            fdst.close()
+        if fsrc:
+            fsrc.close()
+
+def copymode(src, dst):
+    """Copy mode bits from src to dst"""
+    if hasattr(os, 'chmod'):
+        st = os.stat(src)
+        mode = stat.S_IMODE(st[stat.ST_MODE])
+        os.chmod(dst, mode)
+
+def copystat(src, dst):
+    """Copy all stat info (mode bits, atime and mtime) from src to dst"""
+    st = os.stat(src)
+    mode = stat.S_IMODE(st[stat.ST_MODE])
+    if hasattr(os, 'utime'):
+        os.utime(dst, (st[stat.ST_ATIME], st[stat.ST_MTIME]))
+    if hasattr(os, 'chmod'):
+        os.chmod(dst, mode)
+
+
+def copy(src, dst):
+    """Copy data and mode bits ("cp src dst").
+
+    The destination may be a directory.
+
+    """
+    if os.path.isdir(dst):
+        dst = os.path.join(dst, os.path.basename(src))
+    copyfile(src, dst)
+    copymode(src, dst)
+
+def copy2(src, dst):
+    """Copy data and all stat info ("cp -p src dst").
+
+    The destination may be a directory.
+
+    """
+    if os.path.isdir(dst):
+        dst = os.path.join(dst, os.path.basename(src))
+    copyfile(src, dst)
+    copystat(src, dst)
+
+
+def copytree(src, dst, symlinks=0):
+    """Recursively copy a directory tree using copy2().
+
+    The destination directory must not already exist.
+    Error are reported to standard output.
+
+    If the optional symlinks flag is true, symbolic links in the
+    source tree result in symbolic links in the destination tree; if
+    it is false, the contents of the files pointed to by symbolic
+    links are copied.
+
+    XXX Consider this example code rather than the ultimate tool.
+
+    """
+    names = os.listdir(src)
+    os.mkdir(dst)
+    for name in names:
+        srcname = os.path.join(src, name)
+        dstname = os.path.join(dst, name)
+        try:
+            if symlinks and os.path.islink(srcname):
+                linkto = os.readlink(srcname)
+                os.symlink(linkto, dstname)
+            elif os.path.isdir(srcname):
+                copytree(srcname, dstname, symlinks)
+            else:
+                copy2(srcname, dstname)
+            # XXX What about devices, sockets etc.?
+        except (IOError, os.error), why:
+            print "Can't copy %s to %s: %s" % (`srcname`, `dstname`, str(why))
+
+def rmtree(path, ignore_errors=0, onerror=None):
+    """Recursively delete a directory tree.
+
+    If ignore_errors is set, errors are ignored; otherwise, if
+    onerror is set, it is called to handle the error; otherwise, an
+    exception is raised.
+
+    """
+    cmdtuples = []
+    _build_cmdtuple(path, cmdtuples)
+    for cmd in cmdtuples:
+        try:
+            apply(cmd[0], (cmd[1],))
+        except:
+            exc = sys.exc_info()
+            if ignore_errors:
+                pass
+            elif onerror:
+                onerror(cmd[0], cmd[1], exc)
+            else:
+                raise exc[0], (exc[1][0], exc[1][1] + ' removing '+cmd[1])
+
+# Helper for rmtree()
+def _build_cmdtuple(path, cmdtuples):
+    for f in os.listdir(path):
+        real_f = os.path.join(path,f)
+        if os.path.isdir(real_f) and not os.path.islink(real_f):
+            _build_cmdtuple(real_f, cmdtuples)
+        else:
+            cmdtuples.append((os.remove, real_f))
+    cmdtuples.append((os.rmdir, path))

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

@@ -0,0 +1,263 @@
+"""Append module search paths for third-party packages to sys.path.
+
+****************************************************************
+* This module is automatically imported during initialization. *
+****************************************************************
+
+In earlier versions of Python (up to 1.5a3), scripts or modules that
+needed to use site-specific modules would place ``import site''
+somewhere near the top of their code.  Because of the automatic
+import, this is no longer necessary (but code that does it still
+works).
+
+This will append site-specific paths to to the module search path.  On
+Unix, it starts with sys.prefix and sys.exec_prefix (if different) and
+appends lib/python<version>/site-packages as well as lib/site-python.
+On other platforms (mainly Mac and Windows), it uses just sys.prefix
+(and sys.exec_prefix, if different, but this is unlikely).  The
+resulting directories, if they exist, are appended to sys.path, and
+also inspected for path configuration files.
+
+A path configuration file is a file whose name has the form
+<package>.pth; its contents are additional directories (one per line)
+to be added to sys.path.  Non-existing directories (or
+non-directories) are never added to sys.path; no directory is added to
+sys.path more than once.  Blank lines and lines beginning with
+\code{#} are skipped.
+
+For example, suppose sys.prefix and sys.exec_prefix are set to
+/usr/local and there is a directory /usr/local/lib/python1.5/site-packages
+with three subdirectories, foo, bar and spam, and two path
+configuration files, foo.pth and bar.pth.  Assume foo.pth contains the
+following:
+
+  # foo package configuration
+  foo
+  bar
+  bletch
+
+and bar.pth contains:
+
+  # bar package configuration
+  bar
+
+Then the following directories are added to sys.path, in this order:
+
+  /usr/local/lib/python1.5/site-packages/bar
+  /usr/local/lib/python1.5/site-packages/foo
+
+Note that bletch is omitted because it doesn't exist; bar precedes foo
+because bar.pth comes alphabetically before foo.pth; and spam is
+omitted because it is not mentioned in either path configuration file.
+
+After these path manipulations, an attempt is made to import a module
+named sitecustomize, which can perform arbitrary additional
+site-specific customizations.  If this import fails with an
+ImportError exception, it is silently ignored.
+
+"""
+
+import sys, os
+
+def makepath(*paths):
+    dir = os.path.join(*paths)
+    if dir == '__classpath__':
+	return dir
+    return os.path.normcase(os.path.abspath(dir))
+
+L = sys.modules.values()
+for m in L:
+    if hasattr(m, "__file__"):
+        m.__file__ = makepath(m.__file__)
+del m, L
+
+# This ensures that the initial path provided by the interpreter contains
+# only absolute pathnames, even if we're running from the build directory.
+L = []
+for dir in sys.path:
+    dir = makepath(dir)
+    if dir not in L:
+        L.append(dir)
+sys.path[:] = L
+del dir, L
+
+def addsitedir(sitedir):
+    sitedir = makepath(sitedir)
+    if sitedir not in sys.path:
+        sys.path.append(sitedir)        # Add path component
+    try:
+        names = os.listdir(sitedir)
+    except os.error:
+        return
+    names = map(os.path.normcase, names)
+    names.sort()
+    for name in names:
+        if name[-4:] == ".pth":
+            addpackage(sitedir, name)
+
+def addpackage(sitedir, name):
+    fullname = os.path.join(sitedir, name)
+    try:
+        f = open(fullname)
+    except IOError:
+        return
+    while 1:
+        dir = f.readline()
+        if not dir:
+            break
+        if dir[0] == '#':
+            continue
+        if dir[-1] == '\n':
+            dir = dir[:-1]
+        dir = makepath(sitedir, dir)
+        if dir not in sys.path and os.path.exists(dir):
+            sys.path.append(dir)
+
+prefixes = [sys.prefix]
+if sys.exec_prefix != sys.prefix:
+    prefixes.append(sys.exec_prefix)
+for prefix in prefixes:
+    if prefix:
+        if os.sep == '/':
+            sitedirs = [makepath(prefix,
+                                 "lib",
+                                 "python" + sys.version[:3],
+                                 "site-packages"),
+                        makepath(prefix, "lib", "site-python")]
+        else:
+            sitedirs = [prefix]
+        for sitedir in sitedirs:
+            if os.path.isdir(sitedir):
+                addsitedir(sitedir)
+
+# Define new built-ins 'quit' and 'exit'.
+# These are simply strings that display a hint on how to exit.
+if os.sep == ':':
+    exit = 'Use Cmd-Q to quit.'
+elif os.sep == '\\':
+    exit = 'Use Ctrl-Z plus Return to exit.'
+else:
+    exit = 'Use Ctrl-D (i.e. EOF) to exit.'
+import __builtin__
+__builtin__.quit = __builtin__.exit = exit
+del exit
+
+# interactive prompt objects for printing the license text, a list of
+# contributors and the copyright notice.
+class _Printer:
+    MAXLINES = 23
+
+    def __init__(self, name, data, files=(), dirs=()):
+        self.__name = name
+        self.__data = data
+        self.__files = files
+        self.__dirs = dirs
+        self.__lines = None
+
+    def __setup(self):
+        if self.__lines:
+            return
+        data = None
+        for dir in self.__dirs:
+            for file in self.__files:
+                file = os.path.join(dir, file)
+                try:
+                    fp = open(file)
+                    data = fp.read()
+                    fp.close()
+                    break
+                except IOError:
+                    pass
+            if data:
+                break
+        if not data:
+            data = self.__data
+        self.__lines = data.split('\n')
+        self.__linecnt = len(self.__lines)
+
+    def __repr__(self):
+        self.__setup()
+        if len(self.__lines) <= self.MAXLINES:
+            return "\n".join(self.__lines)
+        else:
+            return "Type %s() to see the full %s text" % ((self.__name,)*2)
+
+    def __call__(self):
+        self.__setup()
+        prompt = 'Hit Return for more, or q (and Return) to quit: '
+        lineno = 0
+        while 1:
+            try:
+                for i in range(lineno, lineno + self.MAXLINES):
+                    print self.__lines[i]
+            except IndexError:
+                break
+            else:
+                lineno += self.MAXLINES
+                key = None
+                while key is None:
+                    key = raw_input(prompt)
+                    if key not in ('', 'q'):
+                        key = None
+                if key == 'q':
+                    break
+
+__builtin__.copyright = _Printer("copyright", sys.copyright)
+if sys.platform[:4] == 'java':
+    __builtin__.credits = _Printer("credits",
+        "Jython is maintained by the Jython developers (www.jython.org).")
+else:
+    __builtin__.credits = _Printer("credits",
+        "Python development is led by BeOpen PythonLabs (www.pythonlabs.com).")
+here = sys.prefix + "/Lib" # os.path.dirname(os.__file__)
+__builtin__.license = _Printer(
+    "license", "See http://www.pythonlabs.com/products/python2.0/license.html",
+    ["LICENSE.txt", "LICENSE"],
+    [here, os.path.join(here, os.pardir), os.curdir])
+
+
+# Set the string encoding used by the Unicode implementation.  The
+# default is 'ascii', but if you're willing to experiment, you can
+# change this.
+
+encoding = "ascii" # Default value set by _PyUnicode_Init()
+
+if 0:
+    # Enable to support locale aware default string encodings.
+    import locale
+    loc = locale.getdefaultlocale()
+    if loc[1]:
+        encoding = loc[1]
+
+if 0:
+    # Enable to switch off string to Unicode coercion and implicit
+    # Unicode to string conversion.
+    encoding = "undefined"
+
+if encoding != "ascii":
+    sys.setdefaultencoding(encoding)
+
+#
+# Run custom site specific code, if available.
+#
+try:
+    import sitecustomize
+except ImportError:
+    pass
+
+#
+# Remove sys.setdefaultencoding() so that users cannot change the
+# encoding after initialization.  The test for presence is needed when
+# this module is run as a script, becuase this code is executed twice.
+#
+if hasattr(sys, "setdefaultencoding"):
+    del sys.setdefaultencoding
+
+def _test():
+    print "sys.path = ["
+    for dir in sys.path:
+        print "    %s," % `dir`
+    print "]"
+
+if __name__ == '__main__':
+    _test()