Prefer literal -> lambdas over Kernel#lambda

* I'll take care of fixing the style for new specs.

Author: eregon

.rubocop.yml

@@ -100,3 +100,18 @@ Lint/UriRegexp:
 Lint/Debugger:
   Exclude:
     - 'core/binding/fixtures/irb.rb'
+
+Style/Lambda:
+  Enabled: true
+  EnforcedStyle: literal
+  Exclude:
+    - 'language/lambda_spec.rb'
+    - 'language/proc_spec.rb'
+    - 'core/kernel/lambda_spec.rb'
+
+Style/EmptyLambdaParameter:
+  Enabled: true
+
+Style/StabbyLambdaParentheses:
+  Enabled: true
+  EnforcedStyle: require_no_parentheses

core/argf/close_spec.rb

@@ -22,8 +22,8 @@
 
   it "doesn't raise an IOError if called on a closed stream" do
     argf [@file1_name] do
-      lambda { @argf.close }.should_not raise_error
-      lambda { @argf.close }.should_not raise_error
+      -> { @argf.close }.should_not raise_error
+      -> { @argf.close }.should_not raise_error
     end
   end
 end

core/argf/read_nonblock_spec.rb

@@ -64,7 +64,7 @@
 
       it 'raises IO::EAGAINWaitReadable when empty' do
         argf ['-'] do
