1 files changed, 75 insertions, 490 deletions

diff --git a/spec/ruby/core/module/refine_spec.rb b/spec/ruby/core/module/refine_spec.rb
index 54217a9326..d0fc7015f8 100644
--- a/spec/ruby/core/module/refine_spec.rb
+++ b/spec/ruby/core/module/refine_spec.rb
@@ -11,7 +11,7 @@ describe "Module#refine" do
     end
 
     mod.should_not == inner_self
-    inner_self.should be_kind_of(Module)
+    inner_self.should.is_a?(Module)
     inner_self.name.should == nil
   end
 
@@ -43,7 +43,7 @@ describe "Module#refine" do
       end
     end
 
-    inner_self.public_instance_methods.should include(:blah)
+    inner_self.public_instance_methods.should.include?(:blah)
   end
 
   it "returns created anonymous module" do
@@ -63,7 +63,7 @@ describe "Module#refine" do
       Module.new do
         refine {}
       end
-    end.should raise_error(ArgumentError)
+    end.should.raise(ArgumentError)
   end
 
   it "raises TypeError if not passed a class" do
@@ -71,7 +71,7 @@ describe "Module#refine" do
       Module.new do
         refine("foo") {}
       end
-    end.should raise_error(TypeError)
+    end.should.raise(TypeError, "wrong argument type String (expected Class or Module)")
   end
 
   it "accepts a module as argument" do
@@ -84,7 +84,7 @@ describe "Module#refine" do
       end
     end
 
-    inner_self.public_instance_methods.should include(:blah)
+    inner_self.public_instance_methods.should.include?(:blah)
   end
 
   it "applies refinements to the module" do
@@ -117,7 +117,7 @@ describe "Module#refine" do
       Module.new do
         refine String
       end
-    end.should raise_error(ArgumentError)
+    end.should.raise(ArgumentError)
   end
 
   it "applies refinements to calls in the refine block" do
@@ -136,7 +136,7 @@ describe "Module#refine" do
       refine(String) {def foo; "foo"; end}
       -> {
         "hello".foo
-      }.should raise_error(NoMethodError)
+      }.should.raise(NoMethodError)
     end
   end
 
@@ -145,7 +145,7 @@ describe "Module#refine" do
       refine(String) {def foo; 'foo'; end}
     end
 
-    -> {"hello".foo}.should raise_error(NoMethodError)
+    -> {"hello".foo}.should.raise(NoMethodError)
   end
 
   # When defining multiple refinements in the same module,
@@ -209,7 +209,7 @@ describe "Module#refine" do
 
         [1, 2].to_json_format
       end
-    }.should raise_error(NoMethodError)
+    }.should.raise(NoMethodError)
   end
 
   # method lookup:
@@ -243,34 +243,10 @@ describe "Module#refine" do
       result.should == "foo from singleton class"
     end
 
-    it "looks in the included modules for builtin methods" do
-      result = ruby_exe(<<-RUBY)
-        a = Module.new do
-          def /(other) quo(other) end
-        end
-
-        refinement = Module.new do
-          refine Integer do
-            include a
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          result = 1 / 2
-        end
-
-        print result.class
-      RUBY
-
-      result.should == 'Rational'
-    end
-
     it "looks in later included modules of the refined module first" do
       a = Module.new do
         def foo
-         "foo from A"
+          "foo from A"
         end
       end
 
@@ -298,65 +274,6 @@ describe "Module#refine" do
       result.should == "foo from IncludeMeLater"
     end
 
-    it "looks in prepended modules from the refinement first" do
-      refined_class = ModuleSpecs.build_refined_class
-
-      refinement = Module.new do
-        refine refined_class do
-          include ModuleSpecs::IncludedModule
-          prepend ModuleSpecs::PrependedModule
-
-          def foo; "foo from refinement"; end
-        end
-      end
-
-      result = nil
-      Module.new do
-        using refinement
-        result = refined_class.new.foo
-      end
-
-      result.should == "foo from prepended module"
-    end
-
-    it "looks in refinement then" do
-      refined_class = ModuleSpecs.build_refined_class
-
-      refinement = Module.new do
-        refine(refined_class) do
-          include ModuleSpecs::IncludedModule
-
-          def foo; "foo from refinement"; end
-        end
-      end
-
-      result = nil
-      Module.new do
-        using refinement
-        result = refined_class.new.foo
-      end
-
-      result.should == "foo from refinement"
-    end
-
-    it "looks in included modules from the refinement then" do
-      refined_class = ModuleSpecs.build_refined_class
-
-      refinement = Module.new do
-        refine refined_class do
-          include ModuleSpecs::IncludedModule
-        end
-      end
-
-      result = nil
-      Module.new do
-        using refinement
-        result = refined_class.new.foo
-      end
-
-      result.should == "foo from included module"
-    end
-
     it "looks in the class then" do
       refined_class = ModuleSpecs.build_refined_class
 
