1 files changed, 66 insertions, 68 deletions
diff --git a/spec/ruby/core/method/compose_spec.rb b/spec/ruby/core/method/compose_spec.rb
index 0743dd4f8d..87cf61f7ad 100644
--- a/spec/ruby/core/method/compose_spec.rb
+++ b/spec/ruby/core/method/compose_spec.rb
@@ -2,101 +2,99 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 require_relative '../proc/shared/compose'
 
-ruby_version_is "2.6" do
-  describe "Method#<<" do
-    it "returns a Proc that is the composition of self and the passed Proc" do
-      succ = MethodSpecs::Composition.new.method(:succ)
-      upcase = proc { |s| s.upcase }
+describe "Method#<<" do
+  it "returns a Proc that is the composition of self and the passed Proc" do
+    succ = MethodSpecs::Composition.new.method(:succ)
+    upcase = proc { |s| s.upcase }
 
-      (succ << upcase).call('Ruby').should == "RUBZ"
-    end
+    (succ << upcase).call('Ruby').should == "RUBZ"
+  end
 
-    it "calls passed Proc with arguments and then calls self with result" do
-      pow_2_proc = proc { |x| x * x }
-      double_proc = proc { |x| x + x }
+  it "calls passed Proc with arguments and then calls self with result" do
+    pow_2_proc = proc { |x| x * x }
+    double_proc = proc { |x| x + x }
 
-      pow_2_method = MethodSpecs::Composition.new.method(:pow_2)
-      double_method = MethodSpecs::Composition.new.method(:double)
+    pow_2_method = MethodSpecs::Composition.new.method(:pow_2)
+    double_method = MethodSpecs::Composition.new.method(:double)
 
-      (pow_2_method << double_proc).call(2).should == 16
-      (double_method << pow_2_proc).call(2).should == 8
-    end
+    (pow_2_method << double_proc).call(2).should == 16
+    (double_method << pow_2_proc).call(2).should == 8
+  end
 
-    it "accepts any callable object" do
-      inc = MethodSpecs::Composition.new.method(:inc)
+  it "accepts any callable object" do
+    inc = MethodSpecs::Composition.new.method(:inc)
 
-      double = Object.new
-      def double.call(n); n * 2; end
+    double = Object.new
+    def double.call(n); n * 2; end
 
-      (inc << double).call(3).should == 7
-    end
+    (inc << double).call(3).should == 7
+  end
 
-    it_behaves_like :proc_compose, :<<, -> { MethodSpecs::Composition.new.method(:upcase) }
+  it_behaves_like :proc_compose, :<<, -> { MethodSpecs::Composition.new.method(:upcase) }
 
-    describe "composition" do
-      it "is a lambda" do
-        pow_2 = MethodSpecs::Composition.new.method(:pow_2)
-        double = proc { |x| x + x }
+  describe "composition" do
+    it "is a lambda" do
+      pow_2 = MethodSpecs::Composition.new.method(:pow_2)
+      double = proc { |x| x + x }
 
-        (pow_2 << double).is_a?(Proc).should == true
-        ruby_version_is(''...'3.0') { (pow_2 << double).should.lambda? }
-        ruby_version_is('3.0') { (pow_2 << double).should_not.lambda? }
-      end
+      (pow_2 << double).is_a?(Proc).should == true
+      ruby_version_is(''...'3.0') { (pow_2 << double).should.lambda? }
+      ruby_version_is('3.0') { (pow_2 << double).should_not.lambda? }
+    end
 
-      it "may accept multiple arguments" do
-        inc = MethodSpecs::Composition.new.method(:inc)
-        mul = proc { |n, m| n * m }
+    it "may accept multiple arguments" do
+      inc = MethodSpecs::Composition.new.method(:inc)
+      mul = proc { |n, m| n * m }
 
-        (inc << mul).call(2, 3).should == 7
-      end
+      (inc << mul).call(2, 3).should == 7
     end
   end
+end
 
-  describe "Method#>>" do
-    it "returns a Proc that is the composition of self and the passed Proc" do
-      upcase = proc { |s| s.upcase }
-      succ = MethodSpecs::Composition.new.method(:succ)
+describe "Method#>>" do
+  it "returns a Proc that is the composition of self and the passed Proc" do
+    upcase = proc { |s| s.upcase }
+    succ = MethodSpecs::Composition.new.method(:succ)
 
-      (succ >> upcase).call('Ruby').should == "RUBZ"
-    end
+    (succ >> upcase).call('Ruby').should == "RUBZ"
+  end
 
-    it "calls passed Proc with arguments and then calls self with result" do
-      pow_2_proc = proc { |x| x * x }
-      double_proc = proc { |x| x + x }
+  it "calls passed Proc with arguments and then calls self with result" do
+    pow_2_proc = proc { |x| x * x }
+    double_proc = proc { |x| x + x }
 
-      pow_2_method = MethodSpecs::Composition.new.method(:pow_2)
-      double_method = MethodSpecs::Composition.new.method(:double)
+    pow_2_method = MethodSpecs::Composition.new.method(:pow_2)
+    double_method = MethodSpecs::Composition.new.method(:double)
 
-      (pow_2_method >> double_proc).call(2).should == 8
-      (double_method >> pow_2_proc).call(2).should == 16
-    end
+    (pow_2_method >> double_proc).call(2).should == 8
+    (double_method >> pow_2_proc).call(2).should == 16
+  end
 
-    it "accepts any callable object" do
-      inc = MethodSpecs::Composition.new.method(:inc)
+  it "accepts any callable object" do
+    inc = MethodSpecs::Composition.new.method(:inc)
 
-      double = Object.new
-      def double.call(n); n * 2; end
+    double = Object.new
+    def double.call(n); n * 2; end
 
-      (inc >> double).call(3).should == 8
-    end
+    (inc >> double).call(3).should == 8
+  end
 
-    it_behaves_like :proc_compose, :>>, -> { MethodSpecs::Composition.new.method(:upcase) }
+  it_behaves_like :proc_compose, :>>, -> { MethodSpecs::Composition.new.method(:upcase) }
 
-    describe "composition" do
-      it "is a lambda" do
-        pow_2 = MethodSpecs::Composition.new.method(:pow_2)
-        double = proc { |x| x + x }
+  describe "composition" do
+    it "is a lambda" do
+      pow_2 = MethodSpecs::Composition.new.method(:pow_2)
+      double = proc { |x| x + x }
 
-        (pow_2 >> double).is_a?(Proc).should == true
-        (pow_2 >> double).should.lambda?
-      end
+      (pow_2 >> double).is_a?(Proc).should == true
+      (pow_2 >> double).should.lambda?
+    end
 
-      it "may accept multiple arguments" do
-        mul = MethodSpecs::Composition.new.method(:mul)
-        inc = proc { |n| n + 1 }
+    it "may accept multiple arguments" do
+      mul = MethodSpecs::Composition.new.method(:mul)
+      inc = proc { |n| n + 1 }
 
-        (mul >> inc).call(2, 3).should == 7
-      end
+      (mul >> inc).call(2, 3).should == 7
     end
   end
 end