Added shared specs for IVar, Future, and Promise.

Author: jdantonio

lib/concurrent/async.rb

@@ -82,14 +82,11 @@ def method_missing(method, *args, &block)
         self.define_singleton_method(method) do |*args2|
           Async::validate_argc(@delegate, method, *args2)
           ivar = Concurrent::IVar.new
-          value, reason = nil, nil
           @serializer.post(@executor.value) do
             begin
-              value = @delegate.send(method, *args2, &block)
+              ivar.set(@delegate.send(method, *args2, &block))
             rescue => reason
-              # caught
-            ensure
-              ivar.complete(reason.nil?, value, reason)
+              ivar.fail(reason)
             end
           end
           ivar.value if @blocking

lib/concurrent/future.rb

@@ -76,7 +76,19 @@ def self.execute(opts = {}, &block)
       Future.new(opts, &block).execute
     end
 
-    protected :set, :fail, :complete
+    def set(value = IVar::NO_VALUE, &block)
+      check_for_block_or_value!(block_given?, value)
+      mutex.synchronize do
+        if @state != :unscheduled
+          raise MultipleAssignmentError
+        else
+          @task = block || Proc.new { value }
+        end
+      end
+      execute
+    end
+
+    protected :complete
 
     private
 

lib/concurrent/ivar.rb

@@ -60,12 +60,9 @@ def initialize(value = NO_VALUE, opts = {})
       init_obligation
       self.observers = CopyOnWriteObserverSet.new
       set_deref_options(opts)
+      @state = :pending
 
-      if value == NO_VALUE
-        @state = :pending
-      else
-        set(value)
-      end
+      set(value) unless value == NO_VALUE
     end
 
     # Add an observer on this object that will receive notification on update.
@@ -108,6 +105,8 @@ def add_observer(observer = nil, func = :update, &block)
     def set(value = NO_VALUE)
       if (block_given? && value != NO_VALUE) || (!block_given? && value == NO_VALUE)
         raise ArgumentError.new('must set with either a value or a block')
+      elsif ! compare_and_set_state(:processing, :pending)
+        raise MultipleAssignmentError
       end
 
       begin
@@ -124,13 +123,15 @@ def set(value = NO_VALUE)
     # @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
     #   been set or otherwise completed
     def fail(reason = StandardError.new)
-      complete(false, nil, reason)
+      set { raise reason }
     end
 
+    protected
+
     # @!visibility private
     def complete(success, value, reason) # :nodoc:
       mutex.synchronize do
-        raise MultipleAssignmentError.new('multiple assignment') if [:fulfilled, :rejected].include? @state
+        raise MultipleAssignmentError if [:fulfilled, :rejected].include? @state
         set_state(success, value, reason)
         event.set
       end
@@ -139,5 +140,12 @@ def complete(success, value, reason) # :nodoc:
       observers.notify_and_delete_observers{ [time, self.value, reason] }
       self
     end
+
+    # @!visibility private
+    def check_for_block_or_value!(block_given, value) # :nodoc:
+      if (block_given && value != NO_VALUE) || (! block_given && value == NO_VALUE)
+        raise ArgumentError.new('must set with either a value or a block')
+      end
+    end
   end
 end

lib/concurrent/obligation.rb

@@ -59,7 +59,7 @@ def completed?
     #
     # @return [Boolean]
     def incomplete?
-      [:unscheduled, :pending].include? state
+      ! complete?
     end
 
     # The current value of the obligation. Will be `nil` while the state is

lib/concurrent/promise.rb

@@ -242,24 +242,17 @@ def execute
 
     def set(value = IVar::NO_VALUE, &block)
       raise PromiseExecutionError.new('supported only on root promise') unless root?
-      if (block_given? && value != NO_VALUE) || (!block_given? && value == NO_VALUE)
-        raise ArgumentError.new('must set with either a value or a block')
-      end
+      check_for_block_or_value!(block_given?, value)
       mutex.synchronize do
         if @state != :unscheduled
-          raise PromiseExecutionError.new('execution has already begun')
+          raise MultipleAssignmentError
         else
           @promise_body = block || Proc.new { |result| value }
         end
       end
       execute
     end
 
-    def fail(reason = StandardError.new)
-      raise PromiseExecutionError.new('supported only on root promise') unless root?
-      super
-    end
-
     # Create a new `Promise` object with the given block, execute it, and return the
     # `:pending` object.
     #

spec/concurrent/future_spec.rb

@@ -1,4 +1,5 @@
 require_relative 'dereferenceable_shared'
+require_relative 'ivar_shared'
 require_relative 'obligation_shared'
 require_relative 'observable_shared'
 require_relative 'thread_arguments_shared'
@@ -16,6 +17,11 @@ module Concurrent
       }.execute.tap{ sleep(0.1) }
     end
 
+    context 'manual completion' do
+      subject { Future.new(executor: :immediate){ nil } }
+      it_should_behave_like :ivar
+    end
+
     context 'behavior' do
 
       # thread_arguments
@@ -80,23 +86,6 @@ def trigger_observable(observable)
       it_should_behave_like :observable
     end
 
-    context 'subclassing' do
-
-      subject{ Future.execute(executor: executor){ 42 } }
-
-      it 'protects #set' do
-        expect{ subject.set(100) }.to raise_error
-      end
-
-      it 'protects #fail' do
-        expect{ subject.fail }.to raise_error
-      end
-
-      it 'protects #complete' do
-        expect{ subject.complete(true, 100, nil) }.to raise_error
-      end
-    end
-
     context '#initialize' do
 
       let(:executor) { ImmediateExecutor.new }

