jruby · Aug 9, 2015 · Aug 10, 2015 · Aug 10, 2015 · Aug 10, 2015 · Aug 10, 2015
diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
@@ -1703,14 +1703,21 @@ public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule claz
             return site.call(context, self, self, args, block);
         }
 
+        @Override
         public boolean equals(Object other) {
-            if (!(other instanceof RespondToMissingMethod)) return false;
+            if ( ! (other instanceof RespondToMissingMethod) ) return false;
 
-            RespondToMissingMethod rtmm = (RespondToMissingMethod)other;
+            RespondToMissingMethod that = (RespondToMissingMethod) other;
 
-            return this.site.methodName.equals(rtmm.site.methodName) &&
-                    isImplementedBy(rtmm.getImplementationClass());
+            return this.site.methodName.equals(that.site.methodName) &&
+                    isImplementedBy(that.getImplementationClass());
         }
+
+        @Override
+        public int hashCode() {
+            return /* getImplementationClass().hashCode() + */ 7 * this.site.methodName.hashCode();
+        }
+
     }
 
     public IRubyObject newMethod(IRubyObject receiver, final String methodName, boolean bound, Visibility visibility, boolean respondToMissing, boolean priv) {

diff --git a/core/src/main/java/org/jruby/ext/digest/BubbleBabble.java b/core/src/main/java/org/jruby/ext/digest/BubbleBabble.java
@@ -65,6 +65,13 @@ public static ByteList bubblebabble(byte[] message, int begin, int length) {
                             ((((int) (message[begin + 2 * i])) * 7) +
                                     ((int) (message[begin + (2 * i) + 1])))) % 36;
                 }
+            } else {
+                idx0 = seed % 6;
+                idx1 = 16;
+                idx2 = seed / 6;
+                retval.append(vowels[idx0]);
+                retval.append(consonants[idx1]);
+                retval.append(vowels[idx2]);
             }
         }
         retval.append('x');

diff --git a/core/src/main/java/org/jruby/ext/digest/RubyDigest.java b/core/src/main/java/org/jruby/ext/digest/RubyDigest.java
@@ -16,7 +16,7 @@
  * Copyright (C) 2007 Nick Sieger <nicksieger@gmail.com>
  * Copyright (C) 2008 Vladimir Sizikov <vsizikov@gmail.com>
  * Copyright (C) 2009 Joseph LaFata <joe@quibb.org>
- * 
+ *
  * Alternatively, the contents of this file may be used under the terms of
  * either of the GNU General Public License Version 2 or later (the "GPL"),
  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
