jrubyfx-fxmlloader 0.2-java → 0.3-java

data/lib/fxmlloader/rorba.rb

@@ -24,31 +24,6 @@
  */
 =end
 
-#package com.sun.javafx.fxml;
-#
-#import java.lang.reflect.InvocationTargetException;
-#import java.lang.reflect.Method;
-#import java.lang.reflect.Modifier;
-#import java.lang.reflect.ParameterizedType;
-#import java.lang.reflect.Type;
-#import java.lang.reflect.TypeVariable;
-#import java.math.BigDecimal;
-#import java.math.BigInteger;
-#import java.util.AbstractMap;
-#import java.util.Arrays;
-#import java.util.HashMap;
-#import java.util.LinkedList;
-#import java.util.List;
-#import java.util.Map;
-#import java.util.Set;
-#
-#import java.lang.reflect.*;
-#
-#import javafx.@beans.value.ObservableValue;
-#import sun.reflect.misc.FieldUtil;
-#import sun.reflect.misc.MethodUtil;
-#import sun.reflect.misc.ReflectUtil;
-
 #/**
 # * Exposes Java Bean properties of an object via the {@link Mapend interface.
 # * A call to {@link Map#get(Object)end invokes the getter for the corresponding
@@ -93,9 +68,8 @@ class RubyObjectWrapperBeanAdapter
   def [](key)
     return @bean.send("get#{key[0].upcase}#{key[1..-1]}")
   end
-  
+
   def []=(key, value)
-    dputs "calling setterrorab"
     if (key == nil)
       raise "NULL PTR"
     end
@@ -111,14 +85,14 @@ class RubyObjectWrapperBeanAdapter
     end
     @bean.methods.include? "set#{key[0].upcase}#{key[1..-1]}"
   end
-  
+
   def getType(key)
     if (key == nil)
       raise ArgumentError.new();
     end
     @bean.send(key + "GetType")
   end
-  
+
   def getPropertyModel(key)
     if (key == nil)
       raise ArgumentError.new();

data/lib/fxmlloader/rrba.rb

@@ -32,10 +32,8 @@
 # * corresponding property model.
 # */
 class RubyWrapperBeanAdapter
-  #  private final Object @bean;
 
-
-  @@globalMethodCache = {}
+  @@method_cache = {}
 
   GET_PREFIX = "get"
   IS_PREFIX = "is"
@@ -44,337 +42,235 @@ class RubyWrapperBeanAdapter
 
   VALUE_OF_METHOD_NAME = "valueOf"
 
-  #    static
-  #        contextClassLoader = Thread.currentThread().getContextClassLoader();
-  #
-  #        if (contextClassLoader == nil)
-  #            raise ArgumentError.new();
-  #        end
-  #    end
+  OBJECT_PUBLIC_METHODS = Object.new.public_methods
 
-  #Creates a Bean.new adapter.
-  #
   #@param @bean
   #The Bean object to wrap.
   def initialize(bean)
-    @bean = bean;
-
+    @bean = bean
     type = @bean.java_class
-
-    while (type != Java.java.lang.Object.java_class && !@@globalMethodCache.has_key?(type))
-      @@globalMethodCache[type] = getClassMethodCache(type)
-      type = type.superclass();
-    end
+    javas = []
+    while type != java.lang.Object.java_class && !@@method_cache.has_key?(type)
+      javas += build_cache_for(type)
+      type = type.superclass
+    end
+    #    class_methods = {}
+    #    (@bean.public_methods - OBJECT_PUBLIC_METHODS - javas.map{|x|x.name.to_sym}).each do |method_name|
+    #      puts "ruby method: #{method_name}"
+    #      name = method_name.to_s
+    #      unless class_methods.has_key? name
+    #        class_methods[name] = []
+    #      else
+    #        class_methods[name]
+    #      end << method_name.to_sym
+    #    end
+    #    @@method_cache[@bean.class] =
   end
 
