Merge pull request #86 from pitr-ch/minor

Convenience methods for Obligation and add_observer returning self

Author: jdantonio

lib/concurrent/obligation.rb

@@ -42,9 +42,37 @@ def incomplete?
       [:unscheduled, :pending].include? state
     end
 
+    # @returns [Object] see Dereferenceable#deref
     def value(timeout = nil)
+      wait timeout
+      deref
+    end
+
+    # wait until Obligation is #complete?
+    # @param [Numeric] timeout the maximum time in second to wait.
+    # @return [Obligation] self
+    def wait(timeout = nil)
       event.wait(timeout) if timeout != 0 && incomplete?
-      super()
+      self
+    end
+
+    # wait until Obligation is #complete?
+    # @param [Numeric] timeout the maximum time in second to wait.
+    # @return [Obligation] self
+    # @raise [Exception] when #rejected? it raises #reason
+    def no_error!(timeout = nil)
+      wait(timeout).tap { raise self if rejected? }
+    end
+
+    # @raise [Exception] when #rejected? it raises #reason
+    # @returns [Object] see Dereferenceable#deref
+    def value!(timeout = nil)
+      wait(timeout)
+      if rejected?
+        raise self
+      else
+        deref
+      end
     end
 
     def state
@@ -61,6 +89,14 @@ def reason
       mutex.unlock
     end
 
+    # @example allows Obligation to be risen
+    #   rejected_ivar = Ivar.new.fail
+    #   raise rejected_ivar
+    def exception(*args)
+      raise 'obligation is not rejected' unless rejected?
+      reason.exception(*args)
+    end
+
     protected
 
     # @!visibility private
@@ -81,13 +117,16 @@ def set_state(success, value, reason) # :nodoc:
         @state = :fulfilled
       else
         @reason = reason
-        @state = :rejected
+        @state  = :rejected
       end
     end
 
     # @!visibility private
     def state=(value) # :nodoc:
-      mutex.synchronize { @state = value }
+      mutex.lock
+      @state = value
+    ensure
+      mutex.unlock
     end
 
     # atomic compare and set operation
@@ -100,14 +139,15 @@ def state=(value) # :nodoc:
     #
     # @!visibility private
     def compare_and_set_state(next_state, expected_current) # :nodoc:
-      mutex.synchronize do
-        if @state == expected_current
-          @state = next_state
-          true
-        else
-          false
-        end
+      mutex.lock
+      if @state == expected_current
+        @state = next_state
+        true
+      else
+        false
       end
+    ensure
+      mutex.unlock
     end
 
     # executes the block within mutex if current state is included in expected_states
@@ -116,15 +156,16 @@ def compare_and_set_state(next_state, expected_current) # :nodoc:
     #
     # @!visibility private
     def if_state(*expected_states) # :nodoc:
+      mutex.lock
       raise ArgumentError.new('no block given') unless block_given?
 
-      mutex.synchronize do
-        if expected_states.include? @state
-          yield
-        else
-          false
-        end
+      if expected_states.include? @state
+        yield
+      else
+        false
       end
+    ensure
+      mutex.unlock
     end
   end
 end

lib/concurrent/observable.rb

@@ -10,6 +10,13 @@ def add_observer(*args, &block)
       observers.add_observer(*args, &block)
     end
 
+    # as #add_observer but it can be used for chaning
+    # @return [Observable] self
+    def with_observer(*args, &block)
+      add_observer *args, &block
+      self
+    end
+
     # @return [Object] the deleted observer
     def delete_observer(*args)
       observers.delete_observer(*args)

spec/concurrent/obligation_spec.rb

@@ -30,24 +30,28 @@ def initialize
         obligation.should be_incomplete
       end
 
-      describe '#value' do
+      methods = [:value, :value!, :no_error!]
+      methods.each do |method|
+        describe "##{method}" do
 
-        it 'should return immediately if timeout is zero' do
-          obligation.value(0).should be_nil
-        end
+          it 'should return immediately if timeout is zero' do
+            obligation.send(method, 0).should(method == :no_error! ? eq(obligation) : be_nil)
+          end
 
-        it 'should block on the event if timeout is not set' do
-          obligation.stub(:event).and_return(event)
-          event.should_receive(:wait).with(nil)
+          it 'should block on the event if timeout is not set' do
+            obligation.stub(:event).and_return(event)
+            event.should_receive(:wait).with(nil)
 
