ruby--ruby/spec/ruby/core/kernel/clone_spec.rb

require_relative '../../spec_helper'
require_relative 'fixtures/classes'
require_relative 'shared/dup_clone'

describe "Kernel#clone" do
  it_behaves_like :kernel_dup_clone, :clone

  before :each do
    ScratchPad.clear
    @obj = KernelSpecs::Duplicate.new 1, :a
  end

  it "calls #initialize_copy on the new instance" do
    clone = @obj.clone
    ScratchPad.recorded.should_not == @obj.object_id
    ScratchPad.recorded.should == clone.object_id
  end

  it "uses the internal allocator and does not call #allocate" do
    klass = Class.new
    instance = klass.new

    def klass.allocate
      raise "allocate should not be called"
    end

    clone = instance.clone
    clone.class.should equal klass
  end

  describe "with no arguments" do
    it "copies frozen state from the original" do
      o2 = @obj.clone
      o2.should_not.frozen?

      @obj.freeze
      o3 = @obj.clone
      o3.should.frozen?
    end

    it 'copies frozen?' do
      o = ''.freeze.clone
      o.frozen?.should be_true
    end
  end

  describe "with freeze: nil" do
    ruby_version_is ""..."3.0" do
      it "raises ArgumentError" do
        -> { @obj.clone(freeze: nil) }.should raise_error(ArgumentError, /unexpected value for freeze: NilClass/)
      end
    end

    ruby_version_is "3.0" do
      it "copies frozen state from the original, like #clone without arguments" do
        o2 = @obj.clone(freeze: nil)
        o2.should_not.frozen?

        @obj.freeze
        o3 = @obj.clone(freeze: nil)
        o3.should.frozen?
      end

      it "copies frozen?" do
        o = "".freeze.clone(freeze: nil)
        o.frozen?.should be_true
      end
    end
  end

  describe "with freeze: true" do
    it 'makes a frozen copy if the original is frozen' do
      @obj.freeze
      @obj.clone(freeze: true).should.frozen?
    end

    ruby_version_is ''...'3.0' do
      it 'does not freeze the copy even if the original is not frozen' do
        @obj.clone(freeze: true).should_not.frozen?
      end

      it "calls #initialize_clone with no kwargs" do
        obj = KernelSpecs::CloneFreeze.new
        obj.clone(freeze: true)
        ScratchPad.recorded.should == [obj, {}]
      end
    end

    ruby_version_is '3.0' do
      it 'freezes the copy even if the original was not frozen' do
        @obj.clone(freeze: true).should.frozen?
      end

      it "calls #initialize_clone with kwargs freeze: true" do
        obj = KernelSpecs::CloneFreeze.new
        obj.clone(freeze: true)
        ScratchPad.recorded.should == [obj, { freeze: true }]
      end

      it "calls #initialize_clone with kwargs freeze: true even if #initialize_clone only takes a single argument" do
        obj = KernelSpecs::Clone.new
        -> { obj.clone(freeze: true) }.should raise_error(ArgumentError, 'wrong number of arguments (given 2, expected 1)')
      end
    end
  end

  describe "with freeze: false" do
    it 'does not freeze the copy if the original is frozen' do
      @obj.freeze
      @obj.clone(freeze: false).should_not.frozen?
    end

    it 'does not freeze the copy if the original is not frozen' do
      @obj.clone(freeze: false).should_not.frozen?
    end

    ruby_version_is ''...'3.0' do
      it "calls #initialize_clone with no kwargs" do
        obj = KernelSpecs::CloneFreeze.new
        obj.clone(freeze: false)
        ScratchPad.recorded.should == [obj, {}]
      end
    end

    ruby_version_is '3.0' do
      it "calls #initialize_clone with kwargs freeze: false" do
        obj = KernelSpecs::CloneFreeze.new
        obj.clone(freeze: false)
        ScratchPad.recorded.should == [obj, { freeze: false }]
      end

      it "calls #initialize_clone with kwargs freeze: false even if #initialize_clone only takes a single argument" do
        obj = KernelSpecs::Clone.new
        -> { obj.clone(freeze: false) }.should raise_error(ArgumentError, 'wrong number of arguments (given 2, expected 1)')
      end
    end
  end

  describe "with freeze: anything else" do
    it 'raises ArgumentError when passed not true/false/nil' do
      -> { @obj.clone(freeze: 1) }.should raise_error(ArgumentError, /unexpected value for freeze: Integer/)
      -> { @obj.clone(freeze: "") }.should raise_error(ArgumentError, /unexpected value for freeze: String/)
      -> { @obj.clone(freeze: Object.new) }.should raise_error(ArgumentError, /unexpected value for freeze: Object/)
    end
  end

  it "copies instance variables" do
    clone = @obj.clone
    clone.one.should == 1
    clone.two.should == :a
  end

  it "copies singleton methods" do
    def @obj.special() :the_one end
    clone = @obj.clone
    clone.special.should == :the_one
  end

  it "copies modules included in the singleton class" do
    class << @obj
      include KernelSpecs::DuplicateM
    end

    clone = @obj.clone
    clone.repr.should == "KernelSpecs::Duplicate"
  end

  it "copies constants defined in the singleton class" do
    class << @obj
      CLONE = :clone
    end

    clone = @obj.clone
    class << clone
      CLONE.should == :clone
    end
  end

  it "replaces a singleton object's metaclass with a new copy with the same superclass" do
    cls = Class.new do
      def bar
        ['a']
      end
    end

    object = cls.new
    object.define_singleton_method(:bar) do
      ['b', *super()]
    end
    object.bar.should == ['b', 'a']

    cloned = object.clone

    cloned.singleton_methods.should == [:bar]

    # bar should replace previous one
    cloned.define_singleton_method(:bar) do
      ['c', *super()]
    end
    cloned.bar.should == ['c', 'a']

    # bar should be removed and call through to superclass
    cloned.singleton_class.class_eval do
      remove_method :bar
    end

    cloned.bar.should == ['a']
  end

  ruby_version_is ''...'2.7' do
    it 'copies tainted?' do
      o = ''.taint.clone
      o.tainted?.should be_true
    end
  end
end