concurrent-ruby 0.6.0.pre.1 → 0.6.0.pre.2

data/lib/concurrent/tvar.rb

@@ -1,6 +1,6 @@
 require 'set'
 
-require 'concurrent/thread_local_var'
+require 'concurrent/atomic/thread_local_var'
 
 module Concurrent
 

data/lib/concurrent/utilities.rb

@@ -1,36 +1,3 @@
-require 'rbconfig'
-require 'thread'
-
-module Concurrent
-
-  # Error raised when an operations times out.
-  TimeoutError = Class.new(StandardError)
-
-  # Wait the given number of seconds for the block operation to complete.
-  #
-  # @param [Integer] seconds The number of seconds to wait
-  #
-  # @return The result of the block operation
-  #
-  # @raise Concurrent::TimeoutError when the block operation does not complete
-  #   in the allotted number of seconds.
-  #
-  # @note This method is intended to be a simpler and more reliable replacement
-  # to the Ruby standard library +Timeout::timeout+ method.
-  def timeout(seconds)
-
-    thread = Thread.new do
-      Thread.current[:result] = yield
-    end
-    success = thread.join(seconds)
-
-    if success
-      return thread[:result]
-    else
-      raise TimeoutError
-    end
-  ensure
-    Thread.kill(thread) unless thread.nil?
-  end
-  module_function :timeout
-end
+require 'concurrent/utility/processor_count'
+require 'concurrent/utility/timeout'
+require 'concurrent/utility/timer'

data/lib/concurrent/{processor_count.rb → utility/processor_count.rb}

@@ -5,7 +5,7 @@ module Concurrent
   # Number of processors seen by the OS and used for process scheduling. For performance
   # reasons the calculated value will be memoized on the first call.
   #
-  # When running under JRuby the Java runtime call +java.lang.Runtime.getRuntime.availableProcessors+
+  # When running under JRuby the Java runtime call `java.lang.Runtime.getRuntime.availableProcessors`
   # will be used. According to the Java documentation this "value may change
   # during a particular invocation of the virtual machine... [applications]
   # should therefore occasionally poll this property." Subsequently the result

data/lib/concurrent/utility/timeout.rb

@@ -0,0 +1,36 @@
+require 'rbconfig'
+require 'thread'
+
+module Concurrent
+
+  # Error raised when an operations times out.
+  TimeoutError = Class.new(StandardError)
+
+  # Wait the given number of seconds for the block operation to complete.
+  #
+  # @param [Integer] seconds The number of seconds to wait
+  #
+  # @return The result of the block operation
+  #
+  # @raise Concurrent::TimeoutError when the block operation does not complete
+  #   in the allotted number of seconds.
+  #
+  # @note This method is intended to be a simpler and more reliable replacement
+  # to the Ruby standard library `Timeout::timeout` method.
+  def timeout(seconds)
+
+    thread = Thread.new do
+      Thread.current[:result] = yield
+    end
+    success = thread.join(seconds)
+
+    if success
+      return thread[:result]
+    else
+      raise TimeoutError
+    end
+  ensure
+    Thread.kill(thread) unless thread.nil?
+  end
+  module_function :timeout
+end

data/lib/concurrent/utility/timer.rb

@@ -0,0 +1,21 @@
+require 'concurrent/configuration'
+require 'thread'
+
+module Concurrent
+
+  # Perform the given operation asynchronously after the given number of seconds.
+  #
+  # @param [Fixnum] seconds the interval in seconds to wait before executing the task
+  #
+  # @yield the task to execute
+  #
+  # @return [Boolean] true
+  def timer(seconds, *args, &block)
+    raise ArgumentError.new('no block given') unless block_given?
+    raise ArgumentError.new('interval must be greater than or equal to zero') if seconds < 0
+
+    Concurrent.configuration.global_timer_set.post(seconds, *args, &block)
+    true
+  end
+  module_function :timer
+end

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.6.0.pre.1'
+  VERSION = '0.6.0.pre.2'
 end

data/spec/concurrent/{actor_context_spec.rb → actor/actor_context_spec.rb}

@@ -10,20 +10,12 @@ module Concurrent
       end
     end
 
-    it 'protects #initialize' do
-      expect {
-        described_class.new
-      }.to raise_error(NoMethodError)
-    end
-
     context 'callbacks' do
 
       subject { described_class.send(:new) }
 
       specify { subject.should respond_to :on_start }
 
-      specify { subject.should respond_to :on_reset }
-
       specify { subject.should respond_to :on_shutdown }
     end
 

