jruby · Jul 6, 2015 · Jul 6, 2015 · Jul 6, 2015 · Jul 7, 2015 · Jul 7, 2015
Showing 448 changed files with 6,921 additions and 6,084 deletions.
diff --git a/.travis.yml b/.travis.yml
@@ -77,7 +77,7 @@ matrix:
   fast_finish: true
   allow_failures:
     - env: COMMAND=test/truffle/run.sh
-    - env: PHASE='-Ptruffle-mri-tests'
+    - env: COMMAND=tool/truffle-findbugs.sh
 
 
 branches:

diff --git a/VERSION b/VERSION
@@ -1 +1 @@
-9.0.0.0-SNAPSHOT
+9.0.0.0
diff --git a/core/pom.xml b/core/pom.xml
@@ -12,7 +12,7 @@ DO NOT MODIFIY - GENERATED CODE
   <parent>
     <groupId>org.jruby</groupId>
     <artifactId>jruby-parent</artifactId>
-    <version>9.0.0.0-SNAPSHOT</version>
+    <version>9.0.0.0</version>
   </parent>
   <artifactId>jruby-core</artifactId>
   <name>JRuby Core</name>

diff --git a/core/src/main/java/org/jruby/Main.java b/core/src/main/java/org/jruby/Main.java
@@ -282,6 +282,8 @@ public void run() {
         }
 
         try {
+            doSetContextClassLoader(runtime);
+
             if (in == null) {
                 // no script to run, return success
                 return new Status();
@@ -450,6 +452,18 @@ private boolean checkStreamSyntax(Ruby runtime, InputStream in, String filename)
         }
     }
 
+    private void doSetContextClassLoader(Ruby runtime) {
+        // set thread context JRuby classloader here, for the main thread
+        try {
+            Thread.currentThread().setContextClassLoader(runtime.getJRubyClassLoader());
+        } catch (SecurityException se) {
+            // can't set TC classloader
+            if (runtime.getInstanceConfig().isVerbose()) {
+                config.getError().println("WARNING: Security restrictions disallowed setting context classloader for main thread.");
+            }
+        }
+    }
+
     private void doProcessArguments(InputStream in) {
         config.processArguments(config.parseShebangOptions(in));
     }