-  def getClassMethodCache(type)
-    classMethodCache = {}
+  def build_cache_for(type)
+    class_methods = {}
 
-    ReflectUtil.checkPackageAccess(type);
-    declaredMethods = type.declared_instance_methods();
-    declaredMethods.each do |method|
-      modifiers = method.modifiers();
-
-      if (Modifier.public?(modifiers) && !Modifier.static?(modifiers))
-        name = method.name();
-        namedMethods = classMethodCache[name]
-
-        if (namedMethods == nil)
-          namedMethods = []
-          classMethodCache[name] =  namedMethods
-        end
+    ReflectUtil.checkPackageAccess(type) # TODO: do I want this ?
 
-        namedMethods << (method)
+    java_methods = type.declared_instance_methods.each do |method|
+      modifiers = method.modifiers
+      if Modifier.public?(modifiers) && !Modifier.static?(modifiers)
+        name = method.name
+        unless class_methods.has_key? name
+          class_methods[name] = []
+        else
+          class_methods[name]
+        end << method
       end
     end
 
-    return classMethodCache;
-  end
-
-  #    /**
-  #     * Returns the Bean object this adapter wraps.
-  #     *
-  #     * @return
-  #     * The Bean object, or <tt>nil</tt> if no Bean has been set.
-  #     */
-  def getBean()
-    return @bean;
+    @@method_cache[type] = class_methods
+    return java_methods
   end
 
-  def getMethod(name, *parameterTypes)
-    type = @bean.java_class();
-
-    method = nil;
-    while (type != Java::java.lang.Object.java_class)
-      classMethodCache = @@globalMethodCache[(type)] || {}
-
-      namedMethods = classMethodCache[name]
-      if (namedMethods != nil)
-        for  namedMethod in namedMethods
-          if (namedMethod.name() == (name)  && namedMethod.parameter_types() ==  parameterTypes)
-            method = namedMethod;
-            break;
-          end
+  def getMethod(name, *parameter_types)
+    type = @bean.java_class
+    while type != java.lang.Object.java_class
+      if methods = (@@method_cache[type] || {})[name]
+        methods.each do |method|
+          return method if method.name == name && method.parameter_types == parameter_types
         end
       end
-
-      if (method != nil)
-        break;
-      end
-      type = type.superclass();
+      type = type.superclass
     end
-
-    return method;
+    return nil
   end
 
-  def getGetterMethod( key)
-    getterMethod = getMethod(getMethodName(GET_PREFIX, key));
-
-    if (getterMethod == nil)
-      getterMethod = getMethod(getMethodName(IS_PREFIX, key));
-    end
-
-    return getterMethod;
+  def getter(key)
+    capital = camelize(key)
+    return getMethod(GET_PREFIX + capital) if @bean.respond_to?(GET_PREFIX + capital)
+    return getMethod(IS_PREFIX + capital)
   end
 
-  def getSetterMethod( key)
-    type = getType(key);
-
-    if (type == nil)
-      raise UnsupportedOperationException.new("Cannot determine type for property.");
-    end
+  def setter(key)
+    raise java.lang.UnsupportedOperationException.new("Cannot determine type for property #{key}.") unless type = getType(key)
+    return getMethod(method_name(SET_PREFIX, key), type)
+  end
 
-    return getMethod(getMethodName(SET_PREFIX, key), type)
+  def method_name(prefix, key)
+    return prefix + camelize(key)
   end
 
-  def getMethodName(prefix, key)
-    return prefix + key[0].upcase + key[1..-1];
+  def camelize(key)
+    key[0].upcase + key[1..-1]
   end
 
   def [](key)
     key = key.to_s
