Update to ruby/spec@875a09e

spec/ruby/core/range/bsearch_spec.rb

@@ -9,22 +9,22 @@ describe "Range#bsearch" do
   it_behaves_like :enumeratorized_with_unknown_size, :bsearch, (1..3)
 
   it "raises a TypeError if the block returns an Object" do
-    lambda { (0..1).bsearch { Object.new } }.should raise_error(TypeError)
+    -> { (0..1).bsearch { Object.new } }.should raise_error(TypeError)
   end
 
   it "raises a TypeError if the block returns a String" do
-    lambda { (0..1).bsearch { "1" } }.should raise_error(TypeError)
+    -> { (0..1).bsearch { "1" } }.should raise_error(TypeError)
   end
 
   it "raises a TypeError if the Range has Object values" do
     value = mock("range bsearch")
     r = Range.new value, value
 
-    lambda { r.bsearch { true } }.should raise_error(TypeError)
+    -> { r.bsearch { true } }.should raise_error(TypeError)
   end
 
   it "raises a TypeError if the Range has String values" do
-    lambda { ("a".."e").bsearch { true } }.should raise_error(TypeError)
+    -> { ("a".."e").bsearch { true } }.should raise_error(TypeError)
   end
 
   context "with Integer values" do

spec/ruby/core/range/case_compare_spec.rb

@@ -13,7 +13,7 @@ describe "Range#===" do
     it "requires #succ method to be implemented" do
       range = RangeSpecs::WithoutSucc.new(0)..RangeSpecs::WithoutSucc.new(10)
 