diff --git a/core/src/main/java/org/jruby/RubyArray.java b/core/src/main/java/org/jruby/RubyArray.java
@@ -801,15 +801,11 @@ public IRubyObject fetch(ThreadContext context, IRubyObject arg0, IRubyObject ar
     /** rb_ary_to_ary
      *
      */
-    private static RubyArray aryToAry(IRubyObject obj) {
-        if (obj instanceof RubyArray) return (RubyArray) obj;
+    public static RubyArray aryToAry(IRubyObject obj) {
+        IRubyObject tmp = TypeConverter.checkArrayType(obj);
 
-        if (obj.respondsTo("to_ary")) return obj.convertToArray();
-
-        RubyArray arr = new RubyArray(obj.getRuntime(), false); // possibly should not in object space
-        arr.values = new IRubyObject[]{obj};
-        arr.realLength = 1;
-        return arr;
+        if (!tmp.isNil()) return (RubyArray)tmp;
+        return obj.getRuntime().newArray(obj);
     }
 
     /** rb_ary_splice
@@ -1053,24 +1049,17 @@ public IRubyObject values_at(IRubyObject[] args) {
      *
      */
     public IRubyObject subseq(long beg, long len) {
-        int realLength = this.realLength;
-        if (beg > realLength || beg < 0 || len < 0) return getRuntime().getNil();
-
-        if (beg + len > realLength) {
-            len = realLength - beg;
-
-            if (len < 0) len = 0;
-        }
-
-        if (len == 0) return new RubyArray(getRuntime(), getMetaClass(), IRubyObject.NULL_ARRAY);
-
-        return makeShared(begin + (int) beg, (int) len, getMetaClass());
+        return subseq(getMetaClass(), beg, len, true);
     }
 
     /** rb_ary_subseq
      *
      */
     public IRubyObject subseqLight(long beg, long len) {
+        return subseq(getMetaClass(), beg, len, true);
+    }
+
+    public IRubyObject subseq(RubyClass metaClass, long beg, long len, boolean light) {
         Ruby runtime = getRuntime();
         if (beg > realLength || beg < 0 || len < 0) return runtime.getNil();
 
@@ -1079,8 +1068,8 @@ public IRubyObject subseqLight(long beg, long len) {
             if (len < 0) len = 0;
         }
 
-        if (len == 0) return new RubyArray(runtime, getMetaClass(), IRubyObject.NULL_ARRAY, false);
-        return makeShared(begin + (int) beg, (int) len, new RubyArray(runtime, getMetaClass(), false));
+        if (len == 0) return new RubyArray(runtime, metaClass, IRubyObject.NULL_ARRAY, !light);
+        return makeShared(begin + (int) beg, (int) len, new RubyArray(runtime, metaClass, !light));
     }
 
     /** rb_ary_length
@@ -2290,13 +2279,15 @@ public IRubyObject collect(ThreadContext context, Block block) {
 
         IRubyObject[] arr = new IRubyObject[realLength];
 
-        for (int i = 0; i < realLength; i++) {
+        int i;
+        for (i = 0; i < realLength; i++) {
             // Do not coarsen the "safe" check, since it will misinterpret AIOOBE from the yield
             // See JRUBY-5434
             arr[i] = block.yield(context, safeArrayRef(values, i + begin));
         }
 
-        return new RubyArray(runtime, arr);
+        // use iteration count as new size in case something was deleted along the way
+        return new RubyArray(runtime, arr, 0, i);
     }
 
     @JRubyMethod(name = {"collect"})

diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -595,38 +595,36 @@ public final boolean respondsTo(String name) {
         final DynamicMethod respondTo = getMetaClass().searchMethod("respond_to?");
         final DynamicMethod respondToMissing = getMetaClass().searchMethod("respond_to_missing?");
 
+        // fastest path; builtin respond_to? and respond_to_missing? so we just check isMethodBound
         if ( respondTo.equals(runtime.getRespondToMethod()) &&
              respondToMissing.equals(runtime.getRespondToMissingMethod()) ) {
-            // fastest path; builtin respond_to? which just does isMethodBound
             return getMetaClass().isMethodBound(name, false);
         }
 
         final ThreadContext context = runtime.getCurrentContext();
         final RubySymbol mname = runtime.newSymbol(name);
         final boolean respondToUndefined = respondTo.isUndefined();
-        if ( ! ( respondToUndefined && respondToMissing.isUndefined() ) ) {
-            // medium path, invoke user's respond_to?/respond_to_missing? if defined
-            final DynamicMethod method; final String respondName;
-            if ( respondToUndefined ) {
-                method = respondToMissing; respondName = "respond_to_missing?";
-            } else {
-                method = respondTo; respondName = "respond_to?";
+
+        // respond_to? or respond_to_missing? is not defined, so we must dispatch to trigger method_missing
+        if ( respondToUndefined ) {
+            return callMethod(context, "respond_to?", mname).isTrue();
+        }
+
+        // respond_to? is defined, invoke already-retrieved method object
+        final String respondName = "respond_to?";
+
+        // We have to check and enforce arity
+        final Arity arity = respondTo.getArity();
+        if ( arity.isFixed() ) {
+            if ( arity.required() == 1 ) {
+                return respondTo.call(context, this, metaClass, respondName, mname).isTrue();
             }
-            // We have to check and enforce arity
-            final Arity arity = method.getArity();
-            if ( arity.isFixed() ) {
-                if ( arity.required() == 1 ) {
-                    return method.call(context, this, metaClass, respondName, mname).isTrue();
-                }
-                if ( arity.required() != 2 ) {
-                    throw runtime.newArgumentError(respondName + " must accept 1 or 2 arguments (requires " + arity.getValue() + ")");
-                }
+            if ( arity.required() != 2 ) {
+                throw runtime.newArgumentError(respondName + " must accept 1 or 2 arguments (requires " + arity.getValue() + ")");
             }
-            return method.call(context, this, metaClass, respondName, mname, runtime.getTrue()).isTrue();
         }
 
-        // slowest path, full callMethod to hit method_missing if present, or produce error
-        return callMethod(context, "respond_to?", mname).isTrue();
+        return respondTo.call(context, this, metaClass, respondName, mname, runtime.getTrue()).isTrue();
     }
 
     /**

diff --git a/core/src/main/java/org/jruby/RubyEncoding.java b/core/src/main/java/org/jruby/RubyEncoding.java
@@ -546,6 +546,11 @@ public static IRubyObject getDefaultInternal(ThreadContext context, IRubyObject
         return context.runtime.getEncodingService().getDefaultInternal();
     }
 
+    @Deprecated
+    public static IRubyObject getDefaultInternal(IRubyObject recv) {
+        return getDefaultInternal(recv.getRuntime().getCurrentContext(), recv);
+    }
+
     @JRubyMethod(name = "default_internal=", required = 1, meta = true)
     public static IRubyObject setDefaultInternal(ThreadContext context, IRubyObject recv, IRubyObject encoding) {
         if (context.runtime.isVerbose()) context.runtime.getWarnings().warning("setting Encoding.default_internal");

diff --git a/core/src/main/java/org/jruby/RubyIO.java b/core/src/main/java/org/jruby/RubyIO.java
@@ -4756,12 +4756,8 @@ public static IRubyObject writeStatic(ThreadContext context, IRubyObject recv, I
     }
 
     @Deprecated
+    @JRubyMethod(name = "popen3", rest = true, meta = true)
     public static IRubyObject popen3(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
-        return popen3_19(context, recv, args, block);
-    }
-
-    @Deprecated
-    public static IRubyObject popen3_19(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
         final Ruby runtime = context.runtime;
 
         // TODO: handle opts

diff --git a/core/src/main/java/org/jruby/RubyKernel.java b/core/src/main/java/org/jruby/RubyKernel.java
@@ -396,7 +396,7 @@ public static RubyFloat new_float19(IRubyObject recv, IRubyObject object) {
             if (arg.toString().startsWith("0x")) {
                 return ConvertBytes.byteListToInum19(runtime, arg.getByteList(), 16, true).toFloat();
             }
-            return RubyNumeric.str2fnum19(runtime, arg,true);
+            return RubyNumeric.str2fnum(runtime, arg, true);
         } else if(object.isNil()){
             throw runtime.newTypeError("can't convert nil into Float");
         } else {
@@ -600,12 +600,12 @@ public static IRubyObject readlines(ThreadContext context, IRubyObject recv, IRu
         return RubyArgsFile.readlines(context, context.runtime.getArgsFile(), args);
     }
 
-    @JRubyMethod(name = "respond_to_missing?", module = true)
+    @JRubyMethod(name = "respond_to_missing?", visibility = PRIVATE)
     public static IRubyObject respond_to_missing_p(ThreadContext context, IRubyObject recv, IRubyObject symbol) {
         return context.runtime.getFalse();
     }
 
-    @JRubyMethod(name = "respond_to_missing?", module = true)
+    @JRubyMethod(name = "respond_to_missing?", visibility = PRIVATE)
     public static IRubyObject respond_to_missing_p(ThreadContext context, IRubyObject recv, IRubyObject symbol, IRubyObject isPrivate) {
         return context.runtime.getFalse();
     }

diff --git a/core/src/main/java/org/jruby/RubyNumeric.java b/core/src/main/java/org/jruby/RubyNumeric.java
@@ -284,11 +284,11 @@ public static int fix2int(RubyFixnum arg) {
     }
 
     public static RubyInteger str2inum(Ruby runtime, RubyString str, int base) {
-        return str2inum(runtime,str,base,false);
+        return str2inum(runtime, str, base, false);
     }
 
     public static RubyNumeric int2fix(Ruby runtime, long val) {
-        return RubyFixnum.newFixnum(runtime,val);
+        return RubyFixnum.newFixnum(runtime, val);
     }
 
     /** rb_num2fix
@@ -341,12 +341,24 @@ public static RubyInteger str2inum(Ruby runtime, RubyString str, int base, boole
     }
 
     /**
-     * Converts a string representation of a floating-point number to the 
-     * numeric value.  Parsing starts at the beginning of the string (after 
-     * leading and trailing whitespace have been removed), and stops at the 
-     * end or at the first character that can't be part of a number.  If 
+     * Same as RubyNumeric.str2fnum passing false for strict.
+     *
+     * @param runtime  the ruby runtime
+     * @param arg   the string to be converted
+     * @return  a RubyFloat representing the result of the conversion, which
+     *          will be 0.0 if the conversion failed.
+     */
+    public static RubyFloat str2fnum(Ruby runtime, RubyString arg) {
+        return str2fnum(runtime, arg, false);
+    }
+
+    /**
+     * Converts a string representation of a floating-point number to the
+     * numeric value.  Parsing starts at the beginning of the string (after
+     * leading and trailing whitespace have been removed), and stops at the
+     * end or at the first character that can't be part of a number.  If
      * the string fails to parse as a number, 0.0 is returned.
-     * 
+     *
      * @param runtime  the ruby runtime
      * @param arg   the string to be converted
      * @param strict if true, enforce the strict criteria for String encoding of
@@ -358,7 +370,7 @@ public static RubyInteger str2inum(Ruby runtime, RubyString str, int base, boole
      * @return  a RubyFloat representing the result of the conversion, which
      *          will be 0.0 if the conversion failed.
      */
-    public static RubyFloat str2fnum19(Ruby runtime, RubyString arg, boolean strict) {
+    public static RubyFloat str2fnum(Ruby runtime, RubyString arg, boolean strict) {
         return str2fnumCommon(runtime, arg, strict, biteListCaller19);
     }
 
@@ -1224,4 +1236,9 @@ public Throwable fillInStackTrace() {
             return this;
         }
     }
+
+    @Deprecated
+    public static RubyFloat str2fnum19(Ruby runtime, RubyString arg, boolean strict) {
+        return str2fnumCommon(runtime, arg, strict, biteListCaller19);
+    }
 }