Remove not needed #eval calls

Author: andrykonchin

core/hash/hash_spec.rb

@@ -46,6 +46,6 @@
     a = 1
     b = 2
 
-    eval('{a:, b:}.should == { a: 1, b: 2 }')
+    {a:, b:}.should == { a: 1, b: 2 }
   end
 end

core/method/parameters_spec.rb

@@ -259,12 +259,10 @@ def underscore_parameters(_, _, _ = 1, *_, _:, _: 2, **_, &_); end
 
   it "adds block arg with name & for anonymous block argument" do
     object = Object.new
+    def object.foo(&)
+    end
 
-    eval(<<~RUBY).should == [[:block, :&]]
-      def object.foo(&)
-      end
-      object.method(:foo).parameters
-    RUBY
+    object.method(:foo).parameters.should == [[:block, :&]]
   end
 
   it "returns [:rest, :*], [:keyrest, :**], [:block, :&] for forward parameters operator" do

core/proc/parameters_spec.rb

@@ -64,7 +64,7 @@
   end
 
   it "regards keyword parameters in lambdas as required" do
-    eval("lambda {|x:| }").parameters.first.first.should == :keyreq
+    lambda {|x:| }.parameters.first.first.should == :keyreq
   end
 
   it "sets the first element of each sub-Array to :rest for parameters prefixed with asterisks" do
@@ -131,7 +131,7 @@
   end
 
   it "adds block arg with name & for anonymous block argument" do
-    eval('-> & {}.parameters').should == [[:block, :&]]
+    -> & {}.parameters.should == [[:block, :&]]
   end
 
   it "does not add locals as block options with a block and splat" do

core/range/each_spec.rb

@@ -40,21 +40,21 @@
 
   it "works with endless ranges" do
     a = []
-    eval("(-2..)").each { |x| break if x > 2; a << x }
+    (-2..).each { |x| break if x > 2; a << x }
     a.should == [-2, -1, 0, 1, 2]
 
     a = []
-    eval("(-2...)").each { |x| break if x > 2; a << x }
+    (-2...).each { |x| break if x > 2; a << x }
     a.should == [-2, -1, 0, 1, 2]
   end
 
   it "works with String endless ranges" do
     a = []
-    eval("('A'..)").each { |x| break if x > "D"; a << x }
+    ('A'..).each { |x| break if x > "D"; a << x }
     a.should == ["A", "B", "C", "D"]
 
     a = []
-    eval("('A'...)").each { |x| break if x > "D"; a << x }
+    ('A'...).each { |x| break if x > "D"; a << x }
     a.should == ["A", "B", "C", "D"]
   end
 

core/range/step_spec.rb

@@ -406,108 +406,108 @@
   describe "with an endless range" do
     describe "and Integer values" do
       it "yield Integer values incremented by 1 when not passed a step" do
-        eval("(-2..)").step { |x| break if x > 2; ScratchPad << x }
+        (-2..).step { |x| break if x > 2; ScratchPad << x }
         ScratchPad.recorded.should eql([-2, -1, 0, 1, 2])
 
         ScratchPad.record []
-        eval("(-2...)").step { |x| break if x > 2; ScratchPad << x }
+        (-2...).step { |x| break if x > 2; ScratchPad << x }
         ScratchPad.recorded.should eql([-2, -1, 0, 1, 2])
       end
 
       it "yields Integer values incremented by an Integer step" do
-        eval("(-5..)").step(2) { |x| break if x > 3; ScratchPad << x }
+        (-5..).step(2) { |x| break if x > 3; ScratchPad << x }
         ScratchPad.recorded.should eql([-5, -3, -1, 1, 3])
 
         ScratchPad.record []
-        eval("(-5...)").step(2) { |x| break if x > 3; ScratchPad << x }
+        (-5...).step(2) { |x| break if x > 3; ScratchPad << x }
         ScratchPad.recorded.should eql([-5, -3, -1, 1, 3])
       end
 
       it "yields Float values incremented by a Float step" do
-        eval("(-2..)").step(1.5) { |x| break if x > 1.0; ScratchPad << x }
+        (-2..).step(1.5) { |x| break if x > 1.0; ScratchPad << x }
         ScratchPad.recorded.should eql([-2.0, -0.5, 1.0])
 
         ScratchPad.record []
