jruby · Dec 27, 2015 · Dec 27, 2015 · Dec 27, 2015 · Dec 27, 2015 · Dec 27, 2015
diff --git a/core/src/main/java/org/jruby/RubyEnumerable.java b/core/src/main/java/org/jruby/RubyEnumerable.java
@@ -552,7 +552,7 @@ private static IRubyObject grep(ThreadContext context, IRubyObject self, final I
         final RubyArray result = runtime.newArray();
 
         if (block.isGiven()) {
-            callEach(runtime, context, self, block.getSignature(), new BlockCallback() {
+            callEach(runtime, context, self, Signature.ONE_REQUIRED, new BlockCallback() {
                 public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) {
                     IRubyObject larg = packEnumValues(ctx, largs);
                     if (pattern.callMethod(ctx, "===", larg).isTrue() == isPresent) {

diff --git a/core/src/main/java/org/jruby/RubyHash.java b/core/src/main/java/org/jruby/RubyHash.java
@@ -1213,13 +1213,7 @@ public IRubyObject op_aref(ThreadContext context, IRubyObject key) {
      *
      */
     private boolean hash_le(RubyHash other) {
-        RubyArray keys = keys();
-        for (Object key : keys) {
-            if (!other.get(key).equals( get(key) )) {
-                return false;
-            }
-        }
-        return true;
+        return other.directEntrySet().containsAll(directEntrySet());
     }
 
     @JRubyMethod(name = "<", required = 1)

diff --git a/core/src/main/java/org/jruby/RubyIO.java b/core/src/main/java/org/jruby/RubyIO.java
@@ -270,10 +270,17 @@ public OpenFile getOpenFile() {
     }
 
     public OpenFile getOpenFileChecked() {
+        checkInitialized();
         openFile.checkClosed();
         return openFile;
     }
 
+    // MRI: rb_io_get_fptr
+    public OpenFile getOpenFileInitialized() {
+        checkInitialized();
+        return openFile;
+    }
+
     private static ObjectAllocator IO_ALLOCATOR = new ObjectAllocator() {
         @Override
         public IRubyObject allocate(Ruby runtime, RubyClass klass) {
@@ -2040,7 +2047,9 @@ public IRubyObject close_write(ThreadContext context) {
         RubyIO write_io;
 
         write_io = GetWriteIO();
-        fptr = write_io.getOpenFileChecked();
+        fptr = write_io.getOpenFileInitialized();
+        if (!fptr.isOpen()) return context.nil;
+
         boolean locked = fptr.lock();
         try {
             if (fptr.socketChannel() != null) {
@@ -2055,7 +2064,7 @@ public IRubyObject close_write(ThreadContext context) {
                 return context.nil;
             }
 
-            if (fptr.isReadable()) {
+            if (fptr.isReadable() && !fptr.isDuplex()) {
                 throw runtime.newIOError("closing non-duplex IO for writing");
             }
         } finally {
@@ -2064,12 +2073,11 @@ public IRubyObject close_write(ThreadContext context) {
 
 
         if (this != write_io) {
-            fptr = getOpenFileChecked();
+            fptr = getOpenFileInitialized();
 
             locked = fptr.lock();
             try {
                 fptr.tiedIOForWriting = null;
-                fptr.setMode(fptr.getMode() & ~OpenFile.DUPLEX);
             } finally {
                 if (locked) fptr.unlock();
             }
@@ -2085,7 +2093,8 @@ public IRubyObject close_read(ThreadContext context) {
         OpenFile fptr;
         RubyIO write_io;
 
-        fptr = getOpenFileChecked();
+        fptr = getOpenFileInitialized();
+        if (!fptr.isOpen()) return context.nil;
 
         boolean locked = fptr.lock();
         try {
@@ -2104,7 +2113,7 @@ public IRubyObject close_read(ThreadContext context) {
             write_io = GetWriteIO();
             if (this != write_io) {
                 OpenFile wfptr;
-                wfptr = write_io.getOpenFileChecked();
+                wfptr = write_io.getOpenFileInitialized();
 
                 boolean locked2 = wfptr.lock();
                 try {
@@ -2115,7 +2124,6 @@ public IRubyObject close_read(ThreadContext context) {
                     this.openFile = wfptr;
                     /* bind to write_io temporarily to get rid of memory/fd leak */
                     fptr.tiedIOForWriting = null;
-                    fptr.setMode(fptr.getMode() & ~OpenFile.DUPLEX);
                     write_io.openFile = fptr;
                     fptr.cleanup(runtime, false);
                     /* should not finalize fptr because another thread may be reading it */
@@ -2125,7 +2133,7 @@ public IRubyObject close_read(ThreadContext context) {
                 }
             }
 
-            if (fptr.isWritable()) {
+            if (fptr.isWritable() && !fptr.isDuplex()) {
                 throw runtime.newIOError("closing non-duplex IO for reading");
             }
         } finally {

diff --git a/core/src/main/java/org/jruby/RubyNameError.java b/core/src/main/java/org/jruby/RubyNameError.java
@@ -219,8 +219,8 @@ public IRubyObject name() {
 
     @JRubyMethod
     public IRubyObject receiver(ThreadContext context) {
-        if (name instanceof RubyNameErrorMessage) {
-            return ((RubyNameErrorMessage)name).object;
+        if (message instanceof RubyNameErrorMessage) {
+            return ((RubyNameErrorMessage)message).object;
         }
 
         throw context.runtime.newArgumentError("no receiver is available");

diff --git a/core/src/main/java/org/jruby/RubyObjectSpace.java b/core/src/main/java/org/jruby/RubyObjectSpace.java
@@ -136,8 +136,7 @@ public static IRubyObject each_objectInternal(final ThreadContext context, IRuby
             runtime.eachModule(new Function1<Object, IRubyObject>() {
                 public Object apply(IRubyObject arg1) {
                     if (rubyClass.isInstance(arg1)) {
-                        if (arg1 instanceof IncludedModule ||
-                                (arg1 instanceof RubyClass && ((RubyClass)arg1).isSingleton())) {
+                        if (arg1 instanceof IncludedModule) {
                             // do nothing for included wrappers or singleton classes
                         } else {
                             count[0]++;
@@ -158,7 +157,7 @@ public Object apply(IRubyObject arg1) {
             block.yield(context, attached);
             if (attached instanceof RubyClass) {
                 for (RubyClass child : ((RubyClass)attached).subclasses(true)) {
-                    if (child instanceof IncludedModule || child.isSingleton()) {
+                    if (child instanceof IncludedModule) {
                         // do nothing for included wrappers or singleton classes
                     } else {
                         block.yield(context, child);

diff --git a/core/src/main/java/org/jruby/util/io/OpenFile.java b/core/src/main/java/org/jruby/util/io/OpenFile.java
@@ -706,6 +706,10 @@ public boolean isWritable() {
         return (mode & WRITABLE) != 0;
     }
 
+    public boolean isDuplex() {
+        return (mode & DUPLEX) != 0;
+    }
+
     public boolean isReadBuffered() {
         return READ_DATA_BUFFERED();
     }

diff --git a/spec/ruby/core/enumerable/grep_spec.rb b/spec/ruby/core/enumerable/grep_spec.rb
@@ -29,11 +29,24 @@ class EnumerableSpecGrep2; def ===(obj); /^ca/ =~ obj; end; end
     ary.grep(/a(b)a/) { $1 }.should == ["b", "b"]
   end
 
-  it "calls the block with an array when yielded with multiple arguments" do
-    yields = []
-    EnumerableSpecs::YieldsMixed.new.grep(Object){ |v| yields << v }
-    yields.should == [1, [2], [3, 4], [5, 6, 7], [8, 9], nil, []]
-
-    EnumerableSpecs::YieldsMixed.new.grep(Object).should == yields
+  describe "with a block" do
+    before :each do
+      @numerous = EnumerableSpecs::Numerous.new(*(0..9).to_a)
+      def (@odd_matcher = BasicObject.new).===(obj)
+        obj.odd?
+      end
+    end
+
+    it "returns an Array of matched elements that mapped by the block" do
+      @numerous.grep(@odd_matcher) { |n| n * 2 }.should == [2, 6, 10, 14, 18]
+    end
+
+    it "calls the block with gathered array when yielded with multiple arguments" do
+      EnumerableSpecs::YieldsMixed2.new.grep(Object){ |e| e }.should == EnumerableSpecs::YieldsMixed2.gathered_yields
+    end
+
+    it "raises an ArgumentError when not given a pattern" do
+      -> { @numerous.grep_v { |e| e } }.should raise_error(ArgumentError)
+    end
   end
 end
diff --git a/spec/ruby/core/io/close_read_spec.rb b/spec/ruby/core/io/close_read_spec.rb
@@ -29,9 +29,9 @@
 
   ruby_version_is '2.3' do
     it "doesn't raise an IOError on subsequent invocations" do
-      @io.close_write
+      @io.close_read
 
-      lambda { @io.close_write }.should_not raise_error(IOError)
+      lambda { @io.close_read }.should_not raise_error(IOError)
     end
   end