concurrent-ruby 0.2.1 → 0.2.2

data/lib/concurrent/fixed_thread_pool.rb

@@ -1,99 +1,99 @@
-require 'thread'
-
-require 'concurrent/thread_pool'
-require 'concurrent/event'
-
-module Concurrent
-
-  def self.new_fixed_thread_pool(size)
-    return FixedThreadPool.new(size)
-  end
-
-  class FixedThreadPool < ThreadPool
-    behavior(:thread_pool)
-
-    MIN_POOL_SIZE = 1
-    MAX_POOL_SIZE = 1024
-
-    def initialize(size)
-      super()
-      if size < MIN_POOL_SIZE || size > MAX_POOL_SIZE
-        raise ArgumentError.new("size must be between #{MIN_POOL_SIZE} and #{MAX_POOL_SIZE}")
-      end
-
-      @pool = size.times.collect{ create_worker_thread }
-      collect_garbage
-    end
-
-    def kill
-      mutex.synchronize do
-        @status = :killed
-        @pool.each{|t| Thread.kill(t) }
-      end
-    end
-
-    def size
-      if running?
-        return @pool.length
-      else
-        return 0
-      end
-    end
-
-    def post(*args, &block)
-      raise ArgumentError.new('no block given') unless block_given?
-      if running?
-        @queue << [args, block]
-        return true
-      else
-        return false
-      end
-    end
-
-    # @private
-    def status # :nodoc:
-      mutex.synchronize do
-        @pool.collect{|t| t.status }
-      end
-    end
-
-    private
-
-    # @private
-    def create_worker_thread # :nodoc:
-      thread = Thread.new do
-        loop do
-          task = @queue.pop
-          if task == :stop
-            break
-          else
-            task.last.call(*task.first)
-          end
-        end
-        @pool.delete(Thread.current)
-        if @pool.empty?
-          @termination.set
-          @status = :shutdown unless killed?
-        end
-      end
-
-      thread.abort_on_exception = false
-      return thread
-    end
-
-    # @private
-    def collect_garbage # :nodoc:
-      @collector = Thread.new do
-        sleep(1)
-        mutex.synchronize do
-          @pool.size.times do |i|
-            if @pool[i].status.nil?
-              @pool[i] = create_worker_thread
-            end
-          end
-        end
-      end
-      @collector.abort_on_exception = false
-    end
-  end
-end
+require 'thread'
+
+require 'concurrent/thread_pool'
+require 'concurrent/event'
+
+module Concurrent
+
+  def self.new_fixed_thread_pool(size)
+    return FixedThreadPool.new(size)
+  end
+
+  class FixedThreadPool < ThreadPool
+    behavior(:thread_pool)
+
+    MIN_POOL_SIZE = 1
+    MAX_POOL_SIZE = 1024
+
+    def initialize(size)
+      super()
+      if size < MIN_POOL_SIZE || size > MAX_POOL_SIZE
+        raise ArgumentError.new("size must be between #{MIN_POOL_SIZE} and #{MAX_POOL_SIZE}")
+      end
+
+      @pool = size.times.collect{ create_worker_thread }
+      collect_garbage
+    end
+
+    def kill
+      mutex.synchronize do
+        @status = :killed
+        @pool.each{|t| Thread.kill(t) }
+      end
+    end
+
+    def size
+      if running?
+        return @pool.length
+      else
+        return 0
+      end
+    end
+
+    def post(*args, &block)
+      raise ArgumentError.new('no block given') unless block_given?
+      if running?
+        @queue << [args, block]
+        return true
+      else
+        return false
+      end
+    end
+
+    # @private
+    def status # :nodoc:
+      mutex.synchronize do
+        @pool.collect{|t| t.status }
+      end
+    end
+
+    private
+
+    # @private
+    def create_worker_thread # :nodoc:
+      thread = Thread.new do
+        loop do
+          task = @queue.pop
+          if task == :stop
+            break
+          else
+            task.last.call(*task.first)
+          end
+        end
+        @pool.delete(Thread.current)
+        if @pool.empty?
+          @termination.set
+          @status = :shutdown unless killed?
+        end
+      end
+
+      thread.abort_on_exception = false
+      return thread
+    end
+
+    # @private
+    def collect_garbage # :nodoc:
+      @collector = Thread.new do
+        sleep(1)
+        mutex.synchronize do
+          @pool.size.times do |i|
+            if @pool[i].status.nil?
+              @pool[i] = create_worker_thread
+            end
+          end
+        end
+      end
+      @collector.abort_on_exception = false
+    end
+  end
+end