-          lambda {
+          -> {
             @argf.read_nonblock(4)
           }.should raise_error(IO::EAGAINWaitReadable)
         end

core/argf/readchar_spec.rb

@@ -13,7 +13,7 @@
 
   it "raises EOFError when end of stream reached" do
     argf [@file1, @file2] do
-      lambda { while @argf.readchar; end }.should raise_error(EOFError)
+      -> { while @argf.readchar; end }.should raise_error(EOFError)
     end
   end
 end

core/argf/readline_spec.rb

@@ -17,7 +17,7 @@
 
   it "raises an EOFError when reaching end of files" do
     argf [@file1, @file2] do
-      lambda { while @argf.readline; end }.should raise_error(EOFError)
+      -> { while @argf.readline; end }.should raise_error(EOFError)
     end
   end
 end

core/argf/readpartial_spec.rb

@@ -16,7 +16,7 @@
 
   it "raises an ArgumentError if called without a maximum read length" do
     argf [@file1_name] do
-      lambda { @argf.readpartial }.should raise_error(ArgumentError)
+      -> { @argf.readpartial }.should raise_error(ArgumentError)
     end
   end
 
@@ -59,8 +59,8 @@
       @argf.readpartial(@file1.size)
       @argf.readpartial(1)
       @argf.readpartial(@file2.size)
-      lambda { @argf.readpartial(1) }.should raise_error(EOFError)
-      lambda { @argf.readpartial(1) }.should raise_error(EOFError)
+      -> { @argf.readpartial(1) }.should raise_error(EOFError)
+      -> { @argf.readpartial(1) }.should raise_error(EOFError)
     end
   end
 

core/argf/rewind_spec.rb

@@ -33,7 +33,7 @@
   it "raises an ArgumentError when end of stream reached" do
     argf [@file1_name, @file2_name] do
       @argf.read
-      lambda { @argf.rewind }.should raise_error(ArgumentError)
+      -> { @argf.rewind }.should raise_error(ArgumentError)
     end
   end
 end

core/argf/seek_spec.rb

@@ -57,7 +57,7 @@
 
   it "takes at least one argument (offset)" do
     argf [@file1_name] do
-      lambda { @argf.seek }.should raise_error(ArgumentError)
+      -> { @argf.seek }.should raise_error(ArgumentError)
     end
   end
 end

core/argf/shared/eof.rb

@@ -18,7 +18,7 @@
   it "raises IOError when called on a closed stream" do
     argf [@file1] do
       @argf.read
-      lambda { @argf.send(@method) }.should raise_error(IOError)
+      -> { @argf.send(@method) }.should raise_error(IOError)
     end
   end
 end

core/argf/shared/fileno.rb

@@ -18,7 +18,7 @@
   it "raises an ArgumentError when called on a closed stream" do
     argf [@file1] do
       @argf.read
-      lambda { @argf.send(@method) }.should raise_error(ArgumentError)
+      -> { @argf.send(@method) }.should raise_error(ArgumentError)
     end
   end
 end

core/argf/shared/pos.rb

@@ -25,7 +25,7 @@
   it "raises an ArgumentError when called on a closed stream" do
     argf [@file1] do
       @argf.read
-      lambda { @argf.send(@method) }.should raise_error(ArgumentError)
+      -> { @argf.send(@method) }.should raise_error(ArgumentError)
     end
   end
 end

core/argf/skip_spec.rb

@@ -37,6 +37,6 @@
   # which as a side-effect calls argf.file which will initialize
   # internals of ARGF enough for this to work.
   it "has no effect when nothing has been processed yet" do
-    lambda { ARGF.class.new(@file1_name).skip }.should_not raise_error
+    -> { ARGF.class.new(@file1_name).skip }.should_not raise_error
   end
 end

core/array/allocate_spec.rb

@@ -14,6 +14,6 @@
   end
 
   it "does not accept any arguments" do
-    lambda { Array.allocate(1) }.should raise_error(ArgumentError)
+    -> { Array.allocate(1) }.should raise_error(ArgumentError)
   end
 end

core/array/append_spec.rb

@@ -31,7 +31,7 @@
   end
 
   it "raises a #{frozen_error_class} on a frozen array" do
-    lambda { ArraySpecs.frozen_array << 5 }.should raise_error(frozen_error_class)
+    -> { ArraySpecs.frozen_array << 5 }.should raise_error(frozen_error_class)
   end
 end
 

core/array/at_spec.rb

@@ -47,10 +47,10 @@
   end
 
   it "raises a TypeError when the passed argument can't be coerced to Integer" do
-    lambda { [].at("cat") }.should raise_error(TypeError)
+    -> { [].at("cat") }.should raise_error(TypeError)
   end
 
   it "raises an ArgumentError when 2 or more arguments are passed" do
-    lambda { [:a, :b].at(0,1) }.should raise_error(ArgumentError)
+    -> { [:a, :b].at(0,1) }.should raise_error(ArgumentError)
   end
 end

core/array/bsearch_index_spec.rb

@@ -21,7 +21,7 @@
   end
 
   it "raises a TypeError when block returns a String" do
-    lambda { [1, 2, 3].bsearch_index { "not ok" } }.should raise_error(TypeError)
+    -> { [1, 2, 3].bsearch_index { "not ok" } }.should raise_error(TypeError)
   end
 
   it "returns nil when block is empty" do

core/array/bsearch_spec.rb

@@ -9,11 +9,11 @@
   it_behaves_like :enumeratorized_with_unknown_size, :bsearch, [1,2,3]
 
   it "raises a TypeError if the block returns an Object" do
-    lambda { [1].bsearch { Object.new } }.should raise_error(TypeError)
+    -> { [1].bsearch { Object.new } }.should raise_error(TypeError)
   end
 
   it "raises a TypeError if the block returns a String" do
-    lambda { [1].bsearch { "1" } }.should raise_error(TypeError)
+    -> { [1].bsearch { "1" } }.should raise_error(TypeError)
   end
 
   context "with a block returning true or false" do

core/array/clear_spec.rb

@@ -29,7 +29,7 @@
   end
 
   it "does not accept any arguments" do
-    lambda { [1].clear(true) }.should raise_error(ArgumentError)
+    -> { [1].clear(true) }.should raise_error(ArgumentError)
   end
 
   it "keeps untrusted status" do
@@ -43,6 +43,6 @@
   it "raises a #{frozen_error_class} on a frozen array" do
     a = [1]
     a.freeze
-    lambda { a.clear }.should raise_error(frozen_error_class)
+    -> { a.clear }.should raise_error(frozen_error_class)
   end
 end

core/array/compact_spec.rb

@@ -72,6 +72,6 @@
   end
 
   it "raises a #{frozen_error_class} on a frozen array" do
-    lambda { ArraySpecs.frozen_array.compact! }.should raise_error(frozen_error_class)
+    -> { ArraySpecs.frozen_array.compact! }.should raise_error(frozen_error_class)
   end
 end

core/array/concat_spec.rb

@@ -33,12 +33,12 @@
   end
 
   it "raises a #{frozen_error_class} when Array is frozen and modification occurs" do
-    lambda { ArraySpecs.frozen_array.concat [1] }.should raise_error(frozen_error_class)
+    -> { ArraySpecs.frozen_array.concat [1] }.should raise_error(frozen_error_class)
   end
 
   # see [ruby-core:23666]
   it "raises a #{frozen_error_class} when Array is frozen and no modification occurs" do
-    lambda { ArraySpecs.frozen_array.concat([]) }.should raise_error(frozen_error_class)
+    -> { ArraySpecs.frozen_array.concat([]) }.should raise_error(frozen_error_class)
   end
 
   it "keeps tainted status" do

core/array/cycle_spec.rb

@@ -6,7 +6,7 @@
     ScratchPad.record []
 
     @array = [1, 2, 3]
-    @prc = lambda { |x| ScratchPad << x }
+    @prc = -> x { ScratchPad << x }
   end
 
   it "does not yield and returns nil when the array is empty and passed value is an integer" do
@@ -46,13 +46,13 @@
   end
 
   it "does not rescue StopIteration when not passed a count" do
-    lambda do
+    -> do
       @array.cycle { raise StopIteration }
     end.should raise_error(StopIteration)
   end
 
   it "does not rescue StopIteration when passed a count" do
-    lambda do
+    -> do
       @array.cycle(3) { raise StopIteration }
     end.should raise_error(StopIteration)
   end
@@ -74,23 +74,23 @@
     count = mock("cycle count 2")
     count.should_receive(:to_int).and_return("2")
 
-    lambda { @array.cycle(count, &@prc) }.should raise_error(TypeError)
+    -> { @array.cycle(count, &@prc) }.should raise_error(TypeError)
   end
 
   it "raises a TypeError if passed a String" do
-    lambda { @array.cycle("4") { } }.should raise_error(TypeError)
+    -> { @array.cycle("4") { } }.should raise_error(TypeError)
   end
 
   it "raises a TypeError if passed an Object" do
-    lambda { @array.cycle(mock("cycle count")) { } }.should raise_error(TypeError)
+    -> { @array.cycle(mock("cycle count")) { } }.should raise_error(TypeError)
   end
 
   it "raises a TypeError if passed true" do
-    lambda { @array.cycle(true) { } }.should raise_error(TypeError)
+    -> { @array.cycle(true) { } }.should raise_error(TypeError)
   end
 
   it "raises a TypeError if passed false" do
-    lambda { @array.cycle(false) { } }.should raise_error(TypeError)
+    -> { @array.cycle(false) { } }.should raise_error(TypeError)
   end
 
   before :all do

core/array/delete_at_spec.rb

@@ -36,7 +36,7 @@
   end
 
   it "raises a #{frozen_error_class} on a frozen array" do
-    lambda { [1,2,3].freeze.delete_at(0) }.should raise_error(frozen_error_class)
+    -> { [1,2,3].freeze.delete_at(0) }.should raise_error(frozen_error_class)
   end
 
   it "keeps tainted status" do

core/array/delete_if_spec.rb

@@ -40,11 +40,11 @@
   end
 
   it "raises a #{frozen_error_class} on a frozen array" do
-    lambda { ArraySpecs.frozen_array.delete_if {} }.should raise_error(frozen_error_class)
+    -> { ArraySpecs.frozen_array.delete_if {} }.should raise_error(frozen_error_class)
   end
 
   it "raises a #{frozen_error_class} on an empty frozen array" do
-    lambda { ArraySpecs.empty_frozen_array.delete_if {} }.should raise_error(frozen_error_class)
+    -> { ArraySpecs.empty_frozen_array.delete_if {} }.should raise_error(frozen_error_class)
   end
 
   it "keeps tainted status" do

core/array/delete_spec.rb

@@ -41,7 +41,7 @@ def x.==(other) 3 == other end
   end
 
   it "raises a #{frozen_error_class} on a frozen array" do
-    lambda { [1, 2, 3].freeze.delete(1) }.should raise_error(frozen_error_class)
+    -> { [1, 2, 3].freeze.delete(1) }.should raise_error(frozen_error_class)
   end
 
   it "keeps tainted status" do

core/array/dig_spec.rb

@@ -20,20 +20,20 @@
   end
 
   it "raises a TypeError for a non-numeric index" do
-    lambda {
+    -> {
       ['a'].dig(:first)
     }.should raise_error(TypeError)
   end
 
   it "raises a TypeError if any intermediate step does not respond to #dig" do
     a = [1, 2]
-    lambda {
+    -> {
       a.dig(0, 1)
     }.should raise_error(TypeError)
   end
 
   it "raises an ArgumentError if no arguments provided" do
-    lambda {
+    -> {
       [10].dig()
     }.should raise_error(ArgumentError)
   end

core/array/drop_spec.rb

@@ -6,7 +6,7 @@
   end
 
   it "raises an ArgumentError if the number of elements specified is negative" do
-   lambda { [1, 2].drop(-3) }.should raise_error(ArgumentError)
+   -> { [1, 2].drop(-3) }.should raise_error(ArgumentError)
   end
 
   it "returns an empty Array if all elements are dropped" do