concurrent-ruby 0.6.0.pre.2 → 0.6.0

data/lib/concurrent/obligation.rb

@@ -42,23 +42,59 @@ module Concurrent
       [:unscheduled, :pending].include? state
     end
 
+    # @return [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
+    # @return [Object] see Dereferenceable#deref
+    def value!(timeout = nil)
+      wait(timeout)
+      if rejected?
+        raise self
+      else
+        deref
+      end
     end
 
     def state
       mutex.lock
-      result = @state
+      @state
+    ensure
       mutex.unlock
-      result
     end
 
     def reason
       mutex.lock
-      result = @reason
+      @reason
+    ensure
       mutex.unlock
-      result
+    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
@@ -81,13 +117,16 @@ module Concurrent
         @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 @@ module Concurrent
     #
     # @!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 @@ module Concurrent
     #
     # @!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

data/lib/concurrent/observable.rb

@@ -10,6 +10,13 @@ module Concurrent
       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)

data/lib/concurrent/promise.rb

@@ -162,6 +162,7 @@ module Concurrent
     def synchronized_set_state!(success, value, reason)
       mutex.lock
       set_state!(success, value, reason)
+    ensure
       mutex.unlock
     end
   end

data/lib/concurrent/runnable.rb

@@ -1,11 +1,11 @@
 require 'thread'
 
+require 'concurrent/errors'
+
 module Concurrent
 
   module Runnable
 
-    LifecycleError = Class.new(StandardError)
-
     class Context
       attr_reader :runner, :thread
       def initialize(runner)

data/lib/concurrent/supervisor.rb

@@ -1,5 +1,6 @@
 require 'thread'
 
+require 'concurrent/errors'
 require 'concurrent/runnable'
 
 module Concurrent
@@ -15,8 +16,6 @@ module Concurrent
     CHILD_TYPES = [:worker, :supervisor]
     CHILD_RESTART_OPTIONS = [:permanent, :transient, :temporary]
 
-    MaxRestartFrequencyError = Class.new(StandardError)
-
     WorkerContext = Struct.new(:worker, :type, :restart) do
       attr_accessor :thread
       attr_accessor :terminated

data/lib/concurrent/timer_task.rb

@@ -146,7 +146,7 @@ module Concurrent
   # @see http://docs.oracle.com/javase/7/docs/api/java/util/TimerTask.html
   class TimerTask
     include Dereferenceable
-    include Executor
+    include RubyExecutor
     include Concurrent::Observable
 
     # Default `:execution_interval` in seconds.
@@ -248,9 +248,9 @@ module Concurrent
     #   task is performed again.
     def execution_interval
       mutex.lock
-      result = @execution_interval
+      @execution_interval
+    ensure
       mutex.unlock
-      result
     end
 
     # @!attribute [rw] execution_interval
@@ -260,10 +260,12 @@ module Concurrent
       if (value = value.to_f) <= 0.0
         raise ArgumentError.new('must be greater than zero')
       else
-        mutex.lock
-        result = @execution_interval = value
-        mutex.unlock
-        result
+        begin
+          mutex.lock
+          @execution_interval = value
+        ensure
+          mutex.unlock
+        end
       end
     end
 
@@ -272,9 +274,9 @@ module Concurrent
     #   considered to have failed.
     def timeout_interval
       mutex.lock
-      result = @timeout_interval
+      @timeout_interval
+    ensure
       mutex.unlock
-      result
     end
 
     # @!attribute [rw] timeout_interval
@@ -284,10 +286,12 @@ module Concurrent
       if (value = value.to_f) <= 0.0
         raise ArgumentError.new('must be greater than zero')
       else
-        mutex.lock
-        result = @timeout_interval = value
-        mutex.unlock
-        result
+        begin
+          mutex.lock
+          @timeout_interval = value
+        ensure
+          mutex.unlock
+        end
       end
     end
 

data/lib/concurrent/tvar.rb

@@ -4,57 +4,158 @@ require 'concurrent/atomic/thread_local_var'
 
 module Concurrent
 
-  ABORTED = Object.new
-
-  CURRENT_TRANSACTION = ThreadLocalVar.new(nil)
-
-  ReadLogEntry = Struct.new(:tvar, :version)
-  UndoLogEntry = Struct.new(:tvar, :value)
-
+  # A `TVar` is a transactional variable - a single-element container that
+  # is used as part of a transaction - see `Concurrent::atomically`.
   class TVar
 
+    # Create a new `TVar` with an initial value.
     def initialize(value)
       @value = value
       @version = 0
       @lock = Mutex.new
     end
 
+    # Get the value of a `TVar`.
     def value
       Concurrent::atomically do
         Transaction::current.read(self)
       end
     end
 
