22 files changed, 125 insertions, 95 deletions
diff --git a/spec/ruby/library/bigdecimal/BigDecimal_spec.rb b/spec/ruby/library/bigdecimal/BigDecimal_spec.rb
index ec38c6f113..e1e6fe9fb1 100644
--- a/spec/ruby/library/bigdecimal/BigDecimal_spec.rb
+++ b/spec/ruby/library/bigdecimal/BigDecimal_spec.rb
@@ -51,16 +51,16 @@ describe "Kernel#BigDecimal" do
 
   ruby_version_is "2.6" do
     it "does not ignores trailing garbage" do
-      lambda { BigDecimal("123E45ruby") }.should raise_error(ArgumentError)
-      lambda { BigDecimal("123x45") }.should raise_error(ArgumentError)
-      lambda { BigDecimal("123.4%E5") }.should raise_error(ArgumentError)
-      lambda { BigDecimal("1E2E3E4E5E") }.should raise_error(ArgumentError)
+      -> { BigDecimal("123E45ruby") }.should raise_error(ArgumentError)
+      -> { BigDecimal("123x45") }.should raise_error(ArgumentError)
+      -> { BigDecimal("123.4%E5") }.should raise_error(ArgumentError)
+      -> { BigDecimal("1E2E3E4E5E") }.should raise_error(ArgumentError)
     end
   end
 
   it "raises ArgumentError for invalid strings" do
-    lambda { BigDecimal("ruby") }.should raise_error(ArgumentError)
-    lambda { BigDecimal("  \t\n \r-\t\t\tInfinity   \n") }.should raise_error(ArgumentError)
+    -> { BigDecimal("ruby") }.should raise_error(ArgumentError)
+    -> { BigDecimal("  \t\n \r-\t\t\tInfinity   \n") }.should raise_error(ArgumentError)
   end
 
   it "allows omitting the integer part" do
@@ -82,8 +82,8 @@ describe "Kernel#BigDecimal" do
       reference = BigDecimal("12345.67E89")
 
       BigDecimal("12_345.67E89").should == reference
-      lambda { BigDecimal("1_2_3_4_5_._6____7_E89") }.should raise_error(ArgumentError)
-      lambda { BigDecimal("12345_.67E_8__9_") }.should raise_error(ArgumentError)
+      -> { BigDecimal("1_2_3_4_5_._6____7_E89") }.should raise_error(ArgumentError)
+      -> { BigDecimal("12345_.67E_8__9_") }.should raise_error(ArgumentError)
     end
   end
 
@@ -151,7 +151,7 @@ describe "Kernel#BigDecimal" do
   end
 
   it "raises ArgumentError when Float is used without precision" do
-    lambda { BigDecimal(1.0) }.should raise_error(ArgumentError)
+    -> { BigDecimal(1.0) }.should raise_error(ArgumentError)
   end
 
   it "returns appropriate BigDecimal zero for signed zero" do
diff --git a/spec/ruby/library/bigdecimal/add_spec.rb b/spec/ruby/library/bigdecimal/add_spec.rb
index 1ae5b7f428..5b874687fe 100644
--- a/spec/ruby/library/bigdecimal/add_spec.rb
+++ b/spec/ruby/library/bigdecimal/add_spec.rb
@@ -81,6 +81,12 @@ describe "BigDecimal#add" do
     end
   end
 
+  describe "with Rational" do
+    it "produces a BigDecimal" do
+      (@three + Rational(500, 2)).should == BigDecimal("0.253e3")
+    end
+  end
+
   it "favors the precision specified in the second argument over the global limit" do
     BigDecimalSpecs.with_limit(1) do
       BigDecimal('0.888').add(@zero, 3).should == BigDecimal('0.888')
@@ -165,22 +171,22 @@ describe "BigDecimal#add" do
   end
 
   it "raises TypeError when adds nil" do
