Update to ruby/spec@875a09e

spec/ruby/core/numeric/coerce_spec.rb

@@ -25,7 +25,7 @@ describe "Numeric#coerce" do
       class << a; true; end
 
       # watch it explode
-      lambda { a.coerce(b) }.should raise_error(TypeError)
+      -> { a.coerce(b) }.should raise_error(TypeError)
     end
   end
 
@@ -38,22 +38,22 @@ describe "Numeric#coerce" do
 
   it "raise TypeError if they are instances of different classes and other does not respond to #to_f" do
     other = mock("numeric")
-    lambda { @obj.coerce(other)   }.should raise_error(TypeError)
+    -> { @obj.coerce(other)   }.should raise_error(TypeError)
   end
 
   it "raises a TypeError when passed nil" do
-    lambda { @obj.coerce(nil)     }.should raise_error(TypeError)
+    -> { @obj.coerce(nil)     }.should raise_error(TypeError)
   end
 
   it "raises a TypeError when passed a boolean" do
-    lambda { @obj.coerce(false)   }.should raise_error(TypeError)
+    -> { @obj.coerce(false)   }.should raise_error(TypeError)
   end
 
   it "raises a TypeError when passed a Symbol" do
-    lambda { @obj.coerce(:symbol) }.should raise_error(TypeError)
+    -> { @obj.coerce(:symbol) }.should raise_error(TypeError)
   end
 
   it "raises an ArgumentError when passed a non-numeric String" do
-    lambda { @obj.coerce("test")  }.should raise_error(ArgumentError)
+    -> { @obj.coerce("test")  }.should raise_error(ArgumentError)
   end
 end

spec/ruby/core/numeric/div_spec.rb

@@ -15,8 +15,8 @@ describe "Numeric#div" do
   end
 
   it "raises ZeroDivisionError for 0" do
-    lambda { @obj.div(0) }.should raise_error(ZeroDivisionError)
-    lambda { @obj.div(0.0) }.should raise_error(ZeroDivisionError)
-    lambda { @obj.div(Complex(0,0)) }.should raise_error(ZeroDivisionError)
+    -> { @obj.div(0) }.should raise_error(ZeroDivisionError)
+    -> { @obj.div(0.0) }.should raise_error(ZeroDivisionError)
+    -> { @obj.div(Complex(0,0)) }.should raise_error(ZeroDivisionError)
   end
 end

spec/ruby/core/numeric/quo_spec.rb

@@ -16,11 +16,11 @@ describe "Numeric#quo" do
   end
 
   it "raises a ZeroDivisionError when the given Integer is 0" do
-    lambda { 0.quo(0) }.should raise_error(ZeroDivisionError)
-    lambda { 10.quo(0) }.should raise_error(ZeroDivisionError)
-    lambda { -10.quo(0) }.should raise_error(ZeroDivisionError)
-    lambda { bignum_value.quo(0) }.should raise_error(ZeroDivisionError)
-    lambda { -bignum_value.quo(0) }.should raise_error(ZeroDivisionError)
+    -> { 0.quo(0) }.should raise_error(ZeroDivisionError)
+    -> { 10.quo(0) }.should raise_error(ZeroDivisionError)
+    -> { -10.quo(0) }.should raise_error(ZeroDivisionError)
+    -> { bignum_value.quo(0) }.should raise_error(ZeroDivisionError)
+    -> { -bignum_value.quo(0) }.should raise_error(ZeroDivisionError)
   end
 
   it "calls #to_r to convert the object to a Rational" do
@@ -34,16 +34,16 @@ describe "Numeric#quo" do
     obj = NumericSpecs::Subclass.new
     obj.should_receive(:to_r).and_return(1)
 
-    lambda { obj.quo(19) }.should raise_error(TypeError)
+    -> { obj.quo(19) }.should raise_error(TypeError)
   end
 
   it "raises a TypeError when given a non-Integer" do
