concurrent-ruby 0.6.0.pre.2 → 0.6.0

data/spec/support/example_group_extensions.rb

@@ -0,0 +1,48 @@
+require 'rbconfig'
+
+module Concurrent
+  module TestHelpers
+    def delta(v1, v2)
+      if block_given?
+        v1 = yield(v1)
+        v2 = yield(v2)
+      end
+      return (v1 - v2).abs
+    end
+
+    def mri?
+      RbConfig::CONFIG['ruby_install_name']=~ /^ruby$/i
+    end
+
+    def jruby?
+      RbConfig::CONFIG['ruby_install_name']=~ /^jruby$/i
+    end
+
+    def rbx?
+      RbConfig::CONFIG['ruby_install_name']=~ /^rbx$/i
+    end
+
+    def reset_gem_configuration
+      Concurrent.instance_variable_set(:@configuration, Concurrent::Configuration.new)
+    end
+
+    extend self
+  end
+end
+
+class RSpec::Core::ExampleGroup
+  def self.with_full_reset
+    before(:each) do
+      reset_gem_configuration
+    end
+
+    after(:each) do
+      Thread.list.each do |thread|
+        thread.kill unless thread == Thread.current
+      end
+    end
+  end
+
+  include Concurrent::TestHelpers
+  extend Concurrent::TestHelpers
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 0.6.0.pre.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Jerry D'Antonio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-12 00:00:00.000000000 Z
+date: 2014-05-26 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -24,13 +24,21 @@ files:
 - README.md
 - lib/concurrent.rb
 - lib/concurrent/actor/actor.rb
-- lib/concurrent/actor/actor_context.rb
-- lib/concurrent/actor/actor_ref.rb
 - lib/concurrent/actor/postable.rb
-- lib/concurrent/actor/simple_actor_ref.rb
 - lib/concurrent/actors.rb
+- lib/concurrent/actress.rb
+- lib/concurrent/actress/ad_hoc.rb
+- lib/concurrent/actress/context.rb
+- lib/concurrent/actress/core.rb
+- lib/concurrent/actress/core_delegations.rb
+- lib/concurrent/actress/doc.md
+- lib/concurrent/actress/envelope.rb
+- lib/concurrent/actress/errors.rb
+- lib/concurrent/actress/reference.rb
+- lib/concurrent/actress/type_check.rb
 - lib/concurrent/agent.rb
 - lib/concurrent/async.rb
+- lib/concurrent/atomic/atomic.rb
 - lib/concurrent/atomic/atomic_boolean.rb
 - lib/concurrent/atomic/atomic_fixnum.rb
 - lib/concurrent/atomic/condition.rb
@@ -54,6 +62,7 @@ files:
 - lib/concurrent/dataflow.rb
 - lib/concurrent/delay.rb
 - lib/concurrent/dereferenceable.rb
+- lib/concurrent/errors.rb
 - lib/concurrent/exchanger.rb
 - lib/concurrent/executor/cached_thread_pool.rb
 - lib/concurrent/executor/executor.rb
@@ -77,6 +86,7 @@ files:
 - lib/concurrent/executors.rb
 - lib/concurrent/future.rb
 - lib/concurrent/ivar.rb
+- lib/concurrent/logging.rb
 - lib/concurrent/mvar.rb
 - lib/concurrent/obligation.rb
 - lib/concurrent/observable.rb
@@ -94,16 +104,14 @@ files:
 - lib/concurrent/utility/timer.rb
 - lib/concurrent/version.rb
 - lib/concurrent_ruby.rb
-- lib/concurrent_ruby_ext.bundle
-- spec/concurrent/actor/actor_context_spec.rb
-- spec/concurrent/actor/actor_ref_shared.rb
 - spec/concurrent/actor/actor_spec.rb
 - spec/concurrent/actor/postable_shared.rb
-- spec/concurrent/actor/simple_actor_ref_spec.rb
+- spec/concurrent/actress_spec.rb
 - spec/concurrent/agent_spec.rb
 - spec/concurrent/async_spec.rb
 - spec/concurrent/atomic/atomic_boolean_spec.rb
 - spec/concurrent/atomic/atomic_fixnum_spec.rb
+- spec/concurrent/atomic/atomic_spec.rb
 - spec/concurrent/atomic/condition_spec.rb
 - spec/concurrent/atomic/copy_on_notify_observer_set_spec.rb
 - spec/concurrent/atomic/copy_on_write_observer_set_spec.rb
