concurrent-ruby 0.1.1.pre.3 → 0.1.1.pre.4

data/lib/concurrent/global_thread_pool.rb

@@ -1,16 +1,16 @@
-require 'concurrent/cached_thread_pool'
-
-$GLOBAL_THREAD_POOL ||= Concurrent::CachedThreadPool.new
-
-module Concurrent
-
-  module UsesGlobalThreadPool
-
-    def self.included(base)
-      class << base
-        attr_accessor :thread_pool
-      end
-      base.thread_pool = $GLOBAL_THREAD_POOL
-    end
-  end
-end
+require 'concurrent/cached_thread_pool'
+
+$GLOBAL_THREAD_POOL ||= Concurrent::CachedThreadPool.new
+
+module Concurrent
+
+  module UsesGlobalThreadPool
+
+    def self.included(base)
+      class << base
+        attr_accessor :thread_pool
+      end
+      base.thread_pool = $GLOBAL_THREAD_POOL
+    end
+  end
+end

data/lib/concurrent/goroutine.rb

@@ -1,29 +1,29 @@
-require 'thread'
-
-require 'concurrent/global_thread_pool'
-
-module Kernel
-
-  # Post the given agruments and block to the Global Thread Pool.
-  #
-  # @param args [Array] zero or more arguments for the block
-  # @param block [Proc] operation to be performed concurrently
-  #
-  # @return [true,false] success/failre of thread creation
-  #
-  # @note Althought based on Go's goroutines and Erlang's spawn/1,
-  # Ruby has a vastly different runtime. Threads aren't nearly as
-  # efficient in Ruby. Use this function appropriately.
-  #
-  # @see http://golang.org/doc/effective_go.html#goroutines
-  # @see https://gobyexample.com/goroutines
-  def go(*args, &block)
-    return false unless block_given?
-    if args.first.behaves_as?(:global_thread_pool)
-      args.first.post(*args.slice(1, args.length), &block)
-    else
-      $GLOBAL_THREAD_POOL.post(*args, &block)
-    end
-  end
-  module_function :go
-end
+require 'thread'
+
+require 'concurrent/global_thread_pool'
+
+module Kernel
+
+  # Post the given agruments and block to the Global Thread Pool.
+  #
+  # @param args [Array] zero or more arguments for the block
+  # @param block [Proc] operation to be performed concurrently
+  #
+  # @return [true,false] success/failre of thread creation
+  #
+  # @note Althought based on Go's goroutines and Erlang's spawn/1,
+  # Ruby has a vastly different runtime. Threads aren't nearly as
+  # efficient in Ruby. Use this function appropriately.
+  #
+  # @see http://golang.org/doc/effective_go.html#goroutines
+  # @see https://gobyexample.com/goroutines
+  def go(*args, &block)
+    return false unless block_given?
+    if args.first.behaves_as?(:global_thread_pool)
+      args.first.post(*args.slice(1, args.length), &block)
+    else
+      $GLOBAL_THREAD_POOL.post(*args, &block)
+    end
+  end
+  module_function :go
+end

data/lib/concurrent/null_thread_pool.rb

@@ -1,22 +1,22 @@
-require 'concurrent/global_thread_pool'
-
-module Concurrent
-
-  class NullThreadPool
-    behavior(:global_thread_pool)
-
-    def self.post(*args, &block)
-      Thread.new(*args, &block)
-      return true
-    end
-
-    def post(*args, &block)
-      return NullThreadPool.post(*args, &block)
-    end
-
-    def <<(block)
-      NullThreadPool.post(&block)
-      return self
-    end
-  end
-end
+require 'concurrent/global_thread_pool'
+
+module Concurrent
+
+  class NullThreadPool
+    behavior(:global_thread_pool)
+
+    def self.post(*args, &block)
+      Thread.new(*args, &block)
+      return true
+    end
+
+    def post(*args, &block)
+      return NullThreadPool.post(*args, &block)
+    end
+
+    def <<(block)
+      NullThreadPool.post(&block)
+      return self
+    end
+  end
+end

data/lib/concurrent/obligation.rb

