rubyfox-server 2.8.4.0 → 2.9.0.0

data/lib/rubyfox/server/data/lib/jconsole/history.py

@@ -1,82 +0,0 @@
-"""
- history.py - Handles the History of the jython console
- Copyright (C) 2001 Carlos Quiroz
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License
- as published by the Free Software Foundation; either version 2
- of the License, or any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-"""
-
-from java.lang import System, Runtime
-from java.lang import Runnable, Thread
-
-class History(Runnable):
-    """
-    Command line history
-    """
-    
-    default_history_file = System.getProperty("user.home") + '/.jythonconsole.history'
-    MAX_SIZE = 200
-
-    def __init__(self, console, history_file=default_history_file):
-        Runtime.getRuntime().addShutdownHook(Thread(self))        
-
-        self.history_file = history_file
-        self.history = []
-        self.loadHistory()            
-          
-        self.console = console
-        self.index = len(self.history) - 1
-        self.last = ""
-
-    def append(self, line):
-        if line == None or line == '\n' or len(line) == 0:
-            return
-
-        if line != self.last: # avoids duplicates
-            self.last = line
-            self.history.append(line)
-            
-        self.index = len(self.history) - 1
-
-    def historyUp(self, event=None):
-        if len(self.history) > 0 and self.console.inLastLine():
-            self.console.replaceRow(self.history[self.index])
-            self.index = max(self.index - 1, 0)
-
-    def historyDown(self, event=None):
-        if len(self.history) > 0 and self.console.inLastLine():
-            if self.index == len(self.history) - 1:
-                self.console.replaceRow("")
-            else:
-                self.index += 1
-                self.console.replaceRow(self.history[self.index])
-
-    def loadHistory(self):
-        try:
-            f = open(self.history_file)
-            for line in f.readlines():
-                self.history.append(line[:-1])
-            f.close()
-        except:
-            pass
-        
-    def saveHistory(self):
-        f = open(self.history_file, 'w')
-        for item in self.history[-self.MAX_SIZE:]:
-            f.write("%s\n" % item)
-        f.flush()
-        f.close()
-        
-    def run(self):
-        self.saveHistory()

data/lib/rubyfox/server/data/lib/jconsole/history_test_case.py

@@ -1,133 +0,0 @@
-import unittest
-import tempfile
-from  history import History
-
-try:
-    True, False
-except NameError:
-    (True, False) = (1, 0)
-
-class MockConsole:
-    def replaceRow(self, text):
-        self.text = text
-
-    def inLastLine(self):
-        return True
-
-class HistoryTestCase(unittest.TestCase):
-
-    def setUp(self):
-        self.console = MockConsole()
-
-    def tearDown(self):
-        self.console = None
-
-    def testHistoryUp(self):
-        h = History(self.console, tempfile.mktemp())
-        h.append("one")
-        h.append("two")
-        h.append("three")
-
-        h.historyUp()
-        self.assertEquals("three", self.console.text)
-
-        h.historyUp()
-        self.assertEquals("two", self.console.text)
-
-        h.historyUp()
-        self.assertEquals("one", self.console.text)
-
-        # history doesn't roll, just stops at the last item
-        h.historyUp()
-        self.assertEquals("one", self.console.text)
-
-    def testHistoryDown(self):
-        h = History(self.console,tempfile.mktemp())
-        h.append("one")
-        h.append("two")
-        h.append("three")
-
-        h.historyUp()
-        h.historyUp()
-        
-        h.historyUp()
-        self.assertEquals("one", self.console.text)
-
-        h.historyDown()
-        self.assertEquals("two", self.console.text)
-
-        h.historyDown()
-        self.assertEquals("three", self.console.text)
-
-        h.historyDown()
-        self.assertEquals("", self.console.text)
-
-        # History doesn't wrap
-        h.historyDown()
-        self.assertEquals("", self.console.text)
-
-    def testSkipDuplicates(self):
-       h = History(self.console, tempfile.mktemp())
-       h.append("one")
-       h.append("one")
-       h.append("two")
-       h.append("two")
-       h.append("three")
-       h.append("three")
-
-       h.historyUp()
-       self.assertEquals("three", self.console.text)
-
-       h.historyUp()
-       self.assertEquals("two", self.console.text)
-
-       h.historyUp()
-       self.assertEquals("one", self.console.text)
-
-    def testSkipEmpty(self):
-        h = History(self.console, tempfile.mktemp())
-        size = len(h.history)
-        h.append("")
-        self.assert_(len(h.history) == size)
-
-        h.append("\n")
-        self.assert_(len(h.history) == size)
-
-        h.append(None)
-        self.assert_(len(h.history) == size)
-
-    def testLoadHistory(self):
-        file = tempfile.mktemp()
-        f = open(file, "w")
-        f.write("red\n")
-        f.write("yellow\n")
-        f.write("blue\n")
-        f.flush()
-        f.close()
-
-        h = History(self.console, file)
-        h.historyUp()
-        self.assertEquals("blue", self.console.text)
-
-        h.historyUp()
-        self.assertEquals("yellow", self.console.text)
-
-        h.historyUp()
-        self.assertEquals("red", self.console.text)
-
-    def testSaveHistory(self):
-        file = tempfile.mktemp()
-
-        h = History(self.console, file)
-        h.append("a")
-        h.append("b")
-        h.append("c")
-        h.saveHistory()
-
-        f = open(file)
-        self.assertEquals("a", f.readline()[:-1])
-        self.assertEquals("b", f.readline()[:-1])
-        self.assertEquals("c", f.readline()[:-1])
-
-if __name__ == '__main__':
-    unittest.main()