-    getterMethod = key.end_with?(PROPERTY_SUFFIX) ? getMethod(key) : getGetterMethod(key);
-
-    value = nil
-    if (getterMethod != nil)
-      begin
-        value = getterMethod.invoke @bean
-      rescue IllegalAccessException => exception
-        raise RuntimeException.new(exception);
-      rescue InvocationTargetException => exception
-        raise RuntimeException.new(exception);
+    begin
+      unless key.end_with?(PROPERTY_SUFFIX)
+        camel = camelize(key)
+        unless !@bean.respond_to?(GET_PREFIX + camel) and @bean.respond_to?(IS_PREFIX + camel)
+          @bean.send(GET_PREFIX + camel)
+        else
+          @bean.send(IS_PREFIX + camel)
+        end
+      else
+        @bean.send key
       end
-    else
-      value = nil;
+    rescue NoMethodError => nme
+      raise unless nme.name.to_s.end_with?(key)
+      puts "failing on #{key}"
+#      p @bean
+#      p @bean.class
+#      puts caller
+      nil
     end
-
-    return value;
   end
 
-  #    /**
-  #     * Invokes a setter method for the given property. The
-  #     * {@link #coerce(Object, Class)end method is used as needed to attempt to
-  #     * convert a given value to the property type, as defined by the return
-  #     * value of the getter method.
-  #     *
-  #     * @param key
-  #     * The property name.
-  #     *
-  #     * @param value
-  #     * The property.new value.
-  #     *
-  #     * @return
-  #     * Returns <tt>nil</tt>, since returning the previous value would require
-  #     * an unnecessary call to the getter method.
-  #     *
-  #     * @throws PropertyNotFoundException
-  #     * If the given property does not exist or is read-only.
-  #     */
-  #    @Override
   def []=(key, value)
-    dputs "calling setter"
-    if (key == nil)
-      raise "NULL PTR"
-    end
+    raise "NULL PTR" unless key
 
-    setterMethod = getSetterMethod(key);
+    setter = method_name(SET_PREFIX, key)
 
-    if (setterMethod == nil)
-      dputs caller
-      dputs "error in []=!"
-      dp key, value, @bean
-      raise PropertyNotFoundException.new("Property \"" + key + "\" does not exist"                + " or is read-only.");
-    end
-    begin
-      ty = getType(key)
-      co = coerce(value, ty)
-      setterMethod.invoke(@bean, co );
-    rescue IllegalAccessException => exception
-      dp "issues1"
-      dp exception
-      raise "RuntimeException.new(exception);"
-    rescue InvocationTargetException => exception
-      dp "issues2"
-      dp exception
-      raise R"untimeException.new(exception);"
-    end
-    dputs "eone"
-    return nil;
-  end
-
-  #    /**
-  #     * Verifies the existence of a property.
-  #     *
-  #     * @param key
-  #     * The property name.
-  #     *
-  #     * @return
-  #     * <tt>true</tt> if the property exists; <tt>false</tt>, otherwise.
-  #     */
-  #    @Override
-  def has_key?( key)
-    if (key == nil)
-      raise "NULL PTR"
+    raise "Property \"#{key}\" does not exist or is read-only." unless @bean.respond_to? setter
+    ty = getType(key)
+    co = coerce(value, ty)
+    coi = RubyWrapperBeanAdapter.jit_export(co, value, ty, setter(key))
+    rputs @bean, "#{setter}(#{coi})"
+    if coi.start_with?("*[") # cheap way to not compute it twice :D
+      @bean.send(setter, *co)
+    else
+      @bean.send(setter, co)
     end
-
-    return getType(key.to_s) != nil;
+    co
   end
 
-  def entrySet()
-    raise UnsupportedOperationException.new();
+  def has_key?(key)
+    raise "NULL PTR" unless key
+    getType(key.to_s)
   end
 
-  #    /**
-  #     * Tests the mutability of a property.
-  #     *
-  #     * @param key
-  #     * The property name.
-  #     *
-  #     * @return
-  #     * <tt>true</tt> if the property is read-only; <tt>false</tt>, otherwise.
-  #     */
   def read_only?(key)
-    if (key == nil)
-      raise "NULL PTR"
-    end
-    dputs "checking for readonly-ness of #{key}:"
-    dp getSetterMethod(key)
-    return getSetterMethod(key) == nil;
+    setter(key) == nil
   end
 
