ImmutableStruct Improvements

Author: pitr-ch

lib/concurrent/synchronization/immutable_struct.rb

@@ -1,23 +1,67 @@
 module Concurrent
   module Synchronization
+    # Similar to Struct but the fields are immutable and always visible (like Java final fields)
+    # @example
+    #   Person = ImmutableStruct.with_fields :name, :age
+    #   Person.new 'John Doe', 15
+    #   Person['John Doe', 15]
+    #   Person['John Doe', 15].members # => [:name, :age]
+    #   Person['John Doe', 15].values  # => ['John Doe', 15]
     class ImmutableStruct < Synchronization::Object
       def self.with_fields(*names, &block)
         Class.new(self) do
           attr_reader(*names)
-          instance_eval &block if block
 
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def initialize(#{names.join(', ')})
               #{names.map { |n| '@' + n.to_s }.join(', ')} = #{names.join(', ')}
               ensure_ivar_visibility!
             end
+
+            def members
+              #{names.inspect}
+            end
+
+            def self.members
+              #{names.inspect}
+            end
           RUBY
+
+          instance_eval &block if block
         end
       end
 
+      # Define equality based on class and members' equality. This is optional since for CAS operation
+      # it may be required to compare references which is default behaviour of this class.
+      def self.define_equality!
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def ==(other)
+            self.class == other.class &&
+              #{members.map { |name| "self.#{name} == other.#{name}" }.join(" && ")}
+          end
+        RUBY
+      end
+
       def self.[](*args)
         new *args
       end
+
+      include Enumerable
+
+      def each(&block)
+        return to_enum unless block_given?
+        members.zip(values).each(&block)
+      end
+
+      def size
+        members.size
+      end
+
+      def values
+        members.map { |name| send name }
+      end
+
+      alias_method :to_a, :values
     end
   end
 end

spec/concurrent/synchronized_object_spec.rb

@@ -1,118 +1,133 @@
 module Concurrent
 
-  describe Synchronization::Object do
+  describe Synchronization do
+    describe Synchronization::Object do
 
-    class AClass < Synchronization::Object
-      attr_volatile :volatile
-      attr_accessor :not_volatile
+      class AClass < Synchronization::Object
+        attr_volatile :volatile
+        attr_accessor :not_volatile
 
-      def initialize(value = nil)
-        super()
-        @Final = value
-        ensure_ivar_visibility!
-      end
+        def initialize(value = nil)
+          super()
+          @Final = value
+          ensure_ivar_visibility!
+        end
 
-      def final
-        @Final
-      end
+        def final
+          @Final
+        end
 
-      def count
-        synchronize { @count += 1 }
-      end
+        def count
+          synchronize { @count += 1 }
+        end
 
-      def wait(timeout = nil)
-        synchronize { ns_wait(timeout) }
-      end
+        def wait(timeout = nil)
+          synchronize { ns_wait(timeout) }
+        end
 
-      private
+        private
 
-      def ns_initialize
-        @count = 0
+        def ns_initialize
+          @count = 0
+        end
       end
-    end
 
-    subject { AClass.new }
+      subject { AClass.new }
 
-    describe '#wait' do
+      describe '#wait' do
 
-      it 'waiting thread is sleeping' do
-        t = Thread.new do
-          Thread.abort_on_exception = true
-          subject.wait
+        it 'waiting thread is sleeping' do
+          t = Thread.new do
+            Thread.abort_on_exception = true
+            subject.wait
+          end
+          sleep 0.1
+          expect(t.status).to eq 'sleep'
         end
-        sleep 0.1
-        expect(t.status).to eq 'sleep'
-      end
 
-      it 'sleeping thread can be killed' do
-        t = Thread.new do
-          Thread.abort_on_exception = true
-          subject.wait rescue nil
+        it 'sleeping thread can be killed' do
+          t = Thread.new do
+            Thread.abort_on_exception = true
+            subject.wait rescue nil
+          end
+          sleep 0.1
+          t.kill
+          sleep 0.1
+          expect(t.status).to eq false
+          expect(t.alive?).to eq false
         end
-        sleep 0.1
-        t.kill
-        sleep 0.1
-        expect(t.status).to eq false
-        expect(t.alive?).to eq false
       end
-    end
 
-    describe '#synchronize' do
-      it 'allows only one thread to execute count' do
-        threads = 10.times.map { Thread.new(subject) { 100.times { subject.count } } }
-        threads.each(&:join)
-        expect(subject.count).to eq 1001
+      describe '#synchronize' do
+        it 'allows only one thread to execute count' do
+          threads = 10.times.map { Thread.new(subject) { 100.times { subject.count } } }
+          threads.each(&:join)
+          expect(subject.count).to eq 1001
+        end
       end
-    end
 
-    describe 'signaling' do
-      pending 'for now pending, tested pretty well by Event'
-    end
+      describe 'signaling' do
+        pending 'for now pending, tested pretty well by Event'
+      end
 
-    specify 'final field always visible' do
-      store = AClass.new 'asd'
-      t1    = Thread.new { 1000000000.times { |i| store = AClass.new i.to_s } }
-      t2    = Thread.new { 10.times { expect(store.final).not_to be_nil; Thread.pass } }
-      t2.join
-      t1.kill
-    end
+      specify 'final field always visible' do
+        store = AClass.new 'asd'
+        t1    = Thread.new { 1000000000.times { |i| store = AClass.new i.to_s } }
+        t2    = Thread.new { 10.times { expect(store.final).not_to be_nil; Thread.pass } }
+        t2.join
+        t1.kill
+      end
 
-    describe 'attr volatile' do
-      specify 'older writes are always visible' do
-        store              = AClass.new
-        store.not_volatile = 0
-        store.volatile     = 0
-
-        t1 = Thread.new do
-          Thread.abort_on_exception = true
-          1000000000.times do |i|
-            store.not_volatile = i
-            store.volatile     = i
+      describe 'attr volatile' do
+        specify 'older writes are always visible' do
+          store              = AClass.new
+          store.not_volatile = 0
+          store.volatile     = 0
+
+          t1 = Thread.new do
+            Thread.abort_on_exception = true
+            1000000000.times do |i|
+              store.not_volatile = i
+              store.volatile     = i
+            end
           end
-        end
 
-        t2 = Thread.new do
-          10.times do
-            volatile     = store.volatile
-            not_volatile = store.not_volatile
-            expect(not_volatile).to be >= volatile
-            Thread.pass
+          t2 = Thread.new do
+            10.times do
+              volatile     = store.volatile
+              not_volatile = store.not_volatile
+              expect(not_volatile).to be >= volatile
+              Thread.pass
+            end
           end
-        end
 
-        t2.join
-        t1.kill
+          t2.join
+          t1.kill
+        end
       end
     end
 
     describe Synchronization::ImmutableStruct do
-      let(:klass) { described_class.with_fields(:a, :b) }
-      subject { klass[1, 'a'] }
+      AB = described_class.with_fields(:a, :b)
+      subject { AB[1, 'a'] }
 
       specify do
-        expect(klass.superclass).to eq described_class
+        expect(AB.superclass).to eq described_class
         expect(subject.a).to eq 1
         expect(subject.b).to eq 'a'
+        expect(subject.values).to eq [1, 'a']
+        expect(subject.to_a).to eq [1, 'a']
+        expect(subject.size).to eq 2
+        expect(subject.members).to eq [:a, :b]
+        expect(subject.each.to_a).to eq [[:a, 1], [:b, 'a']]
+        expect(subject.inspect).to match /#<Concurrent::AB:0x[\da-f]+ (@a=1|@b="a"), (@a=1|@b="a")>/
+      end
+
+      specify 'equality' do
+        klass = described_class.with_fields(:a, :b)
+        expect(klass[1, 'a']).not_to be == klass[1, 'a']
+        klass.define_equality!
+        expect(klass[1, 'a']).to be == klass[1, 'a']
       end
     end