@@ -162,7 +170,7 @@ files:
 - spec/concurrent/utility/timeout_spec.rb
 - spec/concurrent/utility/timer_spec.rb
 - spec/spec_helper.rb
-- spec/support/functions.rb
+- spec/support/example_group_extensions.rb
 - spec/support/less_than_or_equal_to_matcher.rb
 homepage: http://www.concurrent-ruby.com
 licenses:
@@ -179,9 +187,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2
@@ -190,15 +198,14 @@ specification_version: 4
 summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,
   F#, C#, Java, and classic concurrency patterns.
 test_files:
-- spec/concurrent/actor/actor_context_spec.rb
-- spec/concurrent/actor/actor_ref_shared.rb
 - spec/concurrent/actor/actor_spec.rb
 - spec/concurrent/actor/postable_shared.rb
-- spec/concurrent/actor/simple_actor_ref_spec.rb
+- spec/concurrent/actress_spec.rb
 - spec/concurrent/agent_spec.rb
 - spec/concurrent/async_spec.rb
 - spec/concurrent/atomic/atomic_boolean_spec.rb
 - spec/concurrent/atomic/atomic_fixnum_spec.rb
+- spec/concurrent/atomic/atomic_spec.rb
 - spec/concurrent/atomic/condition_spec.rb
 - spec/concurrent/atomic/copy_on_notify_observer_set_spec.rb
 - spec/concurrent/atomic/copy_on_write_observer_set_spec.rb
@@ -257,6 +264,6 @@ test_files:
 - spec/concurrent/utility/timeout_spec.rb
 - spec/concurrent/utility/timer_spec.rb
 - spec/spec_helper.rb
-- spec/support/functions.rb
+- spec/support/example_group_extensions.rb
 - spec/support/less_than_or_equal_to_matcher.rb
 has_rdoc: 

data/lib/concurrent/actor/actor_context.rb

@@ -1,77 +0,0 @@
-require 'concurrent/actor/simple_actor_ref'
-
-module Concurrent
-
-  # Actor-based concurrency is all the rage in some circles. Originally described in
-  # 1973, the actor model is a paradigm for creating asynchronous, concurrent objects
-  # that is becoming increasingly popular. Much has changed since actors were first
-  # written about four decades ago, which has led to a serious fragmentation within
-  # the actor community. There is *no* universally accepted, strict definition of
-  # "actor" and actor implementations differ widely between languages and libraries.
-  # 
-  # A good definition of "actor" is:
-  # 
-  #   An independent, concurrent, single-purpose, computational entity that communicates exclusively via message passing.
-  #
-  # The actor framework in this library is heavily influenced by the Akka toolkit,
-  # with additional inspiration from Erlang and Scala. Unlike many of the abstractions
-  # in this library, `ActorContext` takes an *object-oriented* approach to asynchronous
-  # concurrency, rather than a *functional programming* approach.
-  #
-  # Creating an actor class is achieved by including the `ActorContext` module
-  # within a standard Ruby class. One `ActorContext` is mixed in, however, everything
-  # changes. Objects of the class can no longer be instanced with the `#new` method.
-  # Instead, the various factor methods, such as `#spawn`, must be used. These factory
-  # methods do not return direct references to the actor object. Instead they return
-  # objects of one of the `ActorRef` subclasses. The `ActorRef` objects encapsulate
-  # actor objects. This encapsulation is necessary to prevent synchronous method calls
-  # froom being made against the actors. It also allows the messaging and lifecycle
-  # behavior to be implemented within the `ActorRef` subclasses, allowing for better
-  # separation of responsibility.
-  #
-  # @see Concurrent::ActorRef
-  #
-  # @see http://akka.io/
-  # @see http://www.erlang.org/doc/getting_started/conc_prog.html
-  # @see http://www.scala-lang.org/api/current/index.html#scala.actors.Actor
-  #
-  # @see http://doc.akka.io/docs/akka/snapshot/general/supervision.html#What_Restarting_Means What Restarting Means
-  # @see http://doc.akka.io/docs/akka/snapshot/general/supervision.html#What_Lifecycle_Monitoring_Means What Lifecycle Monitoring Means
-  module ActorContext
-
-    # Callback method called by the `ActorRef` which encapsulates the actor instance.
-    def on_start
-    end
-
-    # Callback method called by the `ActorRef` which encapsulates the actor instance.
-    def on_shutdown
-    end
-
-    # Callback method called by the `ActorRef` which encapsulates the actor instance.
-    #
-    # @param [Time] time the date/time at which the error occurred
-    # @param [Array] message the message that caused the error
-    # @param [Exception] exception the exception object that was raised
-    def on_error(time, message, exception)
-    end
-
-    def self.included(base)
-
-      class << base
-
-        # Create a single, unregistered actor. The actor will run on its own, dedicated
-        # thread. The thread will be started the first time a message is post to the actor.
-        # Should the thread ever die it will be restarted the next time a message is post.
-        #
-        # @param [Hash] opts the options defining actor behavior
-        # @option opts [Array] :args (`nil`) arguments to be passed to the actor constructor
-        #
-        # @return [SimpleActorRef] the `ActorRef` encapsulating the actor
-        def spawn(opts = {})
-          args = opts.fetch(:args, [])
-          Concurrent::SimpleActorRef.new(self.new(*args), opts)
-        end
-      end
-    end
-  end
-end

