Implement #dup and #clone for structs

Author: kaikuchn

lib/concurrent/immutable_struct.rb

@@ -70,6 +70,14 @@ def select(&block)
       ns_select(&block)
     end
 
+    # @!macro struct_initialize_copy
+    #
+    # @!visibility private
+    def initialize_copy(original)
+      super
+      ns_initialize_copy
+    end
+
     # @!macro struct_new
     def self.new(*args, &block)
       clazz_name = nil

lib/concurrent/mutable_struct.rb

@@ -169,6 +169,16 @@ def select(&block)
       synchronize { ns_select(&block) }
     end
 
+    # @!macro struct_initialize_copy
+    #
+    # @!visibility private
+    def initialize_copy(original)
+      synchronize do
+        super
+        ns_initialize_copy
+      end
+    end
+
     # @!macro struct_set
     #
     #   Attribute Assignment

lib/concurrent/settable_struct.rb

@@ -69,6 +69,16 @@ def select(&block)
       synchronize { ns_select(&block) }
     end
 
+    # @!macro struct_initialize_copy
+    #
+    # @!visibility private
+    def initialize_copy(original)
+      synchronize do
+        super
+        ns_initialize_copy
+      end
+    end
+
     # @!macro struct_set
     #
     # @raise [Concurrent::ImmutabilityError] if the given member has already been set

lib/concurrent/synchronization/abstract_struct.rb

@@ -115,6 +115,13 @@ def ns_merge(other, &block)
         self.class.new(*self.to_h.merge(other, &block).values)
       end
 
+      # @!macro struct_initialize_copy
+      #
+      # @!visibility private
+      def ns_initialize_copy
+        @values = @values.map(&:clone)
+      end
+
       # @!visibility private
       def pr_underscore(clazz)
         word = clazz.to_s.dup # dup string to workaround JRuby 9.2.0.0 bug https://github.com/jruby/jruby/issues/5229

spec/concurrent/mutable_struct_spec.rb

@@ -149,6 +149,25 @@ module Concurrent
         expect(subject).to receive(:synchronize).at_least(:once).with(no_args).and_call_original
         subject.select{|value| false }
       end
+
+      it 'protects #initialize_copy' do
+        expect(subject).to receive(:synchronize).at_least(:once).with(no_args).and_call_original
+        subject.clone
+      end
+    end
+
+    context 'copy' do
+      context '#dup' do
+        it 'mutates only the copy' do
+          expect(subject.dup.name = 'Jane').not_to eq(subject.name)
+        end
+      end
+
+      context '#clone' do
+        it 'mutates only the copy' do
+          expect(subject.clone.name = 'Jane').not_to eq(subject.name)
+        end
+      end
     end
   end
 end

spec/concurrent/settable_struct_spec.rb

@@ -171,6 +171,31 @@ module Concurrent
         expect(subject).to receive(:synchronize).at_least(:once).with(no_args).and_call_original
         subject.select{|value| false }
       end
+
+      it 'protects #initialize_copy' do
+        expect(subject).to receive(:synchronize).at_least(:once).with(no_args).and_call_original
+        subject.clone
+      end
+    end
+
+    context 'copy' do
+      context '#dup' do
+        it 'retains settability of members' do
+          subject['name'] = 'John'
+          expect { subject.dup['name'] = 'Jane' }
+            .to raise_error(ImmutabilityError)
+          expect(subject['address'] = 'Earth').to eq('Earth')
+        end
+      end
+
+      context '#clone' do
+        it 'retains settability of members' do
+          subject['name'] = 'John'
+          expect { subject.clone['name'] = 'Jane' }
+            .to raise_error(ImmutabilityError)
+          expect(subject['address'] = 'Earth').to eq('Earth')
+        end
+      end
     end
   end
 end

spec/concurrent/struct_shared.rb

@@ -437,6 +437,69 @@ def baz(foo, bar) foo + bar; end
       end
     end
   end
+
+  context 'copy' do
+    let(:this) do
+      described_class.new(:foo, :bar, :baz).new('foo'.freeze, ['bar'], 42)
+    end
+
+    context '#dup' do
+      it 'shallowly duplicates all members along with the struct' do
+        copy = this.dup
+        expect(copy.foo).not_to be this.foo
+        expect(copy.bar).not_to be this.bar
+        expect(copy.bar.first).to be this.bar.first
+        expect(copy.baz).to be this.baz
+      end
+
+      it 'discards frozen state of the struct' do
+        expect(this.freeze.dup).not_to be_frozen
+      end
+
+      it 'retains frozen state of members' do
+        expect(this.dup.foo).to be_frozen
+      end
+
+      it 'discards singleton class' do
+        this.define_singleton_method(:qux) { 'qux' }
+        expect(this.qux).to eq('qux')
+        expect{this.dup.qux}.to raise_error(NoMethodError)
+      end
+
+      it 'copies the singleton class of members' do
+        this.bar.define_singleton_method(:qux) { 'qux' }
+        expect(this.bar.qux).to eq('qux')
+        expect(this.dup.bar.qux).to eq('qux')
+      end
+    end
+
+    context '#clone' do
+      it 'shallowly clones all members along with the struct' do
+        copy = this.clone
+        expect(copy.foo).not_to be this.foo
+        expect(copy.bar).not_to be this.bar
+        expect(copy.bar.first).to be this.bar.first
+        expect(copy.baz).to be this.baz
+      end
+
+      it 'retains frozen state' do
+        expect(this.freeze.clone).to be_frozen
+        expect(this.clone.foo).to be_frozen
+      end
+
+      it 'copies the singleton class' do
+        this.define_singleton_method(:qux) { 'qux' }
+        expect(this.qux).to eq('qux')
+        expect(this.clone.qux).to eq('qux')
+      end
+
+      it 'copies the singleton class of members' do
+        this.bar.define_singleton_method(:qux) { 'qux' }
+        expect(this.bar.qux).to eq('qux')
+        expect(this.clone.bar.qux).to eq('qux')
+      end
+    end
+  end
 end
 
 RSpec.shared_examples :mergeable_struct do