-      lambda do
+      -> do
         range === RangeSpecs::WithoutSucc.new(2)
       end.should raise_error(TypeError, /can't iterate from/)
     end

spec/ruby/core/range/each_spec.rb

@@ -33,12 +33,12 @@ describe "Range#each" do
   end
 
   it "raises a TypeError if the first element does not respond to #succ" do
-    lambda { (0.5..2.4).each { |i| i } }.should raise_error(TypeError)
+    -> { (0.5..2.4).each { |i| i } }.should raise_error(TypeError)
 
     b = mock('x')
     (a = mock('1')).should_receive(:<=>).with(b).and_return(1)
 
-    lambda { (a..b).each { |i| i } }.should raise_error(TypeError)
+    -> { (a..b).each { |i| i } }.should raise_error(TypeError)
   end
 
   it "returns self" do
@@ -54,7 +54,7 @@ describe "Range#each" do
 
   it "raises a TypeError if the first element is a Time object" do
     t = Time.now
-    lambda { (t..t+1).each { |i| i } }.should raise_error(TypeError)
+    -> { (t..t+1).each { |i| i } }.should raise_error(TypeError)
   end
 
   it "passes each Symbol element by using #succ" do

spec/ruby/core/range/first_spec.rb

@@ -21,7 +21,7 @@ describe "Range#first" do
   end
 
   it "raises an ArgumentError when count is negative" do
-    lambda { (0..2).first(-1) }.should raise_error(ArgumentError)
+    -> { (0..2).first(-1) }.should raise_error(ArgumentError)
   end
 
   it "calls #to_int to convert the argument" do
@@ -32,7 +32,7 @@ describe "Range#first" do
   it "raises a TypeError if #to_int does not return an Integer" do
     obj = mock("to_int")
     obj.should_receive(:to_int).and_return("1")
-    lambda { (2..3).first(obj) }.should raise_error(TypeError)
+    -> { (2..3).first(obj) }.should raise_error(TypeError)
   end
 
   it "truncates the value when passed a Float" do
@@ -40,10 +40,10 @@ describe "Range#first" do
   end
 
   it "raises a TypeError when passed nil" do
-    lambda { (2..3).first(nil) }.should raise_error(TypeError)
+    -> { (2..3).first(nil) }.should raise_error(TypeError)
   end
 
   it "raises a TypeError when passed a String" do
-    lambda { (2..3).first("1") }.should raise_error(TypeError)
+    -> { (2..3).first("1") }.should raise_error(TypeError)
   end
 end

spec/ruby/core/range/initialize_spec.rb

@@ -10,32 +10,32 @@ describe "Range#initialize" do
   end
 
   it "initializes correctly the Range object when given 2 arguments" do
-    lambda { @range.send(:initialize, 0, 1) }.should_not raise_error
+    -> { @range.send(:initialize, 0, 1) }.should_not raise_error
   end
 
   it "initializes correctly the Range object when given 3 arguments" do
-    lambda { @range.send(:initialize, 0, 1, true) }.should_not raise_error
+    -> { @range.send(:initialize, 0, 1, true) }.should_not raise_error
   end
 
   it "raises an ArgumentError if passed without or with only one argument" do
-    lambda { @range.send(:initialize) }.should raise_error(ArgumentError)
-    lambda { @range.send(:initialize, 1) }.should raise_error(ArgumentError)
+    -> { @range.send(:initialize) }.should raise_error(ArgumentError)
+    -> { @range.send(:initialize, 1) }.should raise_error(ArgumentError)
   end
 
   it "raises an ArgumentError if passed with four or more arguments" do
-    lambda { @range.send(:initialize, 1, 3, 5, 7) }.should raise_error(ArgumentError)
-    lambda { @range.send(:initialize, 1, 3, 5, 7, 9) }.should raise_error(ArgumentError)
+    -> { @range.send(:initialize, 1, 3, 5, 7) }.should raise_error(ArgumentError)
+    -> { @range.send(:initialize, 1, 3, 5, 7, 9) }.should raise_error(ArgumentError)
   end
 
   it "raises a NameError if called on an already initialized Range" do
-    lambda { (0..1).send(:initialize, 1, 3) }.should raise_error(NameError)
-    lambda { (0..1).send(:initialize, 1, 3, true) }.should raise_error(NameError)
+    -> { (0..1).send(:initialize, 1, 3) }.should raise_error(NameError)
+    -> { (0..1).send(:initialize, 1, 3, true) }.should raise_error(NameError)
   end
 
   it "raises an ArgumentError if arguments don't respond to <=>" do
     o1 = Object.new
     o2 = Object.new
 
-    lambda { @range.send(:initialize, o1, o2) }.should raise_error(ArgumentError)
+    -> { @range.send(:initialize, o1, o2) }.should raise_error(ArgumentError)
   end
 end

spec/ruby/core/range/last_spec.rb

@@ -21,7 +21,7 @@ describe "Range#last" do
   end
 
   it "raises an ArgumentError when count is negative" do
-    lambda { (0..2).last(-1) }.should raise_error(ArgumentError)
+    -> { (0..2).last(-1) }.should raise_error(ArgumentError)
   end
 
   it "calls #to_int to convert the argument" do
@@ -32,7 +32,7 @@ describe "Range#last" do
   it "raises a TypeError if #to_int does not return an Integer" do
     obj = mock("to_int")
     obj.should_receive(:to_int).and_return("1")
-    lambda { (2..3).last(obj) }.should raise_error(TypeError)
+    -> { (2..3).last(obj) }.should raise_error(TypeError)
   end
 
   it "truncates the value when passed a Float" do
@@ -40,10 +40,10 @@ describe "Range#last" do
   end
 
   it "raises a TypeError when passed nil" do
-    lambda { (2..3).last(nil) }.should raise_error(TypeError)
+    -> { (2..3).last(nil) }.should raise_error(TypeError)
   end
 
   it "raises a TypeError when passed a String" do
-    lambda { (2..3).last("1") }.should raise_error(TypeError)
+    -> { (2..3).last("1") }.should raise_error(TypeError)
   end
 end

spec/ruby/core/range/max_spec.rb

@@ -14,7 +14,7 @@ describe "Range#max" do
   end
 
   it "raises TypeError when called on an exclusive range and a non Integer value" do
-    lambda { (303.20...908.1111).max }.should raise_error(TypeError)
+    -> { (303.20...908.1111).max }.should raise_error(TypeError)
   end
 
   it "returns nil when the endpoint is less than the start point" do
@@ -43,7 +43,7 @@ describe "Range#max" do
   it "raises TypeError when called on a Time...Time(excluded end point)" do
     time_start = Time.now
     time_end = Time.now + 1.0
-    lambda { (time_start...time_end).max  }.should raise_error(TypeError)
+    -> { (time_start...time_end).max  }.should raise_error(TypeError)
   end
 end
 

spec/ruby/core/range/new_spec.rb

@@ -25,12 +25,12 @@ describe "Range.new" do
   end
 
   it "raises an ArgumentError when the given start and end can't be compared by using #<=>" do
-    lambda { Range.new(1, mock('x'))         }.should raise_error(ArgumentError)
-    lambda { Range.new(mock('x'), mock('y')) }.should raise_error(ArgumentError)
+    -> { Range.new(1, mock('x'))         }.should raise_error(ArgumentError)
+    -> { Range.new(mock('x'), mock('y')) }.should raise_error(ArgumentError)
 
     b = mock('x')
     (a = mock('nil')).should_receive(:<=>).with(b).and_return(nil)
-    lambda { Range.new(a, b) }.should raise_error(ArgumentError)
+    -> { Range.new(a, b) }.should raise_error(ArgumentError)
   end
 
   ruby_version_is "2.5" do

spec/ruby/core/range/shared/cover_and_include.rb

@@ -29,8 +29,8 @@ describe :range_cover_and_include, shared: true do
   end
 
   it "raises an ArgumentError without exactly one argument" do
-    lambda{ (1..2).send(@method) }.should raise_error(ArgumentError)
-    lambda{ (1..2).send(@method, 1, 2) }.should raise_error(ArgumentError)
+    ->{ (1..2).send(@method) }.should raise_error(ArgumentError)
+    ->{ (1..2).send(@method, 1, 2) }.should raise_error(ArgumentError)
   end
 
   it "returns true if argument is equal to the first value of the range" do

spec/ruby/core/range/step_spec.rb

@@ -12,7 +12,7 @@ describe "Range#step" do
 
   it "raises TypeError if step" do
     obj = mock("mock")
-    lambda { (1..10).step(obj) { } }.should raise_error(TypeError)
+    -> { (1..10).step(obj) { } }.should raise_error(TypeError)
   end
 
   it "calls #to_int to coerce step to an Integer" do
@@ -26,14 +26,14 @@ describe "Range#step" do
   it "raises a TypeError if step does not respond to #to_int" do
     obj = mock("Range#step non-integer")
 
-    lambda { (1..2).step(obj) { } }.should raise_error(TypeError)
+    -> { (1..2).step(obj) { } }.should raise_error(TypeError)
   end
 
   it "raises a TypeError if #to_int does not return an Integer" do
     obj = mock("Range#step non-integer")
     obj.should_receive(:to_int).and_return("1")
 
-    lambda { (1..2).step(obj) { } }.should raise_error(TypeError)
+    -> { (1..2).step(obj) { } }.should raise_error(TypeError)
   end
 
   it "coerces the argument to integer by invoking to_int" do
@@ -47,19 +47,19 @@ describe "Range#step" do
     obj = mock("Range#step non-comparable")
     obj.should_receive(:<=>).with(obj).and_return(1)
 
-    lambda { (obj..obj).step { |x| x } }.should raise_error(TypeError)
+    -> { (obj..obj).step { |x| x } }.should raise_error(TypeError)
   end
 
   it "raises an ArgumentError if step is 0" do
-    lambda { (-1..1).step(0) { |x| x } }.should raise_error(ArgumentError)
+    -> { (-1..1).step(0) { |x| x } }.should raise_error(ArgumentError)
   end
 
   it "raises an ArgumentError if step is 0.0" do
-    lambda { (-1..1).step(0.0) { |x| x } }.should raise_error(ArgumentError)
+    -> { (-1..1).step(0.0) { |x| x } }.should raise_error(ArgumentError)
   end
 
   it "raises an ArgumentError if step is negative" do
-    lambda { (-1..1).step(-2) { |x| x } }.should raise_error(ArgumentError)
+    -> { (-1..1).step(-2) { |x| x } }.should raise_error(ArgumentError)
   end
 
   describe "with inclusive end" do
@@ -159,7 +159,7 @@ describe "Range#step" do
       end
 
       it "raises a TypeError when passed a Float step" do
-        lambda { ("A".."G").step(2.0) { } }.should raise_error(TypeError)
+        -> { ("A".."G").step(2.0) { } }.should raise_error(TypeError)
       end
 
       it "calls #succ on begin and each element returned by #succ" do
@@ -269,7 +269,7 @@ describe "Range#step" do
       end
 
       it "raises a TypeError when passed a Float step" do
-        lambda { ("A"..."G").step(2.0) { } }.should raise_error(TypeError)
+        -> { ("A"..."G").step(2.0) { } }.should raise_error(TypeError)
       end
     end
   end
@@ -280,7 +280,7 @@ describe "Range#step" do
         it "raises a TypeError if step does not respond to #to_int" do
           obj = mock("Range#step non-integer")
           enum = (1..2).step(obj)
-          lambda { enum.size }.should raise_error(TypeError)
+          -> { enum.size }.should raise_error(TypeError)
         end
 
         it "raises a TypeError if #to_int does not return an Integer" do
@@ -288,23 +288,23 @@ describe "Range#step" do
           obj.should_receive(:to_int).and_return("1")
           enum = (1..2).step(obj)
 
-          lambda { enum.size }.should raise_error(TypeError)
+          -> { enum.size }.should raise_error(TypeError)
         end
 
         ruby_version_is ""..."2.6" do
           it "raises an ArgumentError if step is 0" do
             enum = (-1..1).step(0)
-            lambda { enum.size }.should raise_error(ArgumentError)
+            -> { enum.size }.should raise_error(ArgumentError)
           end
 
           it "raises an ArgumentError if step is 0.0" do
             enum = (-1..1).step(0.0)
-            lambda { enum.size }.should raise_error(ArgumentError)
+            -> { enum.size }.should raise_error(ArgumentError)
           end
 
           it "raises an ArgumentError if step is negative" do
             enum = (-1..1).step(-2)
-            lambda {  enum.size }.should raise_error(ArgumentError)
+            -> {  enum.size }.should raise_error(ArgumentError)
           end
         end
 
@@ -366,7 +366,7 @@ describe "Range#step" do
           obj = mock("Range#step non-comparable")
           obj.should_receive(:<=>).with(obj).and_return(1)
           enum = (obj..obj).step
-          lambda { enum.size }.should_not raise_error
+          -> { enum.size }.should_not raise_error
           enum.size.should == nil
         end
       end

spec/ruby/core/range/to_a_spec.rb

@@ -6,7 +6,7 @@ describe "Range#to_a" do
     ('A'..'D').to_a.should == ['A','B','C','D']
     ('A'...'D').to_a.should == ['A','B','C']
     (0xfffd...0xffff).to_a.should == [0xfffd,0xfffe]
-    lambda { (0.5..2.4).to_a }.should raise_error(TypeError)
+    -> { (0.5..2.4).to_a }.should raise_error(TypeError)
   end
 
   it "returns empty array for descending-ordered" do