data/lib/concurrent/actor/actor_ref.rb

@@ -1,67 +0,0 @@
-module Concurrent
-
-  # Base class for classes that encapsulate `ActorContext` objects.
-  #
-  # @see Concurrent::ActorContext
-  module ActorRef
-
-    # @!method post(*msg, &block)
-    #
-    #   Send a message and return a future which will eventually be updated
-    #   with the result of the operation. An optional callback block can be
-    #   given which will be called once the operation is complete. Although
-    #   it is possible to use a callback block and also interrogate the
-    #   returned future it is a good practice to do one or the other.
-    #
-    #   @param [Array] msg One or more elements of the message
-    #
-    #   @yield a callback operation to be performed when the operation is complete.
-    #   @yieldparam [Time] time the date/time at which the error occurred
-    #   @yieldparam [Object] result the result of message processing or `nil` on error
-    #   @yieldparam [Exception] exception the exception object that was raised or `nil` on success
-    #
-    #   @return [IVar] a future that will eventually contain the result of message processing
-
-    # @!method post!(timeout, *msg)
-    #   Send a message synchronously and block awaiting the response.
-    #
-    #   @param [Integer] timeout the maximum number of seconds to block waiting
-    #     for a response
-    #   @param [Array] msg One or more elements of the message
-    #
-    #   @return [Object] the result of successful message processing
-    #
-    #   @raise [Concurrent::TimeoutError] if a timeout occurs
-    #   @raise [Exception] an exception which occurred during message processing
-
-    # @!method running?()
-    #   Is the actor running and processing messages?
-    #   @return [Boolean] `true` if running else `false`
-
-    # @!method shutdown?()
-    #   Is the actor shutdown and no longer processing messages?
-    #   @return [Boolean] `true` if shutdown else `false`
-
-    # @!method shutdown()
-    #   Shutdown the actor, gracefully exit all threads, and stop processing messages.
-    #   @return [Boolean] `true` if shutdown is successful else `false`
-
-    # @!method join(limit = nil)
-    #   Suspend the current thread until the actor has been shutdown
-    #   @param [Integer] limit the maximum number of seconds to block waiting for the
-    #     actor to shutdown. Block indefinitely when `nil` or not given
-    #   @return [Boolean] `true` if the actor shutdown before the limit expired else `false`
-    #   @see http://www.ruby-doc.org/core-2.1.1/Thread.html#method-i-join
-
-    # Send a message and return. It's a fire-and-forget interaction.
-    #
-    # @param [Object] message a single value representing the message to be sent
-    #   to the actor or an array of multiple message components
-    #
-    # @return [ActorRef] self
-    def <<(message)
-      post(*message)
-      self
-    end
-  end
-end

data/lib/concurrent/actor/simple_actor_ref.rb

