diff options
Diffstat (limited to 'spec/ruby/core/proc')
22 files changed, 264 insertions, 175 deletions
diff --git a/spec/ruby/core/proc/allocate_spec.rb b/spec/ruby/core/proc/allocate_spec.rb index 54e1b69df9..96c4eb9fa8 100644 --- a/spec/ruby/core/proc/allocate_spec.rb +++ b/spec/ruby/core/proc/allocate_spec.rb @@ -4,6 +4,6 @@ describe "Proc.allocate" do it "raises a TypeError" do -> { Proc.allocate - }.should raise_error(TypeError) + }.should.raise(TypeError) end end diff --git a/spec/ruby/core/proc/arity_spec.rb b/spec/ruby/core/proc/arity_spec.rb index f7cb5ad0f8..5c7728cb30 100644 --- a/spec/ruby/core/proc/arity_spec.rb +++ b/spec/ruby/core/proc/arity_spec.rb @@ -268,6 +268,14 @@ describe "Proc#arity" do @a.arity.should == 3 @b.arity.should == 3 end + + # implicit rest + evaluate <<-ruby do + @a = lambda { |a, | } + ruby + + @a.arity.should == 1 + end end context "returns negative values" do @@ -530,6 +538,14 @@ describe "Proc#arity" do @a.arity.should == 1 @b.arity.should == 5 end + + # implicit rest + evaluate <<-ruby do + @a = proc { |a, | } + ruby + + @a.arity.should == 1 + end end context "returns negative values" do diff --git a/spec/ruby/core/proc/binding_spec.rb b/spec/ruby/core/proc/binding_spec.rb index 86ab6bd400..d643cbf89c 100644 --- a/spec/ruby/core/proc/binding_spec.rb +++ b/spec/ruby/core/proc/binding_spec.rb @@ -3,7 +3,7 @@ require_relative '../../spec_helper' describe "Proc#binding" do it "returns a Binding instance" do [Proc.new{}, -> {}, proc {}].each { |p| - p.binding.should be_kind_of(Binding) + p.binding.should.is_a?(Binding) } end diff --git a/spec/ruby/core/proc/block_pass_spec.rb b/spec/ruby/core/proc/block_pass_spec.rb index 411c0bf3db..82c08db8a7 100644 --- a/spec/ruby/core/proc/block_pass_spec.rb +++ b/spec/ruby/core/proc/block_pass_spec.rb @@ -8,14 +8,14 @@ describe "Proc as a block pass argument" do it "remains the same object if re-vivified by the target method" do p = Proc.new {} p2 = revivify(&p) - p.should equal p2 + p.should.equal? p2 p.should == p2 end it "remains the same object if reconstructed with Proc.new" do p = Proc.new {} p2 = Proc.new(&p) - p.should equal p2 + p.should.equal? p2 p.should == p2 end end diff --git a/spec/ruby/core/proc/clone_spec.rb b/spec/ruby/core/proc/clone_spec.rb index 7eca9c561e..aee4873e09 100644 --- a/spec/ruby/core/proc/clone_spec.rb +++ b/spec/ruby/core/proc/clone_spec.rb @@ -1,10 +1,11 @@ require_relative '../../spec_helper' +require_relative 'fixtures/common' require_relative 'shared/dup' describe "Proc#clone" do it_behaves_like :proc_dup, :clone - ruby_bug "cloning a frozen proc is broken on Ruby 3.3", "3.3"..."3.4" do + ruby_bug "cloning a frozen proc is broken on Ruby 3.3", ""..."3.4" do it "preserves frozen status" do proc = Proc.new { } proc.freeze @@ -12,4 +13,16 @@ describe "Proc#clone" do proc.clone.frozen?.should == true end end + + it "calls #initialize_clone on subclass" do + obj = ProcSpecs::MyProc2.new(:a, 2) { } + dup = obj.clone + + dup.should_not.equal?(obj) + dup.class.should == ProcSpecs::MyProc2 + + dup.first.should == :a + dup.second.should == 2 + dup.initializer.should == :clone + end end diff --git a/spec/ruby/core/proc/curry_spec.rb b/spec/ruby/core/proc/curry_spec.rb index 24df2a8a72..de13983ca6 100644 --- a/spec/ruby/core/proc/curry_spec.rb +++ b/spec/ruby/core/proc/curry_spec.rb @@ -8,12 +8,12 @@ describe "Proc#curry" do it "returns a Proc when called on a proc" do p = proc { true } - p.curry.should be_an_instance_of(Proc) + p.curry.should.instance_of?(Proc) end it "returns a Proc when called on a lambda" do p = -> { true } - p.curry.should be_an_instance_of(Proc) + p.curry.should.instance_of?(Proc) end it "calls the curried proc with the arguments if sufficient arguments have been given" do @@ -23,11 +23,11 @@ describe "Proc#curry" do it "returns a Proc that consumes the remainder of the arguments unless sufficient arguments have been given" do proc2 = @proc_add.curry[1][2] - proc2.should be_an_instance_of(Proc) + proc2.should.instance_of?(Proc) proc2.call(3).should == 6 lambda2 = @lambda_add.curry[1][2] - lambda2.should be_an_instance_of(Proc) + lambda2.should.instance_of?(Proc) lambda2.call(3).should == 6 @proc_add.curry.call(1,2,3).should == 6 @@ -36,10 +36,10 @@ describe "Proc#curry" do it "can be called multiple times on the same Proc" do @proc_add.curry - -> { @proc_add.curry }.should_not raise_error + -> { @proc_add.curry }.should_not.raise @lambda_add.curry - -> { @lambda_add.curry }.should_not raise_error + -> { @lambda_add.curry }.should_not.raise end it "can be passed superfluous arguments if created from a proc" do @@ -49,8 +49,8 @@ describe "Proc#curry" do end it "raises an ArgumentError if passed superfluous arguments when created from a lambda" do - -> { @lambda_add.curry[1,2,3,4] }.should raise_error(ArgumentError) - -> { @lambda_add.curry[1,2].curry[3,4,5,6] }.should raise_error(ArgumentError) + -> { @lambda_add.curry[1,2,3,4] }.should.raise(ArgumentError) + -> { @lambda_add.curry[1,2].curry[3,4,5,6] }.should.raise(ArgumentError) end it "returns Procs with arities of -1" do @@ -63,7 +63,7 @@ describe "Proc#curry" do it "produces Procs that raise ArgumentError for #binding" do -> do @proc_add.curry.binding - end.should raise_error(ArgumentError) + end.should.raise(ArgumentError) end it "produces Procs that return [[:rest]] for #parameters" do @@ -98,41 +98,41 @@ describe "Proc#curry with arity argument" do end it "accepts an optional Integer argument for the arity" do - -> { @proc_add.curry(3) }.should_not raise_error - -> { @lambda_add.curry(3) }.should_not raise_error + -> { @proc_add.curry(3) }.should_not.raise + -> { @lambda_add.curry(3) }.should_not.raise end it "returns a Proc when called on a proc" do - @proc_add.curry(3).should be_an_instance_of(Proc) + @proc_add.curry(3).should.instance_of?(Proc) end it "returns a Proc when called on a lambda" do - @lambda_add.curry(3).should be_an_instance_of(Proc) + @lambda_add.curry(3).should.instance_of?(Proc) end # [ruby-core:24127] it "retains the lambda-ness of the Proc on which its called" do - @lambda_add.curry(3).lambda?.should be_true - @proc_add.curry(3).lambda?.should be_false + @lambda_add.curry(3).lambda?.should == true + @proc_add.curry(3).lambda?.should == false end it "raises an ArgumentError if called on a lambda that requires more than _arity_ arguments" do - -> { @lambda_add.curry(2) }.should raise_error(ArgumentError) - -> { -> x, y, z, *more{}.curry(2) }.should raise_error(ArgumentError) + -> { @lambda_add.curry(2) }.should.raise(ArgumentError) + -> { -> x, y, z, *more{}.curry(2) }.should.raise(ArgumentError) end it 'returns a Proc if called on a lambda that requires fewer than _arity_ arguments but may take more' do - -> a, b, c, d=nil, e=nil {}.curry(4).should be_an_instance_of(Proc) - -> a, b, c, d=nil, *e {}.curry(4).should be_an_instance_of(Proc) - -> a, b, c, *d {}.curry(4).should be_an_instance_of(Proc) + -> a, b, c, d=nil, e=nil {}.curry(4).should.instance_of?(Proc) + -> a, b, c, d=nil, *e {}.curry(4).should.instance_of?(Proc) + -> a, b, c, *d {}.curry(4).should.instance_of?(Proc) end it "raises an ArgumentError if called on a lambda that requires fewer than _arity_ arguments" do - -> { @lambda_add.curry(4) }.should raise_error(ArgumentError) - -> { -> { true }.curry(1) }.should raise_error(ArgumentError) - -> { -> a, b=nil {}.curry(5) }.should raise_error(ArgumentError) - -> { -> a, &b {}.curry(2) }.should raise_error(ArgumentError) - -> { -> a, b=nil, &c {}.curry(3) }.should raise_error(ArgumentError) + -> { @lambda_add.curry(4) }.should.raise(ArgumentError) + -> { -> { true }.curry(1) }.should.raise(ArgumentError) + -> { -> a, b=nil {}.curry(5) }.should.raise(ArgumentError) + -> { -> a, &b {}.curry(2) }.should.raise(ArgumentError) + -> { -> a, b=nil, &c {}.curry(3) }.should.raise(ArgumentError) end it "calls the curried proc with the arguments if _arity_ arguments have been given" do @@ -142,32 +142,31 @@ describe "Proc#curry with arity argument" do it "returns a Proc that consumes the remainder of the arguments when fewer than _arity_ arguments are given" do proc2 = @proc_add.curry(3)[1][2] - proc2.should be_an_instance_of(Proc) + proc2.should.instance_of?(Proc) proc2.call(3).should == 6 lambda2 = @lambda_add.curry(3)[1][2] - lambda2.should be_an_instance_of(Proc) + lambda2.should.instance_of?(Proc) lambda2.call(3).should == 6 end it "can be specified multiple times on the same Proc" do @proc_add.curry(2) - -> { @proc_add.curry(1) }.should_not raise_error + -> { @proc_add.curry(1) }.should_not.raise @lambda_add.curry(3) - -> { @lambda_add.curry(3) }.should_not raise_error + -> { @lambda_add.curry(3) }.should_not.raise end it "can be passed more than _arity_ arguments if created from a proc" do - -> { @proc_add.curry(3)[1,2,3,4].should == 6 }.should_not - raise_error(ArgumentError) - -> { @proc_add.curry(1)[1,2].curry(3)[3,4,5,6].should == 6 }.should_not - raise_error(ArgumentError) + @proc_add.curry(3)[1,2,3,4].should == 6 + + @proc_add.curry(3)[1,2].curry(3)[3,4,5,6].should == 6 end it "raises an ArgumentError if passed more than _arity_ arguments when created from a lambda" do - -> { @lambda_add.curry(3)[1,2,3,4] }.should raise_error(ArgumentError) - -> { @lambda_add.curry(1)[1,2].curry(3)[3,4,5,6] }.should raise_error(ArgumentError) + -> { @lambda_add.curry(3)[1,2,3,4] }.should.raise(ArgumentError) + -> { @lambda_add.curry(3)[1,2].curry(3)[3,4,5,6] }.should.raise(ArgumentError) end it "returns Procs with arities of -1 regardless of the value of _arity_" do diff --git a/spec/ruby/core/proc/dup_spec.rb b/spec/ruby/core/proc/dup_spec.rb index dd19b3c1e9..8604389422 100644 --- a/spec/ruby/core/proc/dup_spec.rb +++ b/spec/ruby/core/proc/dup_spec.rb @@ -1,4 +1,5 @@ require_relative '../../spec_helper' +require_relative 'fixtures/common' require_relative 'shared/dup' describe "Proc#dup" do @@ -10,4 +11,16 @@ describe "Proc#dup" do proc.frozen?.should == true proc.dup.frozen?.should == false end + + it "calls #initialize_dup on subclass" do + obj = ProcSpecs::MyProc2.new(:a, 2) { } + dup = obj.dup + + dup.should_not.equal?(obj) + dup.class.should == ProcSpecs::MyProc2 + + dup.first.should == :a + dup.second.should == 2 + dup.initializer.should == :dup + end end diff --git a/spec/ruby/core/proc/element_reference_spec.rb b/spec/ruby/core/proc/element_reference_spec.rb index 9077e44c34..ea3a915a11 100644 --- a/spec/ruby/core/proc/element_reference_spec.rb +++ b/spec/ruby/core/proc/element_reference_spec.rb @@ -17,11 +17,11 @@ describe "Proc#call on a Proc created with Kernel#lambda or Kernel#proc" do it_behaves_like :proc_call_on_proc_or_lambda, :call end -describe "Proc#[] with frozen_string_literals" do +describe "Proc#[] with frozen_string_literal: true/false" do it "doesn't duplicate frozen strings" do - ProcArefSpecs.aref.frozen?.should be_false - ProcArefSpecs.aref_freeze.frozen?.should be_true - ProcArefFrozenSpecs.aref.frozen?.should be_true - ProcArefFrozenSpecs.aref_freeze.frozen?.should be_true + ProcArefSpecs.aref.frozen?.should == false + ProcArefSpecs.aref_freeze.frozen?.should == true + ProcArefFrozenSpecs.aref.frozen?.should == true + ProcArefFrozenSpecs.aref_freeze.frozen?.should == true end end diff --git a/spec/ruby/core/proc/fixtures/common.rb b/spec/ruby/core/proc/fixtures/common.rb index 6e27a2dee7..dfe67d7ba8 100644 --- a/spec/ruby/core/proc/fixtures/common.rb +++ b/spec/ruby/core/proc/fixtures/common.rb @@ -32,7 +32,28 @@ module ProcSpecs @second = b end - attr_reader :first, :second + attr_reader :first, :second, :initializer + + def initialize_copy(other) + super + @initializer = :copy + @first = other.first + @second = other.second + end + + def initialize_dup(other) + super + @initializer = :dup + @first = other.first + @second = other.second + end + + def initialize_clone(other, **options) + super + @initializer = :clone + @first = other.first + @second = other.second + end end class Arity diff --git a/spec/ruby/core/proc/fixtures/proc_aref.rb b/spec/ruby/core/proc/fixtures/proc_aref.rb index a305667797..8ee355b14c 100644 --- a/spec/ruby/core/proc/fixtures/proc_aref.rb +++ b/spec/ruby/core/proc/fixtures/proc_aref.rb @@ -1,3 +1,4 @@ +# frozen_string_literal: false module ProcArefSpecs def self.aref proc {|a| a }["sometext"] diff --git a/spec/ruby/core/proc/hash_spec.rb b/spec/ruby/core/proc/hash_spec.rb index ebe0fde1a0..adcb1ccb78 100644 --- a/spec/ruby/core/proc/hash_spec.rb +++ b/spec/ruby/core/proc/hash_spec.rb @@ -2,12 +2,12 @@ require_relative '../../spec_helper' describe "Proc#hash" do it "is provided" do - proc {}.respond_to?(:hash).should be_true - -> {}.respond_to?(:hash).should be_true + proc {}.respond_to?(:hash).should == true + -> {}.respond_to?(:hash).should == true end it "returns an Integer" do - proc { 1 + 489 }.hash.should be_kind_of(Integer) + proc { 1 + 489 }.hash.should.is_a?(Integer) end it "is stable" do diff --git a/spec/ruby/core/proc/lambda_spec.rb b/spec/ruby/core/proc/lambda_spec.rb index 5c3c38fc2a..1ff6147319 100644 --- a/spec/ruby/core/proc/lambda_spec.rb +++ b/spec/ruby/core/proc/lambda_spec.rb @@ -3,60 +3,53 @@ require_relative 'fixtures/common' describe "Proc#lambda?" do it "returns true if the Proc was created from a block with the lambda keyword" do - -> {}.lambda?.should be_true + -> {}.lambda?.should == true end it "returns false if the Proc was created from a block with the proc keyword" do - proc {}.lambda?.should be_false + proc {}.lambda?.should == false end it "returns false if the Proc was created from a block with Proc.new" do - Proc.new {}.lambda?.should be_false - end - - ruby_version_is ""..."3.3" do - it "is preserved when passing a Proc with & to the lambda keyword" do - suppress_warning {lambda(&->{})}.lambda?.should be_true - suppress_warning {lambda(&proc{})}.lambda?.should be_false - end + Proc.new {}.lambda?.should == false end it "is preserved when passing a Proc with & to the proc keyword" do - proc(&->{}).lambda?.should be_true - proc(&proc{}).lambda?.should be_false + proc(&->{}).lambda?.should == true + proc(&proc{}).lambda?.should == false end it "is preserved when passing a Proc with & to Proc.new" do - Proc.new(&->{}).lambda?.should be_true - Proc.new(&proc{}).lambda?.should be_false + Proc.new(&->{}).lambda?.should == true + Proc.new(&proc{}).lambda?.should == false end it "returns false if the Proc was created from a block with &" do - ProcSpecs.new_proc_from_amp{}.lambda?.should be_false + ProcSpecs.new_proc_from_amp{}.lambda?.should == false end it "is preserved when the Proc was passed using &" do - ProcSpecs.new_proc_from_amp(&->{}).lambda?.should be_true - ProcSpecs.new_proc_from_amp(&proc{}).lambda?.should be_false - ProcSpecs.new_proc_from_amp(&Proc.new{}).lambda?.should be_false + ProcSpecs.new_proc_from_amp(&->{}).lambda?.should == true + ProcSpecs.new_proc_from_amp(&proc{}).lambda?.should == false + ProcSpecs.new_proc_from_amp(&Proc.new{}).lambda?.should == false end it "returns true for a Method converted to a Proc" do m = :foo.method(:to_s) - m.to_proc.lambda?.should be_true - ProcSpecs.new_proc_from_amp(&m).lambda?.should be_true + m.to_proc.lambda?.should == true + ProcSpecs.new_proc_from_amp(&m).lambda?.should == true end # [ruby-core:24127] it "is preserved when a Proc is curried" do - ->{}.curry.lambda?.should be_true - proc{}.curry.lambda?.should be_false - Proc.new{}.curry.lambda?.should be_false + ->{}.curry.lambda?.should == true + proc{}.curry.lambda?.should == false + Proc.new{}.curry.lambda?.should == false end it "is preserved when a curried Proc is called without enough arguments" do - -> x, y{}.curry.call(42).lambda?.should be_true - proc{|x,y|}.curry.call(42).lambda?.should be_false - Proc.new{|x,y|}.curry.call(42).lambda?.should be_false + -> x, y{}.curry.call(42).lambda?.should == true + proc{|x,y|}.curry.call(42).lambda?.should == false + Proc.new{|x,y|}.curry.call(42).lambda?.should == false end end diff --git a/spec/ruby/core/proc/new_spec.rb b/spec/ruby/core/proc/new_spec.rb index b2b7387756..f0b817f0cb 100644 --- a/spec/ruby/core/proc/new_spec.rb +++ b/spec/ruby/core/proc/new_spec.rb @@ -71,7 +71,7 @@ describe "Proc.new with an associated block" do end res = some_method() - -> { res.call }.should raise_error(LocalJumpError) + -> { res.call }.should.raise(LocalJumpError) end it "returns from within enclosing method when 'return' is used in the block" do @@ -86,7 +86,7 @@ describe "Proc.new with an associated block" do it "returns a subclass of Proc" do obj = ProcSpecs::MyProc.new { } - obj.should be_kind_of(ProcSpecs::MyProc) + obj.should.is_a?(ProcSpecs::MyProc) end it "calls initialize on the Proc object" do @@ -101,7 +101,7 @@ describe "Proc.new with a block argument" do passed_prc = Proc.new { "hello".size } prc = Proc.new(&passed_prc) - prc.should equal(passed_prc) + prc.should.equal?(passed_prc) prc.call.should == 5 end @@ -110,7 +110,7 @@ describe "Proc.new with a block argument" do passed_prc = Proc.new(&method) prc = Proc.new(&passed_prc) - prc.should equal(passed_prc) + prc.should.equal?(passed_prc) prc.call.should == 5 end @@ -118,7 +118,7 @@ describe "Proc.new with a block argument" do passed_prc = Proc.new(&:size) prc = Proc.new(&passed_prc) - prc.should equal(passed_prc) + prc.should.equal?(passed_prc) prc.call("hello").should == 5 end end @@ -129,7 +129,7 @@ describe "Proc.new with a block argument called indirectly from a subclass" do passed_prc.class.should == ProcSpecs::MyProc prc = ProcSpecs::MyProc.new(&passed_prc) - prc.should equal(passed_prc) + prc.should.equal?(passed_prc) prc.call.should == 5 end @@ -139,7 +139,7 @@ describe "Proc.new with a block argument called indirectly from a subclass" do passed_prc.class.should == ProcSpecs::MyProc prc = ProcSpecs::MyProc.new(&passed_prc) - prc.should equal(passed_prc) + prc.should.equal?(passed_prc) prc.call.should == 5 end @@ -148,22 +148,22 @@ describe "Proc.new with a block argument called indirectly from a subclass" do passed_prc.class.should == ProcSpecs::MyProc prc = ProcSpecs::MyProc.new(&passed_prc) - prc.should equal(passed_prc) + prc.should.equal?(passed_prc) prc.call("hello").should == 5 end end describe "Proc.new without a block" do it "raises an ArgumentError" do - -> { Proc.new }.should raise_error(ArgumentError) + -> { Proc.new }.should.raise(ArgumentError) end it "raises an ArgumentError if invoked from within a method with no block" do - -> { ProcSpecs.new_proc_in_method }.should raise_error(ArgumentError) + -> { ProcSpecs.new_proc_in_method }.should.raise(ArgumentError) end it "raises an ArgumentError if invoked on a subclass from within a method with no block" do - -> { ProcSpecs.new_proc_subclass_in_method }.should raise_error(ArgumentError) + -> { ProcSpecs.new_proc_subclass_in_method }.should.raise(ArgumentError) end it "raises an ArgumentError when passed no block" do @@ -171,8 +171,8 @@ describe "Proc.new without a block" do Proc.new end - -> { ProcSpecs.new_proc_in_method { "hello" } }.should raise_error(ArgumentError, 'tried to create Proc object without a block') - -> { ProcSpecs.new_proc_subclass_in_method { "hello" } }.should raise_error(ArgumentError, 'tried to create Proc object without a block') - -> { some_method { "hello" } }.should raise_error(ArgumentError, 'tried to create Proc object without a block') + -> { ProcSpecs.new_proc_in_method { "hello" } }.should.raise(ArgumentError, 'tried to create Proc object without a block') + -> { ProcSpecs.new_proc_subclass_in_method { "hello" } }.should.raise(ArgumentError, 'tried to create Proc object without a block') + -> { some_method { "hello" } }.should.raise(ArgumentError, 'tried to create Proc object without a block') end end diff --git a/spec/ruby/core/proc/parameters_spec.rb b/spec/ruby/core/proc/parameters_spec.rb index 2a4dcc36b3..ac8c6e3560 100644 --- a/spec/ruby/core/proc/parameters_spec.rb +++ b/spec/ruby/core/proc/parameters_spec.rb @@ -7,8 +7,8 @@ describe "Proc#parameters" do it "returns an Array of Arrays for a proc expecting parameters" do p = proc {|x| } - p.parameters.should be_an_instance_of(Array) - p.parameters.first.should be_an_instance_of(Array) + p.parameters.should.instance_of?(Array) + p.parameters.first.should.instance_of?(Array) end it "sets the first element of each sub-Array to :opt for optional arguments" do @@ -20,19 +20,27 @@ describe "Proc#parameters" do proc {|x| }.parameters.first.first.should == :opt end - ruby_version_is "3.2" do - it "sets the first element of each sub-Array to :req for required argument if lambda keyword used" do - proc {|x| }.parameters(lambda: true).first.first.should == :req - proc {|y,*x| }.parameters(lambda: true).first.first.should == :req - end + it "sets the first element of each sub-Array to :req for required argument if lambda keyword used" do + proc {|x| }.parameters(lambda: true).first.first.should == :req + proc {|y,*x| }.parameters(lambda: true).first.first.should == :req + end - it "regards named parameters in procs as required if lambda keyword used" do - proc {|x| }.parameters(lambda: true).first.first.should == :req - end + it "regards named parameters in procs as required if lambda keyword used" do + proc {|x| }.parameters(lambda: true).first.first.should == :req + end - it "regards named parameters in lambda as optional if lambda: false keyword used" do - -> x { }.parameters(lambda: false).first.first.should == :opt - end + it "regards named parameters in lambda as optional if lambda: false keyword used" do + -> x { }.parameters(lambda: false).first.first.should == :opt + end + + it "regards named parameters in procs and lambdas as required if lambda keyword is truthy" do + proc {|x| }.parameters(lambda: 123).first.first.should == :req + -> x { }.parameters(lambda: 123).first.first.should == :req + end + + it "ignores the lambda keyword if it is nil" do + proc {|x|}.parameters(lambda: nil).first.first.should == :opt + -> x { }.parameters(lambda: nil).first.first.should == :req end it "regards optional keyword parameters in procs as optional" do @@ -54,7 +62,7 @@ describe "Proc#parameters" do end it "regards keyword parameters in lambdas as required" do - eval("lambda {|x:| }").parameters.first.first.should == :keyreq + -> x: { }.parameters.first.first.should == :keyreq end it "sets the first element of each sub-Array to :rest for parameters prefixed with asterisks" do @@ -95,30 +103,21 @@ describe "Proc#parameters" do -> x {}.parameters.should == [[:req, :x]] end - ruby_version_is '3.2' do - it "adds rest arg with name * for \"star\" argument" do - -> * {}.parameters.should == [[:rest, :*]] - end - - it "adds keyrest arg with ** as a name for \"double star\" argument" do - -> ** {}.parameters.should == [[:keyrest, :**]] - end + it "ignores implicit rest arguments" do + proc { |x, | }.parameters.should == [[:opt, :x]] + -> x { }.parameters.should == [[:req, :x]] end - ruby_version_is ''...'3.2' do - it "adds nameless rest arg for \"star\" argument" do - -> * {}.parameters.should == [[:rest]] - end + it "adds rest arg with name * for \"star\" argument" do + -> * {}.parameters.should == [[:rest, :*]] + end - it "adds nameless keyrest arg for \"double star\" argument" do - -> ** {}.parameters.should == [[:keyrest]] - end + it "adds keyrest arg with ** as a name for \"double star\" argument" do + -> ** {}.parameters.should == [[:keyrest, :**]] end - ruby_version_is '3.1' do - it "adds block arg with name & for anonymous block argument" do - eval('-> & {}.parameters').should == [[:block, :&]] - end + it "adds block arg with name & for anonymous block argument" do + -> & {}.parameters.should == [[:block, :&]] end it "does not add locals as block options with a block and splat" do @@ -155,4 +154,30 @@ describe "Proc#parameters" do [:block, :_] ] end + + it "returns :nokey for **nil parameter" do + proc { |**nil| }.parameters.should == [[:nokey]] + end + + ruby_version_is "3.4"..."4.0" do + it "handles the usage of `it` as a parameter" do + eval("proc { it }").parameters.should == [[:opt, nil]] + eval("lambda { it }").parameters.should == [[:req]] + end + end + + ruby_version_is "4.0" do + it "handles the usage of `it` as a parameter" do + eval("proc { it }").parameters.should == [[:opt]] + eval("lambda { it }").parameters.should == [[:req]] + end + end + + ruby_version_is "4.1" do + it "returns :noblock for &nil parameter" do + eval <<~RUBY + proc { |&nil| }.parameters.should == [[:noblock]] + RUBY + end + end end diff --git a/spec/ruby/core/proc/ruby2_keywords_spec.rb b/spec/ruby/core/proc/ruby2_keywords_spec.rb index ab67302231..e06fad8693 100644 --- a/spec/ruby/core/proc/ruby2_keywords_spec.rb +++ b/spec/ruby/core/proc/ruby2_keywords_spec.rb @@ -27,7 +27,7 @@ describe "Proc#ruby2_keywords" do it "returns self" do f = -> *a { } - f.ruby2_keywords.should equal f + f.ruby2_keywords.should.equal? f end it "prints warning when a proc does not accept argument splat" do @@ -39,7 +39,7 @@ describe "Proc#ruby2_keywords" do end it "prints warning when a proc accepts keywords" do - f = -> a:, b: { } + f = -> *a, b: { } -> { f.ruby2_keywords @@ -47,10 +47,20 @@ describe "Proc#ruby2_keywords" do end it "prints warning when a proc accepts keyword splat" do - f = -> **a { } + f = -> *a, **b { } -> { f.ruby2_keywords }.should complain(/Skipping set of ruby2_keywords flag for/) end + + ruby_version_is "4.0" do + it "prints warning when a proc accepts post arguments" do + f = -> *a, b { } + + -> { + f.ruby2_keywords + }.should complain(/Skipping set of ruby2_keywords flag for/) + end + end end diff --git a/spec/ruby/core/proc/shared/call.rb b/spec/ruby/core/proc/shared/call.rb index dbec34df4b..fae2331b68 100644 --- a/spec/ruby/core/proc/shared/call.rb +++ b/spec/ruby/core/proc/shared/call.rb @@ -70,21 +70,21 @@ describe :proc_call_on_proc_or_lambda, shared: true do it "raises an ArgumentError on excess arguments when self is a lambda" do -> { -> x { x }.send(@method, 1, 2) - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) -> { -> x { x }.send(@method, 1, 2, 3) - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end it "raises an ArgumentError on missing arguments when self is a lambda" do -> { -> x { x }.send(@method) - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) -> { -> x, y { [x,y] }.send(@method, 1) - }.should raise_error(ArgumentError) + }.should.raise(ArgumentError) end it "treats a single Array argument as a single argument when self is a lambda" do diff --git a/spec/ruby/core/proc/shared/compose.rb b/spec/ruby/core/proc/shared/compose.rb index 3d3f3b310d..c004cec7c9 100644 --- a/spec/ruby/core/proc/shared/compose.rb +++ b/spec/ruby/core/proc/shared/compose.rb @@ -5,7 +5,7 @@ describe :proc_compose, shared: true do -> { lhs.send(@method, not_callable) - }.should raise_error(TypeError, "callable object is expected") + }.should.raise(TypeError, "callable object is expected") end @@ -17,6 +17,6 @@ describe :proc_compose, shared: true do -> { lhs.send(@method, succ) - }.should raise_error(TypeError, "callable object is expected") + }.should.raise(TypeError, "callable object is expected") end end diff --git a/spec/ruby/core/proc/shared/dup.rb b/spec/ruby/core/proc/shared/dup.rb index c419a4078a..2821d2e00f 100644 --- a/spec/ruby/core/proc/shared/dup.rb +++ b/spec/ruby/core/proc/shared/dup.rb @@ -3,17 +3,15 @@ describe :proc_dup, shared: true do a = -> { "hello" } b = a.send(@method) - a.should_not equal(b) + a.should_not.equal?(b) a.call.should == b.call end - ruby_version_is "3.2" do - it "returns an instance of subclass" do - cl = Class.new(Proc) + it "returns an instance of subclass" do + cl = Class.new(Proc) - cl.new{}.send(@method).class.should == cl - end + cl.new{}.send(@method).class.should == cl end ruby_version_is "3.4" do @@ -25,7 +23,7 @@ describe :proc_dup, shared: true do end it "copies the finalizer" do - code = <<-RUBY + code = <<-'RUBY' obj = Proc.new { } ObjectSpace.define_finalizer(obj, Proc.new { STDOUT.write "finalized\n" }) diff --git a/spec/ruby/core/proc/shared/equal.rb b/spec/ruby/core/proc/shared/equal.rb index d0503fb064..4f6f6c41be 100644 --- a/spec/ruby/core/proc/shared/equal.rb +++ b/spec/ruby/core/proc/shared/equal.rb @@ -3,29 +3,29 @@ require_relative '../fixtures/common' describe :proc_equal, shared: true do it "is a public method" do - Proc.should have_public_instance_method(@method, false) + Proc.public_instance_methods(false).should.include?(@method) end it "returns true if self and other are the same object" do p = proc { :foo } - p.send(@method, p).should be_true + p.send(@method, p).should == true p = Proc.new { :foo } - p.send(@method, p).should be_true + p.send(@method, p).should == true p = -> { :foo } - p.send(@method, p).should be_true + p.send(@method, p).should == true end it "returns true if other is a dup of the original" do p = proc { :foo } - p.send(@method, p.dup).should be_true + p.send(@method, p.dup).should == true p = Proc.new { :foo } - p.send(@method, p.dup).should be_true + p.send(@method, p.dup).should == true p = -> { :foo } - p.send(@method, p.dup).should be_true + p.send(@method, p.dup).should == true end # identical here means the same method invocation. @@ -33,51 +33,51 @@ describe :proc_equal, shared: true do a = ProcSpecs.proc_for_1 b = ProcSpecs.proc_for_1 - a.send(@method, b).should be_false + a.send(@method, b).should == false end it "returns false if procs are distinct but have the same body and environment" do p = proc { :foo } p2 = proc { :foo } - p.send(@method, p2).should be_false + p.send(@method, p2).should == false end it "returns false if lambdas are distinct but have same body and environment" do x = -> { :foo } x2 = -> { :foo } - x.send(@method, x2).should be_false + x.send(@method, x2).should == false end it "returns false if using comparing lambda to proc, even with the same body and env" do p = -> { :foo } p2 = proc { :foo } - p.send(@method, p2).should be_false + p.send(@method, p2).should == false x = proc { :bar } x2 = -> { :bar } - x.send(@method, x2).should be_false + x.send(@method, x2).should == false end it "returns false if other is not a Proc" do p = proc { :foo } - p.send(@method, []).should be_false + p.send(@method, []).should == false p = Proc.new { :foo } - p.send(@method, Object.new).should be_false + p.send(@method, Object.new).should == false p = -> { :foo } - p.send(@method, :foo).should be_false + p.send(@method, :foo).should == false end it "returns false if self and other are both procs but have different bodies" do p = proc { :bar } p2 = proc { :foo } - p.send(@method, p2).should be_false + p.send(@method, p2).should == false end it "returns false if self and other are both lambdas but have different bodies" do p = -> { :foo } p2 = -> { :bar } - p.send(@method, p2).should be_false + p.send(@method, p2).should == false end end diff --git a/spec/ruby/core/proc/shared/to_s.rb b/spec/ruby/core/proc/shared/to_s.rb index f1e2f416fc..a52688a89f 100644 --- a/spec/ruby/core/proc/shared/to_s.rb +++ b/spec/ruby/core/proc/shared/to_s.rb @@ -31,13 +31,13 @@ describe :proc_to_s, shared: true do describe "for a proc created with UnboundMethod#to_proc" do it "returns a description including '(lambda)' and optionally including file and line number" do - def hello; end - s = method("hello").to_proc.send(@method) - if s.include? __FILE__ - s.should =~ /^#<Proc:([^ ]*?) #{Regexp.escape __FILE__}:#{__LINE__ - 3} \(lambda\)>$/ - else - s.should =~ /^#<Proc:([^ ]*?) \(lambda\)>$/ - end + def hello; end + s = method("hello").to_proc.send(@method) + if s.include? __FILE__ + s.should =~ /^#<Proc:([^ ]*?) #{Regexp.escape __FILE__}:#{__LINE__ - 3} \(lambda\)>$/ + else + s.should =~ /^#<Proc:([^ ]*?) \(lambda\)>$/ + end end it "has a binary encoding" do diff --git a/spec/ruby/core/proc/source_location_spec.rb b/spec/ruby/core/proc/source_location_spec.rb index a8b99287d5..d27ad0559e 100644 --- a/spec/ruby/core/proc/source_location_spec.rb +++ b/spec/ruby/core/proc/source_location_spec.rb @@ -10,45 +10,45 @@ describe "Proc#source_location" do end it "returns an Array" do - @proc.source_location.should be_an_instance_of(Array) - @proc_new.source_location.should be_an_instance_of(Array) - @lambda.source_location.should be_an_instance_of(Array) - @method.source_location.should be_an_instance_of(Array) + @proc.source_location.should.instance_of?(Array) + @proc_new.source_location.should.instance_of?(Array) + @lambda.source_location.should.instance_of?(Array) + @method.source_location.should.instance_of?(Array) end it "sets the first value to the path of the file in which the proc was defined" do file = @proc.source_location.first - file.should be_an_instance_of(String) + file.should.instance_of?(String) file.should == File.realpath('fixtures/source_location.rb', __dir__) file = @proc_new.source_location.first - file.should be_an_instance_of(String) + file.should.instance_of?(String) file.should == File.realpath('fixtures/source_location.rb', __dir__) file = @lambda.source_location.first - file.should be_an_instance_of(String) + file.should.instance_of?(String) file.should == File.realpath('fixtures/source_location.rb', __dir__) file = @method.source_location.first - file.should be_an_instance_of(String) + file.should.instance_of?(String) file.should == File.realpath('fixtures/source_location.rb', __dir__) end it "sets the last value to an Integer representing the line on which the proc was defined" do line = @proc.source_location.last - line.should be_an_instance_of(Integer) + line.should.instance_of?(Integer) line.should == 4 line = @proc_new.source_location.last - line.should be_an_instance_of(Integer) + line.should.instance_of?(Integer) line.should == 12 line = @lambda.source_location.last - line.should be_an_instance_of(Integer) + line.should.instance_of?(Integer) line.should == 8 line = @method.source_location.last - line.should be_an_instance_of(Integer) + line.should.instance_of?(Integer) line.should == 15 end diff --git a/spec/ruby/core/proc/to_proc_spec.rb b/spec/ruby/core/proc/to_proc_spec.rb index ffaa34929b..7f35a4f19b 100644 --- a/spec/ruby/core/proc/to_proc_spec.rb +++ b/spec/ruby/core/proc/to_proc_spec.rb @@ -3,7 +3,7 @@ require_relative '../../spec_helper' describe "Proc#to_proc" do it "returns self" do [Proc.new {}, -> {}, proc {}].each { |p| - p.to_proc.should equal(p) + p.to_proc.should.equal?(p) } end end |