data/lib/concurrent/functions.rb

@@ -1,120 +1,120 @@
-require 'concurrent/agent'
-require 'concurrent/defer'
-require 'concurrent/future'
-require 'concurrent/promise'
-
-module Kernel
-
-  ## agent
-
-  def agent(initial, timeout = Concurrent::Agent::TIMEOUT)
-    return Concurrent::Agent.new(initial, timeout)
-  end
-  module_function :agent
-
-  def post(object, &block)
-    if object.respond_to?(:post)
-      return object.post(&block)
-    else
-      raise ArgumentError.new('object does not support #post')
-    end
-  end
-  module_function :post
-
-  ## defer
-
-  def defer(*args, &block)
-    return Concurrent::Defer.new(*args, &block)
-  end
-  module_function :defer
-
-  ## executor
-
-  def executor(*args, &block)
-    return Concurrent::Executor.run(*args, &block)
-  end
-  module_function :executor
-
-  ## future
-
-  def future(*args, &block)
-    return Concurrent::Future.new(*args, &block)
-  end
-  module_function :future
-
-  ## obligation
-
-  def deref(object, timeout = nil)
-    if object.respond_to?(:deref)
-      return object.deref(timeout)
-    elsif object.respond_to?(:value)
-      return object.value(timeout)
-    else
-      raise ArgumentError.new('object does not support #deref')
-    end
-  end
-  module_function :deref
-
-  def pending?(object)
-    if object.respond_to?(:pending?)
-      return object.pending?
-    else
-      raise ArgumentError.new('object does not support #pending?')
-    end
-  end
-  module_function :pending?
-
-  def fulfilled?(object)
-    if object.respond_to?(:fulfilled?)
-      return object.fulfilled?
-    elsif object.respond_to?(:realized?)
-      return object.realized?
-    else
-      raise ArgumentError.new('object does not support #fulfilled?')
-    end
-  end
-  module_function :fulfilled?
-
-  def realized?(object)
-    if object.respond_to?(:realized?)
-      return object.realized?
-    elsif object.respond_to?(:fulfilled?)
-      return object.fulfilled?
-    else
-      raise ArgumentError.new('object does not support #realized?')
-    end
-  end
-  module_function :realized?
-
-  def rejected?(object)
-    if object.respond_to?(:rejected?)
-      return object.rejected?
-    else
-      raise ArgumentError.new('object does not support #rejected?')
-    end
-  end
-  module_function :rejected?
-
-  ## 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 passes to each of its children when the child resolves. When
-  # a promise is rejected all its children will be summarily rejected.
-  # A promise added to a rejected promise will immediately be 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 Promise
-  # @see http://wiki.commonjs.org/wiki/Promises/A
-  def promise(*args, &block)
-    return Concurrent::Promise.new(*args, &block)
-  end
-  module_function :promise
-end
+require 'concurrent/agent'
+require 'concurrent/defer'
+require 'concurrent/future'
+require 'concurrent/promise'
+
+module Kernel
+
+  ## agent
+
+  def agent(initial, timeout = Concurrent::Agent::TIMEOUT)
+    return Concurrent::Agent.new(initial, timeout)
+  end
+  module_function :agent
+
+  def post(object, &block)
+    if object.respond_to?(:post)
+      return object.post(&block)
+    else
+      raise ArgumentError.new('object does not support #post')
+    end
+  end
+  module_function :post
+
+  ## defer
+
+  def defer(*args, &block)
+    return Concurrent::Defer.new(*args, &block)
+  end
+  module_function :defer
+
+  ## executor
+
+  def executor(*args, &block)
+    return Concurrent::Executor.run(*args, &block)
+  end
+  module_function :executor
+
+  ## future
+
+  def future(*args, &block)
+    return Concurrent::Future.new(*args, &block)
+  end
+  module_function :future
+
+  ## obligation
+
+  def deref(object, timeout = nil)
+    if object.respond_to?(:deref)
+      return object.deref(timeout)
+    elsif object.respond_to?(:value)
+      return object.value(timeout)
+    else
+      raise ArgumentError.new('object does not support #deref')
+    end
+  end
+  module_function :deref
+
+  def pending?(object)
+    if object.respond_to?(:pending?)
+      return object.pending?
+    else
+      raise ArgumentError.new('object does not support #pending?')
+    end
+  end
+  module_function :pending?
+
+  def fulfilled?(object)
+    if object.respond_to?(:fulfilled?)
+      return object.fulfilled?
+    elsif object.respond_to?(:realized?)
+      return object.realized?
+    else
+      raise ArgumentError.new('object does not support #fulfilled?')
+    end
+  end
+  module_function :fulfilled?
+
+  def realized?(object)
+    if object.respond_to?(:realized?)
+      return object.realized?
+    elsif object.respond_to?(:fulfilled?)
+      return object.fulfilled?
+    else
+      raise ArgumentError.new('object does not support #realized?')
+    end
+  end
+  module_function :realized?
+
+  def rejected?(object)
+    if object.respond_to?(:rejected?)
+      return object.rejected?
+    else
+      raise ArgumentError.new('object does not support #rejected?')
+    end
+  end
+  module_function :rejected?
+
+  ## 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 passes to each of its children when the child resolves. When
+  # a promise is rejected all its children will be summarily rejected.
+  # A promise added to a rejected promise will immediately be 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 Promise
+  # @see http://wiki.commonjs.org/wiki/Promises/A
+  def promise(*args, &block)
+    return Concurrent::Promise.new(*args, &block)
+  end
+  module_function :promise
+end

