Update to ruby/spec@ed254ba

Author: andrykonchin

spec/ruby/core/data/fixtures/classes.rb

@@ -17,5 +17,12 @@ def initialize(amount:, unit:)
     end
 
     Empty = Data.define()
+
+    DataWithOverriddenInitialize = Data.define(:amount, :unit) do
+      def initialize(*rest, **kw)
+        super
+        ScratchPad.record [:initialize, rest, kw]
+      end
+    end
   end
 end

spec/ruby/core/data/initialize_spec.rb

@@ -71,4 +71,44 @@
   it "supports Data with no fields" do
     -> { DataSpecs::Empty.new }.should_not raise_error
   end
+
+  it "can be overridden" do
+    ScratchPad.record []
+
+    measure_class = Data.define(:amount, :unit) do
+      def initialize(*, **)
+        super
+        ScratchPad << :initialize
+      end
+    end
+
+    measure_class.new(42, "m")
+    ScratchPad.recorded.should == [:initialize]
+  end
+
+  context "when it is overridden" do
+    it "is called with keyword arguments when given positional arguments" do
+      ScratchPad.clear
+      DataSpecs::DataWithOverriddenInitialize.new(42, "m")
+      ScratchPad.recorded.should == [:initialize, [], {amount: 42, unit: "m"}]
+    end
+
+    it "is called with keyword arguments when given keyword arguments" do
+      ScratchPad.clear
+      DataSpecs::DataWithOverriddenInitialize.new(amount: 42, unit: "m")
+      ScratchPad.recorded.should == [:initialize, [], {amount: 42, unit: "m"}]
+    end
+
+    it "is called with keyword arguments when given alternative positional arguments" do
+      ScratchPad.clear
+      DataSpecs::DataWithOverriddenInitialize[42, "m"]
+      ScratchPad.recorded.should == [:initialize, [], {amount: 42, unit: "m"}]
+    end
+
+    it "is called with keyword arguments when given alternative keyword arguments" do
+      ScratchPad.clear
+      DataSpecs::DataWithOverriddenInitialize[amount: 42, unit: "m"]
+      ScratchPad.recorded.should == [:initialize, [], {amount: 42, unit: "m"}]
+    end
+  end
 end

spec/ruby/core/data/with_spec.rb

@@ -30,4 +30,28 @@
       data.with(4, "m")
     }.should raise_error(ArgumentError, "wrong number of arguments (given 2, expected 0)")
   end
+
+  it "does not depend on the Data.new method" do
+    subclass = Class.new(DataSpecs::Measure)
+    data = subclass.new(amount: 42, unit: "km")
+
+    def subclass.new(*)
+      raise "Data.new is called"
+    end
+
+    data_copy = data.with(unit: "m")
+    data_copy.amount.should == 42
+    data_copy.unit.should == "m"
+  end
+
+  ruby_version_is "3.3" do
+    it "calls #initialize" do
+      data = DataSpecs::DataWithOverriddenInitialize.new(42, "m")
+      ScratchPad.clear
+
+      data.with(amount: 0)
+
+      ScratchPad.recorded.should == [:initialize, [], {amount: 0, unit: "m"}]
+    end
+  end
 end

spec/ruby/core/enumerable/fixtures/classes.rb

@@ -38,12 +38,14 @@ def each(*arg)
   class Empty
     include Enumerable
     def each
+      self
     end
   end
 
   class EmptyWithSize
     include Enumerable
     def each
+      self
     end
     def size
       0

spec/ruby/core/exception/full_message_spec.rb

@@ -211,4 +211,16 @@ class << e
     e.full_message(highlight: false).lines.first.should =~ /RuntimeError/
     e.full_message(highlight: true).lines.first.should =~ /#{Regexp.escape("\e[1;4mRuntimeError\e[m")}/
   end