@@ -1,94 +0,0 @@
-require 'concurrent/actor/actor_ref'
-require 'concurrent/atomic/event'
-require 'concurrent/executor/single_thread_executor'
-require 'concurrent/ivar'
-
-module Concurrent
-
-  class SimpleActorRef
-    include ActorRef
-
-    def initialize(actor, opts = {})
-      @actor           = actor
-      @mutex           = Mutex.new
-      @one_by_one      = OneByOne.new
-      @executor        = OptionsParser::get_executor_from(opts)
-      @stop_event      = Event.new
-      @reset_on_error  = opts.fetch(:reset_on_error, true)
-      @exception_class = opts.fetch(:rescue_exception, false) ? Exception : StandardError
-      @args            = opts.fetch(:args, []) if @reset_on_error
-
-      @actor.define_singleton_method(:shutdown, &method(:set_stop_event))
-      @actor.on_start
-    end
-
-    def running?
-      not @stop_event.set?
-    end
-
-    def shutdown?
-      @stop_event.set?
-    end
-
-    def post(*msg, &block)
-      raise ArgumentError.new('message cannot be empty') if msg.empty?
-      ivar = IVar.new
-      @one_by_one.post(@executor, Message.new(msg, ivar, block), &method(:process_message))
-      ivar
-    end
-
-    def post!(timeout, *msg)
-      raise Concurrent::TimeoutError unless timeout.nil? || timeout >= 0
-      ivar = self.post(*msg)
-      ivar.value(timeout)
-      if ivar.incomplete?
-        raise Concurrent::TimeoutError
-      elsif ivar.reason
-        raise ivar.reason
-      end
-      ivar.value
-    end
-
-    def shutdown
-      @mutex.synchronize do
-        return if shutdown?
-        @actor.on_shutdown
-        @stop_event.set
-      end
-    end
-
-    def join(limit = nil)
-      @stop_event.wait(limit)
-    end
-
-    private
-
-    Message = Struct.new(:payload, :ivar, :callback)
-
-    def set_stop_event
-      @stop_event.set
-    end
-
-    def process_message(message)
-      result = ex = nil
-
-      begin
-        result = @actor.receive(*message.payload)
-      rescue @exception_class => ex
-        @actor.on_error(Time.now, message.payload, ex)
-        if @reset_on_error
-          @mutex.synchronize{ @actor = @actor.class.new(*@args) }
-        end
-      ensure
-        now = Time.now
-        message.ivar.complete(ex.nil?, result, ex)
-
-        begin
-          message.callback.call(now, result, ex) if message.callback
-        rescue @exception_class => ex
-          # suppress
-        end
-      end
-    end
-  end
-end

data/spec/concurrent/actor/actor_context_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe ActorContext do
-
-    let(:described_class) do
-      Class.new do
-        include ActorContext
-      end
-    end
-
-    context 'callbacks' do
-
-      subject { described_class.send(:new) }
-
-      specify { subject.should respond_to :on_start }
-
-      specify { subject.should respond_to :on_shutdown }
-    end
-
-    context '#spawn' do
-
-      it 'returns an ActorRef' do
-        described_class.spawn.should be_a ActorRef
-      end
-    end
-  end
-end

data/spec/concurrent/actor/actor_ref_shared.rb

