jruby · Nov 16, 2015 · Nov 16, 2015 · Nov 16, 2015 · Nov 16, 2015 · Nov 16, 2015
diff --git a/COPYING b/COPYING
@@ -78,6 +78,10 @@ below. Also see LICENSE.RUBY for most files found in lib/ruby/stdlib.
  Some parts of the RubySL implementations of the stdlib in lib/ruby/truffle/rubysl
  are copyright (c) 2013 Brian Shirai and are licensed under the 3-clause BSD license.
 
+ pr-zlib is copyright Park Heesob and Daniel Berger. "This library is covered
+ under the same license as zlib itself. For the text of the zlib license,
+ please see http://zlib.net/zlib_license.html."
+
 The complete text of the Eclipse Public License is as follows:
 
   Eclipse Public License - v 1.0

diff --git a/core/pom.xml b/core/pom.xml
@@ -17,7 +17,7 @@ DO NOT MODIFIY - GENERATED CODE
   <artifactId>jruby-core</artifactId>
   <name>JRuby Core</name>
   <properties>
-    <version.ruby>2.2.2</version.ruby>
+    <version.ruby>2.2.3</version.ruby>
     <prawn.dir>${test.dir}/prawn</prawn.dir>
     <spec.tags.dir>${spec.dir}/tags</spec.tags.dir>
     <polyglot.dump.pom>pom.xml</polyglot.dump.pom>
@@ -28,7 +28,7 @@ DO NOT MODIFIY - GENERATED CODE
     <jruby.test.memory.permgen>2G</jruby.test.memory.permgen>
     <installer.gems>${jruby.win32ole.gem}</installer.gems>
     <prawn.git.repo>git://github.com/sandal/prawn.git</prawn.git.repo>
-    <version.ruby.minor>2</version.ruby.minor>
+    <version.ruby.minor>3</version.ruby.minor>
     <tzdata.version>2013d</tzdata.version>
     <install4j.executable>/Applications/install4j 4/bin/install4jc</install4j.executable>
     <jay.bin>jay</jay.bin>
@@ -48,7 +48,7 @@ DO NOT MODIFIY - GENERATED CODE
     <parser.dir>core/src/main/java/org/jruby/parser</parser.dir>
     <jruby.basedir>${basedir}/..</jruby.basedir>
     <rubyspec.dir>${spec.dir}/ruby</rubyspec.dir>
-    <version.ruby.revision>50293</version.ruby.revision>
+    <version.ruby.revision>51636</version.ruby.revision>
     <jruby.test.memory>3G</jruby.test.memory>
     <mspec.dir>${spec.dir}/mspec</mspec.dir>
     <build.date>${maven.build.timestamp}</build.date>

diff --git a/core/src/main/java/org/jruby/Main.java b/core/src/main/java/org/jruby/Main.java
@@ -38,6 +38,7 @@
 package org.jruby;
 
 import org.jruby.exceptions.MainExitException;
+import org.jruby.exceptions.JumpException;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.exceptions.ThreadKill;
 import org.jruby.main.DripMain;