-          obligation.value
-        end
+            obligation.send method
+          end
+
+          it 'should block on the event if timeout is not zero' do
+            obligation.stub(:event).and_return(event)
+            event.should_receive(:wait).with(5)
 
-        it 'should block on the event if timeout is not zero' do
-          obligation.stub(:event).and_return(event)
-          event.should_receive(:wait).with(5)
+            obligation.send(method, 5)
+          end
 
-          obligation.value(5)
         end
       end
     end
@@ -98,6 +102,45 @@ def initialize
 
       end
 
+      describe '#value!' do
+
+        it 'should return immediately if timeout is zero' do
+          obligation.value!(0).should eq 42
+        end
+
+        it 'should return immediately if timeout is not set' do
+          event.should_not_receive(:wait)
+
+          obligation.value!.should eq 42
+        end
+
+        it 'should return immediately if timeout is not zero' do
+          event.should_not_receive(:wait)
+
+          obligation.value!(5).should eq 42
+        end
+
+      end
+
+      describe '#no_error!' do
+
+        it 'should return immediately if timeout is zero' do
+          obligation.no_error!(0).should eq obligation
+        end
+
+        it 'should return immediately if timeout is not set' do
+          event.should_not_receive(:wait)
+
+          obligation.no_error!.should eq obligation
+        end
+
+        it 'should return immediately if timeout is not zero' do
+          event.should_not_receive(:wait)
+
+          obligation.no_error!(5).should eq obligation
+        end
+
+      end
 
     end
 
@@ -115,26 +158,72 @@ def initialize
       it 'should be not incomplete' do
         obligation.should_not be_incomplete
       end
-    end
 
-    describe '#value' do
 
-      it 'should return immediately if timeout is zero' do
-        event.should_not_receive(:wait)
+      describe '#value' do
+
+        it 'should return immediately if timeout is zero' do
+          event.should_not_receive(:wait)
+
+          obligation.value(0).should be_nil
+        end
+
+        it 'should return immediately if timeout is not set' do
+          event.should_not_receive(:wait)
+
+          obligation.value.should be_nil
+        end
+
+        it 'should return immediately if timeout is not zero' do
+          event.should_not_receive(:wait)
+
+          obligation.value(5).should be_nil
+        end
 
-        obligation.value(0).should be_nil
       end
 
-      it 'should return immediately if timeout is not set' do
-        event.should_not_receive(:wait)
+      describe '#value!' do
+
+        it 'should return immediately if timeout is zero' do
+          event.should_not_receive(:wait)
+
+          -> { obligation.value!(0) }.should raise_error
+        end
+
+        it 'should return immediately if timeout is not set' do
+          event.should_not_receive(:wait)
+
+          -> { obligation.value! }.should raise_error
+        end
+
+        it 'should return immediately if timeout is not zero' do
+          event.should_not_receive(:wait)
+
+          -> { obligation.value!(5) }.should raise_error
+        end
 
-        obligation.value.should be_nil
       end
 
-      it 'should return immediately if timeout is not zero' do
-        event.should_not_receive(:wait)
+      describe '#no_error!' do
+
+        it 'should return immediately if timeout is zero' do
+          event.should_not_receive(:wait)
+
+          -> { obligation.no_error!(0) }.should raise_error
+        end
+
+        it 'should return immediately if timeout is not set' do
+          event.should_not_receive(:wait)
+
+          -> { obligation.no_error! }.should raise_error
+        end
+
+        it 'should return immediately if timeout is not zero' do
+          event.should_not_receive(:wait)
+
+          -> { obligation.no_error!(5) }.should raise_error
+        end
 
-        obligation.value(5).should be_nil
       end
 
     end

spec/concurrent/observable_spec.rb

@@ -23,14 +23,19 @@ module Concurrent
     end
 
     it 'uses the given observer set' do
-      expected = CopyOnWriteObserverSet.new
+      expected          = CopyOnWriteObserverSet.new
       subject.observers = expected
       subject.observers.should eql expected
     end
 
     it 'delegates #add_observer' do
-      observer_set.should_receive(:add_observer).with(:observer)
-      subject.add_observer(:observer)
+      observer_set.should_receive(:add_observer).with(:observer).and_return { |v| v }
+      subject.add_observer(:observer).should eq :observer
+    end
+
+    it 'delegates #with_observer' do
+      observer_set.should_receive(:add_observer).with(:observer).and_return { |v| v }
+      subject.with_observer(:observer).should eq subject
     end
 
     it 'delegates #delete_observer' do