@@ -1,263 +0,0 @@
-require 'spec_helper'
-
-def create_actor_test_class
-  Class.new do
-    include Concurrent::ActorContext
-
-    attr_reader :argv
-
-    def initialize(*args)
-      @argv = args
-    end
-
-    def receive(*msg)
-      case msg.first
-      when :poison
-        raise StandardError
-      when :bullet
-        raise Exception
-      when :stop
-        shutdown
-      when :terminate
-        Thread.current.kill
-      when :sleep
-        sleep(msg.last)
-      when :check
-        msg[1].set(msg.last)
-      else
-        msg.first
-      end
-    end
-  end
-end
-
-share_examples_for :actor_ref do
-
-  after(:each) do
-    subject.shutdown
-  end
-
-  it 'includes ActorRef' do
-    subject.should be_a Concurrent::ActorRef
-  end
-
-  context 'running and shutdown' do
-
-    specify { subject.should respond_to :shutdown }
-
-    specify { subject.should be_running }
-
-    specify { subject.should_not be_shutdown }
-
-    specify do
-      subject.shutdown
-      sleep(0.1)
-      subject.should be_shutdown
-    end
-
-    it 'defines a shutdown method on the actor(s)' do
-      subject << :foo
-      subject << :stop
-      sleep(0.1)
-      subject.should be_shutdown
-    end
-  end
-
-  context '#post' do
-
-    it 'raises an exception when the message is empty' do
-      expect {
-        subject.post
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'returns an IVar' do
-      subject.post(:foo).should be_a Concurrent::IVar
-    end
-
-    it 'fulfills the IVar when message is processed' do
-      ivar = subject.post(:foo)
-      sleep(0.1)
-      ivar.should be_fulfilled
-      ivar.value.should eq :foo
-    end
-
-    it 'rejects the IVar when message processing fails' do
-      ivar = subject.post(:poison)
-      sleep(0.1)
-      ivar.should be_rejected
-      ivar.reason.should be_a StandardError
-    end
-  end
-
-  context '#<<' do
-
-    it 'posts the message' do
-      ivar = Concurrent::IVar.new
-      subject << [:check, ivar, :foo]
-      ivar.value(0.1).should eq :foo
-    end
-
-    it 'returns self' do
-      expected = subject
-      result = subject << [1,2,3,4]
-      result.should eq expected
-    end
-  end
-
-  context '#post with callback' do
-
-    specify 'on success calls the callback with time and value' do
-      expected_value = expected_reason = nil
-      subject.post(:foo) do |time, value, reason|
-        expected_value = value
-        expected_reason = reason
-      end
-      sleep(0.1)
-
-      expected_value.should eq :foo
-      expected_reason.should be_nil
-    end
-
-    specify 'on failure calls the callback with time and reason' do
-      expected_value = expected_reason = nil
-      subject.post(:poison) do |time, value, reason|
-        expected_value = value
-        expected_reason = reason
-      end
-      sleep(0.1)
-
-      expected_value.should be_nil
-      expected_reason.should be_a StandardError
-    end
-
-    it 'supresses exceptions thrown by the callback' do
-      expected = nil
-      subject.post(:foo){|time, value, reason| raise StandardError }
-      sleep(0.1)
-
-      subject.post(:bar){|time, value, reason| expected = value }
-      sleep(0.1)
-
-      expected.should eq :bar
-    end
-  end
-
-  context '#post!' do
-
-    it 'raises an exception when the message is empty' do
-      expect {
-        subject.post!(1)
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'blocks for up to the given number of seconds' do
-      start = Time.now.to_f
-      begin
-        subject.post!(1, :sleep, 2)
-      rescue
-      end
-      delta = Time.now.to_f - start
-      delta.should >= 1
-      delta.should <= 2
-    end
-
-    it 'blocks forever when the timeout is nil' do
-      start = Time.now.to_f
-      subject.post!(nil, :sleep, 1)
-      delta = Time.now.to_f - start
-      delta.should > 1
-    end
-
-    it 'raises a TimeoutError when timeout is zero' do
-      expect {
-        subject.post!(0, :foo)
-      }.to raise_error(Concurrent::TimeoutError)
-    end
-
-    it 'raises a TimeoutError when the timeout is reached' do
-      expect {
-        subject.post!(1, :sleep, 10)
-      }.to raise_error(Concurrent::TimeoutError)
-    end
-
-    it 'returns the result of success processing' do
-      subject.post!(1, :foo).should eq :foo
-    end
-
-    it 'bubbles exceptions thrown during processing' do
-      expect {
-        subject.post!(1, :poison)
-      }.to raise_error(StandardError)
-    end
-  end
-
-  context '#join' do
-
-    it 'blocks until shutdown when no limit is given' do
-      start = Time.now
-      subject << :foo # start the actor's thread
-      Thread.new{ sleep(1); subject.shutdown }
-      subject.join
-      stop = Time.now
-
-      subject.should be_shutdown
-      stop.should >= start + 1
-      stop.should <= start + 2
-    end
-
-    it 'blocks for no more than the given number of seconds' do
-      start = Time.now
-      subject << :foo # start the actor's thread
-      Thread.new{ sleep(5); subject.shutdown }
-      subject.join(1)
-      stop = Time.now
-
-      stop.should >= start + 1
-      stop.should <= start + 2
-    end
-
-    it 'returns true when shutdown has completed before timeout' do
-      subject << :foo # start the actor's thread
-      Thread.new{ sleep(1); subject.shutdown }
-      subject.join.should be_true
-    end
-
-    it 'returns false on timeout' do
-      subject << :foo # start the actor's thread
-      Thread.new{ sleep(5); subject.shutdown }
-      subject.join(1).should be_false
-    end
-
-    it 'returns immediately when already shutdown' do
-      start = Time.now
-      subject << :foo # start the actor's thread
-      sleep(0.1)
-      subject.shutdown
-      sleep(0.1)
-
-      start = Time.now
-      subject.join
-      Time.now.should >= start
-      Time.now.should <= start + 0.1
-    end
-  end
-
-  context '#on_error' do
-
-    specify 'is not called on success' do
-      actor = subject.instance_variable_get(:@actor)
-      actor.should_not_receive(:on_error).with(any_args)
-      subject.post(:foo)
-      sleep(0.1)
-    end
-
-    specify 'is called when a message raises an exception' do
-      actor = subject.instance_variable_get(:@actor)
-      actor.should_receive(:on_error).
-        with(anything, [:poison], an_instance_of(StandardError))
-      subject.post(:poison)
-      sleep(0.1)
-    end
-  end
-end