@@ -205,9 +206,14 @@ public static void main(String[] args) {
             if (status.isExit()) {
                 System.exit(status.getStatus());
             }
-        } catch (RaiseException rj) {
-            System.exit(handleRaiseException(rj));
-        } catch (Throwable t) {
+        }
+        catch (RaiseException ex) {
+            System.exit( handleRaiseException(ex) );
+        }
+        catch (JumpException ex) {
+            System.exit( handleUnexpectedJump(ex) );
+        }
+        catch (Throwable t) {
             // If a Truffle exception gets this far it's a hard failure - don't try and dress it up as a Ruby exception
 
             if (main.config.getCompileMode() == RubyInstanceConfig.CompileMode.TRUFFLE) {
@@ -516,25 +522,54 @@ private void doCheckSecurityManager() {
      * run should be System.err. In order to avoid the Ruby err being closed and unable
      * to write, we use System.err unconditionally.
      *
-     * @param rj
+     * @param ex
      * @return
      */
-    protected static int handleRaiseException(RaiseException rj) {
-        RubyException raisedException = rj.getException();
-        Ruby runtime = raisedException.getRuntime();
-        if (runtime.getSystemExit().isInstance(raisedException)) {
+    protected static int handleRaiseException(final RaiseException ex) {
+        RubyException raisedException = ex.getException();
+        final Ruby runtime = raisedException.getRuntime();
+        if ( runtime.getSystemExit().isInstance(raisedException) ) {
             IRubyObject status = raisedException.callMethod(runtime.getCurrentContext(), "status");
-            if (status != null && !status.isNil()) {
+            if (status != null && ! status.isNil()) {
                 return RubyNumeric.fix2int(status);
-            } else {
-                return 0;
             }
-        } else {
-            System.err.print(runtime.getInstanceConfig().getTraceType().printBacktrace(raisedException, runtime.getPosix().isatty(FileDescriptor.err)));
-            return 1;
+            return 0;
         }
+        System.err.print(runtime.getInstanceConfig().getTraceType().printBacktrace(raisedException, runtime.getPosix().isatty(FileDescriptor.err)));
+        return 1;
     }
 
+    private static int handleUnexpectedJump(final JumpException ex) {
+        if ( ex instanceof JumpException.SpecialJump ) { // ex == JumpException.SPECIAL_JUMP
+            System.err.println("Unexpected break: " + ex);
+        }
+        else if ( ex instanceof JumpException.FlowControlException ) {
+            // NOTE: assuming a single global runtime main(args) should have :
+            if ( Ruby.isGlobalRuntimeReady() ) {
+                final Ruby runtime = Ruby.getGlobalRuntime();
+                RaiseException raise = ((JumpException.FlowControlException) ex).buildException(runtime);
+                if ( raise != null ) handleRaiseException(raise);
+            }
+            else {
+                System.err.println("Unexpected jump: " + ex);
+            }
+        }
+        else {
+            System.err.println("Unexpected: " + ex);
+        }
+
+        final StackTraceElement[] trace = ex.getStackTrace();
+        if ( trace != null && trace.length > 0 ) {
+            System.err.println( ThreadContext.createRawBacktraceStringFromThrowable(ex, false) );
+        }
+        else {
+            System.err.println("HINT: to get backtrace for jump exceptions run with -Xjump.backtrace=true");
+        }
+
+        // TODO: should match MRI (>= 2.2.3) exit status - @see ruby/test_enum.rb#test_first
+        return 2;
+    }
+
     public static void printTruffleTimeMetric(String id) {
         if (Options.TRUFFLE_METRICS_TIME.load()) {
             final long millis = System.currentTimeMillis();

diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -1612,7 +1612,9 @@ private void initExceptions() {
         typeError = defineClassIfAllowed("TypeError", standardError);
         argumentError = defineClassIfAllowed("ArgumentError", standardError);
         indexError = defineClassIfAllowed("IndexError", standardError);
-        stopIteration = defineClassIfAllowed("StopIteration", indexError);
+        if (profile.allowClass("StopIteration")) {
+            stopIteration = RubyStopIteration.createStopIterationClass(this, indexError);
+        }
         syntaxError = defineClassIfAllowed("SyntaxError", scriptError);
         loadError = defineClassIfAllowed("LoadError", scriptError);
         notImplementedError = defineClassIfAllowed("NotImplementedError", scriptError);
@@ -4073,7 +4075,7 @@ private RaiseException newLightweightErrnoException(RubyClass exceptionClass, St
         if (RubyInstanceConfig.ERRNO_BACKTRACE) {
             return new RaiseException(this, exceptionClass, message, true);
         } else {
-            return new RaiseException(this, exceptionClass, ERRNO_BACKTRACE_MESSAGE, RubyArray.newEmptyArray(this), true);
+            return new RaiseException(this, exceptionClass, ERRNO_BACKTRACE_MESSAGE, disabledBacktrace(), true);
         }
     }
 
@@ -4088,12 +4090,24 @@ private RaiseException newLightweightErrnoException(RubyClass exceptionClass, St
      *
      * @param message the message for the exception
      */
-    public RaiseException newLightweightStopIterationError(String message) {
+    public RaiseException newStopIteration(IRubyObject result, String message) {
+        final ThreadContext context = getCurrentContext();
         if (RubyInstanceConfig.STOPITERATION_BACKTRACE) {
-            return new RaiseException(this, stopIteration, message, true);
-        } else {
-            return new RaiseException(this, stopIteration, STOPIERATION_BACKTRACE_MESSAGE, RubyArray.newEmptyArray(this), true);
+            RubyException ex = RubyStopIteration.newInstance(context, result, message);
+            return new RaiseException(ex);
         }
+        if ( message == null ) message = STOPIERATION_BACKTRACE_MESSAGE;
+        RubyException ex = RubyStopIteration.newInstance(context, result, message);
+        return new RaiseException(ex, disabledBacktrace());
+    }
+
+    @Deprecated
+    public RaiseException newLightweightStopIterationError(String message) {
+        return newStopIteration(null, message);
+    }
+
+    private IRubyObject disabledBacktrace() {
+        return RubyArray.newEmptyArray(this);
     }
 
     // Equivalent of Data_Wrap_Struct

diff --git a/core/src/main/java/org/jruby/RubyArray.java b/core/src/main/java/org/jruby/RubyArray.java
@@ -2321,7 +2321,7 @@ public RubyArray collectBang(ThreadContext context, Block block) {
     */
     @JRubyMethod(name = "collect!")
     public IRubyObject collect_bang(ThreadContext context, Block block) {
-        return block.isGiven() ? collectBang(context, block) : enumeratorize(context.runtime, this, "collect!");
+        return block.isGiven() ? collectBang(context, block) : enumeratorizeWithSize(context, this, "collect!", enumLengthFn());
     }
 
     /** rb_ary_collect_bang

diff --git a/core/src/main/java/org/jruby/RubyClass.java b/core/src/main/java/org/jruby/RubyClass.java
@@ -1138,6 +1138,9 @@ public static void checkInheritable(IRubyObject superClass) {
         if (((RubyClass)superClass).isSingleton()) {
             throw superClass.getRuntime().newTypeError("can't make subclass of virtual class");
         }
+        if (superClass == superClass.getRuntime().getClassClass()) {
+            throw superClass.getRuntime().newTypeError("can't make subclass of Class");
+        }
     }
 
     public final ObjectMarshal getMarshal() {

diff --git a/core/src/main/java/org/jruby/RubyEnumerable.java b/core/src/main/java/org/jruby/RubyEnumerable.java
@@ -1201,6 +1201,7 @@ public static IRubyObject max_by(ThreadContext context, IRubyObject self, final
 
     @JRubyMethod
     public static IRubyObject max_by(ThreadContext context, IRubyObject self, IRubyObject arg, final Block block) {
+        if (arg == context.nil) return singleExtentBy(context, self, "max", SORT_MAX, block);
         // TODO: Replace with an implementation (quickselect, etc) which requires O(k) memory rather than O(n) memory
         RubyArray sorted = (RubyArray)sort_by(context, self, block);
         return ((RubyArray) sorted.last(arg)).reverse();
@@ -1213,6 +1214,7 @@ public static IRubyObject min_by(ThreadContext context, IRubyObject self, final
 
     @JRubyMethod
     public static IRubyObject min_by(ThreadContext context, IRubyObject self, IRubyObject arg, final Block block) {
+        if (arg == context.nil) return singleExtentBy(context, self, "min", SORT_MIN, block);
         // TODO: Replace with an implementation (quickselect, etc) which requires O(k) memory rather than O(n) memory
         RubyArray sorted = (RubyArray)sort_by(context, self, block);
         return sorted.first(arg);