functional-ruby 0.6.0 → 0.7.0

data/spec/functional/fixed_thread_pool_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-require_relative 'thread_pool_shared'
-
-module Functional
-
-  describe FixedThreadPool do
-
-    subject { FixedThreadPool.new(5) }
-
-    it_should_behave_like 'Thread Pool'
-
-    context '#initialize' do
-
-      it 'raises an exception when the pool size is less than one' do
-        lambda {
-          FixedThreadPool.new(0)
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'raises an exception when the pool size is greater than 1024' do
-        lambda {
-          FixedThreadPool.new(1025)
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'creates a thread pool of the given size' do
-        thread = mock('thread')
-        # add one for the garbage collector
-        Thread.should_receive(:new).exactly(5+1).times.and_return(thread)
-        pool = FixedThreadPool.new(5)
-        pool.size.should eq 5
-      end
-
-      it 'aliases Functional#new_fixed_thread_pool' do
-        pool = Functional.new_fixed_thread_pool(5)
-        pool.should be_a(FixedThreadPool)
-        pool.size.should eq 5
-      end
-    end
-
-    context '#kill' do
-
-      it 'kills all threads' do
-        Thread.should_receive(:kill).exactly(5).times
-        pool = FixedThreadPool.new(5)
-        pool.kill
-        sleep(0.1)
-      end
-    end
-
-    context '#size' do
-
-      let(:pool_size) { 3 }
-      subject { FixedThreadPool.new(pool_size) }
-
-      it 'returns the size of the subject when running' do
-        subject.size.should eq pool_size
-      end
-
-      it 'returns zero while shutting down' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        subject.size.should eq 0
-      end
-
-      it 'returns zero once shut down' do
-        subject.shutdown
-        subject.size.should eq 0
-      end
-    end
-
-    context 'exception handling' do
-
-      it 'restarts threads that experience exception' do
-        pool = FixedThreadPool.new(5)
-        3.times{ pool << proc{ raise StandardError } }
-        sleep(2)
-        pool.size.should eq 5
-        pool.status.should_not include(nil)
-        #pool.status.include?(nil).should be_false
-      end
-    end
-  end
-end

data/spec/functional/future_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-require_relative 'obligation_shared'
-
-module Functional
-
-  describe Future do
-
-    let!(:fulfilled_value) { 10 }
-    let!(:rejected_reason) { StandardError.new('mojo jojo') }
-
-    let(:pending_subject) do
-      Future.new{ sleep(2) }
-    end
-
-    let(:fulfilled_subject) do
-      Future.new{ fulfilled_value }.tap(){ sleep(0.1) }
-    end
-
-    let(:rejected_subject) do
-      Future.new{ raise rejected_reason }.tap(){ sleep(0.1) }
-    end
-
-    before(:each) do
-      $GLOBAL_THREAD_POOL = CachedThreadPool.new
-    end
-
-    it_should_behave_like Obligation
-
-    context 'behavior' do
-
-      it 'implements :future behavior' do
-        lambda {
-          Future.new{ nil }
-        }.should_not raise_error(BehaviorError)
-
-        Future.new{ nil }.behaves_as?(:future).should be_true
-      end
-    end
-
-    context '#initialize' do
-
-      it 'spawns a new thread when a block is given' do
-        $GLOBAL_THREAD_POOL.should_receive(:post).once.with(any_args())
-        Future.new{ nil }
-      end
-
-      it 'does not spawns a new thread when no block given' do
-        Thread.should_not_receive(:new).with(any_args())
-        Future.new
-      end
-
-      it 'immediately sets the state to :fulfilled when no block given' do
-        Future.new.should be_fulfilled
-      end
-
-      it 'immediately sets the value to nil when no block given' do
-        Future.new.value.should be_nil
-      end
-    end
-
-    context 'fulfillment' do
-
-      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
-        end
-        sleep(0.1)
-        [@a, @b, @c].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
-
-      context 'aliases' do
-
-        it 'aliases #realized? for #fulfilled?' do
-          fulfilled_subject.should be_realized
-        end
-
-        it 'aliases #deref for #value' do
-          fulfilled_subject.deref.should eq fulfilled_value
-        end
-
-        it 'aliases Kernel#future for Future.new' do
-          future().should be_a(Future)
-          future(){ nil }.should be_a(Future)
-          future(1, 2, 3).should be_a(Future)
-          future(1, 2, 3){ nil }.should be_a(Future)
-        end
-      end
-    end
-  end
-end

data/spec/functional/obligation_shared.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-
-module Functional
-
-  share_examples_for Obligation do
-
-    context '#state' do
-
-      it 'is :pending when first created' do
-        f = pending_subject
-        f.state.should == :pending
-        f.should be_pending
-      end
-
-      it 'is :fulfilled when the handler completes' do
-        f = fulfilled_subject
-        f.state.should == :fulfilled
-        f.should be_fulfilled
-      end
-
-      it 'is :rejected when the handler raises an exception' do
-        f = rejected_subject
-        f.state.should == :rejected
-        f.should be_rejected
-      end
-    end
-
-    context '#value' do
-
-      it 'blocks the caller when :pending and timeout is nil' do
-        f = pending_subject
-        sleep(0.1)
-        f.value.should be_true
-        f.should be_fulfilled
-      end
-
-      it 'returns nil when reaching the optional timeout value' do
-        f = pending_subject
-        sleep(0.1)
-        f.value(0.1).should be_nil
-        f.should be_pending
-      end
-
-      it 'returns immediately when timeout is zero' do
-        Timeout.should_not_receive(:timeout).with(any_args())
-        f = pending_subject
-        sleep(0.1)
-        f.value(0).should be_nil
-        f.should be_pending
-      end
-
-      it 'is nil when :pending' do
-        expected = pending_subject.value
-        expected.should be_nil
-      end
-
-      it 'is nil when :rejected' do
-        expected = rejected_subject.value
-        expected.should be_nil
-      end
-
-      it 'is set to the return value of the block when :fulfilled' do
-        expected = fulfilled_subject.value
-        expected.should eq fulfilled_value
-      end
-    end
-
-    context '#reason' do
-
-      it 'is nil when :pending' do
-        pending_subject.reason.should be_nil
-      end
-
-      it 'is nil when :fulfilled' do
-        fulfilled_subject.reason.should be_nil
-      end
-
-      it 'is set to error object of the exception when :rejected' do
-        rejected_subject.reason.should be_a(Exception)
-        rejected_subject.reason.to_s.should =~ /#{rejected_reason}/
-      end
-    end
-
-    context 'Kernel aliases' do
-
-      it 'aliases Kernel#deref for #deref' do
-        deref(fulfilled_subject).should eq fulfilled_value
-        deref(fulfilled_subject, 0).should eq fulfilled_value
-      end
-
-      it 'aliases Kernel#pending? for #pending?' do
-        #NOTE: was structured like others but was incorrectly failing
-        # on fulfilled_subject
-        fulfilled_subject.should_receive(:pending?).once
-        pending?(fulfilled_subject)
-        pending_subject.should_receive(:pending?).once
-        pending?(pending_subject)
-        rejected_subject.should_receive(:pending?).once
-        pending?(rejected_subject)
-      end
-
-      it 'aliases Kernel#fulfilled? for #fulfilled?' do
-        fulfilled?(fulfilled_subject).should be_true
-        fulfilled?(pending_subject).should be_false
-        fulfilled?(rejected_subject).should be_false
-      end
-
-      it 'aliases Kernel#realized? for #realized?' do
-        realized?(fulfilled_subject).should be_true
-        realized?(pending_subject).should be_false
-        realized?(rejected_subject).should be_false
-      end
-
-      it 'aliases Kernel#rejected? for #rejected?' do
-        rejected?(rejected_subject).should be_true
-        rejected?(fulfilled_subject).should be_false
-        rejected?(pending_subject).should be_false
-      end
-    end
-  end
-end

data/spec/functional/promise_spec.rb

@@ -1,310 +0,0 @@
-require 'spec_helper'
-require_relative 'obligation_shared'
-
-module Functional
-
-  describe Promise do
-
-    let!(:fulfilled_value) { 10 }
-    let!(:rejected_reason) { StandardError.new('mojo jojo') }
-
-    let(:pending_subject) do
-      Promise.new{ sleep(1) }
-    end
-
-    let(:fulfilled_subject) do
-      Promise.new{ fulfilled_value }.tap(){ sleep(0.1) }
-    end
-
-    let(:rejected_subject) do
-      Promise.new{ raise rejected_reason }.
-        rescue{ nil }.tap(){ sleep(0.1) }
-    end
-
-    before(:each) do
-      $GLOBAL_THREAD_POOL = CachedThreadPool.new
-    end
-
-    it_should_behave_like Obligation
-
-    context 'behavior' do
-
-      it 'implements :promise behavior' do
-        lambda {
-          Promise.new{ nil }
-        }.should_not raise_error(BehaviorError)
-
-        Promise.new{ nil }.behaves_as?(:promise).should be_true
-      end
-
-      it 'implements :future behavior' do
-        lambda {
-          Promise.new{ nil }
-        }.should_not raise_error(BehaviorError)
-
-        Promise.new{ nil }.behaves_as?(:future).should be_true
-      end
-    end
-
-    context '#then' do
-
-      it 'returns a new Promise when :pending' do
-        p1 = pending_subject
-        p2 = p1.then{}
-        p2.should be_a(Promise)
-        p1.should_not eq p2
-      end
-
-      it 'returns a new Promise when :fulfilled' do
-        p1 = fulfilled_subject
-        p2 = p1.then{}
-        p2.should be_a(Promise)
-        p1.should_not eq p2
-      end
-
-      it 'returns a new Promise when :rejected' do
-        p1 = rejected_subject
-        p2 = p1.then{}
-        p2.should be_a(Promise)
-        p1.should_not eq p2
-      end
-
-      it 'immediately rejects new promises when self has been rejected' do
-        p = rejected_subject
-        p.then.should be_rejected
-      end
-
-      it 'accepts a nil block' do
-        lambda {
-          pending_subject.then
-        }.should_not raise_error
-      end
-
-      it 'can be called more than once' do
-        p = pending_subject
-        p1 = p.then{}
-        p2 = p.then{}
-        p1.object_id.should_not eq p2.object_id
-      end
-    end
-
-    context '#rescue' do
-
-      it 'returns self when a block is given' do
-        p1 = pending_subject
-        p2 = p1.rescue{}
-        p1.object_id.should eq p2.object_id
-      end
-
-      it 'returns self when no block is given' do
-        p1 = pending_subject
-        p2 = p1.rescue
-        p1.object_id.should eq p2.object_id
-      end
-
-      it 'accepts an exception class as the first parameter' do
-        lambda {
-          pending_subject.rescue(StandardError){}
-        }.should_not raise_error
-      end
-    end
-
-    context 'fulfillment' do
-
-      it 'passes all arguments to the first promise in the chain' do
-        @a = @b = @c = nil
-        p = Promise.new(1, 2, 3) do |a, b, c|
-          @a, @b, @c = a, b, c
-        end
-        sleep(0.1)
-        [@a, @b, @c].should eq [1, 2, 3]
-      end
-
-      it 'passes the result of each block to all its children' do
-        @expected = nil
-        Promise.new(10){|a| a * 2 }.then{|result| @expected = result}
-        sleep(0.1)
-        @expected.should eq 20
-      end
-
-      it 'sets the promise value to the result if its block' do
-        p = Promise.new(10){|a| a * 2 }.then{|result| result * 2}
-        sleep(0.1)
-        p.value.should eq 40
-      end
-
-      it 'sets the promise state to :fulfilled if the block completes' do
-        p = Promise.new(10){|a| a * 2 }.then{|result| result * 2}
-        sleep(0.1)
-        p.should be_fulfilled
-      end
-
-      it 'passes the last result through when a promise has no block' do
-        @expected = nil
-        Promise.new(10){|a| a * 2 }.then.then{|result| @expected = result}
-        sleep(0.1)
-        @expected.should eq 20
-      end
-    end
-
-    context 'rejection' do
-
-      it 'sets the promise reason the error object on exception' do
-        p = Promise.new{ raise StandardError.new('Boom!') }
-        sleep(0.1)
-        p.reason.should be_a(Exception)
-        p.reason.should.to_s =~ /Boom!/
-      end
-
-      it 'sets the promise state to :rejected on exception' do
-        p = Promise.new{ raise StandardError.new('Boom!') }
-        sleep(0.1)
-        p.should be_rejected
-      end
-
-      it 'recursively rejects all children' do
-        p = Promise.new{ Thread.pass; raise StandardError.new('Boom!') }
-        promises = 10.times.collect{ p.then{ true } }
-        sleep(0.1)
-
-        10.times.each{|i| promises[i].should be_rejected }
-      end
-
-      it 'skips processing rejected promises' do
-        p = Promise.new{ raise StandardError.new('Boom!') }
-        promises = 3.times.collect{ p.then{ true } }
-        sleep(0.1)
-        promises.each{|p| p.value.should_not be_true }
-      end
-
-      it 'calls the first exception block with a matching class' do
-        @expected = nil
-        Promise.new{ raise StandardError }.
-          rescue(StandardError){|ex| @expected = 1 }.
-          rescue(StandardError){|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-          sleep(0.1)
-        @expected.should eq 1
-      end
-
-      it 'matches all with a rescue with no class given' do
-        @expected = nil
-        Promise.new{ raise NoMethodError }.
-          rescue(LoadError){|ex| @expected = 1 }.
-          rescue{|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.1)
-        @expected.should eq 2
-      end
-
-      it 'searches associated rescue handlers in order' do
-        @expected = nil
-        Promise.new{ raise ArgumentError }.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
-        sleep(0.1)
-        @expected.should eq 1
-
-        @expected = nil
-        Promise.new{ raise LoadError }.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
-        sleep(0.1)
-        @expected.should eq 2
-
-        @expected = nil
-        Promise.new{ raise StandardError }.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
-        sleep(0.1)
-        @expected.should eq 3
-      end
-
-      it 'passes the exception object to the matched block' do
-        @expected = nil
-        Promise.new{ raise StandardError }.
-          rescue(ArgumentError){|ex| @expected = ex }.
-          rescue(LoadError){|ex| @expected = ex }.
-          rescue(Exception){|ex| @expected = ex }
-        sleep(0.1)
-        @expected.should be_a(StandardError)
-      end
-
-      it 'ignores rescuers without a block' do
-        @expected = nil
-        Promise.new{ raise StandardError }.
-          rescue(StandardError).
-          rescue(StandardError){|ex| @expected = ex }.
-          rescue(Exception){|ex| @expected = ex }
-        sleep(0.1)
-        @expected.should be_a(StandardError)
-      end
-
-      it 'supresses the exception if no rescue matches' do
-        lambda {
-          Promise.new{ raise StandardError }.
-            rescue(ArgumentError){|ex| @expected = ex }.
-            rescue(StandardError){|ex| @expected = ex }.
-            rescue(Exception){|ex| @expected = ex }
-          sleep(0.1)
-        }.should_not raise_error
-      end
-
-      it 'supresses exceptions thrown from rescue handlers' do
-        lambda {
-          Promise.new{ raise ArgumentError }.
-          rescue(Exception){ raise StandardError }
-          sleep(0.1)
-        }.should_not raise_error(StandardError)
-      end
-
-      it 'calls matching rescue handlers on all children' do
-        @expected = []
-        Promise.new{ Thread.pass; raise StandardError }.
-          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
-          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
-          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
-          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
-          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }
-        sleep(0.1)
-
-        @expected.length.should eq 5
-      end
-    end
-
-    context 'aliases' do
-
-      it 'aliases #realized? for #fulfilled?' do
-        fulfilled_subject.should be_realized
-      end
-
-      it 'aliases #deref for #value' do
-        fulfilled_subject.deref.should eq fulfilled_value
-      end
-
-      it 'aliases #catch for #rescue' do
-        @expected = nil
-        Promise.new{ raise StandardError }.catch{ @expected = true }
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'aliases #on_error for #rescue' do
-        @expected = nil
-        Promise.new{ raise StandardError }.on_error{ @expected = true }
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'aliases Kernel#promise for Promise.new' do
-        promise().should be_a(Promise)
-        promise(){ nil }.should be_a(Promise)
-        promise(1, 2, 3).should be_a(Promise)
-        promise(1, 2, 3){ nil }.should be_a(Promise)
-      end
-    end
-  end
-end