@@ -453,44 +370,22 @@ describe "Module#refine" do
       result.should == ["(1)", "(2)", "(3)"]
     end
 
-    ruby_version_is "" ... "2.6" do
-      it "is not honored by Kernel#public_send" do
-        refined_class = ModuleSpecs.build_refined_class
-
-        refinement = Module.new do
-          refine refined_class do
-            def foo; "foo from refinement"; end
-          end
-        end
+    it "is honored by Kernel#public_send" do
+      refined_class = ModuleSpecs.build_refined_class
 
-        result = nil
-        Module.new do
-          using refinement
-          result = refined_class.new.public_send :foo
+      refinement = Module.new do
+        refine refined_class do
+          def foo; "foo from refinement"; end
         end
-
-        result.should == "foo"
       end
-    end
-
-    ruby_version_is "2.6" do
-      it "is honored by Kernel#public_send" do
-        refined_class = ModuleSpecs.build_refined_class
 
-        refinement = Module.new do
-          refine refined_class do
-            def foo; "foo from refinement"; end
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          result = refined_class.new.public_send :foo
-        end
-
-        result.should == "foo from refinement"
+      result = nil
+      Module.new do
+        using refinement
+        result = refined_class.new.public_send :foo
       end
+
+      result.should == "foo from refinement"
     end
 
     it "is honored by string interpolation" do
@@ -536,250 +431,112 @@ describe "Module#refine" do
       result.should == "hello from refinement"
     end
 