data/lib/concurrent/future.rb

@@ -1,42 +1,42 @@
-require 'thread'
-
-require 'concurrent/global_thread_pool'
-require 'concurrent/obligation'
-require 'concurrent/utilities'
-
-module Concurrent
-
-  class Future
-    include Obligation
-    include UsesGlobalThreadPool
-
-    behavior(:future)
-
-    def initialize(*args, &block)
-      unless block_given?
-        @state = :fulfilled
-      else
-        @value = nil
-        @state = :pending
-        Future.thread_pool.post(*args) do
-          work(*args, &block)
-        end
-      end
-    end
-
-    private
-
-    # @private
-    def work(*args) # :nodoc:
-      mutex.synchronize do
-        begin
-          @value = yield(*args)
-          @state = :fulfilled
-        rescue Exception => ex
-          @state = :rejected
-          @reason = ex
-        end
-      end
-    end
-  end
-end
+require 'thread'
+
+require 'concurrent/global_thread_pool'
+require 'concurrent/obligation'
+require 'concurrent/utilities'
+
+module Concurrent
+
+  class Future
+    include Obligation
+    include UsesGlobalThreadPool
+
+    behavior(:future)
+
+    def initialize(*args, &block)
+      unless block_given?
+        @state = :fulfilled
+      else
+        @value = nil
+        @state = :pending
+        Future.thread_pool.post(*args) do
+          work(*args, &block)
+        end
+      end
+    end
+
+    private
+
+    # @private
+    def work(*args) # :nodoc:
+      mutex.synchronize do
+        begin
+          @value = yield(*args)
+          @state = :fulfilled
+        rescue Exception => ex
+          @state = :rejected
+          @reason = ex
+        end
+      end
+    end
+  end
+end