jruby · Jan 11, 2016 · Jan 11, 2016 · Jan 11, 2016 · Jan 12, 2016 · Jan 13, 2016
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -2838,31 +2838,30 @@ public PrintStream getOutputStream() {
         return new PrintStream(new IOOutputStream(getGlobalVariables().get("$stdout")));
     }
 
-    public RubyModule getClassFromPath(String path) {
-        RubyModule c = getObject();
+    public RubyModule getClassFromPath(final String path) {
         if (path.length() == 0 || path.charAt(0) == '#') {
             throw newTypeError("can't retrieve anonymous class " + path);
         }
+
+        RubyModule c = getObject();
         int pbeg = 0, p = 0;
-        for(int l=path.length(); p<l; ) {
-            while(p<l && path.charAt(p) != ':') {
-                p++;
-            }
-            String str = path.substring(pbeg, p);
+        for ( final int l = path.length(); p < l; ) {
+            while ( p < l && path.charAt(p) != ':' ) p++;
+
+            final String str = path.substring(pbeg, p);
 
-            if(p<l && path.charAt(p) == ':') {
-                if(p+1 < l && path.charAt(p+1) != ':') {
-                    throw newTypeError("undefined class/module " + path.substring(pbeg,p));
+            if ( p < l && path.charAt(p) == ':' ) {
+                if ( ++p < l && path.charAt(p) != ':' ) {
+                    throw newTypeError("undefined class/module " + str);
                 }
-                p += 2;
-                pbeg = p;
+                pbeg = ++p;
             }
 
             IRubyObject cc = c.getConstant(str);
-            if(!(cc instanceof RubyModule)) {
+            if ( ! ( cc instanceof RubyModule ) ) {
                 throw newTypeError(path + " does not refer to class/module");
             }
-            c = (RubyModule)cc;
+            c = (RubyModule) cc;
         }
         return c;
     }

diff --git a/core/src/main/java/org/jruby/RubyFile.java b/core/src/main/java/org/jruby/RubyFile.java
@@ -1703,6 +1703,12 @@ else if (protocol.find()) {
         }
         if (postFix.contains("..")) {
             postFix = "!" + canonicalizePath(postFix.substring(1));
+            if (Platform.IS_WINDOWS && postFix.startsWith("!")) {
+                postFix = postFix.replace("\\", "/");
+                if (startsWithDriveLetterOnWindows(postFix.substring(1))) {
+                    postFix = "!" + postFix.substring(3);
+                }
+            }
         }
         return runtime.newString(preFix + realPath + postFix);
     }

diff --git a/core/src/main/java/org/jruby/javasupport/binding/ClassInitializer.java b/core/src/main/java/org/jruby/javasupport/binding/ClassInitializer.java
@@ -56,8 +56,11 @@ public RubyModule initialize(RubyModule proxy) {
         proxy.setParent(parent);
 
         // set the Java class name and package
-        if ( javaClass.isAnonymousClass() ) {
-            String baseName = ""; // javaClass.getSimpleName() returns "" for anonymous
+        if ( javaClass.isMemberClass() ) {
+            proxy.setBaseName( javaClass.getSimpleName() );
+        }
+        else { // javaClass.isAnonymousClass() || javaClass.isLocalClass()
+            String baseName = javaClass.getSimpleName(); // returns "" for anonymous
             if ( enclosingClass != null ) {
                 // instead of an empty name anonymous classes will have a "conforming"
                 // although not valid (by Ruby semantics) RubyClass name e.g. :
@@ -75,9 +78,6 @@ else if ( length > offset + 1 ) { // skip '$'
             }
             proxy.setBaseName( baseName );
         }
-        else {
-            proxy.setBaseName( javaClass.getSimpleName() );
-        }
 
         installClassFields(proxyClass, state);
         installClassInstanceMethods(proxyClass, state);

diff --git a/core/src/main/java/org/jruby/runtime/Helpers.java b/core/src/main/java/org/jruby/runtime/Helpers.java
@@ -1409,11 +1409,13 @@ public static StaticScope preLoad(ThreadContext context, String[] varNames) {
     }
 
     public static void preLoadCommon(ThreadContext context, StaticScope staticScope, boolean wrap) {
+        RubyModule objectClass = context.runtime.getObject();
         if (wrap) {
-            staticScope.setModule(RubyModule.newModule(context.runtime));
-        } else {
-            staticScope.setModule(context.runtime.getObject());
+            objectClass = RubyModule.newModule(context.runtime);
         }
+
+        staticScope.setModule(objectClass);
+
         DynamicScope scope = DynamicScope.newDynamicScope(staticScope);
 
         // Each root node has a top-level scope that we need to push

diff --git a/core/src/main/java/org/jruby/runtime/marshal/UnmarshalStream.java b/core/src/main/java/org/jruby/runtime/marshal/UnmarshalStream.java
@@ -17,7 +17,7 @@
  * Copyright (C) 2004 Charles O Nutter <headius@headius.com>
  * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
  * Copyright (C) 2006 Ola Bini <ola.bini@ki.se>
- * 
+ *
  * 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"),
@@ -105,29 +105,29 @@ public IRubyObject unmarshalObject(boolean callProc) throws IOException {
     // introduced for keeping ivar read state recursively.
     private static class MarshalState {
         private boolean ivarWaiting;
-        
+
         MarshalState(boolean ivarWaiting) {
             this.ivarWaiting = ivarWaiting;
         }
-        
+
         boolean isIvarWaiting() {
             return ivarWaiting;
         }
-        
+
         void setIvarWaiting(boolean ivarWaiting) {
             this.ivarWaiting = ivarWaiting;
         }
     }
-    
+
     // r_object0
-    public IRubyObject unmarshalObject(MarshalState state) throws IOException {
+    private IRubyObject unmarshalObject(MarshalState state) throws IOException {
         return unmarshalObject(state, true);
     }
 
     // r_object0
-    public IRubyObject unmarshalObject(MarshalState state, boolean callProc) throws IOException {
-        int type = readUnsignedByte();
-        IRubyObject result = null;
+    private IRubyObject unmarshalObject(MarshalState state, boolean callProc) throws IOException {
+        final int type = readUnsignedByte();
+        final IRubyObject result;
         if (cache.isLinkType(type)) {
             result = cache.readLink(this, type);
             if (callProc) return doCallProcForLink(result, type);
@@ -147,15 +147,29 @@ public void registerLinkTarget(IRubyObject newObject) {
     }
 
     public static RubyModule getModuleFromPath(Ruby runtime, String path) {
-        RubyModule value = runtime.getClassFromPath(path);
-        if (!value.isModule()) throw runtime.newArgumentError(path + " does not refer module");
+        final RubyModule value = getConstantFromPath(runtime, path);
+        if ( ! value.isModule() ) throw runtime.newArgumentError(path + " does not refer module");
         return value;
     }
 
     public static RubyClass getClassFromPath(Ruby runtime, String path) {
-        RubyModule value = runtime.getClassFromPath(path);
-        if (!value.isClass()) throw runtime.newArgumentError(path + " does not refer class");
-        return (RubyClass)value;
+        final RubyModule value = getConstantFromPath(runtime, path);
+        if ( ! value.isClass() ) throw runtime.newArgumentError(path + " does not refer class");
+        return (RubyClass) value;
+    }
+
+    private static RubyModule getConstantFromPath(Ruby runtime, String path) {
+        final RubyModule value;
+        try {
+            value = runtime.getClassFromPath(path);
+        }
+        catch (RaiseException e) {
+            if ( runtime.getModule("NameError").isInstance(e.getException()) ) {
+                throw runtime.newArgumentError("undefined class/module " + path);
+            }
+            throw e;
+        }
+        return value;
     }
 
     private IRubyObject doCallProcForLink(IRubyObject result, int type) {
@@ -226,20 +240,12 @@ private IRubyObject unmarshalObjectDirectly(int type, MarshalState state, boolea
                 break;
             case 'e':
                 RubySymbol moduleName = (RubySymbol) unmarshalObject();
-                RubyModule tp = null;
-                try {
-                    tp = runtime.getClassFromPath(moduleName.asJavaString());
-                } catch (RaiseException e) {
-                    if (runtime.getModule("NameError").isInstance(e.getException())) {
-                        throw runtime.newArgumentError("undefined class/module " + moduleName.asJavaString());
-                    } 
-                    throw e;
-                }
+                final RubyModule tp = getModuleFromPath(runtime, moduleName.asJavaString());
 
                 rubyObj = unmarshalObject();
 
                 tp.extend_object(rubyObj);
-                tp.callMethod(runtime.getCurrentContext(),"extended", rubyObj);
+                tp.callMethod(runtime.getCurrentContext(), "extended", rubyObj);
                 break;
             case 'l' :
                 rubyObj = RubyBignum.unmarshalFrom(this);
@@ -266,7 +272,7 @@ private IRubyObject unmarshalObjectDirectly(int type, MarshalState state, boolea
         if (callProc) {
             return doCallProcForObj(rubyObj);
         }
-        
+
         return rubyObj;
     }
 
@@ -337,18 +343,7 @@ public int unmarshalInt() throws IOException {
     private IRubyObject defaultObjectUnmarshal() throws IOException {
         RubySymbol className = (RubySymbol) unmarshalObject(false);
 
-        RubyClass type = null;
-        try {
-            type = getClassFromPath(runtime, className.toString());
-        } catch (RaiseException e) {
-            if (runtime.getModule("NameError").isInstance(e.getException())) {
-                throw runtime.newArgumentError("undefined class/module " + className.asJavaString());
-            }
-
-            throw e;
-        }
-
-        assert type != null : "type shouldn't be null.";
+        RubyClass type = getClassFromPath(runtime, className.toString());
 
         IRubyObject result = (IRubyObject)type.unmarshal(this);
 
@@ -359,27 +354,27 @@ public void defaultVariablesUnmarshal(IRubyObject object) throws IOException {
         int count = unmarshalInt();
 
         RubyClass cls = object.getMetaClass().getRealClass();
-        
+
         for (int i = 0; i < count; i++) {
-            
+
             IRubyObject key = unmarshalObject(false);
-            
+
             if (runtime.is1_9() && object instanceof EncodingCapable) {
-                
+
                 EncodingCapable strObj = (EncodingCapable)object;
 
                 if (key.asJavaString().equals(MarshalStream.SYMBOL_ENCODING_SPECIAL)) {
-                    
+
                     // special case for USASCII and UTF8
                     if (unmarshalObject().isTrue()) {
                         strObj.setEncoding(UTF8Encoding.INSTANCE);
                     } else {
                         strObj.setEncoding(USASCIIEncoding.INSTANCE);
                     }
                     continue;
-                    
+
                 } else if (key.asJavaString().equals("encoding")) {
-                    
+
                     IRubyObject encodingNameObj = unmarshalObject(false);
                     String encodingNameStr = encodingNameObj.asJavaString();
                     ByteList encodingName = new ByteList(ByteList.plain(encodingNameStr));
@@ -391,10 +386,10 @@ public void defaultVariablesUnmarshal(IRubyObject object) throws IOException {
                     Encoding encoding = entry.getEncoding();
                     strObj.setEncoding(encoding);
                     continue;
-                    
+
                 } // else fall through as normal ivar
             }
-            
+
             String name = key.asJavaString();
             IRubyObject value = unmarshalObject();
 
@@ -405,7 +400,7 @@ public void defaultVariablesUnmarshal(IRubyObject object) throws IOException {
     private IRubyObject uclassUnmarshall() throws IOException {
         RubySymbol className = (RubySymbol)unmarshalObject(false);
 
-        RubyClass type = (RubyClass)runtime.getClassFromPath(className.asJavaString());
+        RubyClass type = getClassFromPath(runtime, className.asJavaString());
 
         // singleton, raise error
         if (type.isSingleton()) throw runtime.newTypeError("singleton can't be loaded");
@@ -431,7 +426,7 @@ private IRubyObject userUnmarshal(MarshalState state) throws IOException {
         String className = unmarshalObject(false).asJavaString();
         ByteList marshaled = unmarshalString();
         RubyClass classInstance = findClass(className);
-        RubyString data = RubyString.newString(getRuntime(), marshaled);
+        RubyString data = RubyString.newString(runtime, marshaled);
         if (state.isIvarWaiting()) {
             defaultVariablesUnmarshal(data);
             state.setIvarWaiting(false);
@@ -451,19 +446,7 @@ private IRubyObject userNewUnmarshal() throws IOException {
     }
 
     private RubyClass findClass(String className) {
-        RubyModule classInstance;
-        try {
-            classInstance = runtime.getClassFromPath(className);
-        } catch (RaiseException e) {
-            if (runtime.getModule("NameError").isInstance(e.getException())) {
-                throw runtime.newArgumentError("undefined class/module " + className);
-            } 
-            throw e;
-        }
-        if (! (classInstance instanceof RubyClass)) {
-            throw runtime.newArgumentError(className + " does not refer class"); // sic
-        }
-        return (RubyClass) classInstance;
+        return getClassFromPath(runtime, className);
     }
 
     public int read() throws IOException {

diff --git a/spec/compiler/general_spec.rb b/spec/compiler/general_spec.rb
@@ -394,6 +394,8 @@ def self.bar
       # non-local flow control with while loops
       run("a = 0; 1.times { a += 1; redo if a < 2 }; a") {|result| expect(result).to eq 2 }
       run("def foo(&b); while true; b.call; end; end; foo { break 3 }") {|result| expect(result).to eq 3 }
+
+      expect(lambda { run("def foo(&b); while true; b.call; end; end; foo { eval 'break 3' }") }).to raise_error(LocalJumpError)
     end
 
     it "compiles block passing" do

diff --git a/spec/compiler/rubyscript_spec.rb b/spec/compiler/rubyscript_spec.rb
@@ -7,7 +7,7 @@
     script1.add_import('my.java.import')
 
     script2 = JRuby::Compiler::RubyScript.new("script2")
-    expect(script2.imports).not_to include('my.java.import')
+    expect(script2.imports).to_not include('my.java.import')
   end
 
 end
diff --git a/spec/compiler/skinnymethodadapter_spec.rb b/spec/compiler/skinnymethodadapter_spec.rb
@@ -38,6 +38,18 @@
       end
     end.map(&:to_s).map(&:downcase)
     # 1.9 makes them symbols, so to_s the lot
+    insn_opcodes = insn_opcodes.map(&:to_s)
+    instance_methods = SkinnyMethodAdapter.instance_methods.map(&:to_s)
+
+    insn_opcodes.each do |opcode|
+      opcode = opcode.downcase
+      expect(instance_methods).to include(opcode)
+    end
+
+    expect(instance_methods).to include("go_to")
+    expect(instance_methods).to include("voidreturn")
+    expect(instance_methods).to include("instance_of")
+    expect(instance_methods).to include("newobj")
   end
 
   it "supports all JVM opcodes" do

diff --git a/spec/java_integration/classes/name_spec.rb b/spec/java_integration/classes/name_spec.rb
@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe "Java class" do
+
+  java_import "java_integration.fixtures.InnerClasses"
+
+  it "has (qualified) Ruby name" do
+    expect( InnerClasses.name ).to eql 'Java::Java_integrationFixtures::InnerClasses'
+  end
+
+  it "has name for inner classes" do
+    base_name = InnerClasses.name
+    expect( InnerClasses::CapsInnerClass.name ).to eql "#{base_name}::CapsInnerClass"
+    expect( InnerClasses::lowerInnerClass.name ).to eql "#{base_name}::lowerInnerClass"
+  end
+
+  it "has name for local classes" do
+    base_name = InnerClasses.name
+    local = InnerClasses.localMethodClass
+    # java_integration.fixtures.InnerClasses$1CapsImpl
+    expect( local.class.name ).to eql "#{base_name}::1CapsImpl"
+  end
+
+  it "has name for anonymous classes" do
+    base_name = InnerClasses.name
+    anon = InnerClasses.anonymousMethodClass
+    expect( anon.class.name ).to eql "#{base_name}::1"
+  end
+
+end