@@ -1,67 +1,67 @@
-require 'thread'
-require 'timeout'
-
-require 'functional/behavior'
-
-behavior_info(:future,
-              state: 0,
-              value: -1,
-              reason: 0,
-              pending?: 0,
-              fulfilled?: 0,
-              rejected?: 0)
-
-behavior_info(:promise,
-              state: 0,
-              value: -1,
-              reason: 0,
-              pending?: 0,
-              fulfilled?: 0,
-              rejected?: 0,
-              then: 0,
-              rescue: -1)
-
-module Concurrent
-
-  module Obligation
-
-    attr_reader :state
-    attr_reader :reason
-
-    # Has the obligation been fulfilled?
-    # @return [Boolean]
-    def fulfilled?() return(@state == :fulfilled); end
-    alias_method :realized?, :fulfilled?
-
-    # Is obligation completion still pending?
-    # @return [Boolean]
-    def pending?() return(!(fulfilled? || rejected?)); end
-
-    def value(timeout = nil)
-      if !pending? || timeout == 0
-        return @value
-      elsif timeout.nil?
-        return semaphore.synchronize { value = @value }
-      else
-        begin
-          return Timeout::timeout(timeout.to_f) {
-            semaphore.synchronize { value = @value }
-          }
-        rescue Timeout::Error => ex
-          return nil
-        end
-      end
-    end
-    alias_method :deref, :value
-
-    # Has the promise been rejected?
-    # @return [Boolean]
-    def rejected?() return(@state == :rejected); end
-
-    protected
-
-    def semaphore
-      @semaphore ||= Mutex.new
-    end
-  end
-end
+require 'thread'
+require 'timeout'
+
+require 'functional/behavior'
+
+behavior_info(:future,
+              state: 0,
+              value: -1,
+              reason: 0,
+              pending?: 0,
+              fulfilled?: 0,
+              rejected?: 0)
+
+behavior_info(:promise,
+              state: 0,
+              value: -1,
+              reason: 0,
+              pending?: 0,
+              fulfilled?: 0,
+              rejected?: 0,
+              then: 0,
+              rescue: -1)
+
+module Concurrent
+
+  module Obligation
+
+    attr_reader :state
+    attr_reader :reason
+
+    # Has the obligation been fulfilled?
+    # @return [Boolean]
+    def fulfilled?() return(@state == :fulfilled); end
+    alias_method :realized?, :fulfilled?
+
+    # Has the promise been rejected?
+    # @return [Boolean]
+    def rejected?() return(@state == :rejected); end
+
+    # Is obligation completion still pending?
+    # @return [Boolean]
+    def pending?() return(@state == :pending); end
+
+    def value(timeout = nil)
+      if timeout == 0 || ! pending?
+        return @value
+      elsif timeout.nil?
+        return mutex.synchronize { v = @value }
+      else
+        begin
+          return Timeout::timeout(timeout.to_f) {
+            mutex.synchronize { v = @value }
+          }
+        rescue Timeout::Error => ex
+          return nil
+        end
+      end
+    end
+    alias_method :deref, :value
+
+    protected
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+  end
+end

data/lib/concurrent/promise.rb

