rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,316 @@
+"""Extend introspect.py for Java based Jython classes."""
+
+from org.python.core import PyReflectedFunction
+from java.lang import Class, Object
+from java.lang.reflect import Modifier
+from introspect import *
+from sets import Set
+import string
+import re
+import types
+
+__author__ = "Don Coleman <dcoleman@chariotsolutions.com>"
+
+_re_import_package = re.compile('import\s+(.+)\.') # import package
+# TODO need to check for a trailing '.'  example: "from java import lang." don't autocomplete on trailing '.'
+_re_from_package_import = re.compile('from\s+(\w+(?:\.\w+)*)\.?(?:\s*import\s*)?') # from package import class 
+
+def completePackageName(target):
+    """ Get a package object given the full name."""      
+    targetComponents = target.split('.')
+    base = targetComponents[0]
+    baseModule = __import__(base, globals(), locals())
+    module = baseModule    
+
+    for component in targetComponents[1:]:
+        module = getattr(module, component)
+
+    list = dir(module)
+    list.remove('__name__')
+    list.append('*')
+    return list
+  
+def getPackageName(command):    
+        
+    match = _re_import_package.match(command)
+    if not match:
+        #try the other re
+        match = _re_from_package_import.match(command)
+            
+    return match.groups()[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.
+    """
+
+    # Temp KLUDGE here rather than in console.py
+    command += "."
+
+    attributes = []
+    # Get the proper chunk of code from the command.
+    root = getRoot(command, terminator='.')
+    
+    # check to see if the user is attempting to import a package
+    # this may need to adjust this so that it doesn't pollute the namespace
+    if command.startswith('import ') or command.startswith('from '):
+        target = getPackageName(command)
+        return completePackageName(target)
+    
+    try:
+        if locals is not None:
+            object = eval(root, locals)
+        else:
+            object = eval(root)
+    except:
+        return attributes
+    
+    if ispython(object):  # use existing code
+        attributes = getAttributeNames(object, includeMagic, includeSingle, includeDouble)
+    else:
+        if inspect.isclass(object):
+            attributes = staticMethodNames(object)
+            attributes.extend(staticFieldNames(object))
+        else:
+            attributes = list(instanceMethodNames(object.__class__))
+                    
+    return attributes
+
+def instanceMethodNames(clazz):
+    """return a Set of instance method name for a Class"""
+
+    method_names = Set()
+    declared_methods = Class.getDeclaredMethods(clazz)
+    for method in declared_methods:
+        modifiers = method.getModifiers()
+        if not Modifier.isStatic(modifiers) and Modifier.isPublic(modifiers):
+            name = method.name            
+            method_names.add(name)
+            if name.startswith("get") and len(name) > 3 and len(method.getParameterTypes()) == 0:
+                property_name = name[3].lower() + name[4:]
+                method_names.add(property_name)                
+                                      
+    for eachBase in clazz.__bases__:
+        if not ispython(eachBase):
+            method_names = method_names | instanceMethodNames(eachBase)
+
+    return method_names
+
+def staticMethodNames(clazz):
+    """return a list of static method name for a class"""
+
+    static_methods = {}
+    declared_methods = Class.getDeclaredMethods(clazz)
+    for method in declared_methods:
+        if Modifier.isStatic(method.getModifiers()) and Modifier.isPublic(method.getModifiers()):
+            static_methods[method.name] = method
+    methods = static_methods.keys()
+    
+    for eachBase in clazz.__bases__:
+        # with Jython 2.5 type is a base of Object, which puts asName in the list        
+        # will be a problem for real Java objects that extend Python objects
+        # see similar "fixes" in instanceMethodNames and staticFieldNames
+        if not ispython(eachBase):
+            methods.extend(staticMethodNames(eachBase)) 
+    
+    return methods
+    
+def staticFieldNames(clazz):
+    """return a list of static field names for class"""
+
+    static_fields = {}
+    declared_fields = Class.getDeclaredFields(clazz)
+    for field in declared_fields:
+        if Modifier.isStatic(field.getModifiers()) and Modifier.isPublic(field.getModifiers()):
+            static_fields[field.name] = field
+    fields = static_fields.keys()   
+    
+    for eachBase in clazz.__bases__:
+        if not ispython(eachBase):
+            fields.extend(staticFieldNames(eachBase)) 
+
+    return fields        
+
+def getCallTipJava(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
+
+    if ispython(object):
+        # Patrick's code handles python code
+        # TODO fix in future because getCallTip runs eval() again
+        return getCallTip(command, locals)
+
+    name = ''
+    try:
+        name = object.__name__
+    except AttributeError:
+        pass
+    
+    tipList = []
+    argspec = '' # not using argspec for Java
+    
+    if inspect.isclass(object):
+        # get the constructor(s)
+        # TODO consider getting modifiers since jython can access private methods
+        constructors = object.getConstructors()
+        for constructor in constructors:
+            paramList = []
+            paramTypes = constructor.getParameterTypes()
+            # paramTypes is an array of classes, we need Strings
+            # TODO consider list comprehension
+            for param in paramTypes:
+                paramList.append(param.__name__)
+            paramString = string.join(paramList,', ')
+            tip = "%s(%s)" % (constructor.name, paramString)
+            tipList.append(tip)
+             
+    elif inspect.ismethod(object) or isinstance(object, PyReflectedFunction):
+        method = object
+        try:
+            object = method.im_class
+        except: # PyReflectedFunction
+            object = method.argslist[0].declaringClass
+
+        # java allows overloading so we may have more than one method
+        methodArray = object.getMethods()
+
+        for eachMethod in methodArray:
+            if eachMethod.name == method.__name__:
+                paramList = []
+                for eachParam in eachMethod.parameterTypes:
+                    paramList.append(eachParam.__name__)
+                 
+                paramString = string.join(paramList,', ')
+
+                # create a python style string a la PyCrust
+                # we're showing the parameter type rather than the parameter name, since that's all I can get
+                # we need to show multiple methods for overloading
+                # do we want to show the method visibility?  how about exceptions?
+                # note: name, return type and exceptions same for EVERY overload method
+
+                tip = "%s(%s) -> %s" % (eachMethod.name, paramString, eachMethod.returnType.name)                    
+                tipList.append(tip)
+
+    tip_text = beautify(string.join(tipList,"\n"))
+    calltip = (name, argspec, tip_text)        
+    return calltip
+
+def beautify(tip_text):
+    "Make the call tip text prettier"
+    tip_text = tip_text.replace("java.lang.", "")
+    if "[" in tip_text:
+        tip_text = tip_text.replace("[B", "byte[]")
+        tip_text = tip_text.replace("[S", "short[]")
+        tip_text = tip_text.replace("[I", "int[]")
+        tip_text = tip_text.replace("[J", "long[]")
+        tip_text = tip_text.replace("[F", "float[]")
+        tip_text = tip_text.replace("[D", "double[]")
+        tip_text = tip_text.replace("[Z", "boolean[]")
+        tip_text = tip_text.replace("[C", "char[]")
+    return tip_text
+    
+def ispython21(object):
+    """
+    Figure out if this is Python code or Java Code
+
+    """
+    pyclass = 0
+    pycode = 0
+    pyinstance = 0
+
+    if inspect.isclass(object):
+        try:
+            object.__doc__
+            pyclass = 1
+        except AttributeError:
+            pyclass = 0
+
+    elif inspect.ismethod(object):
+        try:
+            object.__dict__
+            pycode = 1
+        except AttributeError:
+            pycode = 0
+    else: # I guess an instance of an object falls here
+        try:
+            object.__dict__
+            pyinstance = 1
+        except AttributeError:
+            pyinstance = 0
+
+    #    print "object", object, "pyclass", pyclass, "pycode", pycode, "returning", pyclass | pycode
+
+    return pyclass | pycode | pyinstance
+
+
+def ispython22(object):
+    """
+    Return true if object is Python code.    
+    """
+
+    object_type = type(object)
+
+    if object_type.__name__.startswith("java") or isinstance(object, PyReflectedFunction):
+        python = False
+
+    elif object_type is types.MethodType:
+        # both Java and Python methods return MethodType
+        try:
+            object.__dict__
+            python = True
+        except AttributeError:
+            python = False
+    else:
+        # assume everything else is python
+        python = True
+
+    return python
+
+def ispython25(object):
+    """
+    Return true if object is Python code.    
+    """
+
+    if isinstance(object, Class):
+        python = False
+    elif isinstance(object, Object):
+        python = False
+    elif isinstance(object, PyReflectedFunction):
+        python = False
+    elif type(object) == types.MethodType and not ispython(object.im_class):
+        python = False
+    else:
+        # assume everything else is python
+        python = True       
+    
+    return python
+
+# Dynamically assign the version of ispython
+# To deal with differences between Jython 2.1, 2.2 and 2.5
+if sys.version == '2.1':
+    ispython = ispython21
+elif sys.version.startswith('2.5'):
+    ispython = ispython25
+else:
+    ispython = ispython22
+    
+def debug(name, value=None):
+    if value == None:
+        print >> sys.stderr, name
+    else:
+        print >> sys.stderr, "%s = %s" % (name, value)

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

@@ -0,0 +1,107 @@
+import unittest
+import jintrospect
+from java.lang import String
+
+class JIntrospectTestCase(unittest.TestCase):
+
+    def testGetAutoCompleteList(self):
+        s = String("Unit Test")
+        list = jintrospect.getAutoCompleteList("s", locals())
+        self.assertNotEmpty(list)
+        self.assertContains(list, "contains")
+
+    def testGetCallTipJava(self):
+        s = String("Unit Test")
+        tip = jintrospect.getCallTipJava("s.contains", locals())
+        self.assertEquals("contains(CharSequence) -> boolean", tip[2])
+
+    def testGetPackageName(self):
+        package_name = jintrospect.getPackageName("import java.")
+        self.assertEquals("java", package_name)
+
+        package_name = jintrospect.getPackageName("from java.awt import")
+        self.assertEquals("java.awt", package_name)
+
+    def testCompletePackageName(self):
+        try:
+            list = jintrospect.completePackageName("bogus")
+            fail("Expecting import error.")
+        except ImportError:
+            pass
+
+        list = jintrospect.completePackageName("java")
+        self.assertNotEmpty(list)
+        self.assertContains(list, "awt")
+
+        list = jintrospect.completePackageName("java.util")
+        self.assertNotEmpty(list)
+        self.assertContains(list, "ArrayList")
+
+    def testIsPython(self):
+        s = String("Java String")
+        self.assert_(not jintrospect.ispython(s))
+
+        self.assert_(jintrospect.ispython(jintrospect))
+
+    def testIsPython22(self):
+        # NOTE: This will fail with AP 2.1.  Would it fail for old version too?             
+        ps = "python string"
+        self.assert_(jintrospect.ispython(ps))
+        d = {}
+        self.assert_(jintrospect.ispython(d))
+        
+    def testStaticJavaMethods(self):
+        """ Instances of Java classes should not show static methods as completion choices. """
+        static_methods = jintrospect.getAutoCompleteList("String", {"String" : String})
+        self.assert_("valueOf" in static_methods, "'valueOf' missing from static method list")
+        instance_methods = jintrospect.getAutoCompleteList("s", {"s" : String("Test")})
+        self.assert_("valueOf" not in instance_methods, "'valueOf' should not be in the instance method list")
+
+    def testJavaAccessorAsProperty(self):
+        instance_methods = jintrospect.getAutoCompleteList("s", {"s" : String("Test")})
+        self.assert_("class" in instance_methods, "'class' property should be in the instance method list")
+        
+    def testJavaLangRemoved(self):
+        object_name, argspec, tip_text = jintrospect.getCallTip('String', {'String' : 's'})
+        self.assertDoesNotContain(tip_text, "java.lang.")
+        
+    def testPrimitiveArrayConversion(self):
+        """[B, [C and [I should be replaced"""        
+        object_name, argspec, tip_text = jintrospect.getCallTipJava('String', { 'String' : String })
+        self.assertDoesNotContain(tip_text, "[B")
+        self.assertDoesNotContain(tip_text, "[C")
+        self.assertDoesNotContain(tip_text, "[I")
+        self.assertContains(tip_text, "byte[]")
+        self.assertContains(tip_text, "char[]")
+        self.assertContains(tip_text, "int[]")
+
+    # http://code.google.com/p/jythonconsole/issues/detail?id=2
+    # def testMultipleStatements(self):
+    #     command = "import sys; sys"
+    #     list = jintrospect.getAutoCompleteList(command, locals())
+    #     self.assert_(len(list) > 0)
+
+    # note: static methods and fields are tested in static_test_case
+
+    def assertNotEmpty(self, list):
+        if list == None:
+            self.fail("list is None")
+        if len(list) < 1:
+            self.fail("list is empty")
+
+    def assertContains(self, list, value):
+        try:
+            list.index(value)
+        except ValueError:
+            self.fail("%s does not contain %s" % (type(list).__name__, value))
+
+    def assertDoesNotContain(self, list, value):
+        try:
+            list.index(value)
+            self.fail("%s should contain %s" % (type(list).__name__, value))            
+        except ValueError:
+            self.assert_(True)
+        
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,178 @@
+from java.lang import Character
+from javax.swing import JWindow, JList, JScrollPane
+from java.awt import Color, Dimension
+from java.awt.event import KeyEvent
+import sys
+
+__author__ = "Don Coleman <dcoleman@chariotsolutions.com>"
+__cvsid__ = "$Id: popup.py,v 1.9 2003/05/01 03:43:53 dcoleman Exp $"
+
+class Popup(JWindow):
+    """Popup window to display list of methods for completion"""
+    
+    MAX_HEIGHT = 300
+    MIN_WIDTH = 200
+    MAX_WIDTH = 400
+    
+    def __init__(self, frame, textComponent):
+        JWindow.__init__(self, frame)
+        self.textComponent = textComponent
+        self.size = (200,200)
+        self.list = JList(keyPressed=self.key)
+        self.list.setBackground(Color(255,255,225)) # TODO move this color
+        self.getContentPane().add(JScrollPane(self.list))
+        self.list.setSelectedIndex(0)
+
+        self.originalData = ""
+        self.data = ""
+        self.typed = ""
+
+    def key(self, e):
+        # print >> sys.stderr, "Other Listener"
+        if not self.visible:
+            return
+
+        code = e.getKeyCode()
+        
+        if code == KeyEvent.VK_ESCAPE:
+            self.hide()
+
+        elif code == KeyEvent.VK_ENTER or code == KeyEvent.VK_TAB:
+            self.chooseSelected()
+            e.consume()
+
+        elif code == KeyEvent.VK_SPACE:
+            # TODO for functions: choose the selected option, add parenthesis
+            # and put the cursor between them.  example: obj.function(^cursor_here)
+            self.chooseSelected()
+
+        elif code == KeyEvent.VK_PERIOD:
+            self.chooseSelected()
+            #e.consume()
+            
+        # This fails because the key listener in console gets it first
+        elif code == KeyEvent.VK_LEFT_PARENTHESIS:
+            self.chooseSelected()
+
+        elif code == 8: # BACKSPACE
+            if len(self.typed) == 0:
+                self.hide()
+            self.typed = self.typed[:-1]
+            print >> sys.stderr, self.typed
+            self.data = filter(self.originalData, self.typed)
+            self.list.setListData(self.data)
+            self.list.setSelectedIndex(0)
+                
+        elif code == KeyEvent.VK_UP:
+            self.up()
+            # consume event to avoid history previous
+            e.consume()
+            
+        elif code == KeyEvent.VK_DOWN:
+            self.down()
+            # consume event to avoid history next
+            e.consume()
+            
+        elif code == KeyEvent.VK_PAGE_UP:
+            self.pageUp()
+            e.consume()
+
+        elif code == KeyEvent.VK_PAGE_DOWN:
+            self.pageDown()
+            e.consume()
+
+        else:
+            char = e.getKeyChar()
+            if Character.isJavaLetterOrDigit(char):
+                self.typed += char 
+                self.data = filter(self.data, self.typed)
+                self.list.setListData(self.data)
+                self.list.setSelectedIndex(0)
+                
+    def down(self):
+        index = self.list.getSelectedIndex()
+        max = self.getListSize() - 1
+        
+        if index < max:
+            index += 1
+            self.setSelected(index)
+        
+    def up(self):
+        index = self.list.getSelectedIndex()
+
+        if index > 0:
+            index -= 1
+            self.setSelected(index)
+
+    def pageUp(self):
+        index = self.list.getSelectedIndex()
+        visibleRows = self.list.getVisibleRowCount()
+        index = max(index - visibleRows, 0)
+        self.setSelected(index)
+
+    def pageDown(self):
+        index = self.list.getSelectedIndex()
+        visibleRows = self.list.getVisibleRowCount()
+        index = min(index + visibleRows, self.getListSize() - 1)
+        self.setSelected(index)
+
+    def setSelected(self, index):
+        self.list.setSelectedIndex(index)
+        self.list.ensureIndexIsVisible(index)
+
+    def getListSize(self):
+        return self.list.getModel().getSize()
+
+    def chooseSelected(self):
+        """Choose the selected value in the list"""
+        value = self.list.getSelectedValue()
+        if value != None:
+            startPosition = self.dotPosition + 1
+            caretPosition = self.textComponent.getCaretPosition()
+            self.textComponent.select(startPosition, caretPosition) 
+            self.textComponent.replaceSelection(value)
+            self.textComponent.setCaretPosition(startPosition + len(value))
+        self.hide()
+
+    def setMethods(self, methodList):
+        methodList.sort()
+        self.data = methodList
+        self.originalData = methodList
+        self.typed = ""
+        self.list.setListData(methodList)
+
+    def show(self):
+        # when the popup becomes visible, get the cursor
+        # so we know how to replace the selection
+        self.dotPosition = self.textComponent.getCaretPosition()
+        self.setSize(self.getPreferredSize())
+        self.super__show()
+
+    def showMethodCompletionList(self, list, displayPoint):
+        self.setLocation(displayPoint)
+        self.setMethods(list)
+        self.show()
+        self.list.setSelectedIndex(0)
+
+    def getPreferredSize(self):
+        # need to add a magic amount to the size to avoid scrollbars
+        # I'm sure there's a better way to do this
+        MAGIC = 20
+        size = self.list.getPreferredScrollableViewportSize()
+        height = size.height + MAGIC
+        width = size.width + MAGIC
+        if height > Popup.MAX_HEIGHT:
+            height = Popup.MAX_HEIGHT
+        if width > Popup.MAX_WIDTH:
+            width = Popup.MAX_WIDTH
+        if width < Popup.MIN_WIDTH:
+            width = Popup.MIN_WIDTH
+        return Dimension(width, height)
+
+    
+# this needs a list renderer that will hilight the prefix
+def filter(list, prefix):
+    prefix = prefix.lower()
+    list = [eachItem for eachItem in list if str(eachItem).lower().startswith(prefix)]
+    return list
+

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

@@ -0,0 +1,8 @@
+import glob
+
+for filename in glob.glob('*_test_case.py'):
+	exec 'from %s import *'%filename[:-3]
+
+if __name__ == '__main__':
+	import unittest
+	unittest.main()

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

@@ -0,0 +1,36 @@
+import unittest
+import jintrospect
+
+class StaticTestCase(unittest.TestCase):
+
+    def setUp(self):
+        pass
+        
+    def testStaticAutoComplete(self):
+        from java.util.logging import Level
+        list = jintrospect.getAutoCompleteList("Level", locals())
+        self.assertEquals(10, len(list))
+        self.assert_(list.index("INFO") > -1)
+
+    # This works but sometimes prints a bunch of junk on OS 10.4.9 if a Swing GUI is running
+    def testStaticPropertyFromAncestor(self):
+        from javax.swing import JButton
+        list = jintrospect.getAutoCompleteList("JButton", locals())
+        self.assert_(len(list) > 0)
+        self.assert_(list.index("TEXT_CHANGED_PROPERTY") > -1)
+  
+    def testStaticPropertyFromAncestorInterface(self):
+        from javax.xml.transform.stream import StreamResult
+        list = jintrospect.getAutoCompleteList("StreamResult", locals())
+        self.assert_(len(list) > 0)
+        self.assert_(list.index("PI_ENABLE_OUTPUT_ESCAPING") > -1)
+
+    def testStaticMethodFromAncestor(self):
+        from javax.swing.border import EtchedBorder
+        list = jintrospect.getAutoCompleteList("EtchedBorder", locals())
+        #print list
+        self.assert_(len(list) > 0)
+        self.assert_(list.index("getInteriorRectangle") > -1)
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,38 @@
+import sys
+import unittest
+import introspect
+
+class IntrospectTestCase(unittest.TestCase):
+
+    def setUp(self):
+        try:
+            sys.ps2
+        except AttributeError:
+            sys.ps2 = '... '
+
+    def testUnboundMethod(self):
+        import string
+        method = 'string.index('
+        (name, argspec, tip) = introspect.getCallTip(method, locals())
+
+        self.assertEquals('index', name)
+        self.assertEquals('s, *args', argspec)
+        self.assertEquals('index(s, *args)\n\nindex(s, sub [,start [,end]]) -> int\n\nLike find but raises ValueError when the substring is not found.', tip)
+
+    def testBuiltinFunction(self):
+        """Builtin types don't work, like they do in PyCrust.  This is because they have a null __doc__ string in Jython."""
+        method = 'len('
+        
+        (name, argspec, tip) = introspect.getCallTip(method, locals())
+        
+        self.assertEquals('len', name)
+        
+        if not sys.platform.startswith('java'):
+            # next line worked with Python 2.2, fails with Python 2.3 and 2.5 on OS X, probably need newer introspect, inspect or dis
+            # self.assertEquals('len(object) -> integer', argspec)
+            self.assertEquals('', argspec)
+            self.assertEquals('len(object) -> integer\n\nReturn the number of items of a sequence or mapping.', tip)
+
+
+if __name__ == '__main__':
+    unittest.main()