rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,349 @@
+"""Common pathname manipulations, JDK version.
+
+Instead of importing this module directly, import os and refer to this
+module as os.path.
+
+"""
+
+# Incompletely implemented:
+# islink -- How?
+# ismount -- How?
+# normcase -- How?
+
+# Missing:
+# sameopenfile -- Java doesn't have fstat nor file descriptors?
+# samestat -- How?
+
+from java.io import File
+import java.io.IOException
+from java.lang import System
+import os
+
+
+def _tostr(s, method):
+    if isinstance(s, basestring):
+        return s
+    import org
+    raise TypeError, "%s() argument must be a str or unicode object, not %s" % (
+                method, org.python.core.Py.safeRepr(s))
+        
+def dirname(path):
+    """Return the directory component of a pathname"""
+    path = _tostr(path, "dirname")
+    result = File(path).getParent()
+    if not result:
+	if isabs(path):
+	    result = path # Must be root
+	else:
+	    result = ""
+    return result
+
+def basename(path):
+    """Return the final component of a pathname"""
+    path = _tostr(path, "basename")
+    return File(path).getName()
+
+def split(path):
+    """Split a pathname.
+
+    Return tuple "(head, tail)" where "tail" is everything after the
+    final slash.  Either part may be empty.
+
+    """
+    path = _tostr(path, "split")
+    return (dirname(path), basename(path))
+
+def splitext(path):
+    """Split the extension from a pathname.
+
+    Extension is everything from the last dot to the end.  Return
+    "(root, ext)", either part may be empty.
+
+    """
+    i = 0
+    n = -1
+    for c in path:
+        if c == '.': n = i
+        i = i+1
+    if n < 0:
+        return (path, "")
+    else:
+        return (path[:n], path[n:])
+
+def splitdrive(path):
+    """Split a pathname into drive and path specifiers. 
+
+    Returns a 2-tuple "(drive,path)"; either part may be empty.
+    """
+    # Algorithm based on CPython's ntpath.splitdrive and ntpath.isabs.
+    if path[1:2] == ':' and path[0].lower() in 'abcdefghijklmnopqrstuvwxyz' \
+            and (path[2:] == '' or path[2] in '/\\'):
+        return path[:2], path[2:]
+    return '', path
+
+def exists(path):
+    """Test whether a path exists.
+
+    Returns false for broken symbolic links.
+
+    """
+    path = _tostr(path, "exists")
+    return File(path).exists()
+
+def isabs(path):
+    """Test whether a path is absolute"""
+    path = _tostr(path, "isabs")
+    return File(path).isAbsolute()
+
+def isfile(path):
+    """Test whether a path is a regular file"""
+    path = _tostr(path, "isfile")
+    return File(path).isFile()
+
+def isdir(path):
+    """Test whether a path is a directory"""
+    path = _tostr(path, "isdir")
+    return File(path).isDirectory()
+
+def join(path, *args):
+    """Join two or more pathname components, inserting os.sep as needed"""
+    path = _tostr(path, "join")
+    f = File(path)
+    for a in args:
+        a = _tostr(a, "join")
+	g = File(a)
+	if g.isAbsolute() or len(f.getPath()) == 0:
+	    f = g
+	else:
+	    f = File(f, a)
+    return f.getPath()
+
+def normcase(path):
+    """Normalize case of pathname.
+
+    XXX Not done right under JDK.
+
+    """
+    path = _tostr(path, "normcase")
+    return File(path).getPath()
+
+def commonprefix(m):
+    "Given a list of pathnames, return 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 islink(path):
+    """Test whether a path is a symbolic link.
+
+    XXX This incorrectly always returns false under JDK.
+
+    """
+    return 0
+
+def samefile(path, path2):
+    """Test whether two pathnames reference the same actual file"""
+    path = _tostr(path, "samefile")
+    path2 = _tostr(path2, "samefile")
+    return _realpath(path) == _realpath(path2)
+
+def ismount(path):
+    """Test whether a path is a mount point.
+
+    XXX This incorrectly always returns false under JDK.
+
+    """
+    return 0
+
+def walk(top, func, arg):
+    """Walk a directory tree.
+
+    walk(top,func,args) calls func(arg, d, files) for each directory
+    "d" in the tree rooted at "top" (including "top" itself).  "files"
+    is a list of all the files and subdirs in directory "d".
+
+    """
+    try:
+        names = os.listdir(top)
+    except os.error:
+        return
+    func(arg, top, names)
+    for name in names:
+	name = join(top, name)
+	if isdir(name) and not islink(name):
+	    walk(name, func, arg)
+
+def expanduser(path):
+    if path[:1] == "~":
+	c = path[1:2]
+	if not c:
+	    return gethome()
+	if c == os.sep:
+	    return File(gethome(), path[2:]).getPath()
+    return path
+
+def getuser():
+    return System.getProperty("user.name")
+
+def gethome():
+    return System.getProperty("user.home")
+
+
+# normpath() from Python 1.5.2, with Java appropriate generalizations
+
+# Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
+# It should be understood that this may change the meaning of the path
+# if it contains symbolic links!
+def normpath(path):
+    """Normalize path, eliminating double slashes, etc."""
+    sep = os.sep
+    if sep == '\\':
+        path = path.replace("/", sep)
+    curdir = os.curdir
+    pardir = os.pardir
+    import string
+    # Treat initial slashes specially
+    slashes = ''
+    while path[:1] == sep:
+        slashes = slashes + sep
+        path = path[1:]
+    comps = string.splitfields(path, sep)
+    i = 0
+    while i < len(comps):
+        if comps[i] == curdir:
+            del comps[i]
+            while i < len(comps) and comps[i] == '':
+                del comps[i]
+        elif comps[i] == pardir and i > 0 and comps[i-1] not in ('', pardir):
+            del comps[i-1:i+1]
+            i = i-1
+        elif comps[i] == '' and i > 0 and comps[i-1] <> '':
+            del comps[i]
+        else:
+            i = i+1
+    # If the path is now empty, substitute '.'
+    if not comps and not slashes:
+        comps.append(curdir)
+    return slashes + string.joinfields(comps, sep)
+
+def abspath(path):
+    """Return an absolute path normalized but symbolic links not eliminated"""
+    path = _tostr(path, "abspath")
+    return _abspath(path)
+
+def _abspath(path):
+    # Must use normpath separately because getAbsolutePath doesn't normalize
+    # and getCanonicalPath would eliminate symlinks.
+    return normpath(File(path).getAbsolutePath())
+
+def realpath(path):
+    """Return an absolute path normalized and symbolic links eliminated"""
+    path = _tostr(path, "realpath")
+    return _realpath(path)
+    
+def _realpath(path):
+    try:
+        return File(path).getCanonicalPath()
+    except java.io.IOException:
+        return _abspath(path)
+
+def getsize(path):
+    path = _tostr(path, "getsize")
+    f = File(path)
+    size = f.length()
+    # Sadly, if the returned length is zero, we don't really know if the file
+    # is zero sized or does not exist.
+    if size == 0 and not f.exists():
+        raise OSError(0, 'No such file or directory', path)
+    return size
+
+def getmtime(path):
+    path = _tostr(path, "getmtime")
+    f = File(path)
+    if not f.exists():
+        raise OSError(0, 'No such file or directory', path)
+    return f.lastModified() / 1000.0
+
+def getatime(path):
+    # We can't detect access time so we return modification time. This
+    # matches the behaviour in os.stat().
+    path = _tostr(path, "getatime")
+    f = File(path)
+    if not f.exists():
+        raise OSError(0, 'No such file or directory', path)
+    return f.lastModified() / 1000.0
+
+
+# expandvars is stolen from CPython-2.1.1's Lib/ntpath.py:
+
+# Expand paths containing shell variable substitutions.
+# The following rules apply:
+#       - no expansion within single quotes
+#       - no escape character, except for '$$' which is translated into '$'
+#       - ${varname} is accepted.
+#       - varnames can be made out of letters, digits and the character '_'
+# XXX With COMMAND.COM you can use any characters in a variable name,
+# XXX except '^|<>='.
+
+def expandvars(path):
+    """Expand shell variables of form $var and ${var}.
+
+    Unknown variables are left unchanged."""
+    if '$' not in path:
+        return path
+    import string
+    varchars = string.letters + string.digits + '_-'
+    res = ''
+    index = 0
+    pathlen = len(path)
+    while index < pathlen:
+        c = path[index]
+        if c == '\'':   # no expansion within single quotes
+            path = path[index + 1:]
+            pathlen = len(path)
+            try:
+                index = path.index('\'')
+                res = res + '\'' + path[:index + 1]
+            except ValueError:
+                res = res + path
+                index = pathlen - 1
+        elif c == '$':  # variable or '$$'
+            if path[index + 1:index + 2] == '$':
+                res = res + c
+                index = index + 1
+            elif path[index + 1:index + 2] == '{':
+                path = path[index+2:]
+                pathlen = len(path)
+                try:
+                    index = path.index('}')
+                    var = path[:index]
+                    if os.environ.has_key(var):
+                        res = res + os.environ[var]
+                except ValueError:
+                    res = res + path
+                    index = pathlen - 1
+            else:
+                var = ''
+                index = index + 1
+                c = path[index:index + 1]
+                while c != '' and c in varchars:
+                    var = var + c
+                    index = index + 1
+                    c = path[index:index + 1]
+                if os.environ.has_key(var):
+                    res = res + os.environ[var]
+                if c != '':
+                    res = res + c
+        else:
+            res = res + c
+        index = index + 1
+    return res
+
+
+

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