@@ -1,166 +1,174 @@
-require 'thread'
-
-require 'concurrent/global_thread_pool'
-require 'concurrent/obligation'
-require 'concurrent/utilities'
-
-module Concurrent
-
-  class Promise
-    include Obligation
-    include UsesGlobalThreadPool
-
-    behavior(:future)
-    behavior(:promise)
-
-    # Creates a new promise object. "A promise represents the eventual
-    # value returned from the single completion of an operation."
-    # Promises can be chained in a tree structure where each promise
-    # has zero or more children. Promises are resolved asynchronously
-    # in the order they are added to the tree. Parents are guaranteed
-    # to be resolved before their children. The result of each promise
-    # is passed to each of its children upon resolution. When
-    # a promise is rejected all its children will be summarily rejected.
-    # A promise that is neither resolved or rejected is pending.
-    #
-    # @param args [Array] zero or more arguments for the block
-    # @param block [Proc] the block to call when attempting fulfillment
-    #
-    # @see http://wiki.commonjs.org/wiki/Promises/A
-    # @see http://promises-aplus.github.io/promises-spec/
-    def initialize(*args, &block)
-      if args.first.is_a?(Promise)
-        @parent = args.first
-      else
-        @parent = nil
-        @chain = [self]
-      end
-
-      @mutex = Mutex.new
-      @handler = block || Proc.new{|result| result }
-      @state = :pending
-      @value = nil
-      @reason = nil
-      @children = []
-      @rescuers = []
-
-      realize(*args) if root?
-    end
-
-    # Create a new child Promise. The block argument for the child will
-    # be the result of fulfilling its parent. If the child will
-    # immediately be rejected if the parent has already been rejected.
-    #
-    # @param block [Proc] the block to call when attempting fulfillment
-    #
-    # @return [Promise] the new promise
-    def then(&block)
-      child = @mutex.synchronize do
-        block = Proc.new{|result| result } unless block_given?
-        @children << Promise.new(self, &block)
-        @children.last.on_reject(@reason) if rejected?
-        push(@children.last)
-        @children.last
-      end
-      return child
-    end
-
-    # Add a rescue handler to be run if the promise is rejected (via raised
-    # exception). Multiple rescue handlers may be added to a Promise.
-    # Rescue blocks will be checked in order and the first one with a
-    # matching Exception class will be processed. The block argument
-    # will be the exception that caused the rejection.
-    #
-    # @param clazz [Class] The class of exception to rescue
-    # @param block [Proc] the block to call if the rescue is matched
-    #
-    # @return [self] so that additional chaining can occur
-    def rescue(clazz = Exception, &block)
-      @mutex.synchronize do
-        @rescuers << Rescuer.new(clazz, block) if block_given?
-      end
-      return self
-    end
-    alias_method :catch, :rescue
-    alias_method :on_error, :rescue
-
-    protected
-
-    attr_reader :parent
-    attr_reader :handler
-    attr_reader :rescuers
-
-    # @private
-    Rescuer = Struct.new(:clazz, :block)
-
-    # @private
-    def root? # :nodoc:
-      @parent.nil?
-    end
-
-    # @private
-    def push(promise) # :nodoc:
-      if root?
-        @chain << promise
-      else
-        @parent.push(promise)
-      end
-    end
-
-    # @private
-    def on_fulfill(value) # :nodoc:
-      @mutex.synchronize do
-        if pending?
-          @value = @handler.call(value)
-          @state = :fulfilled
-          @reason = nil
-        end
-      end
-      return @value
-    end
-
-    # @private
-    def on_reject(reason) # :nodoc:
-      @mutex.synchronize do
-        if pending?
-          @state = :rejected
-          @reason = reason
-          self.try_rescue(reason)
-          @value = nil
-        end
-        @children.each{|child| child.on_reject(reason) }
-      end
-    end
-
-    # @private
-    def try_rescue(ex) # :nodoc:
-      rescuer = @rescuers.find{|r| ex.is_a?(r.clazz) }
-      rescuer.block.call(ex) if rescuer
-    rescue Exception => e
-      # supress
-    end
-
-    # @private
-    def realize(*args) # :nodoc:
-      Promise.thread_pool.post(@chain, @mutex, args) do |chain, mutex, args|
-        result = args.length == 1 ? args.first : args
-        index = 0
-        loop do
-          Thread.pass
-          current = mutex.synchronize{ chain[index] }
-          unless current.rejected?
-            current.semaphore.synchronize do
-              begin
-                result = current.on_fulfill(result)
-              rescue Exception => ex
-                current.on_reject(ex)
-              end
-            end
-          end
-          index += 1
-          sleep while index >= chain.length
-        end
-      end
-    end
-  end
-end
+require 'thread'
+
+require 'concurrent/global_thread_pool'
+require 'concurrent/obligation'
+require 'concurrent/utilities'
+
+module Concurrent
+
+  class Promise
+    include Obligation
+    include UsesGlobalThreadPool
+
+    behavior(:future)
+    behavior(:promise)
+
+    # Creates a new promise object. "A promise represents the eventual
+    # value returned from the single completion of an operation."
+    # Promises can be chained in a tree structure where each promise
+    # has zero or more children. Promises are resolved asynchronously
+    # in the order they are added to the tree. Parents are guaranteed
+    # to be resolved before their children. The result of each promise
+    # is passed to each of its children upon resolution. When
+    # a promise is rejected all its children will be summarily rejected.
+    # A promise that is neither resolved or rejected is pending.
+    #
+    # @param args [Array] zero or more arguments for the block
+    # @param block [Proc] the block to call when attempting fulfillment
+    #
+    # @see http://wiki.commonjs.org/wiki/Promises/A
+    # @see http://promises-aplus.github.io/promises-spec/
+    def initialize(*args, &block)
+      if args.first.is_a?(Promise)
+        @parent = args.first
+      else
+        @parent = nil
+        @chain = [self]
+      end
+
+      @lock = Mutex.new
+      @handler = block || Proc.new{|result| result }
+      @state = :pending
+      @value = nil
+      @reason = nil
+      @rescued = false
+      @children = []
+      @rescuers = []
+
+      realize(*args) if root?
+    end
+
+    def rescued?
+      return @rescued
+    end
+
+    # Create a new child Promise. The block argument for the child will
+    # be the result of fulfilling its parent. If the child will
+    # immediately be rejected if the parent has already been rejected.
+    #
+    # @param block [Proc] the block to call when attempting fulfillment
+    #
+    # @return [Promise] the new promise
+    def then(&block)
+      child = @lock.synchronize do
+        block = Proc.new{|result| result } unless block_given?
+        @children << Promise.new(self, &block)
+        @children.last.on_reject(@reason) if rejected?
+        push(@children.last)
+        @children.last
+      end
+      return child
+    end
+
+    # Add a rescue handler to be run if the promise is rejected (via raised
+    # exception). Multiple rescue handlers may be added to a Promise.
+    # Rescue blocks will be checked in order and the first one with a
+    # matching Exception class will be processed. The block argument
+    # will be the exception that caused the rejection.
+    #
+    # @param clazz [Class] The class of exception to rescue
+    # @param block [Proc] the block to call if the rescue is matched
+    #
+    # @return [self] so that additional chaining can occur
+    def rescue(clazz = Exception, &block)
+      return self if fulfilled? || rescued? || ! block_given?
+      @lock.synchronize do
+        rescuer = Rescuer.new(clazz, block)
+        if pending?
+          @rescuers << rescuer
+        else
+          try_rescue(reason, rescuer)
+        end
+      end
+      return self
+    end
+    alias_method :catch, :rescue
+    alias_method :on_error, :rescue
+
+    protected
+
+    attr_reader :parent
+    attr_reader :handler
+    attr_reader :rescuers
+
+    # @private
+    Rescuer = Struct.new(:clazz, :block)
+
+    # @private
+    def root? # :nodoc:
+      @parent.nil?
+    end
+
+    # @private
+    def push(promise) # :nodoc:
+      if root?
+        @chain << promise
+      else
+        @parent.push(promise)
+      end
+    end
+
+    # @private
+    def on_fulfill(value) # :nodoc:
+      @lock.synchronize do
+        @value = @handler.call(value)
+        @state = :fulfilled
+        @reason = nil
+      end
+      return @value
+    end
+
+    # @private
+    def on_reject(reason) # :nodoc:
+      @value = nil
+      @state = :rejected
+      @reason = reason
+      try_rescue(reason)
+      @children.each{|child| child.on_reject(reason) }
+    end
+
+    # @private
+    def try_rescue(ex, *rescuers) # :nodoc:
+      rescuers = @rescuers if rescuers.empty?
+      rescuer = rescuers.find{|r| ex.is_a?(r.clazz) }
+      if rescuer
+        rescuer.block.call(ex)
+        @rescued = true
+      end
+    rescue Exception => e
+      # supress
+    end
+
+    # @private
+    def realize(*args) # :nodoc:
+      Promise.thread_pool.post(@chain, @lock, args) do |chain, lock, args|
+        result = args.length == 1 ? args.first : args
+        index = 0
+        loop do
+          current = lock.synchronize{ chain[index] }
+          unless current.rejected?
+            current.mutex.synchronize do
+              begin
+                result = current.on_fulfill(result)
+              rescue Exception => ex
+                current.on_reject(ex)
+              end
+            end
+          end
+          index += 1
+          Thread.pass while index >= chain.length
+        end
+      end
+    end
+  end
+end