data/spec/concurrent/{actor_ref_shared.rb → actor/actor_ref_shared.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-def shared_actor_test_class
+def create_actor_test_class
   Class.new do
     include Concurrent::ActorContext
 
@@ -33,6 +33,10 @@ end
 
 share_examples_for :actor_ref do
 
+  after(:each) do
+    subject.shutdown
+  end
+
   it 'includes ActorRef' do
     subject.should be_a Concurrent::ActorRef
   end
@@ -95,7 +99,9 @@ share_examples_for :actor_ref do
     end
 
     it 'returns self' do
-      (subject << [1,2,3,4]).should eq subject
+      expected = subject
+      result = subject << [1,2,3,4]
+      result.should eq expected
     end
   end
 
@@ -158,10 +164,7 @@ share_examples_for :actor_ref do
 
     it 'blocks forever when the timeout is nil' do
       start = Time.now.to_f
-      begin
-        subject.post!(nil, :sleep, 1)
-      rescue
-      end
+      subject.post!(nil, :sleep, 1)
       delta = Time.now.to_f - start
       delta.should > 1
     end
@@ -257,57 +260,4 @@ share_examples_for :actor_ref do
       sleep(0.1)
     end
   end
-
-  context 'observation' do
-
-    let(:observer_class) do
-      Class.new do
-        attr_reader :time, :msg, :value, :reason
-        def update(time, msg, value, reason)
-          @msg = msg
-          @time = time
-          @value = value
-          @reason = reason
-        end
-      end
-    end
-
-    it 'notifies observers' do
-      o1 = observer_class.new
-      o2 = observer_class.new
-
-      subject.add_observer(o1)
-      subject.add_observer(o2)
-
-      subject << :foo
-      sleep(0.1)
-
-      o1.value.should eq :foo
-      o1.reason.should be_nil
-
-      o2.value.should eq :foo
-      o2.reason.should be_nil
-    end
-
-    it 'does not notify removed observers' do
-      o1 = observer_class.new
-      o2 = observer_class.new
-
-      subject.add_observer(o1)
-      subject.add_observer(o2)
-
-      subject << :foo
-      sleep(0.1)
-
-      subject.delete_observer(o1)
-      subject << :bar
-      sleep(0.1)
-      o1.value.should_not eq :bar
-
-      subject.delete_observers
-      subject << :baz
-      sleep(0.1)
-      o1.value.should_not eq :baz
-    end
-  end
 end

data/spec/concurrent/{actor_spec.rb → actor/actor_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 require_relative 'postable_shared'
-require_relative 'runnable_shared'
+require_relative '../runnable_shared'
 
 module Concurrent
 
@@ -90,15 +90,16 @@ module Concurrent
 
     context 'exception handling' do
 
-      it 'supresses exceptions thrown when handling messages' do
-        actor = actor_class.new{|msg| raise StandardError }
-        @thread = Thread.new{ actor.run }
-        expect {
-          @thread.join(0.1)
-          10.times { actor.post(true) }
-        }.not_to raise_error
-        actor.stop
-      end
+      #it 'supresses exceptions thrown when handling messages' do
+        #pending('intermittently failing; deprecated')
+        #actor = actor_class.new{|msg| raise StandardError }
+        #@thread = Thread.new{ actor.run }
+        #expect {
+          #@thread.join(0.1)
+          #10.times { actor.post(true) }
+        #}.not_to raise_error
+        #actor.stop
+      #end
     end
 
     context 'observation' do
@@ -132,25 +133,26 @@ module Concurrent
         }.new
       end
 
-      it 'notifies observers when a message is successfully handled' do
-        pending('intermittently failing; deprecated')
-        observer.should_receive(:update).exactly(10).times.with(any_args())
-        subject.add_observer(observer)
-        @thread = Thread.new{ subject.run }
-        @thread.join(0.1)
-        10.times { subject.post(42) }
-        @thread.join(0.1)
-      end
-
-      it 'notifies observers when a message raises an exception' do
-        error = StandardError.new
-        observer.should_receive(:update).exactly(10).times.with(any_args())
-        subject.add_observer(observer)
-        @thread = Thread.new{ subject.run }
-        @thread.join(0.1)
-        10.times { subject.post(error) }
-        @thread.join(0.1)
-      end
+      #it 'notifies observers when a message is successfully handled' do
+        #pending('intermittently failing; deprecated')
+        #observer.should_receive(:update).exactly(10).times.with(any_args())
+        #subject.add_observer(observer)
+        #@thread = Thread.new{ subject.run }
+        #@thread.join(0.1)
+        #10.times { subject.post(42) }
+        #@thread.join(0.1)
+      #end
+
+      #it 'notifies observers when a message raises an exception' do
+        #pending('intermittently failing; deprecated')
+        #error = StandardError.new
+        #observer.should_receive(:update).exactly(10).times.with(any_args())
+        #subject.add_observer(observer)
+        #@thread = Thread.new{ subject.run }
+        #@thread.join(0.1)
+        #10.times { subject.post(error) }
+        #@thread.join(0.1)
+      #end
 
       it 'passes the time, message, value, and reason to the observer on success' do
         subject.add_observer(observer)
@@ -243,18 +245,18 @@ module Concurrent
         @thread.kill
       end
 
-      it 'posts to the mailbox with Poolbox#<<' do
-        pending('intermittently failing; deprecated')
-        @expected = false
-        mailbox, pool = clazz.pool(1)
-        @thread = Thread.new{ pool.first.run }
-        sleep(0.1)
-        mailbox << 42
-        sleep(0.1)
-        pool.first.last_message.should eq [42]
-        pool.first.stop
-        @thread.kill
-      end
+      #it 'posts to the mailbox with Poolbox#<<' do
+        #pending('intermittently failing; deprecated')
+        #@expected = false
+        #mailbox, pool = clazz.pool(1)
+        #@thread = Thread.new{ pool.first.run }
+        #sleep(0.1)
+        #mailbox << 42
+        #sleep(0.1)
+        #pool.first.last_message.should eq [42]
+        #pool.first.stop
+        #@thread.kill
+      #end
     end
 
     context 'subclassing' do

data/spec/concurrent/actor/simple_actor_ref_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+require_relative 'actor_ref_shared'
+
+module Concurrent
+
+  describe SimpleActorRef do
+
+    after(:each) do
+      subject.shutdown
+      sleep(0.1)
+    end
+
+    subject do
+      create_actor_test_class.spawn
+    end
+
+    it_should_behave_like :actor_ref
+
+    context 'construction' do
+
+      it 'supports :args being nil' do
+        subject = create_actor_test_class.spawn
+        actor = subject.instance_variable_get(:@actor)
+        actor.argv.should be_empty
+      end
+
+      it 'passes all :args option to the actor constructor' do
+        subject = create_actor_test_class.spawn(args: [1, 2, 3, 4])
+        actor = subject.instance_variable_get(:@actor)
+        actor.argv.should eq [1, 2, 3, 4]
+      end
+
+      it 'passes the options hash to the ActorRef constructor' do
+        subject # prevent the after(:all) block from breaking this test
+        opts = {foo: :bar, hello: :world}
+        described_class.should_receive(:new).once.with(anything, opts)
+        create_actor_test_class.spawn(opts)
+      end
+
+      it 'calls #on_start on the actor' do
+        actor = double(:create_actor_test_class)
+        actor.should_receive(:on_start).once.with(no_args)
+        SimpleActorRef.new(actor)
+      end
+    end
+
+    context 'reset_on_error' do
+
+      it 'creates a new actor on exception when true' do
+        clazz = create_actor_test_class
+        args = [:foo, :bar, :hello, :world]
+        ref = clazz.spawn(reset_on_error: true, args: args)
+        clazz.should_receive(:new).once.with(*args)
+        ref.post(:poison)
+      end
+
+      it 'does not create a new actor on exception when false' do
+        clazz = create_actor_test_class
+        args = [:foo, :bar, :hello, :world]
+        ref = clazz.spawn(reset_on_error: true, args: args)
+        clazz.should_not_receive(:new).with(any_args)
+        ref.post(:poison)
+      end
+
+      it 'defaults to true' do
+        clazz = create_actor_test_class
+        args = [:foo, :bar, :hello, :world]
+        ref = clazz.spawn(args: args)
+        clazz.should_receive(:new).once.with(*args)
+        ref.post(:poison)
+      end
+    end
+
+    context 'rescue_exception' do
+
+      after(:each) do
+        @ref.shutdown if @ref
+      end
+
+      it 'rescues Exception in the actor thread when true' do
+        @ref = create_actor_test_class.spawn(
+          abort_on_exception: false,
+          rescue_exception: true
+        )
+
+        ivar = @ref.post(:poison)
+        sleep(0.1)
+        ivar.reason.should be_a StandardError
+
+        ivar = @ref.post(:bullet)
+        sleep(0.1)
+        ivar.reason.should be_a Exception
+      end
+
+      it 'rescues StandardError in the actor thread when false' do
+        @ref = create_actor_test_class.spawn(
+          abort_on_exception: false,
+          rescue_exception: false
+        )
+
+        ivar = @ref.post(:poison)
+        sleep(0.1)
+        ivar.reason.should be_a StandardError
+
+        ivar = @ref.post(:bullet)
+        sleep(0.1)
+        ivar.reason.should be_nil
+      end
+
+      it 'defaults to false' do
+        @ref = create_actor_test_class.spawn(abort_on_exception: false)
+
+        ivar = @ref.post(:poison)
+        sleep(0.1)
+        ivar.reason.should be_a StandardError
+
+        ivar = @ref.post(:bullet)
+        sleep(0.1)
+        ivar.reason.should be_nil
+      end
+    end
+
+    context '#shutdown' do
+
+      it 'calls #on_shutdown when shutdown' do
+        actor = subject.instance_variable_get(:@actor)
+        actor.should_receive(:on_shutdown).once.with(no_args)
+        subject << :foo
+        sleep(0.1)
+
+        subject.shutdown
+      end
+    end
+  end
+end