data/lib/rubyfox/server/data/lib/jconsole/introspect.py

@@ -1,373 +0,0 @@
-"""Provides a variety of introspective-type support functions for
-things like call tips and command auto completion.
-
-NOTE: this file is a modification of Patrick O'Brien's version 1.62
-"""
-
-from __future__ import nested_scopes
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id: introspect.py,v 1.5 2003/05/01 03:43:53 dcoleman Exp $"
-__revision__ = "$Revision: 1.5 $"[11:-2]
-
-
-import cStringIO
-import inspect
-import sys
-import tokenize
-import types
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-def getAutoCompleteList(command='', locals=None, includeMagic=1, 
-                        includeSingle=1, includeDouble=1):
-    """Return list of auto-completion options for command.
-    
-    The list of options will be based on the locals namespace."""
-    attributes = []
-    # Get the proper chunk of code from the command.
-    root = getRoot(command, terminator='.')
-    try:
-        if locals is not None:
-            object = eval(root, locals)
-        else:
-            object = eval(root)
-    except:
-        pass
-    else:
-        attributes = getAttributeNames(object, includeMagic, 
-                                       includeSingle, includeDouble)
-    return attributes
-    
-def getAttributeNames(object, includeMagic=1, includeSingle=1,
-                      includeDouble=1):
-    """Return list of unique attributes, including inherited, for object."""
-    attributes = []
-    dict = {}
-    if not hasattrAlwaysReturnsTrue(object):
-        # Add some attributes that don't always get picked up.  If
-        # they don't apply, they'll get filtered out at the end.
-        attributes += ['__bases__', '__class__', '__dict__', '__name__', 
-                       'func_closure', 'func_code', 'func_defaults', 
-                       'func_dict', 'func_doc', 'func_globals', 'func_name']
-    if includeMagic:
-        try: attributes += object._getAttributeNames()
-        except: pass
-    # Get all attribute names.
-    attrdict = getAllAttributeNames(object)
-    for attrlist in attrdict.values():
-        attributes += attrlist
-    # Remove duplicates from the attribute list.
-    for item in attributes:
-        dict[item] = None
-    attributes = dict.keys()
-    attributes.sort(lambda x, y: cmp(x.upper(), y.upper()))
-    if not includeSingle:
-        attributes = filter(lambda item: item[0]!='_' \
-                            or item[1]=='_', attributes)
-    if not includeDouble:
-        attributes = filter(lambda item: item[:2]!='__', attributes)
-    # Make sure we haven't picked up any bogus attributes somehow.
-    attributes = [attribute for attribute in attributes \
-                  if hasattr(object, attribute)]
-    return attributes
-
-def hasattrAlwaysReturnsTrue(object):
-    return hasattr(object, 'bogu5_123_aTTri8ute')
-
-def getAllAttributeNames(object):
-    """Return dict of all attributes, including inherited, for an object.
-    
-    Recursively walk through a class and all base classes.
-    """
-    attrdict = {}  # (object, technique, count): [list of attributes]
-    # !!!
-    # Do Not use hasattr() as a test anywhere in this function,
-    # because it is unreliable with remote objects: xmlrpc, soap, etc.
-    # They always return true for hasattr().
-    # !!!
-    try:
-        # Yes, this can fail if object is an instance of a class with
-        # __str__ (or __repr__) having a bug or raising an
-        # exception. :-(
-        key = str(object)
-    except:
-        key = 'anonymous'
-    # Wake up sleepy objects - a hack for ZODB objects in "ghost" state.
-    wakeupcall = dir(object)
-    del wakeupcall
-    # Get attributes available through the normal convention.
-    attributes = dir(object)
-    attrdict[(key, 'dir', len(attributes))] = attributes
-    # Get attributes from the object's dictionary, if it has one.
-    try:
-        attributes = object.__dict__.keys()
-        attributes.sort()
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        attrdict[(key, '__dict__', len(attributes))] = attributes
-    # For a class instance, get the attributes for the class.
-    try:
-        klass = object.__class__
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        if klass is object:
-            # Break a circular reference. This happens with extension
-            # classes.
-            pass
-        else:
-            attrdict.update(getAllAttributeNames(klass))
-    # Also get attributes from any and all parent classes.
-    try:
-        bases = object.__bases__
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        if isinstance(bases, types.TupleType):
-            for base in bases:
-                if type(base) is types.TypeType:
-                    # Break a circular reference. Happens in Python 2.2.
-                    pass
-                if type(base) is type(type):
-                    # Break a circular reference. Happens in Jython 2.2b1.
-                    pass    
-                else:
-                    attrdict.update(getAllAttributeNames(base))
-    return attrdict
-
-def getCallTip(command='', locals=None):
-    """For a command, return a tuple of object name, argspec, tip text.
-    
-    The call tip information will be based on the locals namespace."""
-    calltip = ('', '', '')  # object name, argspec, tip text.
-    # Get the proper chunk of code from the command.
-    root = getRoot(command, terminator='(')
-    try:
-        if locals is not None:
-            object = eval(root, locals)
-        else:
-            object = eval(root)
-    except:
-        return calltip
-    name = ''
-    object, dropSelf = getBaseObject(object)
-    try:
-        name = object.__name__
-    except AttributeError:
-        pass
-    tip1 = ''
-    argspec = ''
-    if inspect.isbuiltin(object):
-        # Builtin functions don't have an argspec that we can get.
-        pass
-    elif inspect.isfunction(object):
-        # tip1 is a string like: "getCallTip(command='', locals=None)"
-        argspec = apply(inspect.formatargspec, inspect.getargspec(object))
-        if dropSelf:
-            # The first parameter to a method is a reference to an
-            # instance, usually coded as "self", and is usually passed
-            # automatically by Python; therefore we want to drop it.
-            temp = argspec.split(',')
-            if len(temp) == 1:  # No other arguments.
-                argspec = '()'
-            else:  # Drop the first argument.
-                argspec = '(' + ','.join(temp[1:]).lstrip()
-        tip1 = name + argspec
-    doc = ''
-    if callable(object):
-        doc = inspect.getdoc(object)
-    if doc:
-        # tip2 is the first separated line of the docstring, like:
-        # "Return call tip text for a command."
-        # tip3 is the rest of the docstring, like:
-        # "The call tip information will be based on ... <snip>
-        firstline = doc.split('\n')[0].lstrip()
-        if tip1 == firstline:
-            tip1 = ''
-        else:
-            tip1 += '\n\n'
-        docpieces = doc.split('\n\n')
-        tip2 = docpieces[0]
-        tip3 = '\n\n'.join(docpieces[1:])
-        tip = '%s%s\n\n%s' % (tip1, tip2, tip3)
-    else:
-        tip = tip1
-    calltip = (name, argspec[1:-1], tip.strip())
-    return calltip
-
-def getRoot(command, terminator=None):
-    """Return the rightmost root portion of an arbitrary Python command.
-    
-    Return only the root portion that can be eval()'d without side
-    effects.  The command would normally terminate with a '(' or
-    '.'. The terminator and anything after the terminator will be
-    dropped."""
-    command = command.split('\n')[-1]
-    if command.startswith(sys.ps2):
-        command = command[len(sys.ps2):]
-    command = command.lstrip()
-    command = rtrimTerminus(command, terminator)
-    tokens = getTokens(command)
-    if not tokens:
-        return ''
-    if tokens[-1][0] is tokenize.ENDMARKER:
-        # Remove the end marker.
-        del tokens[-1]
-    if not tokens:
-        return ''
-    if terminator == '.' and \
-           (tokens[-1][1] <> '.' or tokens[-1][0] is not tokenize.OP):
-        # Trap decimals in numbers, versus the dot operator.
-        return ''
-    else:
-        # Strip off the terminator.
-        if terminator and command.endswith(terminator):
-            size = 0 - len(terminator)
-            command = command[:size]
-    command = command.rstrip()
-    tokens = getTokens(command)
-    tokens.reverse()
-    line = ''
-    start = None
-    prefix = ''
-    laststring = '.'
-    emptyTypes = ('[]', '()', '{}')
-    for token in tokens:
-        tokentype = token[0]
-        tokenstring = token[1]
-        line = token[4]
-        if tokentype is tokenize.ENDMARKER:
-            continue
-        if tokentype in (tokenize.NAME, tokenize.STRING, tokenize.NUMBER) \
-        and laststring != '.':
-            # We've reached something that's not part of the root.
-            if prefix and line[token[3][1]] != ' ':
-                # If it doesn't have a space after it, remove the prefix.
-                prefix = ''
-            break
-        if tokentype in (tokenize.NAME, tokenize.STRING, tokenize.NUMBER) \
-        or (tokentype is tokenize.OP and tokenstring == '.'):
-            if prefix:
-                # The prefix isn't valid because it comes after a dot.
-                prefix = ''
-                break
-            else:
-                # start represents the last known good point in the line.
-                start = token[2][1]
-        elif len(tokenstring) == 1 and tokenstring in ('[({])}'):
-            # Remember, we're working backwords.
-            # So prefix += tokenstring would be wrong.
-            if prefix in emptyTypes and tokenstring in ('[({'):
-                # We've already got an empty type identified so now we
-                # are in a nested situation and we can break out with
-                # what we've got.
-                break
-            else:
-                prefix = tokenstring + prefix
-        else:
-            # We've reached something that's not part of the root.
-            break
-        laststring = tokenstring
-    if start is None:
-        start = len(line)
-    root = line[start:]
-    if prefix in emptyTypes:
-        # Empty types are safe to be eval()'d and introspected.
-        root = prefix + root
-    return root    
-
-def getTokens(command):
-    """Return list of token tuples for command."""
-    command = str(command)  # In case the command is unicode, which fails.
-    f = cStringIO.StringIO(command)
-    # tokens is a list of token tuples, each looking like: 
-    # (type, string, (srow, scol), (erow, ecol), line)
-    tokens = []
-    # Can't use list comprehension:
-    #   tokens = [token for token in tokenize.generate_tokens(f.readline)]
-    # because of need to append as much as possible before TokenError.
-    try:
-##        This code wasn't backward compatible with Python 2.1.3.
-##
-##        for token in tokenize.generate_tokens(f.readline):
-##            tokens.append(token)
-
-        # This works with Python 2.1.3 (with nested_scopes).
-        def eater(*args):
-            tokens.append(args)
-        tokenize.tokenize_loop(f.readline, eater)
-    except tokenize.TokenError:
-        # This is due to a premature EOF, which we expect since we are
-        # feeding in fragments of Python code.
-        pass
-    return tokens    
-
-def rtrimTerminus(command, terminator=None):
-    """Return command minus anything that follows the final terminator."""
-    if terminator:
-        pieces = command.split(terminator)
-        if len(pieces) > 1:
-            command = terminator.join(pieces[:-1]) + terminator
-    return command
-
-def getBaseObject(object):
-    """Return base object and dropSelf indicator for an object."""
-    if inspect.isbuiltin(object):
-        # Builtin functions don't have an argspec that we can get.
-        dropSelf = 0
-    elif inspect.ismethod(object):
-        # Get the function from the object otherwise
-        # inspect.getargspec() complains that the object isn't a
-        # Python function.
-        try:
-            if object.im_self is None:
-                # This is an unbound method so we do not drop self
-                # from the argspec, since an instance must be passed
-                # as the first arg.
-                dropSelf = 0
-            else:
-                dropSelf = 1
-            object = object.im_func
-        except AttributeError:
-            dropSelf = 0
-    elif inspect.isclass(object):
-        # Get the __init__ method function for the class.
-        constructor = getConstructor(object)
-        if constructor is not None:
-            object = constructor
-            dropSelf = 1
-        else:
-            dropSelf = 0
-    elif callable(object):
-        # Get the __call__ method instead.
-        try:
-            call_method = object.__call__.im_func
-            if call_method.__name__ == '__call__':
-                # unbound jython method end up here, example: string.index(
-                dropSelf = 0
-            else:
-                object = call_method
-                dropSelf = 1
-        except AttributeError:
-            # unbound python methods end up here
-            dropSelf = 0
-    else:
-        dropSelf = 0
-    return object, dropSelf
-
-def getConstructor(object):
-    """Return constructor for class object, or None if there isn't one."""
-    try:
-        return object.__init__.im_func
-    except AttributeError:
-        for base in object.__bases__:
-            constructor = getConstructor(base)
-            if constructor is not None:
-                return constructor
-    return None