-    ruby_version_is "" ... "2.7" do
-      it "is not honored by Kernel#method" do
-        klass = Class.new
-        refinement = Module.new do
-          refine klass do
-            def foo; end
-          end
-        end
-
-        -> {
-          Module.new do
-            using refinement
-            klass.new.method(:foo)
-          end
-        }.should raise_error(NameError, /undefined method `foo'/)
-      end
-    end
-
-    ruby_version_is "2.7" do
-      it "is honored by Kernel#method" do
-        klass = Class.new
-        refinement = Module.new do
-          refine klass do
-            def foo; end
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          result = klass.new.method(:foo).class
+    it "is honored by Kernel#method" do
+      klass = Class.new
+      refinement = Module.new do
+        refine klass do
+          def foo; end
         end
-
-        result.should == Method
       end
-    end
 
-    ruby_version_is "" ... "2.7" do
-      it "is not honored by Kernel#instance_method" do
-        klass = Class.new
-        refinement = Module.new do
-          refine klass do
-            def foo; end
-          end
-        end
-
-        -> {
-          Module.new do
-            using refinement
-            klass.instance_method(:foo)
-          end
-        }.should raise_error(NameError, /undefined method `foo'/)
-      end
-    end
-
-    ruby_version_is "2.7" do
-      it "is honored by Kernel#method" do
-        klass = Class.new
-        refinement = Module.new do
-          refine klass do
-            def foo; end
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          result = klass.instance_method(:foo).class
-        end
-
-        result.should == UnboundMethod
+      result = nil
+      Module.new do
+        using refinement
+        result = klass.new.method(:foo).class
       end
-    end
-
-    ruby_version_is "" ... "2.6" do
-      it "is not honored by Kernel#respond_to?" do
-        klass = Class.new
-        refinement = Module.new do
-          refine klass do
-            def foo; end
-          end
-        end
 
-        result = nil
-        Module.new do
-          using refinement
-          result = klass.new.respond_to?(:foo)
-        end
-
-        result.should == false
-      end
+      result.should == Method
     end
 
-    ruby_version_is "2.6" do
-      it "is honored by Kernel#respond_to?" do
-        klass = Class.new
-        refinement = Module.new do
-          refine klass do
-            def foo; end
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          result = klass.new.respond_to?(:foo)
+    it "is honored by Kernel#public_method" do
+      klass = Class.new
+      refinement = Module.new do
+        refine klass do
+          def foo; end
         end
-
-        result.should == true
       end
-    end
 
-    ruby_version_is ""..."2.6" do
-      it "is not honored by &" do
-        refinement = Module.new do
-          refine String do
-            def to_proc(*args)
-              -> * { 'foo' }
-            end
-          end
-        end
-
-        -> do
-          Module.new do
-            using refinement
-            ["hola"].map(&"upcase")
-          end
-        end.should raise_error(TypeError, /wrong argument type String \(expected Proc\)/)
+      result = nil
+      Module.new do
+        using refinement
+        result = klass.new.public_method(:foo).class
       end
-    end
-
-    ruby_version_is "2.6" do
-      it "is honored by &" do
-        refinement = Module.new do
-          refine String do
-            def to_proc(*args)
-              -> * { 'foo' }
-            end
-          end
-        end
-
-        result = nil
-        Module.new do
-          using refinement
-          result = ["hola"].map(&"upcase")
-        end
 
-        result.should == ['foo']
-      end
+      result.should == Method
     end
-  end
-
-  context "when super is called in a refinement" do
-    it "looks in the included to refinery module" do
-      refined_class = ModuleSpecs.build_refined_class
 
+    it "is honored by Kernel#instance_method" do
+      klass = Class.new
       refinement = Module.new do
-        refine refined_class do
-          include ModuleSpecs::IncludedModule
-
-          def foo
-            super
-          end
+        refine klass do
+          def foo; end
         end
       end
 
       result = nil
       Module.new do
         using refinement
-        result = refined_class.new.foo
+        result = klass.instance_method(:foo).class
       end
 
-      result.should == "foo from included module"
+      result.should == UnboundMethod
     end
 
-    it "looks in the refined class" do
-      refined_class = ModuleSpecs.build_refined_class
-
+    it "is honored by Kernel#respond_to?" do
+      klass = Class.new
       refinement = Module.new do
-        refine refined_class do
-          def foo
-            super
-          end
+        refine klass do
+          def foo; end
         end
       end
 
       result = nil
       Module.new do
         using refinement
-        result = refined_class.new.foo
+        result = klass.new.respond_to?(:foo)
       end
 
-      result.should == "foo"
+      result.should == true
     end
 
-    it "looks in the refined class from included module" do
-      refined_class = ModuleSpecs.build_refined_class(for_super: true)
-
-      a = Module.new do
-        def foo
-          [:A] + super
-        end
-      end
-
+    it "is honored by &" do
       refinement = Module.new do
-        refine refined_class do
-          include a
+        refine String do
+          def to_proc(*args)
+            -> * { 'foo' }
+          end
         end
       end
 
       result = nil
       Module.new do
         using refinement
-
-        result = refined_class.new.foo
+        result = ["hola"].map(&"upcase")
       end
 
-      result.should == [:A, :C]
+      result.should == ['foo']
     end
+  end
 
-    it "looks in the refined ancestors from included module" do
-      refined_class = ModuleSpecs.build_refined_class(for_super: true)
-      subclass = Class.new(refined_class)
-
-      a = Module.new do
-        def foo
-          [:A] + super
-        end
-      end
+  context "when super is called in a refinement" do
+    it "looks in the refined class" do
+      refined_class = ModuleSpecs.build_refined_class
 
       refinement = Module.new do
         refine refined_class do
-          include a
+          def foo
+            super
+          end
         end
       end
 
       result = nil
       Module.new do
         using refinement
-
-        result = subclass.new.foo
+        result = refined_class.new.foo
       end
 
-      result.should == [:A, :C]
+      result.should == "foo"
     end
 
     # super in a method of a refinement invokes the method in the refined
@@ -839,179 +596,8 @@ describe "Module#refine" do
         using refinement_with_super
         -> {
           refined_class.new.bar
-        }.should raise_error(NoMethodError)
-      end
-    end
-
-    it "does't have access to active refinements for C from included module" do
-      refined_class = ModuleSpecs.build_refined_class
-
-      a = Module.new do
-        def foo
-          super + bar
-        end
-      end
-
-      refinement = Module.new do
-        refine refined_class do
-          include a
-
-          def bar
-            "bar is not seen from A methods"
-          end
-        end
-      end
-
-      Module.new do
-        using refinement
-        -> {
-          refined_class.new.foo
-        }.should raise_error(NameError) { |e| e.name.should == :bar }
-      end
-    end
-
-    it "does't have access to other active refinements from included module" do
-      refined_class = ModuleSpecs.build_refined_class
-
-      refinement_integer = Module.new do
-        refine Integer do
-          def bar
-            "bar is not seen from A methods"
-          end
-        end
+        }.should.raise(NoMethodError)
       end