-        eval("(-2..)").step(1.5) { |x| break if x > 1.0; ScratchPad << x }
+        (-2..).step(1.5) { |x| break if x > 1.0; ScratchPad << x }
         ScratchPad.recorded.should eql([-2.0, -0.5, 1.0])
       end
     end
 
     describe "and Float values" do
       it "yields Float values incremented by 1 and less than end when not passed a step" do
-        eval("(-2.0..)").step { |x| break if x > 1.5; ScratchPad << x }
+        (-2.0..).step { |x| break if x > 1.5; ScratchPad << x }
         ScratchPad.recorded.should eql([-2.0, -1.0, 0.0, 1.0])
 
         ScratchPad.record []
-        eval("(-2.0...)").step { |x| break if x > 1.5; ScratchPad << x }
+        (-2.0...).step { |x| break if x > 1.5; ScratchPad << x }
         ScratchPad.recorded.should eql([-2.0, -1.0, 0.0, 1.0])
       end
 
       it "yields Float values incremented by an Integer step" do
-        eval("(-5.0..)").step(2) { |x| break if x > 3.5; ScratchPad << x }
+        (-5.0..).step(2) { |x| break if x > 3.5; ScratchPad << x }
         ScratchPad.recorded.should eql([-5.0, -3.0, -1.0, 1.0, 3.0])
 
         ScratchPad.record []
-        eval("(-5.0...)").step(2) { |x| break if x > 3.5; ScratchPad << x }
+        (-5.0...).step(2) { |x| break if x > 3.5; ScratchPad << x }
         ScratchPad.recorded.should eql([-5.0, -3.0, -1.0, 1.0, 3.0])
       end
 
       it "yields Float values incremented by a Float step" do
-        eval("(-1.0..)").step(0.5) { |x| break if x > 0.6; ScratchPad << x }
+        (-1.0..).step(0.5) { |x| break if x > 0.6; ScratchPad << x }
         ScratchPad.recorded.should eql([-1.0, -0.5, 0.0, 0.5])
 
         ScratchPad.record []
-        eval("(-1.0...)").step(0.5) { |x| break if x > 0.6; ScratchPad << x }
+        (-1.0...).step(0.5) { |x| break if x > 0.6; ScratchPad << x }
         ScratchPad.recorded.should eql([-1.0, -0.5, 0.0, 0.5])
       end
 
       it "handles infinite values at the start" do
-        eval("(-Float::INFINITY..)").step(2) { |x| ScratchPad << x; break if ScratchPad.recorded.size == 3 }
+        (-Float::INFINITY..).step(2) { |x| ScratchPad << x; break if ScratchPad.recorded.size == 3 }
         ScratchPad.recorded.should eql([-Float::INFINITY, -Float::INFINITY, -Float::INFINITY])
 
         ScratchPad.record []
-        eval("(-Float::INFINITY...)").step(2) { |x| ScratchPad << x; break if ScratchPad.recorded.size == 3 }
+        (-Float::INFINITY...).step(2) { |x| ScratchPad << x; break if ScratchPad.recorded.size == 3 }
         ScratchPad.recorded.should eql([-Float::INFINITY, -Float::INFINITY, -Float::INFINITY])
       end
     end
 
     describe "and String values" do
       it "yields String values incremented by #succ and less than or equal to end when not passed a step" do
-        eval("('A'..)").step { |x| break if x > "D"; ScratchPad << x }
+        ('A'..).step { |x| break if x > "D"; ScratchPad << x }
         ScratchPad.recorded.should == ["A", "B", "C", "D"]
 
         ScratchPad.record []
-        eval("('A'...)").step { |x| break if x > "D"; ScratchPad << x }
+        ('A'...).step { |x| break if x > "D"; ScratchPad << x }
         ScratchPad.recorded.should == ["A", "B", "C", "D"]
       end
 
       it "yields String values incremented by #succ called Integer step times" do
-        eval("('A'..)").step(2) { |x| break if x > "F"; ScratchPad << x }
+        ('A'..).step(2) { |x| break if x > "F"; ScratchPad << x }
         ScratchPad.recorded.should == ["A", "C", "E"]
 
         ScratchPad.record []
-        eval("('A'...)").step(2) { |x| break if x > "F"; ScratchPad << x }
+        ('A'...).step(2) { |x| break if x > "F"; ScratchPad << x }
         ScratchPad.recorded.should == ["A", "C", "E"]
       end
 
       it "raises a TypeError when passed a Float step" do
