jruby · Apr 6, 2015 · Apr 6, 2015 · Apr 7, 2015 · Apr 8, 2015 · Apr 8, 2015
diff --git a/README.md b/README.md
@@ -1,62 +1,81 @@
-# JRuby -  A Java implementation of the Ruby language
+# JRuby - an implementation of the Ruby language on the JVM
 
 Master: [![Build Status](https://travis-ci.org/jruby/jruby.png?branch=master)](https://travis-ci.org/jruby/jruby) 
 1.7 branch: [![Build Status](https://travis-ci.org/jruby/jruby.png?branch=jruby-1_7)](https://travis-ci.org/jruby/jruby/branches)
 
-Authors: Stefan Matthias Aust, Anders Bengtsson, Geert Bevin, Ola Bini,
- Piergiuliano Bossi, Johannes Brodwall, Rocky Burt, Paul Butcher,
- Benoit Cerrina, Wyss Clemens, David Corbin, Benoit Daloze, Thomas E Enebo,
- Robert Feldt, Chad Fowler, Russ Freeman, Joey Gibson, Kiel Hodges,
- Xandy Johnson, Kelvin Liu, Kevin Menard, Alan Moore, Akinori Musha,
- Charles Nutter, Takashi Okamoto, Jan Arne Petersen, Tobias Reif, David Saff,
- Subramanya Sastry, Chris Seaton, Nick Sieger, Ed Sinjiashvili, Vladimir Sizikov,
- Daiki Ueno, Matthias Veit, Jason Voegele, Sergey Yevtushenko, Robert Yokota,
-   and many gracious contributors from the community.
+## About
 
-Project Contact: Thomas E Enebo <tom.enebo@gmail.com>
+JRuby is an implementation of the [Ruby language](http://www.ruby-lang.org)
+using the JVM.
 
-JRuby also uses code generously shared by the creator of the Ruby language, 
-Yukihiro Matsumoto <matz@netlab.co.jp>.
+It aims to be a complete, correct and fast implementation of Ruby, at the same
+time as providing powerful new features such as concurrency without a
+[global-interpreter-lock](http://en.wikipedia.org/wiki/Global_Interpreter_Lock),
+true parallelism, and tight integration to the Java language to allow you to
+uses Java classes in your Ruby program and to allow JRuby to be embedded into a
+Java application.
 
-## About
+You can use JRuby simply as a faster version of Ruby, you can use it to run Ruby
+on the JVM and access powerful JVM libraries such as highly tuned concurrency
+primitives, you can use it to embed Ruby as a scripting language in your Java
+program, or many other possibilites.
 
-JRuby is the effort to recreate the Ruby (http://www.ruby-lang.org) interpreter
-in Java.
+We're a welcoming community - you can talk to us on [#jruby on Freenode](http://richard.esplins.org/siwi/2011/07/08/getting-started-freenode-irc/).
+There are core team members in the EU and US time zones.
 
-The Java version is tightly integrated with Java to allow both to script
-any Java class and to embed the interpreter into any Java application. 
-See the [docs](docs) directory for more information.
+Visit the [JRuby website](http://jruby.org) and the [JRuby wiki](https://github.com/jruby/jruby/wiki)
+for more information.
 
-## Prerequisites
+## Getting JRuby
 
-* A Java 7-compatible (or higher) Java development kit (JDK)
-* Maven 3+
-* Apache Ant 1.8+ (see https://github.com/jruby/jruby/issues/2236)
+To run JRuby you will need a JRE (the JVM runtime environment) version 7 or higher.
 
-## Run
+Your operating system may provide a JRE and JRuby in a package manager, but you may find that this
+version is very old.
 
-    bin/jruby rubyfile.rb
+An alternative is to use one of the Ruby version managers.
 
-interprets the file `rubyfile.rb`.
+For [`rbenv`](https://github.com/sstephenson/rbenv) you will need the
+[`ruby-build`](https://github.com/sstephenson/ruby-build) plugin. You may find that your system
+package manager can provide these. Then you can run:
 
-If you checked out from the repository or downloaded the source distribution,
-see the next section to build JRuby first.
+```
+$ rbenv install rbenv install jruby-9.0.0.0-dev
+```
 
-## Compiling from source
+For [`rvm`](https://rvm.io) you can simply do:
 
-See [BUILDING](BUILDING.md) for more information.
+```
+$ rvm install jruby
+```
 
-## Testing
+You can also [download packages from the JRuby website](http://jruby.org/download) that
+you can unpack and run in place.
 
-See [BUILDING: Developing and Testing](BUILDING.md#developing-and-testing) for
-more information.
+## Building JRuby from source
 
-## More Information
+See [BUILDING](BUILDING.md) for information about prerequisites, how to compile JRuby from source
+and how to test it.
 
-Visit http://jruby.org for more information.
+## Authors
 
-Visit http://jruby.github.io/jruby for the Maven Site documentation.
+Stefan Matthias Aust, Anders Bengtsson, Geert Bevin, Ola Bini,
+ Piergiuliano Bossi, Johannes Brodwall, Rocky Burt, Paul Butcher,
+ Benoit Cerrina, Wyss Clemens, David Corbin, Benoit Daloze, Thomas E Enebo,
+ Robert Feldt, Chad Fowler, Russ Freeman, Joey Gibson, Kiel Hodges,
+ Xandy Johnson, Kelvin Liu, Kevin Menard, Alan Moore, Akinori Musha,
+ Charles Nutter, Takashi Okamoto, Jan Arne Petersen, Tobias Reif, David Saff,
+ Subramanya Sastry, Chris Seaton, Nick Sieger, Ed Sinjiashvili, Vladimir Sizikov,
+ Daiki Ueno, Matthias Veit, Jason Voegele, Sergey Yevtushenko, Robert Yokota,
+   and many gracious contributors from the community.
+
+JRuby uses code generously shared by the creator of the Ruby language, 
+Yukihiro Matsumoto <matz@netlab.co.jp>.
+
+Project Contact: Thomas E Enebo <tom.enebo@gmail.com>
 
 ## License
 
-Read the [COPYING](COPYING) file.
+JRuby is licensed to you under three licenses - the EPL 1.0, GPL 2 and LGPL 2.1.
+Some components have other licenses and copyright. See the [COPYING](COPYING)
+file for more specifics.
diff --git a/core/src/main/java/org/jruby/Main.java b/core/src/main/java/org/jruby/Main.java
@@ -517,7 +517,7 @@ private void doCheckSecurityManager() {
      * @param rj
      * @return
      */
-    private static int handleRaiseException(RaiseException rj) {
+    protected static int handleRaiseException(RaiseException rj) {
         RubyException raisedException = rj.getException();
         Ruby runtime = raisedException.getRuntime();
         if (runtime.getSystemExit().isInstance(raisedException)) {

diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -5073,7 +5073,7 @@ public FilenoUtil getFilenoUtil() {
     private EnumMap<DefinedMessage, RubyString> definedMessages = new EnumMap<DefinedMessage, RubyString>(DefinedMessage.class);
     private EnumMap<RubyThread.Status, RubyString> threadStatuses = new EnumMap<RubyThread.Status, RubyString>(RubyThread.Status.class);
 
-    private interface ObjectSpacer {
+    public interface ObjectSpacer {
         public void addToObjectSpace(Ruby runtime, boolean useObjectSpace, IRubyObject object);
     }
 

diff --git a/core/src/main/java/org/jruby/RubyProc.java b/core/src/main/java/org/jruby/RubyProc.java
@@ -249,8 +249,8 @@ public static IRubyObject[] prepareArgs(ThreadContext context, Block.Type type,
         if (args == null) return IRubyObject.NULL_ARRAY;
 
         if (type == Block.Type.LAMBDA) {
-            if (blockBody instanceof InterpretedIRBlockBody) {
-                ((InterpretedIRBlockBody) blockBody).getSignature().checkArity(context.runtime, args);
+            if (blockBody instanceof IRBlockBody) {
+                ((IRBlockBody) blockBody).getSignature().checkArity(context.runtime, args);
             } else {
                 arity.checkArity(context.runtime, args.length);
             }
@@ -260,27 +260,41 @@ public static IRubyObject[] prepareArgs(ThreadContext context, Block.Type type,
         boolean isFixed = arity.isFixed();
         int required = arity.required();
         int actual = args.length;
+        boolean restKwargs = blockBody instanceof IRBlockBody && ((IRBlockBody) blockBody).getSignature().kwargs();
 
+        // FIXME: This is a hot mess.  restkwargs factors into destructing a single element array as well.  I just weaved it into this logic.
         // for procs and blocks, single array passed to multi-arg must be spread
-        if (arity != Arity.ONE_ARGUMENT &&  required != 0 &&
-                (isFixed || arity != Arity.OPTIONAL) &&
+        if ((arity != Arity.ONE_ARGUMENT &&  required != 0 && (isFixed || arity != Arity.OPTIONAL) || restKwargs) &&
                 actual == 1 && args[0].respondsTo("to_ary")) {
             args = args[0].convertToArray().toJavaArray();
             actual = args.length;
         }
 
-        // FIXME: This code is horrible so I named it poorly.  We add 1 if we have kwargs so we do not accidentally
-        // chomp it off of args array.  Much of this logic needs to be encapsulated as part of our transition from
-        // Arity to Signature.
-        int fudge = blockBody instanceof IRBlockBody && ((IRBlockBody) blockBody).getSignature().kwargs() ? 1 : 0;
+        // FIXME: NOTE IN THE BLOCKCAPALYPSE: I think we only care if there is any kwargs syntax at all and if so it is +1
+        // argument.  This ended up more complex because required() on signature adds +1 is required kwargs.  I suspect
+        // required() is used for two purposes and the +1 might be useful in some other way so I made it all work and
+        // after this we should clean this up (IRBlockBody and BlockBody are also messing with args[] so that should
+        // be part of this cleanup.
+
+        // We add one to our fill and adjust number of incoming args code when there are kwargs.  We subtract one
+        // if it happens to be requiredkwargs since required gets a +1.  This is horrible :)
+        int needsKwargs = blockBody instanceof IRBlockBody && ((IRBlockBody) blockBody).getSignature().kwargs() ?
+                1 - ((IRBlockBody) blockBody).getSignature().getRequiredKeywordCount() : 0;
 
         // fixed arity > 0 with mismatch needs a new args array
-        if (isFixed && required > 0 && required+fudge != actual) {
-            IRubyObject[] newArgs = Arrays.copyOf(args, required);
+        if (isFixed && required > 0 && required+needsKwargs != actual) {
+            IRubyObject[] newArgs = Arrays.copyOf(args, required+needsKwargs);
+
 
-            // pad with nil
-            if (required > actual) {
+            if (required > actual) {                      // Not enough required args pad.
                 Helpers.fillNil(newArgs, actual, required, context.runtime);
+                // ENEBO: what if we need kwargs here?
+            } else if (needsKwargs != 0) {
+                if (args.length < required+needsKwargs) { // Not enough args and we need an empty {} for kwargs processing.
+                    newArgs[newArgs.length - 1] = RubyHash.newHash(context.runtime);
+                } else {                                  // We have more args than we need and kwargs is always the last arg.
+                    newArgs[newArgs.length - 1] = args[args.length - 1];
+                }
             }
 
             args = newArgs;

diff --git a/core/src/main/java/org/jruby/internal/runtime/methods/JavaMethod.java b/core/src/main/java/org/jruby/internal/runtime/methods/JavaMethod.java
@@ -46,6 +46,10 @@ public abstract class JavaMethod extends DynamicMethod implements Cloneable, Met
     private String[] parameterList;
     private CallConfiguration callerRequirement = CallConfiguration.FrameNoneScopeNone;
 
+    private static String[] ONE_REQ = new String[] { "q" };
+    private static String[] TWO_REQ = new String[] { "q", "q" };
+    private static String[] THREE_REQ = new String[] { "q", "q", "q" };
+
     public static final Class[][] METHODS = {
         {JavaMethodZero.class, JavaMethodZeroOrOne.class, JavaMethodZeroOrOneOrTwo.class, JavaMethodZeroOrOneOrTwoOrThree.class},
         {null, JavaMethodOne.class, JavaMethodOneOrTwo.class, JavaMethodOneOrTwoOrThree.class},
@@ -972,12 +976,15 @@ public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule claz
     public static abstract class JavaMethodOne extends JavaMethodOneOrN {
         public JavaMethodOne(RubyModule implementationClass, Visibility visibility) {
             super(implementationClass, visibility);
+            setParameterList(ONE_REQ);
         }
         public JavaMethodOne(RubyModule implementationClass, Visibility visibility, CallConfiguration callConfig) {
             super(implementationClass, visibility, callConfig);
+            setParameterList(ONE_REQ);
         }
         public JavaMethodOne(RubyModule implementationClass, Visibility visibility, CallConfiguration callConfig, String name) {
             super(implementationClass, visibility, callConfig, name);
+            setParameterList(ONE_REQ);
         }
 
         public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args) {
@@ -1038,9 +1045,11 @@ public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule claz
     public static abstract class JavaMethodTwo extends JavaMethodTwoOrN {
         public JavaMethodTwo(RubyModule implementationClass, Visibility visibility) {
             super(implementationClass, visibility);
+            setParameterList(TWO_REQ);
         }
         public JavaMethodTwo(RubyModule implementationClass, Visibility visibility, CallConfiguration callConfig) {
             super(implementationClass, visibility, callConfig);
+            setParameterList(TWO_REQ);
         }
 
         public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args) {
@@ -1079,9 +1088,11 @@ public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule claz
     public static abstract class JavaMethodThree extends JavaMethodThreeOrN {
         public JavaMethodThree(RubyModule implementationClass, Visibility visibility) {
             super(implementationClass, visibility);
+            setParameterList(THREE_REQ);
         }
         public JavaMethodThree(RubyModule implementationClass, Visibility visibility, CallConfiguration callConfig) {
             super(implementationClass, visibility, callConfig);
+            setParameterList(THREE_REQ);
         }
 
         public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args) {

diff --git a/core/src/main/java/org/jruby/ir/instructions/ReceivePostReqdArgInstr.java b/core/src/main/java/org/jruby/ir/instructions/ReceivePostReqdArgInstr.java
@@ -10,6 +10,7 @@
 import org.jruby.ir.transformations.inlining.CloneInfo;
 import org.jruby.ir.transformations.inlining.InlineCloneInfo;
 import org.jruby.ir.transformations.inlining.SimpleCloneInfo;
+import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
 /**
@@ -70,8 +71,8 @@ public static ReceivePostReqdArgInstr decode(IRReaderDecoder d) {
         return new ReceivePostReqdArgInstr(d.decodeVariable(), d.decodeInt(), d.decodeInt(), d.decodeInt());
     }
 
-    public IRubyObject receivePostReqdArg(IRubyObject[] args, boolean acceptsKeywordArgument) {
-        return IRRuntimeHelpers.receivePostReqdArg(args, preReqdArgsCount, postReqdArgsCount, argIndex, acceptsKeywordArgument);
+    public IRubyObject receivePostReqdArg(ThreadContext context, IRubyObject[] args, boolean acceptsKeywordArgument) {
+        return IRRuntimeHelpers.receivePostReqdArg(context, args, preReqdArgsCount, postReqdArgsCount, argIndex, acceptsKeywordArgument);
     }
 
     @Override

diff --git a/core/src/main/java/org/jruby/ir/interpreter/InterpreterEngine.java b/core/src/main/java/org/jruby/ir/interpreter/InterpreterEngine.java
@@ -247,9 +247,8 @@ protected static void receiveArg(ThreadContext context, Instr i, Operation opera
                 setResult(temp, currDynScope, instr.getResult(), result);
                 return;
             case RECV_POST_REQD_ARG:
-                result = ((ReceivePostReqdArgInstr)instr).receivePostReqdArg(args, acceptsKeywordArgument);
-                // For blocks, missing arg translates to nil
-                setResult(temp, currDynScope, instr.getResult(), result == null ? context.nil : result);
+                result = ((ReceivePostReqdArgInstr)instr).receivePostReqdArg(context, args, acceptsKeywordArgument);
+                setResult(temp, currDynScope, instr.getResult(), result);
                 return;
             case RECV_RUBY_EXC:
                 setResult(temp, currDynScope, instr.getResult(), IRRuntimeHelpers.unwrapRubyException(exception));

diff --git a/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java b/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java
@@ -489,6 +489,7 @@ public static IRubyObject[] convertValueIntoArgArray(ThreadContext context, IRub
         }
     }
 
+    @JIT
     public static Block getBlockFromObject(ThreadContext context, Object value) {
         Block block;
         if (value instanceof Block) {
@@ -790,11 +791,12 @@ public static IRubyObject constructRestArg(ThreadContext context, Object[] args,
         return context.runtime.newArray(restArgs);
     }
 
-    public static IRubyObject receivePostReqdArg(IRubyObject[] args, int preReqdArgsCount, int postReqdArgsCount, int argIndex, boolean acceptsKeywordArgument) {
+    @JIT
+    public static IRubyObject receivePostReqdArg(ThreadContext context, IRubyObject[] args, int preReqdArgsCount, int postReqdArgsCount, int argIndex, boolean acceptsKeywordArgument) {
         boolean kwargs = extractKwargsHash(args, preReqdArgsCount + postReqdArgsCount, acceptsKeywordArgument) != null;
         int n = kwargs ? args.length - 1 : args.length;
         int remaining = n - preReqdArgsCount;
-        if (remaining <= argIndex) return null;  // For blocks!
+        if (remaining <= argIndex) return context.nil;
 
         return (remaining > postReqdArgsCount) ? args[n - postReqdArgsCount + argIndex] : args[preReqdArgsCount + argIndex];
     }

diff --git a/core/src/main/java/org/jruby/ir/targets/JVMVisitor.java b/core/src/main/java/org/jruby/ir/targets/JVMVisitor.java
@@ -1546,12 +1546,13 @@ public void ReceivePreReqdArgInstr(ReceivePreReqdArgInstr instr) {
 
     @Override
     public void ReceivePostReqdArgInstr(ReceivePostReqdArgInstr instr) {
+        jvmMethod().loadContext();
         jvmMethod().loadArgs();
         jvmAdapter().pushInt(instr.preReqdArgsCount);
         jvmAdapter().pushInt(instr.postReqdArgsCount);
         jvmAdapter().pushInt(instr.getArgIndex());
         jvmAdapter().ldc(jvm.methodData().scope.receivesKeywordArgs());
-        jvmMethod().invokeIRHelper("receivePostReqdArg", sig(IRubyObject.class, IRubyObject[].class, int.class, int.class, int.class, boolean.class));
+        jvmMethod().invokeIRHelper("receivePostReqdArg", sig(IRubyObject.class, ThreadContext.class, IRubyObject[].class, int.class, int.class, int.class, boolean.class));
         jvmStoreLocal(instr.getResult());
     }
 

diff --git a/core/src/main/java/org/jruby/management/BeanManagerImpl.java b/core/src/main/java/org/jruby/management/BeanManagerImpl.java
@@ -3,6 +3,9 @@
 import java.lang.management.ManagementFactory;
 import java.lang.reflect.Method;
 import java.security.AccessControlException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
 import javax.management.InstanceAlreadyExistsException;
 import javax.management.InstanceNotFoundException;
 import javax.management.MBeanRegistrationException;
@@ -19,13 +22,16 @@ public class BeanManagerImpl implements BeanManager {
 
     private static final Logger LOG = LoggerFactory.getLogger("BeanManagerImpl");
 
+    private static final SimpleDateFormat FORMAT = new SimpleDateFormat("yyyyMMddHHmmssSSS");
+
     public final String base;
 
     private final boolean managementEnabled;
 
     public BeanManagerImpl(Ruby ruby, boolean managementEnabled) {
         this.managementEnabled = managementEnabled;
-        this.base = "org.jruby:type=Runtime,name=" + ruby.getRuntimeNumber() + ",";
+        this.base = "org.jruby:type=Runtime,name=" + FORMAT.format(new Date()) +
+                ruby.getRuntimeNumber() + ",";
     }
 
     public void register(JITCompilerMBean jitCompiler) {

diff --git a/core/src/main/java/org/jruby/runtime/DynamicScope.java b/core/src/main/java/org/jruby/runtime/DynamicScope.java
@@ -100,6 +100,11 @@ public final DynamicScope getParentScope() {
         return parent;
     }
 
+    @Deprecated
+    public DynamicScope getNextCapturedScope() {  // Used by ruby-debug-ide
+        return getParentScope();
+    }
+
     /**
      * Returns the n-th parent scope of this scope.
      * May return <code>null</code>.