@@ -50,48 +50,47 @@
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.anno.JRubyModule;
+import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.Visibility;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
+import org.jruby.util.log.Logger;
+import org.jruby.util.log.LoggerFactory;
 
 /**
  * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a>
  */
 @JRubyModule(name="Digest")
 public class RubyDigest {
-    private static Provider provider = null;
-    private static final Map<String, MessageDigest> CLONEABLE_DIGESTS = new HashMap<String, MessageDigest>();
+
+    private static final Map<String, MessageDigest> CLONEABLE_DIGESTS = new HashMap<String, MessageDigest>(8, 1);
     static {
         // standard digests from JCA specification; if we can retrieve and clone, save them
-        for (String name : new String[] {"MD2", "MD5", "SHA-1", "SHA-256", "SHA-384", "SHA-512"})
-        try {
-            MessageDigest digest = MessageDigest.getInstance(name);
-            digest.clone();
-            CLONEABLE_DIGESTS.put(name, digest);
-        } catch (Exception e) {
-            e.printStackTrace();
-            // ignore; go to next iteration
+        for (String name : new String[] {"MD2", "MD5", "SHA-1", "SHA-256", "SHA-384", "SHA-512"}) {
+            try {
+                MessageDigest digest = MessageDigest.getInstance(name);
+                digest.clone();
+                CLONEABLE_DIGESTS.put(name, digest);
+            }
+            catch (Exception e) {
+                logger().debug(name + " not clonable", e);
+            }
         }
     }
 
+    private static Logger logger() { return LoggerFactory.getLogger("RubyDigest"); }
+
+    private static final String PROVIDER = "org.bouncycastle.jce.provider.BouncyCastleProvider";
+    private static Provider provider = null;
+
     public static void createDigest(Ruby runtime) {
-        // We're not setting the provider or anything, but it seems that BouncyCastle does some internal things in its
-        // provider's constructor which require it to be executed in a secure context.
-        // Ideally this hack should be removed. See JRUBY-3919 and this BC bug:
-        //   http://www.bouncycastle.org/jira/browse/BJA-227
-        provider = (Provider) AccessController.doPrivileged(new PrivilegedAction() {
-            public Object run() {
-                try {
-                    return Class.forName("org.bouncycastle.jce.provider.BouncyCastleProvider").newInstance();
-                } catch(Throwable t) {
-                    // provider is not available
-                    return null;
-                }
-            }
-        });
+        try {
+            provider = (Provider) Class.forName(PROVIDER).newInstance();
+        }
+        catch (Throwable t) { /* provider is not available */ }
 
         RubyModule mDigest = runtime.defineModule("Digest");
         mDigest.defineAnnotatedMethods(RubyDigest.class);
@@ -104,27 +103,29 @@ public Object run() {
         cDigestBase.defineAnnotatedMethods(DigestBase.class);
     }
 
-    private static MessageDigest createMessageDigest(Ruby runtime, String providerName) throws NoSuchAlgorithmException {
-        MessageDigest cloneable = CLONEABLE_DIGESTS.get(providerName);
+    private static MessageDigest createMessageDigest(final String name) throws NoSuchAlgorithmException {
+        MessageDigest cloneable = CLONEABLE_DIGESTS.get(name);
         if (cloneable != null) {
             try {
-                return (MessageDigest)cloneable.clone();
-            } catch (CloneNotSupportedException cnse) {
+                return (MessageDigest) cloneable.clone();
+            }
+            catch (CloneNotSupportedException e) {
                 // should never happen, since we tested it in static init
             }
         }
 
         // fall back on JCA mechanisms for getting a digest
-        if(provider != null) {
+        if (provider != null) {
             try {
-                return MessageDigest.getInstance(providerName, provider);
-            } catch(NoSuchAlgorithmException e) {
+                return MessageDigest.getInstance(name, provider);
+            }
+            catch (NoSuchAlgorithmException e) {
                 // bouncy castle doesn't support algorithm
             }
         }
 
         // fall back to default JCA providers
-        return MessageDigest.getInstance(providerName);
+        return MessageDigest.getInstance(name);
     }
 
     private final static byte[] digits = {
@@ -146,17 +147,17 @@ private static ByteList toHex(byte[] val) {
         return byteList;
     }
 
-    private static IRubyObject toHexString(Ruby runtime, byte[] val) {
+    private static RubyString toHexString(Ruby runtime, byte[] val) {
         return RubyString.newStringNoCopy(runtime, new ByteList(ByteList.plain(toHex(val)), USASCIIEncoding.INSTANCE));
     }
 
     @JRubyMethod(name = "hexencode", required = 1, meta = true)
-    public static IRubyObject s_hexencode(IRubyObject recv, IRubyObject arg) {
-        return toHexString(recv.getRuntime(), arg.convertToString().getBytes());
+    public static RubyString hexencode(IRubyObject self, IRubyObject arg) {
+        return toHexString(self.getRuntime(), arg.convertToString().getBytes());
     }
 
     @JRubyMethod(name = "bubblebabble", required = 1, meta = true)
-    public static IRubyObject bubblebabble(IRubyObject recv, IRubyObject arg) {
+    public static RubyString bubblebabble(IRubyObject recv, IRubyObject arg) {
         final ByteList bytes = arg.convertToString().getByteList();
         return RubyString.newString(recv.getRuntime(), BubbleBabble.bubblebabble(bytes.unsafeBytes(), bytes.begin(), bytes.length()));
     }
@@ -196,47 +197,49 @@ public static class SHA512 {}
 
     public static void createDigestMD5(Ruby runtime) {
         runtime.getLoadService().require("digest");
-        RubyModule mDigest = runtime.getModule("Digest");
-        RubyClass cDigestBase = mDigest.getClass("Base");
-        RubyClass cDigest_MD5 = mDigest.defineClassUnder("MD5",cDigestBase,cDigestBase.getAllocator());
-        cDigest_MD5.setInternalVariable("metadata", new Metadata("MD5", 64));
+        RubyModule Digest = runtime.getModule("Digest");
+        RubyClass Base = Digest.getClass("Base");
+        RubyClass MD5 = Digest.defineClassUnder("MD5", Base, Base.getAllocator());
+        MD5.setInternalVariable("metadata", new Metadata("MD5", 64));
     }
 
     public static void createDigestRMD160(Ruby runtime) {
         runtime.getLoadService().require("digest");
         if(provider == null) {
             throw runtime.newLoadError("RMD160 not supported without BouncyCastle");
         }
-        RubyModule mDigest = runtime.getModule("Digest");
-        RubyClass cDigestBase = mDigest.getClass("Base");
-        RubyClass cDigest_RMD160 = mDigest.defineClassUnder("RMD160",cDigestBase,cDigestBase.getAllocator());
-        cDigest_RMD160.setInternalVariable("metadata", new Metadata("RIPEMD160", 64));
+        RubyModule Digest = runtime.getModule("Digest");
+        RubyClass Base = Digest.getClass("Base");
+        RubyClass RMD160 = Digest.defineClassUnder("RMD160", Base, Base.getAllocator());
+        RMD160.setInternalVariable("metadata", new Metadata("RIPEMD160", 64));
     }
 
     public static void createDigestSHA1(Ruby runtime) {
         runtime.getLoadService().require("digest");
-        RubyModule mDigest = runtime.getModule("Digest");
-        RubyClass cDigestBase = mDigest.getClass("Base");
-        RubyClass cDigest_SHA1 = mDigest.defineClassUnder("SHA1",cDigestBase,cDigestBase.getAllocator());
-        cDigest_SHA1.setInternalVariable("metadata", new Metadata("SHA1", 64));
+        RubyModule Digest = runtime.getModule("Digest");
+        RubyClass Base = Digest.getClass("Base");
+        RubyClass SHA1 = Digest.defineClassUnder("SHA1", Base, Base.getAllocator());
+        SHA1.setInternalVariable("metadata", new Metadata("SHA1", 64));
     }
 
     public static void createDigestSHA2(Ruby runtime) {
         runtime.getLoadService().require("digest");
         try {
-            createMessageDigest(runtime, "SHA-256");
-        } catch(NoSuchAlgorithmException e) {
-            throw runtime.newLoadError("SHA2 not supported");
-        }
-        RubyModule mDigest = runtime.getModule("Digest");
-        RubyClass cDigestBase = mDigest.getClass("Base");
-        RubyClass cDigest_SHA2_256 = mDigest.defineClassUnder("SHA256",cDigestBase,cDigestBase.getAllocator());
-        Metadata sha256Metadata = new Metadata("SHA-256", 64);
-        cDigest_SHA2_256.setInternalVariable("metadata", sha256Metadata);
-        RubyClass cDigest_SHA2_384 = mDigest.defineClassUnder("SHA384",cDigestBase,cDigestBase.getAllocator());
-        cDigest_SHA2_384.setInternalVariable("metadata", new Metadata("SHA-384", 128));
-        RubyClass cDigest_SHA2_512 = mDigest.defineClassUnder("SHA512",cDigestBase,cDigestBase.getAllocator());
-        cDigest_SHA2_512.setInternalVariable("metadata", new Metadata("SHA-512", 128));
+            createMessageDigest("SHA-256");
+        }
+        catch (NoSuchAlgorithmException e) {
+            RaiseException ex = runtime.newLoadError("SHA2 not supported");
+            ex.initCause(e);
+            throw ex;
+        }
+        final RubyModule Digest = runtime.getModule("Digest");
+        final RubyClass Base = Digest.getClass("Base");
+        RubyClass SHA256 = Digest.defineClassUnder("SHA256", Base, Base.getAllocator());
+        SHA256.setInternalVariable("metadata", new Metadata("SHA-256", 64));
+        RubyClass SHA384 = Digest.defineClassUnder("SHA384", Base, Base.getAllocator());
+        SHA384.setInternalVariable("metadata", new Metadata("SHA-384", 128));
+        RubyClass SHA512 = Digest.defineClassUnder("SHA512", Base, Base.getAllocator());
+        SHA512.setInternalVariable("metadata", new Metadata("SHA-512", 128));
     }
 
     @JRubyModule(name = "Digest::Instance")
@@ -303,7 +306,7 @@ public static IRubyObject newObject(ThreadContext context, IRubyObject self) {
 
         @JRubyMethod(optional = 1)
         public static IRubyObject digest(ThreadContext context, IRubyObject self, IRubyObject[] args) {
-            IRubyObject value = null;
+            final IRubyObject value;
             if (args != null && args.length > 0) {
                 self.callMethod(context, "reset");
                 self.callMethod(context, "update", args[0]);
@@ -363,7 +366,7 @@ public IRubyObject allocate(Ruby runtime, RubyClass klass) {
         public DigestClass(Ruby runtime, RubyClass type) {
             super(runtime, type);
         }
-        
+
         @JRubyMethod(name = "digest", required = 1, rest = true, meta = true)
         public static IRubyObject s_digest(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block unusedBlock) {
             Ruby runtime = recv.getRuntime();
@@ -408,7 +411,7 @@ public DigestBase(Ruby runtime, RubyClass type) {
             if(metadata == null) {
                 throw runtime.newNotImplementedError("the " + type + "() function is unimplemented on this machine");
             }
-            
+
             try {
                 setAlgorithm(metadata);
             } catch(NoSuchAlgorithmException e) {
@@ -431,15 +434,16 @@ private Metadata getMetadata(RubyModule type) {
         @JRubyMethod(required = 1, visibility = Visibility.PRIVATE)
         @Override
         public IRubyObject initialize_copy(IRubyObject obj) {
-            if(this == obj) {
-                return this;
-            }
-            ((RubyObject)obj).checkFrozen();
+            if (this == obj) return this;
+
+            DigestBase from = (DigestBase) obj;
+            from.checkFrozen();
 
-            String name = ((DigestBase)obj).algo.getAlgorithm();
             try {
-                algo = (MessageDigest)((DigestBase)obj).algo.clone();
-            } catch(CloneNotSupportedException e) {
+                this.algo = (MessageDigest) from.algo.clone();
+            }
+            catch (CloneNotSupportedException e) {
+                String name = from.algo.getAlgorithm();
                 throw getRuntime().newTypeError("Could not initialize copy of digest (" + name + ")");
             }
             return this;
@@ -458,7 +462,7 @@ public IRubyObject finish() {
             algo.reset();
             return digest;
         }
-        
+
         @JRubyMethod()
         public IRubyObject digest_length() {
             return RubyFixnum.newFixnum(getRuntime(), algo.getDigestLength());
@@ -486,8 +490,9 @@ public IRubyObject bubblebabble(ThreadContext context) {
         }
 
         private void setAlgorithm(Metadata metadata) throws NoSuchAlgorithmException {
-           this.algo = createMessageDigest(getRuntime(), metadata.getName());
+           this.algo = createMessageDigest(metadata.getName());
            this.blockLength = metadata.getBlockLength();
         }
+
     }
 }// RubyDigest
diff --git a/core/src/main/java/org/jruby/ir/targets/Bootstrap.java b/core/src/main/java/org/jruby/ir/targets/Bootstrap.java
@@ -422,7 +422,7 @@ static MethodHandle buildNativeHandle(InvokeSite site, DynamicMethod method, boo
         MethodHandle mh = null;
         SmartBinder binder = null;
 
-        if (method instanceof NativeCallMethod) {
+        if (method instanceof NativeCallMethod && ((NativeCallMethod) method).getNativeCall() != null) {
             NativeCallMethod nativeMethod = (NativeCallMethod)method;
             DynamicMethod.NativeCall nativeCall = nativeMethod.getNativeCall();
 

diff --git a/core/src/main/java/org/jruby/java/dispatch/CallableSelector.java b/core/src/main/java/org/jruby/java/dispatch/CallableSelector.java
@@ -185,6 +185,7 @@ private static <T extends ParameterTypes> T findMatchingCallableForArgs(final Ru
                     final T candidate = candidates.get(c);
                     final Class<?>[] cTypes = candidate.getParameterTypes();
 
+                    // TODO still need to handle var-args better Class<?> lastType;
                     for ( int i = 0; i < msTypes.length; i++ ) {
                         final Class<?> msType = msTypes[i], cType = cTypes[i];
                         if ( msType != cType && msType.isAssignableFrom(cType) ) {
@@ -375,7 +376,19 @@ private static <T extends ParameterTypes> List<T> findCallableCandidates(final T
             incoming = retained.toArray( new ParameterTypes[retained.size()] );
         }
 
-        return retained;
+        // final step rule out argument length mismatch :
+        int j = 0; for ( int i = 0; i < retained.size(); i++ ) {
+            T callable = retained.get(i);
+            if ( callable.isVarArgs() ) {
+                if ( callable.getArity() > args.length - 1 ) continue;
+            }
+            else {
+                if ( callable.getArity() != args.length ) continue;
+            }
+            retained.set(j++, callable);
+        }
+
+        return j < retained.size() ? retained.subList(0, j) : retained;
     }
 
     private static int calcExactnessScore(final ParameterTypes callable, final IRubyObject[] args) {

diff --git a/core/src/main/java/org/jruby/java/proxies/JavaInterfaceTemplate.java b/core/src/main/java/org/jruby/java/proxies/JavaInterfaceTemplate.java
@@ -37,7 +37,7 @@ public static RubyModule createJavaInterfaceTemplateModule(ThreadContext context
         singleton.addReadAttribute(context, "java_class");
         singleton.defineAnnotatedMethods(JavaInterfaceTemplate.class);
 
-        JavaInterfaceTemplate.defineAnnotatedMethods(Java.JavaProxyClassMethods.class);
+        JavaInterfaceTemplate.defineAnnotatedMethods(JavaProxy.ClassMethods.class);
 
         return JavaInterfaceTemplate;
     }