-
-      a = Module.new do
-        def foo
-          super + 1.bar
-        end
-      end
-
-      refinement = Module.new do
-        refine refined_class do
-          include a
-        end
-      end
-
-      Module.new do
-        using refinement
-        using refinement_integer
-        -> {
-          refined_class.new.foo
-        }.should raise_error(NameError) { |e| e.name.should == :bar }
-      end
-    end
-
-    # https://bugs.ruby-lang.org/issues/16977
-    it "looks in the another active refinement if super called from included modules" do
-      refined_class = ModuleSpecs.build_refined_class(for_super: true)
-
-      a = Module.new do
-        def foo
-          [:A] + super
-        end
-      end
-
-      b = Module.new do
-        def foo
-          [:B] + super
-        end
-      end
-
-      refinement_a = Module.new do
-        refine refined_class do
-          include a
-        end
-      end
-
-      refinement_b = Module.new do
-        refine refined_class do
-          include b
-        end
-      end
-
-      result = nil
-      Module.new do
-        using refinement_a
-        using refinement_b
-        result = refined_class.new.foo
-      end
-
-      result.should == [:B, :A, :C]
-    end
-
-    it "looks in the current active refinement from included modules" do
-      refined_class = ModuleSpecs.build_refined_class(for_super: true)
-
-      a = Module.new do
-        def foo
-          [:A] + super
-        end
-      end
-
-      b = Module.new do
-        def foo
-          [:B] + super
-        end
-      end
-
-      refinement = Module.new do
-        refine refined_class do
-          def foo
-            [:LAST] + super
-          end
-        end
-      end
-
-      refinement_a_b = Module.new do
-        refine refined_class do
-          include a
-          include b
-        end
-      end
-
-      result = nil
-      Module.new do
-        using refinement
-        using refinement_a_b
-        result = refined_class.new.foo
-      end
-
-      result.should == [:B, :A, :LAST, :C]
-    end
-
-    it "looks in the lexical scope refinements before other active refinements" do
-      refined_class = ModuleSpecs.build_refined_class(for_super: true)
-
-      refinement_local = Module.new do
-        refine refined_class do
-          def foo
-            [:LOCAL] + super
-          end
-        end
-      end
-
-      a = Module.new do
-        using refinement_local
-
-        def foo
-          [:A] + super
-        end
-      end
-
-      refinement = Module.new do
-        refine refined_class do
-          include a
-        end
-      end
-
-      result = nil
-      Module.new do
-        using refinement
-        result = refined_class.new.foo
-      end
-
-      result.should == [:A, :LOCAL, :C]
     end
   end
 
@@ -1024,7 +610,7 @@ describe "Module#refine" do
       }
       [1,2].orig_count.should == 2
     end
-    -> { [1,2].orig_count }.should raise_error(NoMethodError)
+    -> { [1,2].orig_count }.should.raise(NoMethodError)
   end
 
   it 'and alias_method aliases a method within a refinement module, but not outside it' do
@@ -1036,7 +622,7 @@ describe "Module#refine" do
       }
       [1,2].orig_count.should == 2
     end
-    -> { [1,2].orig_count }.should raise_error(NoMethodError)
+    -> { [1,2].orig_count }.should.raise(NoMethodError)
   end
 
   it "and instance_methods returns a list of methods including those of the refined module" do
@@ -1118,11 +704,10 @@ describe "Module#refine" do
         end
       end
     end
-    spec = self
-    klass = Class.new { instance_methods.should_not spec.send(:include, :refinement_only_method) }
+    klass = Class.new { instance_methods.should_not.include?(:refinement_only_method) }
     instance = klass.new
-    instance.methods.should_not include :refinement_only_method
+    instance.methods.should_not.include? :refinement_only_method
     instance.respond_to?(:refinement_only_method).should == false
-    -> { instance.method :refinement_only_method }.should raise_error(NameError)
+    -> { instance.method :refinement_only_method }.should.raise(NameError)
   end
 end