-        -> { eval("('A'..)").step(2.0) { } }.should raise_error(TypeError)
-        -> { eval("('A'...)").step(2.0) { } }.should raise_error(TypeError)
+        -> { ('A'..).step(2.0) { } }.should raise_error(TypeError)
+        -> { ('A'...).step(2.0) { } }.should raise_error(TypeError)
       end
 
       ruby_version_is "3.4" do
         it "yields String values adjusted by step" do
-          eval("('A'..)").step("A") { |x| break if x > "AAA"; ScratchPad << x }
+          ('A'..).step("A") { |x| break if x > "AAA"; ScratchPad << x }
           ScratchPad.recorded.should == ["A", "AA", "AAA"]
 
           ScratchPad.record []
-          eval("('A'...)").step("A") { |x| break if x > "AAA"; ScratchPad << x }
+          ('A'...).step("A") { |x| break if x > "AAA"; ScratchPad << x }
           ScratchPad.recorded.should == ["A", "AA", "AAA"]
         end
 
         it "raises a TypeError when passed an incompatible type step" do
-          -> { eval("('A'..)").step([]) { } }.should raise_error(TypeError)
-          -> { eval("('A'...)").step([]) { } }.should raise_error(TypeError)
+          -> { ('A'..).step([]) { } }.should raise_error(TypeError)
+          -> { ('A'...).step([]) { } }.should raise_error(TypeError)
         end
       end
     end

language/block_spec.rb

@@ -294,7 +294,7 @@ def obj.to_ary; raise "Exception raised in #to_ary" end
     end
 
     it "may include a rescue clause" do
-      eval("@y.z do raise ArgumentError; rescue ArgumentError; 7; end").should == 7
+      @y.z do raise ArgumentError; rescue ArgumentError; 7; end.should == 7
     end
   end
 
@@ -308,7 +308,7 @@ def obj.to_ary; raise "Exception raised in #to_ary" end
     end
 
     it "may include a rescue clause" do
-      eval('@y.z do || raise ArgumentError; rescue ArgumentError; 7; end').should == 7
+      @y.z do || raise ArgumentError; rescue ArgumentError; 7; end.should == 7
     end
   end
 
@@ -337,7 +337,7 @@ def obj.to_ary; raise "Exception raised in #to_ary" end
     end
 
     it "may include a rescue clause" do
-      eval('@y.s(1) do |x| raise ArgumentError; rescue ArgumentError; 7; end').should == 7
+      @y.s(1) do |x| raise ArgumentError; rescue ArgumentError; 7; end.should == 7
     end
   end
 
@@ -737,9 +737,9 @@ def obj.to_ary; raise "Exception raised in #to_ary" end
     end
 
     it "accepts unnamed arguments" do
-      eval("lambda { |_,_| }").should be_an_instance_of(Proc)
-      eval("->(_,_) {}").should be_an_instance_of(Proc)
-      eval("Proc.new { |_,_| }").should be_an_instance_of(Proc)
+      lambda { |_,_| }.should be_an_instance_of(Proc)
+      ->(_,_) {}.should be_an_instance_of(Proc)
+      Proc.new { |_,_| }.should be_an_instance_of(Proc)
     end
   end
 
@@ -1002,10 +1002,8 @@ def a; 1; end
 # tested more thoroughly in language/delegation_spec.rb
 describe "Anonymous block forwarding" do
   it "forwards blocks to other method that formally declares anonymous block" do
-    eval <<-EOF
-        def b(&); c(&) end
-        def c(&); yield :non_null end
-    EOF
+    def b(&); c(&) end
+    def c(&); yield :non_null end
 
     b { |c| c }.should == :non_null
   end
@@ -1015,37 +1013,29 @@ def c(&); yield :non_null end
   end
 
   it "works when it's the only declared parameter" do
-    eval <<-EOF
-        def inner; yield end
-        def block_only(&); inner(&) end
-    EOF
+    def inner; yield end
+    def block_only(&); inner(&) end
 
     block_only { 1 }.should == 1
   end
 
   it "works alongside positional parameters" do
-    eval <<-EOF
-        def inner; yield end
-        def pos(arg1, &); inner(&) end
-    EOF
+    def inner; yield end
+    def pos(arg1, &); inner(&) end
 
     pos(:a) { 1 }.should == 1
   end
 
   it "works alongside positional arguments and splatted keyword arguments" do