-  #    /**
-  #     * Returns the property model for the given property.
-  #     *
-  #     * @param key
-  #     * The property name.
-  #     *
-  #     * @return
-  #     * The named property model, or <tt>nil</tt> if no such property exists.
-  #     */
-  #    @SuppressWarnings("unchecked")
-  def getPropertyModel( key)
-    if (key == nil)
-      raise ArgumentError.new();
-    end
-
-    return self[key + PROPERTY_SUFFIX]
+  def getPropertyModel(key)
+    raise ArgumentError.new unless key
+    self[key + PROPERTY_SUFFIX]
   end
 
-  #    /**
-  #     * Returns the type of a property.
-  #     *
-  #     * @param key
-  #     * The property name.
-  #     */
   def getType(key)
-    if (key == nil)
-      raise ArgumentError.new();
+    raise ArgumentError.new unless key
+    if @bean.respond_to? "#{key}GetType" # ruby type support ;-D
+      @bean.send("#{key}GetType")
+    else
+      getter = getter(key)
+      getter && getter.return_type
     end
-
-    getterMethod = getGetterMethod(key);
-
-    return (getterMethod == nil) ? nil : getterMethod.return_type();
   end
 
-  #    /**
-  #     * Returns the generic type of a property.
-  #     *
-  #     * @param key
-  #     * The property name.
-  #     */
-  def getGenericType(key)
-    if (key == nil)
-      raise ArgumentError.new();
-    end
-
-    getterMethod = getGetterMethod(key);
-    dputs "GOt getter method for #{key}"
-    dp getterMethod
-    dputs getterMethod
-
-    return (getterMethod == nil) ? nil : getterMethod.return_type
-  end
+  alias :getGenericType :getType
 
   def coerce(value, type)
     RubyWrapperBeanAdapter.coerce(value, type)
   end
-  #    /**
-  #     * Coerces a value to a given type.
-  #     *
-  #     * @param value
-  #     * @param type
-  #     *
-  #     * @return
-  #     * The coerced value.
-  #     */
-  #    @SuppressWarnings("unchecked")
-  def self.coerce( value,  type)
-    dputs "coercing..."
-    if (type == nil)
-      dputs "WHAT!"
-      raise "ArgumentError.new();"
-    end
-    if (value.class == Java::JavaObject)
-      dputs "de-objectifying it!!!!"
-      dp value.class
-      dp value.java_class
-      dp value.to_java
-      value = value.to_java
-    end
 
-    coercedValue = nil;
-    if (value == nil)
-      # Null values can only be coerced to nil
-      coercedValue = nil;
-    elsif (value.is_a?(EventHandlerWrapper) && type == Java.javafx.event.EventHandler.java_class) || (value.respond_to?(:java_class) && !value.is_a?(EventHandlerWrapper) && type.assignable_from?(value.java_class))
-      # Value doesn't require coercion
-      coercedValue = value;
-    elsif !value.respond_to?(:java_class) && !type.enum?
-      # its a ruby value
+  def self.jit_export(co, value, ty, setter, ignore=nil)
+    coi = co.inspect
+    if co.is_a? Java::JavaLang::Enum
+      coi = "Java::#{co.java_class.name.gsub(/[\$\.]/, "::")}::#{co.to_s}"
+    elsif co.is_a? EventHandlerWrapper
+      coi = "EventHandlerWrapper.new(__local_fxml_controller, #{co.funcName.inspect})"
+    elsif co.is_a? ScriptEventHandler
+      coi = "ScriptEventHandler.new(#{co.script.inspect}, __local_sem_lang_inst_#{rget_sem(co.scriptEngine)})"
+    elsif tmp = rget(value)
+      coi = tmp
+    elsif co.is_a? Java::javafx.scene.paint.Paint
+      coi = "RubyWrapperBeanAdapter.coerce(#{value.inspect}, #{ty.ruby_class}.java_class)"
+    elsif setter.respond_to? :varargs? and setter.varargs?
+      coi = "*#{coi}"
+    elsif coi.start_with? "#<"
+      #      puts "ignoring #{setting}(#{coi})
+      #        How about #{setting}(RubyWrapperBeanAdapter.coerce(#{value.inspect}, #{ty})) ?#
+
+      #      "
+      coi = "RubyWrapperBeanAdapter.coerce(#{value.inspect}, #{ty.ruby_class}.java_class)"
+    end
+    return coi
+  end
+
+  @@mapper = nil
+  def self.mapper
+    unless @@mapper
       dir = ->(x){x}
       to_x = ->(x){->(o){o.send(x)}}
       to_dbl = ->(x){java.lang.Double.valueOf(x.to_s)}
       to_bool = ->(x){java.lang.Boolean.valueOf(x.to_s)}