+    # Set the value of a `TVar`.
     def value=(value)
       Concurrent::atomically do
         Transaction::current.write(self, value)
       end
     end
 
-    def unsafe_value
+    # @!visibility private
+    def unsafe_value # :nodoc:
       @value
     end
 
-    def unsafe_value=(value)
+    # @!visibility private
+    def unsafe_value=(value) # :nodoc:
       @value = value
     end
 
-    def unsafe_version
+    # @!visibility private
+    def unsafe_version # :nodoc:
       @version
     end
 
-    def unsafe_increment_version
+    # @!visibility private
+    def unsafe_increment_version # :nodoc:
       @version += 1
     end
 
-    def unsafe_lock
+    # @!visibility private
+    def unsafe_lock # :nodoc:
       @lock
     end
 
   end
 
+  # Run a block that reads and writes `TVar`s as a single atomic transaction.
+  # With respect to the value of `TVar` objects, the transaction is atomic,
+  # in that it either happens or it does not, consistent, in that the `TVar`
+  # objects involved will never enter an illegal state, and isolated, in that
+  # transactions never interfere with each other. You may recognise these
+  # properties from database transactions.
+  # 
+  # There are some very important and unusual semantics that you must be aware of:
+  # 
+  # *   Most importantly, the block that you pass to atomically may be executed more than once. In most cases your code should be free of side-effects, except for via TVar.
+  # 
+  # *   If an exception escapes an atomically block it will abort the transaction.
+  # 
+  # *   It is undefined behaviour to use callcc or Fiber with atomically.
+  # 
+  # *   If you create a new thread within an atomically, it will not be part of the transaction. Creating a thread counts as a side-effect.
+  # 
+  # Transactions within transactions are flattened to a single transaction.
+  # 
+  # @example
+  #   a = new TVar(100_000)
+  #   b = new TVar(100)
+  #   
+  #   Concurrent::atomically do
+  #     a.value -= 10
+  #     b.value += 10
+  #   end
+  def atomically
+    raise ArgumentError.new('no block given') unless block_given?
+
+    # Get the current transaction
+
+    transaction = Transaction::current
+
+    # Are we not already in a transaction (not nested)?
+
+    if transaction.nil?
+      # New transaction
+
+      begin
+        # Retry loop
+        
+        loop do
+
+          # Create a new transaction
+
+          transaction = Transaction.new
+          Transaction::current = transaction
+
+          # Run the block, aborting on exceptions
+
+          begin
+            result = yield
+          rescue Transaction::AbortError => e
+            transaction.abort
+            result = Transaction::ABORTED
+          rescue => e
+            transaction.abort
+            throw e
+          end
+          # If we can commit, break out of the loop
+
+          if result != Transaction::ABORTED
+            if transaction.commit
+              break result
+            end
+          end
+        end
+      ensure
+        # Clear the current transaction
+
+        Transaction::current = nil
+      end
+    else
+      # Nested transaction - flatten it and just run the block
+
+      yield
+    end
+  end
+
+  # Abort a currently running transaction - see `Concurrent::atomically`.
+  def abort_transaction
+    raise Transaction::AbortError.new
+  end
+
+  module_function :atomically, :abort_transaction
+
+  private
+
   class Transaction
 
+    ABORTED = Object.new
+
+    CURRENT_TRANSACTION = ThreadLocalVar.new(nil)
+
+    ReadLogEntry = Struct.new(:tvar, :version)
+    UndoLogEntry = Struct.new(:tvar, :value)
+
+    AbortError = Class.new(StandardError)
+
     def initialize
       @write_set = Set.new
       @read_log = []
@@ -148,65 +249,4 @@ module Concurrent
 
   end
 
-  AbortError = Class.new(StandardError)
-
-  def atomically
-    raise ArgumentError.new('no block given') unless block_given?
-
-    # Get the current transaction
-
-    transaction = Transaction::current
-
-    # Are we not already in a transaction (not nested)?
-
-    if transaction.nil?
-      # New transaction
-
-      begin
-        # Retry loop
-        
-        loop do
-
-          # Create a new transaction
-
-          transaction = Transaction.new
-          Transaction::current = transaction
-
-          # Run the block, aborting on exceptions
-
-          begin
-            result = yield
-          rescue AbortError => e
-            transaction.abort
-            result = ABORTED
-          rescue => e
-            transaction.abort
-            throw e
-          end
-          # If we can commit, break out of the loop
-
-          if result != ABORTED
-            if transaction.commit
-              break result
-            end
-          end
-        end
-      ensure
-        # Clear the current transaction
-
-        Transaction::current = nil
-      end
-    else
-      # Nested transaction - flatten it and just run the block
-
-      yield
-    end
-  end
-
-  def abort_transaction
-    raise AbortError.new
-  end
-
-  module_function :atomically, :abort_transaction
-
 end