jruby · Mar 25, 2015 · Mar 25, 2015 · Mar 25, 2015 · Mar 25, 2015 · Mar 25, 2015
diff --git a/core/src/main/java/org/jruby/java/addons/ArrayJavaAddons.java b/core/src/main/java/org/jruby/java/addons/ArrayJavaAddons.java
@@ -1,6 +1,5 @@
 package org.jruby.java.addons;
 
-import java.lang.reflect.Array;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyFixnum;
@@ -10,121 +9,115 @@
 import org.jruby.runtime.builtin.IRubyObject;
 
 public class ArrayJavaAddons {
-    @JRubyMethod
-    public static IRubyObject copy_data(
-            ThreadContext context, IRubyObject rubyArray, IRubyObject javaArray,
-            IRubyObject fillValue) {
-        JavaArray javaArrayJavaObj = (JavaArray)javaArray.dataGetStruct();
+
+    @JRubyMethod(name = "copy_data")
+    public static IRubyObject copy_data(final ThreadContext context,
+        final IRubyObject fromRuby, final IRubyObject toJava, final IRubyObject fillValue) {
+        JavaArray javaArray = (JavaArray) toJava.dataGetStruct();
+        final int javaLength = javaArray.getLength();
+        final Class<?> targetType = javaArray.getComponentType();
+
         Object fillJavaObject = null;
-        int javaLength = (int)javaArrayJavaObj.length().getLongValue();
-        Class targetType = javaArrayJavaObj.getComponentType();
-
-        if (!fillValue.isNil()) {
-            fillJavaObject = fillValue.toJava(targetType);
-        }
-
-        RubyArray array = null;
-        int rubyLength;
-        if (rubyArray instanceof RubyArray) {
-            array = (RubyArray)rubyArray;
-            rubyLength = ((RubyArray)rubyArray).getLength();
+        if ( ! fillValue.isNil() ) fillJavaObject = fillValue.toJava(targetType);
+
+        RubyArray rubyArray = null;
+        if (fromRuby instanceof RubyArray) {
+            rubyArray = (RubyArray) fromRuby;
         } else {
-            rubyLength = 0;
-            fillJavaObject = rubyArray.toJava(targetType);
+            fillJavaObject = fromRuby.toJava(targetType);
         }
-        
+
         int i = 0;
-        for (; i < rubyLength && i < javaLength; i++) {
-            javaArrayJavaObj.setWithExceptionHandling(i, array.entry(i).toJava(targetType));
+        if ( rubyArray != null ) {
+            final int rubyLength = rubyArray.getLength();
+            for (; i < rubyLength && i < javaLength; i++) {
+                javaArray.setWithExceptionHandling(i, rubyArray.eltInternal(i).toJava(targetType));
+            }
         }
-        
-        if (i < javaLength && fillJavaObject != null) {
-            javaArrayJavaObj.fillWithExceptionHandling(i, javaLength, fillJavaObject);
+
+        if ( i < javaLength && fillJavaObject != null ) {
+            javaArray.fillWithExceptionHandling(i, javaLength, fillJavaObject);
         }
-        
-        return javaArray;
+
+        return toJava;
     }
-    
-    @JRubyMethod
-    public static IRubyObject copy_data_simple(
-            ThreadContext context, IRubyObject from, IRubyObject to) {
-        JavaArray javaArray = (JavaArray)to.dataGetStruct();
-        RubyArray rubyArray = (RubyArray)from;
-        
-        copyDataToJavaArray(context, rubyArray, javaArray);
-        
-        return to;
+
+    @JRubyMethod(name = { "copy_data", "copy_data_simple" })
+    public static IRubyObject copy_data(final ThreadContext context,
+        IRubyObject fromRuby, IRubyObject toJava) {
+        JavaArray javaArray = (JavaArray) toJava.dataGetStruct();
+        RubyArray rubyArray = (RubyArray) fromRuby;
+
+        copyDataToJavaArray(rubyArray, javaArray, 0);
+
+        return toJava;
     }
-
-    public static void copyDataToJavaArray(
-            ThreadContext context, RubyArray rubyArray, JavaArray javaArray) {
-        int javaLength = (int)javaArray.length().getLongValue();
-        Class targetType = javaArray.getComponentType();
-
-        int rubyLength = rubyArray.getLength();
-
-        int i = 0;
-        for (; i < rubyLength && i < javaLength; i++) {
-            javaArray.setWithExceptionHandling(i, rubyArray.entry(i).toJava(targetType));
+
+    @Deprecated // not used
+    public static void copyDataToJavaArray(final ThreadContext context,
+        final RubyArray rubyArray, final JavaArray javaArray) {
+        copyDataToJavaArray(rubyArray, javaArray, 0);
+    }
+
+    private static void copyDataToJavaArray(
+        final RubyArray rubyArray, final JavaArray javaArray, int offset) {
+        int length = javaArray.getLength();
+        if ( length > rubyArray.getLength() ) length = rubyArray.getLength();
+
+        final Class<?> targetType = javaArray.getComponentType();
+        for ( int i = offset; i < length; i++ ) {
+            javaArray.setWithExceptionHandling(i, rubyArray.eltInternal(i).toJava(targetType));
         }
     }
-    
+
     @JRubyMethod
-    public static IRubyObject dimensions(ThreadContext context, IRubyObject maybeArray) {
-        Ruby runtime = context.runtime;
-        if (!(maybeArray instanceof RubyArray)) {
-            return runtime.newEmptyArray();
-        }
-        RubyArray rubyArray = (RubyArray)maybeArray;
-        RubyArray dims = runtime.newEmptyArray();
-
-        return dimsRecurse(context, rubyArray, dims, 0);
+    public static IRubyObject dimensions(ThreadContext context, IRubyObject rubyArray) {
+        return dimensions(context, rubyArray, context.runtime.newEmptyArray());
     }
-    
+
     @JRubyMethod
-    public static IRubyObject dimensions(ThreadContext context, IRubyObject maybeArray, IRubyObject dims) {
-        Ruby runtime = context.runtime;
-        if (!(maybeArray instanceof RubyArray)) {
+    public static IRubyObject dimensions(ThreadContext context, IRubyObject rubyArray, IRubyObject dims) {
+        final Ruby runtime = context.runtime;
+        if ( ! ( rubyArray instanceof RubyArray ) ) {
             return runtime.newEmptyArray();
         }
         assert dims instanceof RubyArray;
-
-        RubyArray rubyArray = (RubyArray)maybeArray;
-
-        return dimsRecurse(context, rubyArray, (RubyArray)dims, 0);
+
+        return calcDimensions(runtime, (RubyArray) rubyArray, (RubyArray) dims, 0);
     }
-    
+
     @JRubyMethod
-    public static IRubyObject dimensions(ThreadContext context, IRubyObject maybeArray, IRubyObject dims, IRubyObject index) {
-        Ruby runtime = context.runtime;
-        if (!(maybeArray instanceof RubyArray)) {
+    public static IRubyObject dimensions(ThreadContext context, IRubyObject rubyArray, IRubyObject dims, IRubyObject index) {
+        final Ruby runtime = context.runtime;
+        if ( ! ( rubyArray instanceof RubyArray ) ) {
             return runtime.newEmptyArray();
         }
         assert dims instanceof RubyArray;
         assert index instanceof RubyFixnum;
-
-        RubyArray rubyArray = (RubyArray)maybeArray;
-
-        return dimsRecurse(context, rubyArray, (RubyArray)dims, (int)((RubyFixnum)index).getLongValue());
+
+        final int i = (int) ((RubyFixnum) index).getLongValue();
+        return calcDimensions(runtime, (RubyArray) rubyArray, (RubyArray) dims, i);
     }
-
-    private static RubyArray dimsRecurse(ThreadContext context, RubyArray rubyArray, RubyArray dims, int index) {
-        Ruby runtime = context.runtime;
 
-        while (dims.size() <= index) {
-            dims.append(RubyFixnum.zero(runtime));
+    private static RubyArray calcDimensions(final Ruby runtime,
+        final RubyArray array, final RubyArray dims, final int index) {
+
+        while ( dims.size() <= index ) {
+            dims.append( RubyFixnum.zero(runtime) );
         }
-
-        if (rubyArray.size() > ((RubyFixnum)dims.eltInternal(index)).getLongValue()) {
-            dims.eltInternalSet(index, RubyFixnum.newFixnum(runtime, rubyArray.size()));
+
+        final long dim = ((RubyFixnum) dims.eltInternal(index)).getLongValue();
+        if ( array.size() > dim ) {
+            dims.eltInternalSet(index, RubyFixnum.newFixnum(runtime, array.size()));
         }
-
-        for (int i = 0; i < rubyArray.size(); i++) {
-            if (rubyArray.eltInternal(i) instanceof RubyArray) {
-                dimsRecurse(context, (RubyArray)rubyArray.eltInternal(i), dims, 1);
+
+        for ( int i = 0; i < array.size(); i++ ) {
+            final IRubyObject element = array.eltInternal(i);
+            if ( element instanceof RubyArray ) {
+                calcDimensions(runtime, (RubyArray) element, dims, 1);
             }
         }
-        
+
         return dims;
     }
 }
diff --git a/core/src/main/java/org/jruby/java/addons/KernelJavaAddons.java b/core/src/main/java/org/jruby/java/addons/KernelJavaAddons.java
@@ -46,28 +46,25 @@ public static IRubyObject rbRaise(ThreadContext context, IRubyObject recv, IRuby
     }
 
     @JRubyMethod
-    public static IRubyObject to_java(ThreadContext context, IRubyObject fromObject) {
-        if (fromObject instanceof RubyArray) {
-            return context.runtime.getJavaSupport().getObjectJavaClass().javaArrayFromRubyArray(context, fromObject);
-        } else {
-            return Java.getInstance(context.runtime, fromObject.toJava(Object.class));
+    public static IRubyObject to_java(ThreadContext context, final IRubyObject fromObject) {
+        if ( fromObject instanceof RubyArray ) {
+            final JavaClass targetType = context.runtime.getJavaSupport().getObjectJavaClass();
+            return targetType.javaArrayFromRubyArray(context, (RubyArray) fromObject);
         }
+        return Java.getInstance(context.runtime, fromObject.toJava(Object.class));
     }
 
     @JRubyMethod
-    public static IRubyObject to_java(ThreadContext context, IRubyObject fromObject, IRubyObject type) {
-        if (type.isNil()) {
-            return to_java(context, fromObject);
-        }
+    public static IRubyObject to_java(ThreadContext context, final IRubyObject fromObject, final IRubyObject type) {
+        if ( type.isNil() ) return to_java(context, fromObject);
 
-        Ruby runtime = context.runtime;
-        JavaClass targetType = getTargetType(context, runtime, type);
+        final Ruby runtime = context.runtime;
+        final JavaClass targetType = getTargetType(context, runtime, type);
 
-        if (fromObject instanceof RubyArray) {
-            return targetType.javaArrayFromRubyArray(context, fromObject);
-        } else {
-            return Java.getInstance(runtime, fromObject.toJava(targetType.javaClass()));
+        if ( fromObject instanceof RubyArray ) {
+            return targetType.javaArrayFromRubyArray(context, (RubyArray) fromObject);
         }
+        return Java.getInstance(runtime, fromObject.toJava(targetType.javaClass()));
     }
 
     @JRubyMethod(rest = true)
@@ -118,11 +115,14 @@ private static JavaClass getTargetType(ThreadContext context, Ruby runtime, IRub
         if (type instanceof RubyString || type instanceof RubySymbol) {
             targetType = runtime.getJavaSupport().getNameClassMap().get(type.asJavaString());
             if (targetType == null) targetType = JavaClass.forNameVerbose(runtime, type.asJavaString());
-        } else if (type instanceof RubyModule && type.respondsTo("java_class")) {
+        }
+        else if (type instanceof RubyModule && type.respondsTo("java_class")) {
             targetType = (JavaClass) Helpers.invoke(context, type, "java_class");
-        } else if (type instanceof JavaProxy) {
-            if  (((JavaProxy)type).getObject() instanceof Class) {
-                targetType = JavaClass.get(runtime, (Class)((JavaProxy)type).getObject());
+        }
+        else if (type instanceof JavaProxy) {
+            final Object wrapped = ((JavaProxy) type).getObject();
+            if ( wrapped instanceof Class ) {
+                targetType = JavaClass.get(runtime, (Class) wrapped);
             } else {
                 throw runtime.newTypeError("not a valid target type: " + type);
             }