-      value_of = ->(x){type.ruby_class.valueOf(x.to_s)}
+      value_of = ->(x, type){type.ruby_class.valueOf(x.to_s)}
       # TODO: Java::double[].java_class.component_type
-      mapper = {
+      @@mapper = {
         [String, java.lang.String.java_class] => dir,
         [Fixnum, java.lang.Integer.java_class] => dir,
         [Float, java.lang.Double.java_class] => dir,
         [Float, Java::double.java_class] => dir,
+        [FalseClass, Java::boolean.java_class] => dir,
+        [TrueClass, Java::boolean.java_class] => dir,
         [String, Java::double.java_class] => to_dbl,
         [String, java.lang.Double.java_class] => to_dbl,
         [String, Java::int.java_class] => to_x.call(:to_i),
         [String,java.lang.Integer.java_class] => to_x.call(:to_i),
         [String, Java::boolean.java_class] => to_bool,
         [String, Java::javafx.scene.paint.Paint.java_class] => value_of,
-        [String, Java::java.lang.Object.java_class] => ->(x){x},
+        [String, Java::javafx.scene.paint.Color.java_class] => value_of,
+        [String, Java::java.lang.Object.java_class] => dir,
         [String, Java::double[].java_class] => ->(x){x.split(/[, ]+/).map(&:to_f)}
       }
+    end
+    @@mapper
+  end
+
+  def self.coerce( value,  type)
+    if (type == nil)
+      raise "ArgumentError.new();"
+    end
+    if (value.class == Java::JavaObject)
+      value = value.to_java
+    end
+
+    coercedValue = nil;
+    if (value == nil)
+      # Null values can only be coerced to nil
+      coercedValue = nil;
+    elsif type == java.lang.Object.java_class || (value.is_a?(EventHandlerWrapper) && type == Java.javafx.event.EventHandler.java_class) || (value.respond_to?(:java_class) && !value.is_a?(EventHandlerWrapper) && type.assignable_from?(value.java_class))
+      # Value doesn't require coercion
+      coercedValue = value;
+    elsif !value.respond_to?(:java_class) && !type.enum?
+      # its a ruby value
+
       if mapper[[value.class, type]]
-        coercedValue = mapper[[value.class, type]].call(value)
+        coercedValue = mapper[[value.class, type]]
+        if coercedValue.arity == 1
+          coercedValue = coercedValue.call(value)
+        else
+          coercedValue = coercedValue.call(value, type)
+        end
       else
-        dputs "!! Non-normal RUBY coerce (#{value}, #{type}) (#{value.inspect}, [#{value.class}, #{type.inspect}])"
         raise "Unknown Coercion map: (#{value}, #{type}) (#{value.inspect}, [#{value.class}, #{type.inspect}]; Please file a bug on this."
       end
       # Ruby String :D
@@ -390,122 +286,8 @@ class RubyWrapperBeanAdapter
       dputs "COnverting url to string"
       coercedValue = value.to_s
     else
-      dputs "!! Non-normal coerce (#{value}, #{type}) (#{value.inspect}, #{type.inspect})"
-      if (type == java.lang.Boolean.java_class || type == Boolean.TYPE)
-        coercedValue = Boolean.valueOf(value.toString());
-      elsif (type == Character.java_class            || type == Character.TYPE)
-        coercedValue = value.toString().charAt(0);
-      elsif (type == Byte.java_class            || type == Byte.TYPE)
-        if (value.is_a? Number)
-          coercedValue = (value).byteValue();
-        else
-          coercedValue = Byte.valueOf(value.toString());
-        end
-      elsif (type == Short.java_class            || type == Short.TYPE)
-        if (value.is_a? Number)
-          coercedValue = (value).shortValue();
-        else
-          coercedValue = Short.valueOf(value.toString());
-        end
-      elsif (type == Integer.java_class            || type == Integer.TYPE)
-        if (value.is_a? Number)
-          coercedValue = (value).intValue();
-        else
-          coercedValue = Integer.valueOf(value.toString());
-        end
-      elsif (type == Long.java_class            || type == Long.TYPE)
-        if (value.is_a? Number)
-          coercedValue = (value).longValue();
-        else
-          coercedValue = Long.valueOf(value.toString());
-        end
-      elsif (type == BigInteger.java_class)
-        if (value.is_a? Number)
-          coercedValue = BigInteger.valueOf((value).longValue());
-        else
-          coercedValue = BigInteger.new(value.toString());
-        end
-      elsif (type == Float.java_class            || type == Float.TYPE)
-        if (value.is_a? Number)
-          coercedValue = (value).floatValue();
-        else
-          coercedValue = Float.valueOf(value.toString());
-        end
-      elsif (type == Double.java_class            || type == Double.TYPE)
-        if (value.is_a? Number)
-          coercedValue = (value).doubleValue();
-        else
-          coercedValue = Double.valueOf(value.toString());
-        end
-      elsif (type == Number.java_class)
-        number = value.toString();
-        if (number.contains("."))
-          coercedValue = Double.valueOf(number);
-        else
-          coercedValue = Long.valueOf(number);
-        end
-      elsif (type == BigDecimal.java_class)
-        if (value.is_a? Number)
-          coercedValue = BigDecimal.valueOf((value).doubleValue());
-        else
-          coercedValue = BigDecimal.new(value.toString());
-        end
-      elsif (type == Class.java_class)
-        begin
-          ReflectUtil.checkPackageAccess(value.toString());
-          coercedValue = Class.forName(
-            value.to_s,
-            false,
-            JRuby.runtime.get_class_loader);
-        rescue ClassNotFoundException => exception
-          raise Exception.new(exception);
-        end
-      else
-        dputs "elsee"
-        valueType = value.java_class();
-        valueOfMethod = nil;
-
-        while (valueOfMethod == nil                && valueType != nil)
-          begin
-            dputs "checking access"
-            ReflectUtil.checkPackageAccess(type);
-            valueOfMethod = type.declared_method(VALUE_OF_METHOD_NAME, valueType);
-          rescue NoSuchMethodException => exception
-            # No-op
-          end
-
-          if (valueOfMethod == nil)
-            valueType = valueType.superclass();
-          end
-        end
-
-        if (valueOfMethod == nil)
-          raise IllegalArgumentException.new("Unable to coerce " + value + " to " + type + ".");
-        end
-
-        if type.isEnum()                && value.is_a?(String) && value[0] == value[0].downcase
-          value = RubyWrapperBeansAdapter.toUpcase value;
-        end
-
-        begin
-          coercedValue = MethodUtil.invoke(valueOfMethod, nil, [ value ]);
-        rescue IllegalAccessException => exception
-          dputs "EAI1"
-          dp exception
-          raise "RuntimeException.new(exception);"
-        rescue InvocationTargetException => exception
-          dputs "ETI1"
-          dp exception
-          raise "RuntimeException.new(exception);"
-        rescue SecurityException => exception
-          dputs "SE1"
-          dp exception
-          raise "RuntimeException.new(exception);"
-        end
-      end
+      raise "!! Non-normal coerce (#{value}, #{type}) (#{value.inspect}, #{type.inspect})"
     end
-    dputs "Coerced #{value.class} into a #{coercedValue.class} for #{type}"
-    dp value, coercedValue
     return coercedValue;
   end
 
@@ -574,7 +356,6 @@ class RubyWrapperBeanAdapter
     elsif target.is_a? String
       targetType = java.lang.String.java_class
     else
-      dp target, sourceType, key, value
       raise "Shoots!"
     end
 
@@ -587,7 +368,6 @@ class RubyWrapperBeanAdapter
       elsif value.is_a? String
         valueClass = java.lang.String.java_class
       else
-        dp target, sourceType, key, value
         raise "Shoots TWICE!"
       end
       setterMethod = getStaticSetterMethod(sourceType, key, valueClass, targetType);
@@ -609,6 +389,7 @@ class RubyWrapperBeanAdapter
 
     # Invoke the setter
     begin
+      rputs target, "#{sourceType.ruby_class.inspect}.set#{key[0].upcase}#{key[1..-1]}(self, #{jit_export(value, value, targetType, key, "#{sourceType.ruby_class.inspect}.#{key}=")})"
       getStaticSetterMethod(sourceType, key, valueClass, targetType, true).call(target.java_object, value);
     rescue InvocationTargetException => exception
       raise "RuntimeException.new(exception);"
@@ -681,8 +462,6 @@ class RubyWrapperBeanAdapter
     if (itemType.is_a? ParameterizedType)
       itemType = (itemType).getRawType();
     end
-    dputs "Listem item type is for "
-    dp listType, itemType
     return itemType;
   end
 
@@ -710,41 +489,26 @@ class RubyWrapperBeanAdapter
     itemType = nil;
 
     parentType = listType;
-    dputs "searching for generic #{listType}"
     while (parentType != nil)
-      dputs "Still not nill"
-      dp parentType
       if (parentType.is_a? ParameterizedType)
-        dputs "Parametratized type!"
         parameterizedType = parentType;
         rawType = parameterizedType.getRawType();
-        dp rawType, parameterizedType
         if (List.java_class.assignable_from?(rawType))
           itemType = parameterizedType.getActualTypeArguments()[0];
-          dputs "OOOOOHHH item type is #{itemType}"
-          dp itemType
         end
 
         break;
       end
 
       classType = parentType;
-      dputs "checinhg generic interfaces"
       genericInterfaces = classType.generic_interfaces();
 
       genericInterfaces.each do |genericInterface|
-        dputs "serarcing ingeraface"
-        dp genericInterface
         if (genericInterface.is_a? ParameterizedType)
           parameterizedType = genericInterface;
           interfaceType = parameterizedType.getRawType();
-          dputs "checking"
-          dp parameterizedType, interfaceType
           if (List.java_class.assignable_from?(interfaceType.java_class)) || (List.java_class.assignable_from?(interfaceType.java_object))
             itemType = parameterizedType.getActualTypeArguments()[0];
-            dputs "found it at "
-            dp parameterizedType, interfaceType, itemType
-            dp itemType.bounds
             break;
           end
         end
@@ -758,8 +522,6 @@ class RubyWrapperBeanAdapter
     end
 
     if (itemType != nil && itemType.is_a?(java.lang.reflect.TypeVariable))
-      dputs 'aww shucks'
-      dp itemType
       itemType = Java::java.lang.Object.java_class;
     end
 
@@ -996,9 +758,9 @@ class RubyWrapperBeanAdapter
 
     return allCapsBuilder.toString();
   end
-  
+
   def self.for(names)
-    if names.is_a? java.lang.Object
+    if names.is_a? java.lang.Object or (names.is_a? Java::JavaObject and (names = names.to_java))
       RubyWrapperBeanAdapter.new(names)
     else
       RubyObjectWrapperBeanAdapter.new(names)