-    eval <<-EOF
-        def inner; yield end
-        def pos_kwrest(arg1, **kw, &); inner(&) end
-    EOF
+    def inner; yield end
+    def pos_kwrest(arg1, **kw, &); inner(&) end
 
     pos_kwrest(:a, arg: 3) { 1 }.should == 1
   end
 
   it "works alongside positional arguments and disallowed keyword arguments" do
-    eval <<-EOF
-        def inner; yield end
-        def no_kw(arg1, **nil, &); inner(&) end
-    EOF
+    def inner; yield end
+    def no_kw(arg1, **nil, &); inner(&) end
 
     no_kw(:a) { 1 }.should == 1
   end

language/hash_spec.rb

@@ -75,33 +75,33 @@
   end
 
   it "recognizes '=' at the end of the key" do
-    eval("{:a==>1}").should == {:"a=" => 1}
-    eval("{:a= =>1}").should == {:"a=" => 1}
-    eval("{:a= => 1}").should == {:"a=" => 1}
+    {:a==>1}.should == {:"a=" => 1}
+    {:a= =>1}.should == {:"a=" => 1}
+    {:a= => 1}.should == {:"a=" => 1}
   end
 
   it "with '==>' in the middle raises SyntaxError" do
     -> { eval("{:a ==> 1}") }.should raise_error(SyntaxError)
   end
 
   it "recognizes '!' at the end of the key" do
-    eval("{:a! =>1}").should == {:"a!" => 1}
-    eval("{:a! => 1}").should == {:"a!" => 1}
+    {:a! =>1}.should == {:"a!" => 1}
+    {:a! => 1}.should == {:"a!" => 1}
 
-    eval("{a!:1}").should == {:"a!" => 1}
-    eval("{a!: 1}").should == {:"a!" => 1}
+    {a!:1}.should == {:"a!" => 1}
+    {a!: 1}.should == {:"a!" => 1}
   end
 
   it "raises a SyntaxError if there is no space between `!` and `=>`" do
     -> { eval("{:a!=> 1}") }.should raise_error(SyntaxError)
   end
 
   it "recognizes '?' at the end of the key" do
-    eval("{:a? =>1}").should == {:"a?" => 1}
-    eval("{:a? => 1}").should == {:"a?" => 1}
+    {:a? =>1}.should == {:"a?" => 1}
+    {:a? => 1}.should == {:"a?" => 1}
 
-    eval("{a?:1}").should == {:"a?" => 1}
-    eval("{a?: 1}").should == {:"a?" => 1}
+    {a?:1}.should == {:"a?" => 1}
+    {a?: 1}.should == {:"a?" => 1}
   end
 
   it "raises a SyntaxError if there is no space between `?` and `=>`" do
@@ -127,7 +127,7 @@
 
   it "accepts mixed 'key: value', 'key => value' and '\"key\"': value' syntax" do
     h = {:a => 1, :b => 2, "c" => 3, :d => 4}
-    eval('{a: 1, :b => 2, "c" => 3, "d": 4}').should == h
+    {a: 1, :b => 2, "c" => 3, "d": 4}.should == h
   end
 
   it "expands an '**{}' element into the containing Hash literal initialization" do
@@ -260,22 +260,22 @@ def m(h)
   describe "hash with omitted value" do
     it "accepts short notation 'key' for 'key: value' syntax" do
       a, b, c = 1, 2, 3
-      h = eval('{a:}')
+      h = {a:}
       {a: 1}.should == h
-      h = eval('{a:, b:, c:}')
+      h = {a:, b:, c:}
       {a: 1, b: 2, c: 3}.should == h
     end
 
     it "ignores hanging comma on short notation" do
       a, b, c = 1, 2, 3
-      h = eval('{a:, b:, c:,}')
+      h = {a:, b:, c:,}
       {a: 1, b: 2, c: 3}.should == h
     end
 
     it "accepts mixed syntax" do
       a, e = 1, 5
-      h = eval('{a:, b: 2, "c" => 3, :d => 4, e:}')
-      eval('{a: 1, :b => 2, "c" => 3, "d": 4, e: 5}').should == h
+      h = {a:, b: 2, "c" => 3, :d => 4, e:}
+      {a: 1, :b => 2, "c" => 3, "d": 4, e: 5}.should == h
     end
 
     it "works with methods and local vars" do

language/keyword_arguments_spec.rb

@@ -332,7 +332,7 @@ def m(a:, b:)
         a = 1
         b = 2
 
-        eval('m(a:, b:).should == [1, 2]')
+        m(a:, b:).should == [1, 2]
       end
     end