Add 4 convenience methods to obligation

wait - waits and returns self
no_error! - waits and raises on rejection, otherwise returns self
value! - returns value, or raises if rejected
exception - allows to call `raise rejected_ivar`

Author: pitr-ch

lib/concurrent/obligation.rb

@@ -43,8 +43,26 @@ def incomplete?
     end
 
     def value(timeout = nil)
+      wait timeout
+      deref
+    end
+
+    def wait(timeout = nil)
       event.wait(timeout) if timeout != 0 && incomplete?
-      super()
+      self
+    end
+
+    def no_error!(timeout = nil)
+      wait(timeout).tap { raise self if rejected? }
+    end
+
+    def value!(timeout = nil)
+      wait(timeout)
+      if rejected?
+        raise self
+      else
+        deref
+      end
     end
 
     def state
@@ -61,6 +79,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 +107,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 +129,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 +146,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

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