+
+  it "allows cause with empty backtrace" do
+    begin
+      raise RuntimeError.new("Some runtime error"), cause: RuntimeError.new("Some other runtime error")
+    rescue => e
+    end
+
+    full_message = e.full_message
+    full_message.should include "RuntimeError"
+    full_message.should include "Some runtime error"
+    full_message.should include "Some other runtime error"
+  end
 end

spec/ruby/core/io/popen_spec.rb

@@ -95,6 +95,22 @@
     @io = IO.popen(ruby_cmd('exit 0'), mode)
   end
 
+  it "accepts a path using the chdir: keyword argument" do
+    path = File.dirname(@fname)
+
+    @io = IO.popen(ruby_cmd("puts Dir.pwd"), "r", chdir: path)
+    @io.read.chomp.should == path
+  end
+
+  it "accepts a path using the chdir: keyword argument and a coercible path" do
+    path = File.dirname(@fname)
+    object = mock("path")
+    object.should_receive(:to_path).and_return(path)
+
+    @io = IO.popen(ruby_cmd("puts Dir.pwd"), "r", chdir: object)
+    @io.read.chomp.should == path
+  end
+
   describe "with a block" do
     it "yields an open IO to the block" do
       IO.popen(ruby_cmd('exit'), "r") do |io|

spec/ruby/core/kernel/raise_spec.rb

@@ -203,6 +203,84 @@
       e.cause.should == e1
     end
   end
+
+  it "re-raises a previously rescued exception that doesn't have a cause and isn't a cause of any other exception with setting a cause implicitly" do
+    begin
+      begin
+        raise "Error 1"
+      rescue => e1
+        begin
+          raise "Error 2"
+        rescue => e2
+          raise "Error 3"
+        end
+      end
+    rescue => e
+      e.message.should == "Error 3"
+      e.cause.should == e2
+    end
+  end
+
+  it "re-raises a previously rescued exception that doesn't have a cause and is a cause of other exception without setting a cause implicitly" do
+    begin
+      begin
+        raise "Error 1"
+      rescue => e1
+        begin
+          raise "Error 2"
+        rescue => e2
+          e1.cause.should == nil
+          e2.cause.should == e1
+          raise e1
+        end
+      end
+    rescue => e
+      e.should == e1
+      e.cause.should == nil
+    end
+  end
+
+  it "re-raises a previously rescued exception that doesn't have a cause and is a cause of other exception (that wasn't raised explicitly) without setting a cause implicitly" do
+    begin
+      begin
+        raise "Error 1"
+      rescue => e1
+        begin
+          foo # raises NameError
+        rescue => e2
+          e1.cause.should == nil
+          e2.cause.should == e1
+          raise e1
+        end
+      end
+    rescue => e
+      e.should == e1
+      e.cause.should == nil
+    end
+  end
+
+  it "re-raises a previously rescued exception that has a cause but isn't a cause of any other exception without setting a cause implicitly" do
+    begin
+      begin
+        raise "Error 1"
+      rescue => e1
+        begin
+          raise "Error 2"
+        rescue => e2
+          begin
+            raise "Error 3", cause: RuntimeError.new("Error 4")
+          rescue => e3
+            e2.cause.should == e1
+            e3.cause.should_not == e2
+            raise e2
+          end
+        end
+      end
+    rescue => e
+      e.should == e2
+      e.cause.should == e1
+    end
+  end
 end
 
 describe "Kernel#raise" do

spec/ruby/language/assignments_spec.rb

@@ -41,6 +41,37 @@ def object.[]=(_, _) end
         ScratchPad.recorded.should == [:rhs]
       end
     end
