jruby · May 29, 2015 · May 31, 2015 · May 31, 2015 · Jun 1, 2015 · Jun 1, 2015
Showing 771 changed files with 5,866 additions and 3,965 deletions.
diff --git a/core/src/main/java/emma.properties b/core/src/main/java/emma.properties
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -1944,8 +1944,14 @@ public DynamicMethod getDefaultMethodMissing() {
         return defaultMethodMissing;
     }
 
-    public void setDefaultMethodMissing(DynamicMethod method) {
+    public boolean isDefaultMethodMissing(DynamicMethod method) {
+        return defaultMethodMissing == method || defaultModuleMethodMissing == method;
+
+    }
+
+    public void setDefaultMethodMissing(DynamicMethod method, DynamicMethod moduleMethod) {
         defaultMethodMissing = method;
+        defaultModuleMethodMissing = moduleMethod;
     }
 
     public DynamicMethod getRespondToMethod() {
@@ -4740,7 +4746,7 @@ public RubyString getThreadStatus(RubyThread.Status status) {
      * @return the freeze-duped version of the string
      */
     public RubyString freezeAndDedupString(RubyString string) {
-        if (string.getMetaClass() == stringClass) {
+        if (string.getMetaClass() != stringClass) {
             // never cache a non-natural String
             RubyString duped = string.strDup(this);
             duped.setFrozen(true);
@@ -4901,7 +4907,8 @@ public FilenoUtil getFilenoUtil() {
             procSysModule, precisionModule, errnoModule;
 
     private DynamicMethod privateMethodMissing, protectedMethodMissing, variableMethodMissing,
-            superMethodMissing, normalMethodMissing, defaultMethodMissing, respondTo, respondToMissing;
+            superMethodMissing, normalMethodMissing, defaultMethodMissing, defaultModuleMethodMissing,
+            respondTo, respondToMissing;
 
     // record separator var, to speed up io ops that use it
     private GlobalVariable recordSeparatorVar;

diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -225,7 +225,9 @@ public static RubyClass createBasicObjectClass(Ruby runtime, RubyClass objectCla
     static void recacheBuiltinMethods(Ruby runtime) {
         RubyModule objectClass = runtime.getBasicObject();
 
-        runtime.setDefaultMethodMissing(objectClass.searchMethod("method_missing"));
+        // Since method_missing is marked module we actually define two builtin versions
+        runtime.setDefaultMethodMissing(objectClass.searchMethod("method_missing"),
+                objectClass.getMetaClass().searchMethod("method_missing"));
     }
 
     @JRubyMethod(name = "initialize", visibility = PRIVATE)

diff --git a/core/src/main/java/org/jruby/RubyClass.java b/core/src/main/java/org/jruby/RubyClass.java
@@ -657,21 +657,23 @@ private static IRubyObject checkFuncallFailed(ThreadContext context, IRubyObject
      */
     private static boolean checkFuncallRespondTo(ThreadContext context, RubyClass klass, IRubyObject recv, String mid) {
         Ruby runtime = context.runtime;
-        RubyClass defined_class;
         DynamicMethod me = klass.searchMethod("respond_to?");
 
         // NOTE: isBuiltin here would be NOEX_BASIC in MRI, a flag only added to respond_to?, method_missing, and
         //       respond_to_missing? Same effect, I believe.
         if (me != null && !me.isUndefined() && !me.isBuiltin()) {
-            Arity arity = me.getArity();
+            int arityValue = me.getArity().getValue();
 
-            if (arity.getValue() > 2)
-                throw runtime.newArgumentError("respond_to? must accept 1 or 2 arguments (requires " + arity + ")");
+            if (arityValue > 2) throw runtime.newArgumentError("respond_to? must accept 1 or 2 arguments (requires " + arityValue + ")");
 
-            IRubyObject result = me.call(context, recv, klass, "respond_to?", runtime.newString(mid), runtime.getTrue());
-            if (!result.isTrue()) {
-                return false;
+            IRubyObject result;
+            if (arityValue == 1) {
+                result = me.call(context, recv, klass, "respond_to?", runtime.newSymbol(mid));
+            } else {
+                result = me.call(context, recv, klass, "respond_to?", runtime.newSymbol(mid), runtime.getTrue());
             }
+
+            if (!result.isTrue()) return false;
         }
         return true;
     }

diff --git a/core/src/main/java/org/jruby/RubyComparable.java b/core/src/main/java/org/jruby/RubyComparable.java
@@ -140,15 +140,21 @@ public static IRubyObject op_equal19(ThreadContext context, IRubyObject recv, IR
         return callCmpMethod(context, recv, other, context.runtime.getFalse());
     }
 
-    private static IRubyObject callCmpMethod(ThreadContext context, IRubyObject recv, IRubyObject other, IRubyObject returnValueOnError) {
-        Ruby runtime = context.runtime;
+    private static IRubyObject callCmpMethod(final ThreadContext context, final IRubyObject recv, final IRubyObject other, IRubyObject returnValueOnError) {
+        final Ruby runtime = context.runtime;
 
         if (recv == other) return runtime.getTrue();
 
         IRubyObject savedError = runtime.getGlobalVariables().get("$!");
 
         try {
-            IRubyObject result = invokedynamic(context, recv, OP_CMP, other);
+            IRubyObject result = runtime.execRecursiveOuter(new Ruby.RecursiveFunction() {
+                @Override
+                public IRubyObject call(IRubyObject obj, boolean recur) {
+                    if (recur) return runtime.getNil();
+                    return invokedynamic(context, recv, OP_CMP, other);
+                }
+            }, recv);
 
             // This is only to prevent throwing exceptions by cmperr - it has poor performance
             if (result.isNil()) {

diff --git a/core/src/main/java/org/jruby/RubyDir.java b/core/src/main/java/org/jruby/RubyDir.java
@@ -43,15 +43,17 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.zip.ZipEntry;
-import jnr.posix.FileStat;
 
+import jnr.posix.FileStat;
 import jnr.posix.POSIX;
+
 import org.jruby.anno.JRubyMethod;
 import org.jruby.anno.JRubyClass;
+
 import jnr.posix.util.Platform;
+
 import org.jcodings.Encoding;
 import org.jcodings.specific.UTF8Encoding;
-
 import org.jruby.exceptions.RaiseException;
 import org.jruby.javasupport.JavaUtil;
 import org.jruby.runtime.Block;
@@ -310,16 +312,8 @@ public static IRubyObject chdir(ThreadContext context, IRubyObject recv, IRubyOb
             realPath = adjustedPath;
         }
         else {
-            JRubyFile dir = getDir(runtime, adjustedPath, true);
-
-            // We get canonical path to try and flatten the path out.
-            // a dir '/subdir/..' should return as '/'
-            // cnutter: Do we want to flatten path out?
-            try {
-                realPath = dir.getCanonicalPath();
-            } catch (IOException e) {
-                realPath = dir.getAbsolutePath();
-            }
+            FileResource dir = getDir(runtime, adjustedPath, true);
+            realPath = dir.canonicalPath();
         }
 
         IRubyObject result = null;
@@ -457,8 +451,10 @@ public static IRubyObject mkdir19(ThreadContext context, IRubyObject recv, IRuby
     }
 
     private static IRubyObject mkdirCommon(Ruby runtime, String path, IRubyObject[] args) {
-        File newDir = getDir(runtime, path, false);
-
+        if (path.startsWith("uri:")) {
+            throw runtime.newErrnoEACCESError(path);
+        }
+        File newDir = getDir(runtime, path, false).hackyGetJRubyFile();
 
         String name = path.replace('\\', '/');
 
@@ -666,10 +662,10 @@ public IRubyObject fileno(ThreadContext context) {
      * @param   path path for which to return the <code>File</code> object.
      * @param   mustExist is true the directory must exist.  If false it must not.
      */
-    protected static JRubyFile getDir(final Ruby runtime, final String path, final boolean mustExist) {
+    protected static FileResource getDir(final Ruby runtime, final String path, final boolean mustExist) {
         String dir = dirFromPath(path, runtime);
 
-        JRubyFile result = JRubyFile.create(runtime.getCurrentDirectory(), dir);
+        FileResource result = JRubyFile.createResource(runtime, dir);
 
         if (mustExist && !result.exists()) {
             throw runtime.newErrnoENOENTError(dir);
@@ -722,7 +718,7 @@ private static String dirFromPath(final String path, final Ruby runtime) throws
         String dir = path;
         String[] pathParts = RubyFile.splitURI(path);
         if (pathParts != null) {
-            if (pathParts[0].equals("file:") && pathParts[1].length() > 0 && pathParts[1].indexOf("!/") == -1) {
+            if (pathParts[0].startsWith("file:") && pathParts[1].length() > 0 && pathParts[1].indexOf("!/") == -1) {
                 dir = pathParts[1];
             } else {
                 throw runtime.newErrnoENOTDIRError(dir);

diff --git a/core/src/main/java/org/jruby/RubyHash.java b/core/src/main/java/org/jruby/RubyHash.java
@@ -1014,10 +1014,7 @@ protected void op_asetForString(Ruby runtime, RubyString key, IRubyObject value)
             entry.value = value;
         } else {
             checkIterating();
-            if (!key.isFrozen()) {
-                key = key.strDup(runtime, key.getMetaClass().getRealClass());
-                key.setFrozen(true);
-            }
+            if (!key.isFrozen()) key = runtime.freezeAndDedupString(key);
             internalPut(key, value, false);
         }
     }
@@ -1028,10 +1025,7 @@ protected void op_asetSmallForString(Ruby runtime, RubyString key, IRubyObject v
             entry.value = value;
         } else {
             checkIterating();
-            if (!key.isFrozen()) {
-                key = key.strDup(runtime, key.getMetaClass().getRealClass());
-                key.setFrozen(true);
-            }
+            if (!key.isFrozen()) key = runtime.freezeAndDedupString(key);
             internalPutSmall(key, value, false);
         }
     }

diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
@@ -2944,29 +2944,41 @@ public IRubyObject remove_class_variable19(ThreadContext context, IRubyObject na
         return remove_class_variable(context, name);
     }
 
-    /** rb_mod_class_variables
-     *
-     */
+    @Deprecated
+    public RubyArray class_variables19(ThreadContext context) {
+        return class_variables(context);
+    }
+
+    @JRubyMethod(name = "class_variables")
     public RubyArray class_variables(ThreadContext context) {
-        return class_variables19(context);
+        Ruby runtime = context.runtime;
+        RubyArray ary = runtime.newArray();
+
+        Collection<String> names = classVariablesCommon(true);
+        for (String name : names) {
+            ary.add(runtime.newSymbol(name));
+        }
+        return ary;
     }
 
     @JRubyMethod(name = "class_variables")
-    public RubyArray class_variables19(ThreadContext context) {
+    public RubyArray class_variables(ThreadContext context, IRubyObject inherit) {
         Ruby runtime = context.runtime;
         RubyArray ary = runtime.newArray();
 
-        Collection<String> names = classVariablesCommon();
+        Collection<String> names = classVariablesCommon(inherit.isTrue());
         for (String name : names) {
             ary.add(runtime.newSymbol(name));
         }
         return ary;
     }
 
-    private Collection<String> classVariablesCommon() {
+
+    private Collection<String> classVariablesCommon(boolean inherit) {
         Set<String> names = new HashSet<String>();
         for (RubyModule p = this; p != null; p = p.getSuperClass()) {
             names.addAll(p.getClassVariableNameList());
+            if (!inherit) break;
         }
         return names;
     }