@@ -0,0 +1,194 @@
+"""
+Implement subshell functionality for Jython.
+
+This is mostly to provide the environ object for the os module,
+and subshell execution functionality for os.system and popen* functions.
+
+javashell attempts to determine a suitable command shell for the host
+operating system, and uses that shell to determine environment variables
+and to provide subshell execution functionality.
+"""
+from java.lang import System, Runtime
+from java.io import IOException
+from java.io import InputStreamReader
+from java.io import BufferedReader
+from UserDict import UserDict
+import jarray
+import string
+import sys
+import types
+
+# circular dependency to let javaos import javashell lazily
+# without breaking LazyDict out into a new top-level module
+from javaos import LazyDict 
+
+__all__ = [ "shellexecute", "environ", "putenv", "getenv" ]
+
+def __warn( *args ):
+    print " ".join( [str( arg ) for arg in args ])
+    
+class _ShellEnv:
+    """Provide environment derived by spawning a subshell and parsing its
+    environment.  Also supports subshell execution functions and provides
+    empty environment support for platforms with unknown shell functionality.
+    """
+    def __init__( self, cmd=None, getEnv=None, keyTransform=None ):
+        """Construct _ShellEnv instance.
+        cmd: list of exec() arguments required to run a command in
+            subshell, or None
+        getEnv: shell command to list environment variables, or None
+        keyTransform: normalization function for environment keys,
+          such as 'string.upper', or None
+        """
+        self.cmd = cmd
+        self.getEnv = getEnv
+        self.environment = LazyDict(populate=self._getEnvironment,
+                                    keyTransform=keyTransform)
+        self._keyTransform = self.environment._keyTransform
+
+    def execute( self, cmd ):
+        """Execute cmd in a shell, and return the java.lang.Process instance.
+        Accepts either a string command to be executed in a shell,
+        or a sequence of [executable, args...].
+        """
+        shellCmd = self._formatCmd( cmd )
+
+        if self.environment._populated:
+            env = self._formatEnvironment( self.environment )
+        else:
+            env = None
+        try:
+            p = Runtime.getRuntime().exec( shellCmd, env )
+            return p
+        except IOException, ex:
+            raise OSError(
+                0,
+                "Failed to execute command (%s): %s" % ( shellCmd, ex )
+                )
+
+    ########## utility methods
+    def _formatCmd( self, cmd ):
+        """Format a command for execution in a shell."""
+        if self.cmd is None:
+            msgFmt = "Unable to execute commands in subshell because shell" \
+                     " functionality not implemented for OS %s with shell"  \
+                     " setting %s. Failed command=%s""" 
+            raise OSError( 0, msgFmt % ( _osType, _envType, cmd ))
+            
+        if isinstance(cmd, basestring):
+            shellCmd = self.cmd + [cmd]
+        else:
+            shellCmd = cmd
+            
+        return shellCmd
+
+    def _formatEnvironment( self, env ):
+        """Format enviroment in lines suitable for Runtime.exec"""
+        lines = []
+        for keyValue in env.items():
+            lines.append( "%s=%s" % keyValue )
+        return lines
+
+    def _getEnvironment( self ):
+        """Get the environment variables by spawning a subshell.
+        This allows multi-line variables as long as subsequent lines do
+        not have '=' signs.
+        """
+        env = {}
+        if self.getEnv:
+            try:
+                p = self.execute( self.getEnv )
+                r = BufferedReader( InputStreamReader( p.getInputStream() ) )
+                lines = []
+                while True:
+                  line = r.readLine()
+                  if not line:
+                    break
+                  lines.append(line)
+                if '=' not in lines[0]:
+                    __warn(
+                        "Failed to get environment, getEnv command (%s) " \
+                        "did not print environment as key=value lines.\n" \
+                        "Output=%s" % ( self.getEnv, '\n'.join( lines ) )
+                        )
+                    return env
+
+                for line in lines:
+                    try:
+                        i = line.index( '=' )
+                        key = self._keyTransform(line[:i])
+                        value = line[i+1:] # remove = and end-of-line
+                    except ValueError:
+                        # found no '=', treat line as part of previous value
+                        value = '%s\n%s' % ( value, line )
+                    env[ key ] = value
+            except OSError, ex:
+                __warn( "Failed to get environment, environ will be empty:",
+                        ex )
+        return env
+
+def _getOsType( os=None ):
+    """Select the OS behavior based on os argument, 'python.os' registry
+    setting and 'os.name' Java property.
+    os: explicitly select desired OS. os=None to autodetect, os='None' to
+    disable 
+    """
+    os = str(os or sys.registry.getProperty( "python.os" ) or \
+               System.getProperty( "os.name" ))
+        
+    _osTypeMap = (
+        ( "nt", ( 'nt', 'Windows NT', 'Windows NT 4.0', 'WindowsNT',
+                  'Windows 2000', 'Windows 2003', 'Windows XP', 'Windows CE',
+                  'Windows Vista' )),
+        ( "dos", ( 'dos', 'Windows 95', 'Windows 98', 'Windows ME' )),
+        ( "mac", ( 'mac', 'MacOS', 'Darwin' )),
+        ( "None", ( 'None', )),
+        )
+    foundType = None
+    for osType, patterns in _osTypeMap:
+        for pattern in patterns:
+            if os.startswith( pattern ):
+                foundType = osType
+                break
+        if foundType:
+            break
+    if not foundType:
+        foundType = "posix" # default - posix seems to vary most widely
+
+    return foundType
+
+def _getShellEnv():
+    # default to None/empty for shell and environment behavior
+    shellCmd = None
+    envCmd = None
+    envTransform = None
+
+    envType = sys.registry.getProperty("python.environment", "shell")
+    if envType == "shell":
+        osType = _getOsType()
+        
+        # override defaults based on osType
+        if osType == "nt":
+            shellCmd = ["cmd", "/c"]
+            envCmd = "set"
+            envTransform = string.upper
+        elif osType == "dos":
+            shellCmd = ["command.com", "/c"]
+            envCmd = "set"
+            envTransform = string.upper
+        elif osType == "posix":
+            shellCmd = ["sh", "-c"]
+            envCmd = "env"
+        elif osType == "mac":
+            curdir = ':'  # override Posix directories
+            pardir = '::' 
+        elif osType == "None":
+            pass
+        # else:
+        #    # may want a warning, but only at high verbosity:
+        #    __warn( "Unknown os type '%s', using default behavior." % osType )
+
+    return _ShellEnv( shellCmd, envCmd, envTransform )
+
+_shellEnv = _getShellEnv()
+shellexecute = _shellEnv.execute

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