spec/concurrent/ivar_shared.rb

@@ -0,0 +1,88 @@
+shared_examples :ivar do
+
+  context 'initialization' do
+
+    it 'sets the state to incomplete' do
+      expect(subject).to be_incomplete
+    end
+  end
+
+  context '#set' do
+
+    it 'sets the state to be fulfilled' do
+      subject.set(14)
+      expect(subject).to be_fulfilled
+    end
+
+    it 'sets the value' do
+      subject.set(14)
+      expect(subject.value).to eq 14
+    end
+
+    it 'raises an exception if set more than once' do
+      subject.set(14)
+      expect {subject.set(2)}.to raise_error(Concurrent::MultipleAssignmentError)
+      expect(subject.value).to eq 14
+    end
+
+    it 'returns self' do
+      expect(subject.set(42)).to eq subject
+    end
+    it 'fulfils when given a block which executes successfully' do
+      subject.set{ 42 }
+      expect(subject.value).to eq 42
+    end
+
+    it 'rejects when given a block which raises an exception' do
+      expected = ArgumentError.new
+      subject.set{ raise expected }
+      expect(subject.reason).to eq expected
+    end
+
+    it 'raises an exception when given a value and a block' do
+      expect {
+        subject.set(42){ :guide }
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an exception when given neither a value nor a block' do
+      expect {
+        subject.set
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context '#fail' do
+
+    it 'sets the state to be rejected' do
+      subject.fail
+      expect(subject).to be_rejected
+    end
+
+    it 'sets the value to be nil' do
+      subject.fail
+      expect(subject.value).to be_nil
+    end
+
+    it 'sets the reason to the given exception' do
+      expected = ArgumentError.new
+      subject.fail(expected)
+      expect(subject.reason).to eq expected
+    end
+
+    it 'raises an exception if set more than once' do
+      subject.fail
+      expect {subject.fail}.to raise_error(Concurrent::MultipleAssignmentError)
+      expect(subject.value).to be_nil
+    end
+
+    it 'defaults the reason to a StandardError' do
+      subject.fail
+      expect(subject.reason).to be_a StandardError
+    end
+
+    it 'returns self' do
+      expect(subject.fail).to eq subject
+    end
+  end
+end

spec/concurrent/ivar_spec.rb

@@ -1,4 +1,5 @@
 require_relative 'dereferenceable_shared'
+require_relative 'ivar_shared'
 require_relative 'obligation_shared'
 require_relative 'observable_shared'
 
@@ -14,6 +15,11 @@ module Concurrent
       i
     end
 
+    context 'manual completion' do
+      subject{ IVar.new }
+      it_should_behave_like :ivar
+    end
+
     context 'behavior' do
 
       # obligation
@@ -85,105 +91,11 @@ def trigger_observable(observable)
 
       it 'can set an initial value' do
         i = IVar.new(14)
-        expect(i).to be_completed
+        expect(i).to be_complete
       end
 
     end
 
-    context '#set' do
-
-      it 'sets the state to be fulfilled' do
-        i = IVar.new
-        i.set(14)
-        expect(i).to be_fulfilled
-      end
-
-      it 'sets the value' do
-        i = IVar.new
-        i.set(14)
-        expect(i.value).to eq 14
-      end
-
-      it 'raises an exception if set more than once' do
-        i = IVar.new
-        i.set(14)
-        expect {i.set(2)}.to raise_error(Concurrent::MultipleAssignmentError)
-        expect(i.value).to eq 14
-      end
-
-      it 'returns self' do
-        i = IVar.new
-        expect(i.set(42)).to eq i
-      end
-
-      it 'fulfils when given a block which executes successfully' do
-        i = IVar.new
-        i.set{ 42 }
-        expect(i.value).to eq 42
-      end
-
-      it 'rejects when given a block which raises an exception' do
-        i = IVar.new
-        expected = ArgumentError.new
-        i.set{ raise expected }
-        expect(i.reason).to eq expected
-      end
-
-      it 'raises an exception when given a value and a block' do
-        i = IVar.new
-        expect {
-          i.set(42){ :guide }
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'raises an exception when given neither a value nor a block' do
-        i = IVar.new
-        expect {
-          i.set
-        }.to raise_error(ArgumentError)
-      end
-    end
-
-    context '#fail' do
-
-      it 'sets the state to be rejected' do
-        i = IVar.new
-        i.fail
-        expect(i).to be_rejected
-      end
-
-      it 'sets the value to be nil' do
-        i = IVar.new
-        i.fail
-        expect(i.value).to be_nil
-      end
-
-      it 'sets the reason to the given exception' do
-        i = IVar.new
-        expected = ArgumentError.new
-        i.fail(expected)
-        expect(i.reason).to eq expected
-      end
-
-      it 'raises an exception if set more than once' do
-        i = IVar.new
-        i.fail
-        expect {i.fail}.to raise_error(Concurrent::MultipleAssignmentError)
-        expect(i.value).to be_nil
-      end
-
-      it 'defaults the reason to a StandardError' do
-        i = IVar.new
-        i.fail
-        expect(i.reason).to be_a StandardError
-      end
-
-      it 'returns self' do
-        i = IVar.new
-        expect(i.fail).to eq i
-      end
-    end
-
     context 'observation' do
 
       let(:clazz) do