-    lambda {
+    -> {
       @one.add(nil, 10)
     }.should raise_error(TypeError)
-    lambda {
+    -> {
       @one.add(nil, 0)
     }.should raise_error(TypeError)
   end
 
   it "raises TypeError when precision parameter is nil" do
-    lambda {
+    -> {
       @one.add(@one, nil)
     }.should raise_error(TypeError)
   end
 
   it "raises ArgumentError when precision parameter is negative" do
-    lambda {
+    -> {
       @one.add(@one, -10)
     }.should raise_error(ArgumentError)
   end
diff --git a/spec/ruby/library/bigdecimal/ceil_spec.rb b/spec/ruby/library/bigdecimal/ceil_spec.rb
index 879c4fcf36..60e71b12fb 100644
--- a/spec/ruby/library/bigdecimal/ceil_spec.rb
+++ b/spec/ruby/library/bigdecimal/ceil_spec.rb
@@ -48,9 +48,9 @@ describe "BigDecimal#ceil" do
   end
 
   it "raise exception, if self is special value" do
-    lambda { @infinity.ceil }.should raise_error(FloatDomainError)
-    lambda { @infinity_neg.ceil }.should raise_error(FloatDomainError)
-    lambda { @nan.ceil }.should raise_error(FloatDomainError)
+    -> { @infinity.ceil }.should raise_error(FloatDomainError)
+    -> { @infinity_neg.ceil }.should raise_error(FloatDomainError)
+    -> { @nan.ceil }.should raise_error(FloatDomainError)
   end
 
   it "returns n digits right of the decimal point if given n > 0" do
diff --git a/spec/ruby/library/bigdecimal/div_spec.rb b/spec/ruby/library/bigdecimal/div_spec.rb
index 23d1ae1efd..0c9eb2ddec 100644
--- a/spec/ruby/library/bigdecimal/div_spec.rb
+++ b/spec/ruby/library/bigdecimal/div_spec.rb
@@ -51,9 +51,9 @@ describe "BigDecimal#div" do
   end
 
   it "raises FloatDomainError if NaN is involved" do
-    lambda { @one.div(@nan) }.should raise_error(FloatDomainError)
-    lambda { @nan.div(@one) }.should raise_error(FloatDomainError)
-    lambda { @nan.div(@nan) }.should raise_error(FloatDomainError)
+    -> { @one.div(@nan) }.should raise_error(FloatDomainError)
+    -> { @nan.div(@one) }.should raise_error(FloatDomainError)
+    -> { @nan.div(@nan) }.should raise_error(FloatDomainError)
   end
 
   it "returns 0 if divided by Infinity and no precision given" do
@@ -69,14 +69,14 @@ describe "BigDecimal#div" do
   end
 
   it "raises ZeroDivisionError if divided by zero and no precision given" do
-    lambda { @one.div(@zero) }.should raise_error(ZeroDivisionError)
-    lambda { @one.div(@zero_plus) }.should raise_error(ZeroDivisionError)
-    lambda { @one.div(@zero_minus) }.should raise_error(ZeroDivisionError)
-
-    lambda { @zero.div(@zero) }.should raise_error(ZeroDivisionError)
-    lambda { @zero_minus.div(@zero_plus) }.should raise_error(ZeroDivisionError)
-    lambda { @zero_minus.div(@zero_minus) }.should raise_error(ZeroDivisionError)
-    lambda { @zero_plus.div(@zero_minus) }.should raise_error(ZeroDivisionError)
+    -> { @one.div(@zero) }.should raise_error(ZeroDivisionError)
+    -> { @one.div(@zero_plus) }.should raise_error(ZeroDivisionError)
+    -> { @one.div(@zero_minus) }.should raise_error(ZeroDivisionError)
+
+    -> { @zero.div(@zero) }.should raise_error(ZeroDivisionError)
+    -> { @zero_minus.div(@zero_plus) }.should raise_error(ZeroDivisionError)
+    -> { @zero_minus.div(@zero_minus) }.should raise_error(ZeroDivisionError)
+    -> { @zero_plus.div(@zero_minus) }.should raise_error(ZeroDivisionError)
   end
 
   it "returns NaN if zero is divided by zero" do
@@ -90,9 +90,9 @@ describe "BigDecimal#div" do
   end
 
   it "raises FloatDomainError if (+|-) Infinity divided by 1 and no precision given" do
-    lambda { @infinity_minus.div(@one) }.should raise_error(FloatDomainError)
-    lambda { @infinity.div(@one) }.should raise_error(FloatDomainError)
-    lambda { @infinity_minus.div(@one_minus) }.should raise_error(FloatDomainError)
+    -> { @infinity_minus.div(@one) }.should raise_error(FloatDomainError)
+    -> { @infinity.div(@one) }.should raise_error(FloatDomainError)
+    -> { @infinity_minus.div(@one_minus) }.should raise_error(FloatDomainError)
   end
 
   it "returns (+|-)Infinity if (+|-)Infinity by 1 and precision given" do
diff --git a/spec/ruby/library/bigdecimal/divide_spec.rb b/spec/ruby/library/bigdecimal/divide_spec.rb
index 2aac99799f..c62b23557d 100644
--- a/spec/ruby/library/bigdecimal/divide_spec.rb
+++ b/spec/ruby/library/bigdecimal/divide_spec.rb
@@ -4,4 +4,14 @@ require 'bigdecimal'
 
 describe "BigDecimal#/" do
   it_behaves_like :bigdecimal_quo, :/, []
+
+  before :each do
+    @three = BigDecimal("3")
+  end
+
+  describe "with Rational" do
+    it "produces a BigDecimal" do
+      (@three / Rational(500, 2)).should == BigDecimal("0.12e-1")
+    end
+  end
 end
diff --git a/spec/ruby/library/bigdecimal/divmod_spec.rb b/spec/ruby/library/bigdecimal/divmod_spec.rb
index 3946d6f208..ae8b84983a 100644
--- a/spec/ruby/library/bigdecimal/divmod_spec.rb
+++ b/spec/ruby/library/bigdecimal/divmod_spec.rb
@@ -38,9 +38,9 @@ describe "BigDecimal#mod_part_of_divmod" do
   it "raises ZeroDivisionError if other is zero" do
     bd5667 = BigDecimal("5667.19")
 
-    lambda { bd5667.mod_part_of_divmod(0) }.should raise_error(ZeroDivisionError)
-    lambda { bd5667.mod_part_of_divmod(BigDecimal("0")) }.should raise_error(ZeroDivisionError)
-    lambda { @zero.mod_part_of_divmod(@zero) }.should raise_error(ZeroDivisionError)
+    -> { bd5667.mod_part_of_divmod(0) }.should raise_error(ZeroDivisionError)
+    -> { bd5667.mod_part_of_divmod(BigDecimal("0")) }.should raise_error(ZeroDivisionError)
+    -> { @zero.mod_part_of_divmod(@zero) }.should raise_error(ZeroDivisionError)
   end
 end
 
@@ -140,7 +140,7 @@ describe "BigDecimal#divmod" do
   it "raises ZeroDivisionError if the divisor is zero" do
     (@special_vals + @regular_vals + @zeroes - [@nan]).each do |val|
       @zeroes.each do |zero|
-        lambda { val.divmod(zero) }.should raise_error(ZeroDivisionError)
+        -> { val.divmod(zero) }.should raise_error(ZeroDivisionError)
       end
     end
   end
@@ -172,7 +172,7 @@ describe "BigDecimal#divmod" do
   end
 
   it "raises TypeError if the argument cannot be coerced to BigDecimal" do
-    lambda {
+    -> {
       @one.divmod('1')
     }.should raise_error(TypeError)
   end
diff --git a/spec/ruby/library/bigdecimal/fix_spec.rb b/spec/ruby/library/bigdecimal/fix_spec.rb
index af852d6471..53b30cbf8b 100644
--- a/spec/ruby/library/bigdecimal/fix_spec.rb
+++ b/spec/ruby/library/bigdecimal/fix_spec.rb
@@ -49,7 +49,7 @@ describe "BigDecimal#fix" do
   end
 
   it "does not allow any arguments" do
-    lambda {
+    -> {
       @mixed.fix(10)
     }.should raise_error(ArgumentError)
   end
diff --git a/spec/ruby/library/bigdecimal/floor_spec.rb b/spec/ruby/library/bigdecimal/floor_spec.rb
index 509cb00e10..a7dfec2c9a 100644
--- a/spec/ruby/library/bigdecimal/floor_spec.rb
+++ b/spec/ruby/library/bigdecimal/floor_spec.rb
@@ -41,9 +41,9 @@ describe "BigDecimal#floor" do
   end
 
   it "raise exception, if self is special value" do
-    lambda { @infinity.floor }.should raise_error(FloatDomainError)
-    lambda { @infinity_neg.floor }.should raise_error(FloatDomainError)
-    lambda { @nan.floor }.should raise_error(FloatDomainError)
+    -> { @infinity.floor }.should raise_error(FloatDomainError)
+    -> { @infinity_neg.floor }.should raise_error(FloatDomainError)
+    -> { @nan.floor }.should raise_error(FloatDomainError)
   end
 
   it "returns n digits right of the decimal point if given n > 0" do
diff --git a/spec/ruby/library/bigdecimal/gt_spec.rb b/spec/ruby/library/bigdecimal/gt_spec.rb
index 8ebb631cb8..4717cfdd9d 100644
--- a/spec/ruby/library/bigdecimal/gt_spec.rb
+++ b/spec/ruby/library/bigdecimal/gt_spec.rb
@@ -86,11 +86,11 @@ describe "BigDecimal#>" do
   end
 
   it "raises an ArgumentError if the argument can't be coerced into a BigDecimal" do
-    lambda {@zero         > nil }.should raise_error(ArgumentError)
-    lambda {@infinity     > nil }.should raise_error(ArgumentError)
-    lambda {@infinity_neg > nil }.should raise_error(ArgumentError)
-    lambda {@mixed        > nil }.should raise_error(ArgumentError)
-    lambda {@pos_int      > nil }.should raise_error(ArgumentError)
-    lambda {@neg_frac     > nil }.should raise_error(ArgumentError)
+    -> {@zero         > nil }.should raise_error(ArgumentError)
+    -> {@infinity     > nil }.should raise_error(ArgumentError)
+    -> {@infinity_neg > nil }.should raise_error(ArgumentError)
+    -> {@mixed        > nil }.should raise_error(ArgumentError)
+    -> {@pos_int      > nil }.should raise_error(ArgumentError)
+    -> {@neg_frac     > nil }.should raise_error(ArgumentError)
   end
 end
diff --git a/spec/ruby/library/bigdecimal/gte_spec.rb b/spec/ruby/library/bigdecimal/gte_spec.rb
index 6b0b7f41e9..8dc81707f0 100644
--- a/spec/ruby/library/bigdecimal/gte_spec.rb
+++ b/spec/ruby/library/bigdecimal/gte_spec.rb
@@ -90,11 +90,11 @@ describe "BigDecimal#>=" do
   end
 
   it "returns nil if the argument is nil" do
-    lambda {@zero         >= nil }.should raise_error(ArgumentError)
-    lambda {@infinity     >= nil }.should raise_error(ArgumentError)
-    lambda {@infinity_neg >= nil }.should raise_error(ArgumentError)
-    lambda {@mixed        >= nil }.should raise_error(ArgumentError)
-    lambda {@pos_int      >= nil }.should raise_error(ArgumentError)
-    lambda {@neg_frac     >= nil }.should raise_error(ArgumentError)
+    -> {@zero         >= nil }.should raise_error(ArgumentError)
+    -> {@infinity     >= nil }.should raise_error(ArgumentError)
+    -> {@infinity_neg >= nil }.should raise_error(ArgumentError)
+    -> {@mixed        >= nil }.should raise_error(ArgumentError)
+    -> {@pos_int      >= nil }.should raise_error(ArgumentError)
+    -> {@neg_frac     >= nil }.should raise_error(ArgumentError)
   end
 end
diff --git a/spec/ruby/library/bigdecimal/lt_spec.rb b/spec/ruby/library/bigdecimal/lt_spec.rb
index 1894daf17f..61f4f19912 100644
--- a/spec/ruby/library/bigdecimal/lt_spec.rb
+++ b/spec/ruby/library/bigdecimal/lt_spec.rb
@@ -84,11 +84,11 @@ describe "BigDecimal#<" do
   end
 
   it "raises an ArgumentError if the argument can't be coerced into a BigDecimal" do
-    lambda {@zero         < nil }.should raise_error(ArgumentError)
-    lambda {@infinity     < nil }.should raise_error(ArgumentError)
-    lambda {@infinity_neg < nil }.should raise_error(ArgumentError)
-    lambda {@mixed        < nil }.should raise_error(ArgumentError)
-    lambda {@pos_int      < nil }.should raise_error(ArgumentError)
-    lambda {@neg_frac     < nil }.should raise_error(ArgumentError)
+    -> {@zero         < nil }.should raise_error(ArgumentError)
+    -> {@infinity     < nil }.should raise_error(ArgumentError)
+    -> {@infinity_neg < nil }.should raise_error(ArgumentError)
+    -> {@mixed        < nil }.should raise_error(ArgumentError)
+    -> {@pos_int      < nil }.should raise_error(ArgumentError)
+    -> {@neg_frac     < nil }.should raise_error(ArgumentError)
   end
 end
diff --git a/spec/ruby/library/bigdecimal/lte_spec.rb b/spec/ruby/library/bigdecimal/lte_spec.rb
index 56d3caa3b1..fc632315f8 100644
--- a/spec/ruby/library/bigdecimal/lte_spec.rb
+++ b/spec/ruby/library/bigdecimal/lte_spec.rb
@@ -90,11 +90,11 @@ describe "BigDecimal#<=" do
   end
 
   it "raises an ArgumentError if the argument can't be coerced into a BigDecimal" do
-    lambda {@zero         <= nil }.should raise_error(ArgumentError)
-    lambda {@infinity     <= nil }.should raise_error(ArgumentError)
-    lambda {@infinity_neg <= nil }.should raise_error(ArgumentError)
-    lambda {@mixed        <= nil }.should raise_error(ArgumentError)
-    lambda {@pos_int      <= nil }.should raise_error(ArgumentError)
-    lambda {@neg_frac     <= nil }.should raise_error(ArgumentError)
+    -> {@zero         <= nil }.should raise_error(ArgumentError)
+    -> {@infinity     <= nil }.should raise_error(ArgumentError)
+    -> {@infinity_neg <= nil }.should raise_error(ArgumentError)
+    -> {@mixed        <= nil }.should raise_error(ArgumentError)
+    -> {@pos_int      <= nil }.should raise_error(ArgumentError)
+    -> {@neg_frac     <= nil }.should raise_error(ArgumentError)
   end
 end
diff --git a/spec/ruby/library/bigdecimal/mode_spec.rb b/spec/ruby/library/bigdecimal/mode_spec.rb
index 1de19c9971..f57028ae5d 100644
--- a/spec/ruby/library/bigdecimal/mode_spec.rb
+++ b/spec/ruby/library/bigdecimal/mode_spec.rb
@@ -24,13 +24,13 @@ describe "BigDecimal.mode" do
 
   it "raise an exception if the flag is true" do
     BigDecimal.mode(BigDecimal::EXCEPTION_NaN, true)
-    lambda { BigDecimal("NaN").add(BigDecimal("1"),0) }.should raise_error(FloatDomainError)
+    -> { BigDecimal("NaN").add(BigDecimal("1"),0) }.should raise_error(FloatDomainError)
     BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, true)
-    lambda { BigDecimal("0").add(BigDecimal("Infinity"),0) }.should raise_error(FloatDomainError)
+    -> { BigDecimal("0").add(BigDecimal("Infinity"),0) }.should raise_error(FloatDomainError)
     BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, true)
-    lambda { BigDecimal("1").quo(BigDecimal("0")) }.should raise_error(FloatDomainError)
+    -> { BigDecimal("1").quo(BigDecimal("0")) }.should raise_error(FloatDomainError)
     BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, true)
-    lambda { BigDecimal("1E11111111111111111111") }.should raise_error(FloatDomainError)
-    lambda { (BigDecimal("1E1000000000000000000")**10) }.should raise_error(FloatDomainError)
+    -> { BigDecimal("1E11111111111111111111") }.should raise_error(FloatDomainError)
+    -> { (BigDecimal("1E1000000000000000000")**10) }.should raise_error(FloatDomainError)
   end
 end
diff --git a/spec/ruby/library/bigdecimal/multiply_spec.rb b/spec/ruby/library/bigdecimal/multiply_spec.rb
index 4e5a8d6681..a8ce1da32e 100644
--- a/spec/ruby/library/bigdecimal/multiply_spec.rb
+++ b/spec/ruby/library/bigdecimal/multiply_spec.rb
@@ -8,6 +8,7 @@ end
 
 describe "BigDecimal#*" do
   before :each do
+    @three = BigDecimal("3")
     @e3_minus = BigDecimal("3E-20001")
     @e3_plus = BigDecimal("3E20001")
     @e = BigDecimal("1.00000000000000000000123456789")
@@ -31,4 +32,10 @@ describe "BigDecimal#*" do
       (@e3_minus * object).should == BigDecimal("9")
     end
   end
+
+  describe "with Rational" do
+    it "produces a BigDecimal" do
+      (@three * Rational(500, 2)).should == BigDecimal("0.75e3")
+    end
+  end
 end
diff --git a/spec/ruby/library/bigdecimal/remainder_spec.rb b/spec/ruby/library/bigdecimal/remainder_spec.rb
index 8626064a2f..04233edece 100644
--- a/spec/ruby/library/bigdecimal/remainder_spec.rb
+++ b/spec/ruby/library/bigdecimal/remainder_spec.rb
@@ -84,7 +84,7 @@ describe "BigDecimal#remainder" do
   end
 
   it "raises TypeError if the argument cannot be coerced to BigDecimal" do
-    lambda {
+    -> {
       @one.remainder('2')
     }.should raise_error(TypeError)
   end
diff --git a/spec/ruby/library/bigdecimal/round_spec.rb b/spec/ruby/library/bigdecimal/round_spec.rb
index 467e2c5563..501a1a7342 100644
--- a/spec/ruby/library/bigdecimal/round_spec.rb
+++ b/spec/ruby/library/bigdecimal/round_spec.rb
@@ -217,18 +217,18 @@ describe "BigDecimal#round" do
   end
 
   it 'raise exception, if self is special value' do
-    lambda { BigDecimal('NaN').round }.should raise_error(FloatDomainError)
-    lambda { BigDecimal('Infinity').round }.should raise_error(FloatDomainError)
-    lambda { BigDecimal('-Infinity').round }.should raise_error(FloatDomainError)
+    -> { BigDecimal('NaN').round }.should raise_error(FloatDomainError)
+    -> { BigDecimal('Infinity').round }.should raise_error(FloatDomainError)
+    -> { BigDecimal('-Infinity').round }.should raise_error(FloatDomainError)
   end
 
   it 'do not raise exception, if self is special value and precision is given' do
-    lambda { BigDecimal('NaN').round(2) }.should_not raise_error(FloatDomainError)
-    lambda { BigDecimal('Infinity').round(2) }.should_not raise_error(FloatDomainError)
-    lambda { BigDecimal('-Infinity').round(2) }.should_not raise_error(FloatDomainError)
+    -> { BigDecimal('NaN').round(2) }.should_not raise_error(FloatDomainError)
+    -> { BigDecimal('Infinity').round(2) }.should_not raise_error(FloatDomainError)
+    -> { BigDecimal('-Infinity').round(2) }.should_not raise_error(FloatDomainError)
   end
 
   it "raise for a non-existent round mode" do
-    lambda { @p1_50.round(0, :nonsense) }.should raise_error(ArgumentError, "invalid rounding mode")
+    -> { @p1_50.round(0, :nonsense) }.should raise_error(ArgumentError, "invalid rounding mode")
   end
 end
diff --git a/spec/ruby/library/bigdecimal/shared/modulo.rb b/spec/ruby/library/bigdecimal/shared/modulo.rb
index d570b86d7a..67c0ecf2fc 100644
--- a/spec/ruby/library/bigdecimal/shared/modulo.rb
+++ b/spec/ruby/library/bigdecimal/shared/modulo.rb
@@ -108,7 +108,7 @@ describe :bigdecimal_modulo, shared: true do
   end
 
   it "raises TypeError if the argument cannot be coerced to BigDecimal" do
-    lambda {
+    -> {
       @one.send(@method, '2')
     }.should raise_error(TypeError)
   end
@@ -118,8 +118,8 @@ describe :bigdecimal_modulo_zerodivisionerror, shared: true do
   it "raises ZeroDivisionError if other is zero" do
     bd5667 = BigDecimal("5667.19")
 
-    lambda { bd5667.send(@method, 0) }.should raise_error(ZeroDivisionError)
-    lambda { bd5667.send(@method, BigDecimal("0")) }.should raise_error(ZeroDivisionError)
-    lambda { @zero.send(@method, @zero) }.should raise_error(ZeroDivisionError)
+    -> { bd5667.send(@method, 0) }.should raise_error(ZeroDivisionError)
+    -> { bd5667.send(@method, BigDecimal("0")) }.should raise_error(ZeroDivisionError)
+    -> { @zero.send(@method, @zero) }.should raise_error(ZeroDivisionError)
   end
 end
diff --git a/spec/ruby/library/bigdecimal/shared/to_int.rb b/spec/ruby/library/bigdecimal/shared/to_int.rb
index 729a25f511..02f6092f23 100644
--- a/spec/ruby/library/bigdecimal/shared/to_int.rb
+++ b/spec/ruby/library/bigdecimal/shared/to_int.rb
@@ -2,8 +2,8 @@ require 'bigdecimal'
 
 describe :bigdecimal_to_int , shared: true do
   it "raises FloatDomainError if BigDecimal is infinity or NaN" do
-    lambda { BigDecimal("Infinity").send(@method) }.should raise_error(FloatDomainError)
-    lambda { BigDecimal("NaN").send(@method) }.should raise_error(FloatDomainError)
+    -> { BigDecimal("Infinity").send(@method) }.should raise_error(FloatDomainError)
+    -> { BigDecimal("NaN").send(@method) }.should raise_error(FloatDomainError)
   end
 
   it "returns Integer or Bignum otherwise" do
diff --git a/spec/ruby/library/bigdecimal/sqrt_spec.rb b/spec/ruby/library/bigdecimal/sqrt_spec.rb
index 75182fcbc8..d149003b9f 100644
--- a/spec/ruby/library/bigdecimal/sqrt_spec.rb
+++ b/spec/ruby/library/bigdecimal/sqrt_spec.rb
@@ -41,37 +41,37 @@ describe "BigDecimal#sqrt" do
   end
 
   it "raises ArgumentError when no argument is given" do
-    lambda {
+    -> {
       @one.sqrt
     }.should raise_error(ArgumentError)
   end
 
   it "raises ArgumentError if a negative number is given" do
-    lambda {
+    -> {
       @one.sqrt(-1)
     }.should raise_error(ArgumentError)
   end
 
   it "raises ArgumentError if 2 arguments are given" do
-    lambda {
+    -> {
       @one.sqrt(1, 1)
     }.should raise_error(ArgumentError)
   end
 
   it "raises TypeError if nil is given" do
-    lambda {
+    -> {
       @one.sqrt(nil)
     }.should raise_error(TypeError)
   end
 
   it "raises TypeError if a string is given" do
-    lambda {
+    -> {
       @one.sqrt("stuff")
     }.should raise_error(TypeError)
   end
 
   it "raises TypeError if a plain Object is given" do
-    lambda {
+    -> {
       @one.sqrt(Object.new)
     }.should raise_error(TypeError)
   end
@@ -82,7 +82,7 @@ describe "BigDecimal#sqrt" do
   end
 
   it "raises FloatDomainError on negative values" do
-    lambda {
+    -> {
       BigDecimal('-1').sqrt(10)
     }.should raise_error(FloatDomainError)
   end
@@ -92,13 +92,13 @@ describe "BigDecimal#sqrt" do
   end
 
   it "raises FloatDomainError for negative infinity" do
-    lambda {
+    -> {
       @infinity_minus.sqrt(1)
     }.should raise_error(FloatDomainError)
   end
 
   it "raises FloatDomainError for NaN" do
-    lambda {
+    -> {
       @nan.sqrt(1)
     }.should raise_error(FloatDomainError)
   end
diff --git a/spec/ruby/library/bigdecimal/sub_spec.rb b/spec/ruby/library/bigdecimal/sub_spec.rb
index f0068b12a9..29ec851193 100644
--- a/spec/ruby/library/bigdecimal/sub_spec.rb
+++ b/spec/ruby/library/bigdecimal/sub_spec.rb
@@ -7,6 +7,7 @@ describe "BigDecimal#sub" do
     @one = BigDecimal("1")
     @zero = BigDecimal("0")
     @two = BigDecimal("2")
+    @three = BigDecimal("3")
     @nan = BigDecimal("NaN")
     @infinity = BigDecimal("Infinity")
     @infinity_minus = BigDecimal("-Infinity")
@@ -42,6 +43,12 @@ describe "BigDecimal#sub" do
     end
   end
 
+  describe "with Rational" do
+    it "produces a BigDecimal" do
+      (@three - Rational(500, 2)).should == BigDecimal('-0.247e3')
+    end
+  end
+
   it "returns NaN if NaN is involved" do
     @one.sub(@nan, 1).nan?.should == true
     @nan.sub(@one, 1).nan?.should == true
diff --git a/spec/ruby/library/bigdecimal/to_s_spec.rb b/spec/ruby/library/bigdecimal/to_s_spec.rb
index c7ee6a01b0..b6154c680d 100644
--- a/spec/ruby/library/bigdecimal/to_s_spec.rb
+++ b/spec/ruby/library/bigdecimal/to_s_spec.rb
@@ -26,7 +26,7 @@ describe "BigDecimal#to_s" do
   end
 
   it "takes an optional argument" do
-    lambda {@bigdec.to_s("F")}.should_not raise_error()
+    -> {@bigdec.to_s("F")}.should_not raise_error()
   end
 
   it "starts with + if + is supplied and value is positive" do
diff --git a/spec/ruby/library/bigdecimal/truncate_spec.rb b/spec/ruby/library/bigdecimal/truncate_spec.rb
index 7edee771c9..d3a15f62c7 100644
--- a/spec/ruby/library/bigdecimal/truncate_spec.rb
+++ b/spec/ruby/library/bigdecimal/truncate_spec.rb
@@ -74,8 +74,8 @@ describe "BigDecimal#truncate" do
   end
 
   it "returns the same value if self is special value" do
-    lambda { @nan.truncate }.should raise_error(FloatDomainError)
-    lambda { @infinity.truncate }.should raise_error(FloatDomainError)
-    lambda { @infinity_negative.truncate }.should raise_error(FloatDomainError)
+    -> { @nan.truncate }.should raise_error(FloatDomainError)
+    -> { @infinity.truncate }.should raise_error(FloatDomainError)
+    -> { @infinity_negative.truncate }.should raise_error(FloatDomainError)
   end
 end