added: ImmediateExecutor, a simple executor where tasks are executed by thread that posted them

added: ImmediateExecutor specs
future_spec, context fulfillment, changed to use ImmediateExecutor, so it can run faster

Author: mighe

lib/concurrent.rb

@@ -21,6 +21,7 @@
 
 require 'concurrent/cached_thread_pool'
 require 'concurrent/fixed_thread_pool'
+require 'concurrent/immediate_executor'
 
 require 'concurrent/event_machine_defer_proxy' if defined?(EventMachine)
 

lib/concurrent/immediate_executor.rb

@@ -0,0 +1,14 @@
+module Concurrent
+  class ImmediateExecutor
+
+    def post(*args, &block)
+      block.call(*args)
+    end
+
+    def <<(block)
+      post(&block)
+      self
+    end
+
+  end
+end

spec/concurrent/future_spec.rb

@@ -58,36 +58,37 @@ module Concurrent
 
     context 'fulfillment' do
 
+      before(:each) do
+        Future.thread_pool = ImmediateExecutor.new
+      end
+
       it 'passes all arguments to handler' do
-        @a = @b = @c = nil
-        f = Future.new(1, 2, 3) do |a, b, c|
-          @a, @b, @c = a, b, c
+        result = nil
+
+        Future.new(1, 2, 3) do |a, b, c|
+          result  = [a, b, c]
         end
-        sleep(0.1)
-        [@a, @b, @c].should eq [1, 2, 3]
+
+        result.should eq [1, 2, 3]
       end
 
       it 'sets the value to the result of the handler' do
         f = Future.new(10){|a| a * 2 }
-        sleep(0.1)
         f.value.should eq 20
       end
 
       it 'sets the state to :fulfilled when the block completes' do
         f = Future.new(10){|a| a * 2 }
-        sleep(0.1)
         f.should be_fulfilled
       end
 
       it 'sets the value to nil when the handler raises an exception' do
         f = Future.new{ raise StandardError }
-        sleep(0.1)
         f.value.should be_nil
       end
 
       it 'sets the state to :rejected when the handler raises an exception' do
         f = Future.new{ raise StandardError }
-        sleep(0.1)
         f.should be_rejected
       end
 

spec/concurrent/immediate_executor_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe ImmediateExecutor do
+
+    let(:executor) { ImmediateExecutor.new }
+
+    context "#post" do
+      it 'executes the block using the arguments as parameters' do
+        result = executor.post(1, 2, 3, 4) { |a, b, c, d| [a, b, c, d] }
+        result.should eq [1, 2, 3, 4]
+      end
+    end
+
+    context "#<<" do
+
+      it "returns true" do
+        result = executor << proc { false }
+        result.should be_true
+      end
+
+      it "executes the passed callable" do
+        x = 0
+
+        executor << proc { x = 5 }
+
+        x.should eq 5
+      end
+
+    end
+  end
+end