@@ -0,0 +1,119 @@
+# java classes reload support (experimental)
+# Copyright 2000 Samuele Pedroni
+
+# ?? could have problem with import pkg.jclass.inner (this should not be used in any case)
+# ?? using import * with a load-set together with reloading can be confusing
+#    cannot be fixed => anyway import * is not for production code
+
+__version__ = "0.3"
+
+import sys
+from org.python.core import imp,PyJavaPackage,PyJavaClass
+from _jython import is_lazy as _is_lazy
+
+import jxxload_help
+
+
+class _LoaderFactory(jxxload_help.JavaLoaderFactory):
+    def __init__(self,path):
+        vfs = jxxload_help.PathVFS()
+        for fname in path:
+            vfs.addVFS(fname)
+        self.vfs = vfs
+
+    def makeLoader(self):
+        return jxxload_help.PathVFSJavaLoader(self.vfs,imp.getSyspathJavaLoader())
+
+class _Unload:
+
+    def __init__(self,ls):
+        self.ls = ls
+        self.ls_name = ls._name
+        self.loader = ls._mgr.loader
+
+    def do_unload(self,pkg):
+        for n in pkg.__dict__.keys():
+            e = pkg.__dict__[n]
+            if isinstance(e,PyJavaClass):
+                if _is_lazy(e): continue
+                if e.classLoader is self.loader:
+                    del pkg.__dict__[n]
+                    if pkg.__name__:
+                        n = self.ls_name + '.' + pkg.__name__ + '.' +n
+                    else:
+                        n = self.ls_name + '.' + n
+                    if sys.modules.has_key(n): del sys.modules[n]
+
+            elif isinstance(e,PyJavaPackage):
+                self.do_unload(e)
+
+    def __call__(self):
+        if self.loader:
+            if self.ls._mgr.checkLoader() is self.loader:
+                self.do_unload(self.ls._top)
+                self.ls._mgr.resetLoader()
+            loader = self.loader
+            jxxload_help.DiscardHelp.discard(loader,loader.interfaces)
+            self.loader = None
+
+class LoadSet:
+# ?? for the moment from import * and dir do not work for LoadSet, but work for
+# contained pkgs
+# need java impl as PyObject
+
+    def __init__(self,name,path):
+        mgr = jxxload_help.PackageManager(path,_LoaderFactory(path))
+        self._name = name
+        self._mgr = mgr
+        self._top = mgr.topLevelPackage
+
+    def __getattr__(self,name):
+        try:
+            return getattr(self._top,name)
+        except:
+            if name == 'unload': return _Unload(self)
+            raise
+            
+
+    def __repr__(self):
+        return "<java load-set %s>" % self._name
+
+def unloadf(ls):
+    if not isinstance(ls,LoadSet): raise TypeError,"unloadf(): arg is not a load-set"
+    return _Unload(ls)
+
+def makeLoadSet(name,path):
+    if sys.modules.has_key(name): return sys.modules[name]
+    sys.modules[name] = ls = LoadSet(name,path)
+    return ls
+
+_reload = reload
+
+def _do_reload(ls_name,mgr,pkg):
+    pkg_name = pkg.__name__
+    for n in pkg.__dict__.keys():
+        e = pkg.__dict__[n]
+        if isinstance(e,PyJavaClass):
+            if _is_lazy(e): continue
+            del pkg.__dict__[n]
+            try :
+                c = mgr.findClass(pkg_name,n);
+                if c:
+                    pkg.__dict__[n] = c
+                    if pkg_name:
+                        n = ls_name + '.' + pkg_name + '.' + n
+                    else:
+                        n = ls_name + '.' + n
+                    if sys.modules.has_key(n): sys.modules[n] = c
+            except:
+                pass
+        elif isinstance(e,PyJavaPackage):
+            _do_reload(ls_name,mgr,e)
+
+def reload(ls):
+    if isinstance(ls,LoadSet):
+        ls._mgr.resetLoader()
+        _do_reload(ls._name,ls._mgr,ls._top)
+        return ls
+    else:
+        return _reload(ls)