-    lambda {
+    -> {
       (obj = mock('x')).should_not_receive(:to_int)
       13.quo(obj)
     }.should raise_error(TypeError)
-    lambda { 13.quo("10")    }.should raise_error(TypeError)
-    lambda { 13.quo(:symbol) }.should raise_error(TypeError)
+    -> { 13.quo("10")    }.should raise_error(TypeError)
+    -> { 13.quo(:symbol) }.should raise_error(TypeError)
   end
 
   it "returns the result of calling self#/ with other" do

spec/ruby/core/numeric/real_spec.rb

@@ -25,7 +25,7 @@ describe "Numeric#real" do
 
   it "raises an ArgumentError if given any arguments" do
     @numbers.each do |number|
-      lambda { number.real(number) }.should raise_error(ArgumentError)
+      -> { number.real(number) }.should raise_error(ArgumentError)
     end
   end
 end

spec/ruby/core/numeric/shared/imag.rb

@@ -20,7 +20,7 @@ describe :numeric_imag, shared: true do
 
   it "raises an ArgumentError if given any arguments" do
    @numbers.each do |number|
-     lambda { number.send(@method, number) }.should raise_error(ArgumentError)
+     -> { number.send(@method, number) }.should raise_error(ArgumentError)
    end
   end
 end

spec/ruby/core/numeric/shared/rect.rb

@@ -42,7 +42,7 @@ describe :numeric_rect, shared: true do
 
   it "raises an ArgumentError if given any arguments" do
    @numbers.each do |number|
-     lambda { number.send(@method, number) }.should raise_error(ArgumentError)
+     -> { number.send(@method, number) }.should raise_error(ArgumentError)
    end
   end
 end

spec/ruby/core/numeric/shared/step.rb

@@ -8,7 +8,7 @@ require_relative '../fixtures/classes'
 describe :numeric_step, :shared => true do
   before :each do
     ScratchPad.record []
-    @prc = lambda { |x| ScratchPad << x }
+    @prc = -> x { ScratchPad << x }
   end
 
   it "defaults to step = 1" do
@@ -233,33 +233,33 @@ describe :numeric_step, :shared => true do
 
     describe "with self and stop as Fixnums" do
       it "raises an #{error} when step is a numeric representation" do
-        lambda { 1.send(@method, *@step_args.call(5, "1")) {} }.should raise_error(error)
-        lambda { 1.send(@method, *@step_args.call(5, "0.1")) {} }.should raise_error(error)
-        lambda { 1.send(@method, *@step_args.call(5, "1/3")) {} }.should raise_error(error)
+        -> { 1.send(@method, *@step_args.call(5, "1")) {} }.should raise_error(error)
+        -> { 1.send(@method, *@step_args.call(5, "0.1")) {} }.should raise_error(error)
+        -> { 1.send(@method, *@step_args.call(5, "1/3")) {} }.should raise_error(error)
       end
       it "raises an #{error} with step as an alphanumeric string" do
-        lambda { 1.send(@method, *@step_args.call(5, "foo")) {} }.should raise_error(error)
+        -> { 1.send(@method, *@step_args.call(5, "foo")) {} }.should raise_error(error)
       end
     end
 
     describe "with self and stop as Floats" do
       it "raises an #{error} when step is a numeric representation" do
-        lambda { 1.1.send(@method, *@step_args.call(5.1, "1")) {} }.should raise_error(error)
-        lambda { 1.1.send(@method, *@step_args.call(5.1, "0.1")) {} }.should raise_error(error)
-        lambda { 1.1.send(@method, *@step_args.call(5.1, "1/3")) {} }.should raise_error(error)
+        -> { 1.1.send(@method, *@step_args.call(5.1, "1")) {} }.should raise_error(error)
+        -> { 1.1.send(@method, *@step_args.call(5.1, "0.1")) {} }.should raise_error(error)
+        -> { 1.1.send(@method, *@step_args.call(5.1, "1/3")) {} }.should raise_error(error)
       end
       it "raises an #{error} with step as an alphanumeric string" do
-        lambda { 1.1.send(@method, *@step_args.call(5.1, "foo")) {} }.should raise_error(error)
+        -> { 1.1.send(@method, *@step_args.call(5.1, "foo")) {} }.should raise_error(error)
       end
     end
   end
 
   it "does not rescue ArgumentError exceptions" do
-    lambda { 1.send(@method, *@step_args.call(2)) { raise ArgumentError, "" }}.should raise_error(ArgumentError)
+    -> { 1.send(@method, *@step_args.call(2)) { raise ArgumentError, "" }}.should raise_error(ArgumentError)
   end
 
   it "does not rescue TypeError exceptions" do
-    lambda { 1.send(@method, *@step_args.call(2)) { raise TypeError, "" } }.should raise_error(TypeError)
+    -> { 1.send(@method, *@step_args.call(2)) { raise TypeError, "" } }.should raise_error(TypeError)
   end
 
   describe "when no block is given" do
@@ -311,23 +311,23 @@ describe :numeric_step, :shared => true do
 
           describe "with self and stop as Fixnums" do
             it "raises an #{error} when step is a numeric representation" do
-              lambda { 1.send(@method, *@step_args.call(5, "1")).size }.should raise_error(error)
-              lambda { 1.send(@method, *@step_args.call(5, "0.1")).size }.should raise_error(error)
-              lambda { 1.send(@method, *@step_args.call(5, "1/3")).size }.should raise_error(error)
+              -> { 1.send(@method, *@step_args.call(5, "1")).size }.should raise_error(error)
+              -> { 1.send(@method, *@step_args.call(5, "0.1")).size }.should raise_error(error)
+              -> { 1.send(@method, *@step_args.call(5, "1/3")).size }.should raise_error(error)
             end
             it "raises an #{error} with step as an alphanumeric string" do
-              lambda { 1.send(@method, *@step_args.call(5, "foo")).size }.should raise_error(error)
+              -> { 1.send(@method, *@step_args.call(5, "foo")).size }.should raise_error(error)
             end
           end
 
           describe "with self and stop as Floats" do
             it "raises an #{error} when step is a numeric representation" do
-              lambda { 1.1.send(@method, *@step_args.call(5.1, "1")).size }.should raise_error(error)
-              lambda { 1.1.send(@method, *@step_args.call(5.1, "0.1")).size }.should raise_error(error)
-              lambda { 1.1.send(@method, *@step_args.call(5.1, "1/3")).size }.should raise_error(error)
+              -> { 1.1.send(@method, *@step_args.call(5.1, "1")).size }.should raise_error(error)
+              -> { 1.1.send(@method, *@step_args.call(5.1, "0.1")).size }.should raise_error(error)
+              -> { 1.1.send(@method, *@step_args.call(5.1, "1/3")).size }.should raise_error(error)
             end
             it "raises an #{error} with step as an alphanumeric string" do
-              lambda { 1.1.send(@method, *@step_args.call(5.1, "foo")).size }.should raise_error(error)
+              -> { 1.1.send(@method, *@step_args.call(5.1, "foo")).size }.should raise_error(error)
             end
           end
         end

spec/ruby/core/numeric/singleton_method_added_spec.rb

@@ -18,22 +18,22 @@ describe "Numeric#singleton_method_added" do
   end
 
   it "raises a TypeError when trying to define a singleton method on a Numeric" do
-    lambda do
+    -> do
       a = NumericSpecs::Subclass.new
       def a.test; end
     end.should raise_error(TypeError)
 
-    lambda do
+    -> do
       a = 1
       def a.test; end
     end.should raise_error(TypeError)
 
-    lambda do
+    -> do
       a = 1.5
       def a.test; end
     end.should raise_error(TypeError)
 
-    lambda do
+    -> do
       a = bignum_value
       def a.test; end
     end.should raise_error(TypeError)

spec/ruby/core/numeric/step_spec.rb

@@ -6,17 +6,17 @@ describe "Numeric#step" do
 
   describe 'with positional args' do
     it "raises an ArgumentError when step is 0" do
-      lambda { 1.step(5, 0) {} }.should raise_error(ArgumentError)
+      -> { 1.step(5, 0) {} }.should raise_error(ArgumentError)
     end
 
     it "raises an ArgumentError when step is 0.0" do
-      lambda { 1.step(2, 0.0) {} }.should raise_error(ArgumentError)
+      -> { 1.step(2, 0.0) {} }.should raise_error(ArgumentError)
     end
 
     before :all do
       # This lambda definition limits to return the arguments it receives.
       # It's needed to test numeric_step behaviour with positional arguments.
-      @step_args = ->(*args) { args }
+      @step_args = -> *args { args }
     end
 
     it_behaves_like :numeric_step, :step
@@ -40,12 +40,12 @@ describe "Numeric#step" do
           ruby_version_is ""..."2.6" do
             it "raises an ArgumentError when step is 0" do
               enum = 1.step(5, 0)
-              lambda { enum.size }.should raise_error(ArgumentError)
+              -> { enum.size }.should raise_error(ArgumentError)
             end
 
             it "raises an ArgumentError when step is 0.0" do
               enum = 1.step(2, 0.0)
-              lambda { enum.size }.should raise_error(ArgumentError)
+              -> { enum.size }.should raise_error(ArgumentError)
             end
           end
 
@@ -87,11 +87,11 @@ describe "Numeric#step" do
 
   describe 'with keyword arguments' do
     it "doesn't raise an error when step is 0" do
-      lambda { 1.step(to: 5, by: 0) { break } }.should_not raise_error
+      -> { 1.step(to: 5, by: 0) { break } }.should_not raise_error
     end
 
     it "doesn't raise an error when step is 0.0" do
-      lambda { 1.step(to: 2, by: 0.0) { break } }.should_not raise_error
+      -> { 1.step(to: 2, by: 0.0) { break } }.should_not raise_error
     end
 
     it "should loop over self when step is 0 or 0.0" do
@@ -138,7 +138,7 @@ describe "Numeric#step" do
       # This lambda transforms a positional step method args into
       # keyword arguments.
       # It's needed to test numeric_step behaviour with keyword arguments.
-      @step_args = ->(*args) do
+      @step_args = -> *args do
         kw_args = {to: args[0]}
         kw_args[:by] = args[1] if args.size == 2
         [kw_args]
@@ -149,19 +149,19 @@ describe "Numeric#step" do
 
   describe 'with mixed arguments' do
     it "doesn't raise an error when step is 0" do
-      lambda { 1.step(5, by: 0) { break } }.should_not raise_error
+      -> { 1.step(5, by: 0) { break } }.should_not raise_error
     end
 
     it "doesn't raise an error when step is 0.0" do
-      lambda { 1.step(2, by: 0.0) { break } }.should_not raise_error
+      -> { 1.step(2, by: 0.0) { break } }.should_not raise_error
     end
 
     it "raises a ArgumentError when limit and to are defined" do
-      lambda { 1.step(5, 1, to: 5) { break } }.should raise_error(ArgumentError)
+      -> { 1.step(5, 1, to: 5) { break } }.should raise_error(ArgumentError)
     end
 
     it "raises a ArgumentError when step and by are defined" do
-      lambda { 1.step(5, 1, by: 5) { break } }.should raise_error(ArgumentError)
+      -> { 1.step(5, 1, by: 5) { break } }.should raise_error(ArgumentError)
     end
 
     it "should loop over self when step is 0 or 0.0" do
@@ -188,7 +188,7 @@ describe "Numeric#step" do
       # a mix of positional and keyword arguments.
       # It's needed to test numeric_step behaviour with positional mixed with
       # keyword arguments.
-      @step_args = ->(*args) do
+      @step_args = -> *args do
         if args.size == 2
           [args[0], {by: args[1]}]
         else