+
+    context "given block argument" do
+      before do
+        @klass = Class.new do
+          def initialize(h) @h = h end
+          def [](k, &block) @h[k]; end
+          def []=(k, v, &block) @h[k] = v; end
+        end
+      end
+
+      ruby_version_is ""..."3.4" do
+        it "accepts block argument" do
+          obj = @klass.new(a: 1)
+          block = proc {}
+
+          eval "obj[:a, &block] = 2"
+          eval("obj[:a, &block]").should == 2
+        end
+      end
+
+      ruby_version_is "3.4" do
+        it "raises SyntaxError" do
+          obj = @klass.new(a: 1)
+          block = proc {}
+
+          -> {
+            eval "obj[:a, &block] = 2"
+          }.should raise_error(SyntaxError, /unexpected block arg given in index assignment|block arg given in index assignment/)
+        end
+      end
+    end
   end
 
   describe 'using +=' do
@@ -114,6 +145,37 @@ def []=(k, v) @a[k] = v; 42 end
         a.public_method(:k, 2).should == 2
       end
 
+      context "given block argument" do
+        before do
+          @klass = Class.new do
+            def initialize(h) @h = h end
+            def [](k, &block) @h[k]; end
+            def []=(k, v, &block) @h[k] = v; end
+          end
+        end
+
+        ruby_version_is ""..."3.4" do
+          it "accepts block argument" do
+            obj = @klass.new(a: 1)
+            block = proc {}
+
+            eval "obj[:a, &block] += 2"
+            eval("obj[:a, &block]").should == 3
+          end
+        end
+
+        ruby_version_is "3.4" do
+          it "raises SyntaxError" do
+            obj = @klass.new(a: 1)
+            block = proc {}
+
+            -> {
+              eval "obj[:a, &block] += 2"
+            }.should raise_error(SyntaxError, /unexpected block arg given in index assignment|block arg given in index assignment/)
+          end
+        end
+      end
+
       context 'splatted argument' do
         it 'correctly handles it' do
           @b[:m] = 10

spec/ruby/language/hash_spec.rb

@@ -149,6 +149,26 @@ def h.to_hash; {:b => 2, :c => 3}; end
     {a: 1, **h, c: 4}.should == {a: 1, b: 2, c: 4}
   end
 
+  ruby_version_is ""..."3.4" do
+    it "does not expand nil using ** into {} and raises TypeError" do
+      h = nil
+      -> { {a: 1, **h} }.should raise_error(TypeError, "no implicit conversion of nil into Hash")
+
+      -> { {a: 1, **nil} }.should raise_error(TypeError, "no implicit conversion of nil into Hash")
+    end
+  end
+
+  ruby_version_is "3.4" do
+    it "expands nil using ** into {}" do
+      h = nil
+      {**h}.should == {}
+      {a: 1, **h}.should == {a: 1}
+
+      {**nil}.should == {}
+      {a: 1, **nil}.should == {a: 1}
+    end
+  end
+
   it "expands an '**{}' or '**obj' element with the last key/value pair taking precedence" do
     -> {
       @h = eval "{a: 1, **{a: 2, b: 3, c: 1}, c: 3}"

spec/ruby/language/method_spec.rb

@@ -1175,6 +1175,31 @@ def m(a = nil, b = {}, v: false)
   end
 end
 
+context "when passing **nil into a method that accepts keyword arguments" do
+  ruby_version_is ""..."3.4" do
+    it "raises TypeError" do
+      def m(**kw) kw; end
+
+      h = nil
+      -> { m(a: 1, **h) }.should raise_error(TypeError, "no implicit conversion of nil into Hash")
+      -> { m(a: 1, **nil) }.should raise_error(TypeError, "no implicit conversion of nil into Hash")
+    end
+  end
+
+  ruby_version_is "3.4" do
+    it "expands nil using ** into {}" do
+      def m(**kw) kw; end
+
+      h = nil
+      m(**h).should == {}
+      m(a: 1, **h).should == {a: 1}
+
+      m(**nil).should == {}
+      m(a: 1, **nil).should == {a: 1}
+    end
+  end
+end
+
 describe "A method call with a space between method name and parentheses" do
   before(:each) do
     def m(*args)