celluloid-promise 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    M2JmNWExNzczMTEzMjJjMDg4NTY1ZTkzZGU0YTEwZTEzNDI4MzFjYQ==
+  data.tar.gz: !binary |-
+    NmNiMzJjYzlkMWFlZWFhZGIwMTNlYjY3YzFmNzFiZDE0N2NiODQxMA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZmU0OTUzMDQ3MzZlOTE1ZGU3ZjgxMjE1ZjFjYzU1MWQwNmUzOTkwZmY5NzI4
+    Y2ViMDcxZTE2ZTNiZjU5NzhlZTk4OTQwZmY1ZGE4MDhlZTA2ZGZiNjRhNmQw
+    MjllYzU4ZTUwODM2NmYxMWJmMTdkZjRlYzI4MjUwYTk4NGUyYTU=
+  data.tar.gz: !binary |-
+    NTYyYjgxOGIwZGY4MDdhZjQ2YTM2YWIyNGY4NWYwN2YwNzAzZThjMWM1MzZm
+    NmQ0Y2FmZTNhZmNlN2I0ODQ1MDg0NTNhZGE0MjU1MjY4MjU0ZmU4ZjViMzRl
+    NTZjZDc0NWQxODdlYTMyYjdkOWM3NjYwM2EyODIzZTkwYTcyMzU=

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,59 @@
+h1. Celluloid Promise
+
+!https://secure.travis-ci.org/cotag/celluloid-promise.png!
+
+A promise / deferred implementation for Celluloid inspired by "AngularJS":http://docs.angularjs.org/api/ng.$q / "Kris Kowal's Q.":https://github.com/kriskowal/q
+
+From the perspective of dealing with error handling, deferred and promise apis are to asynchronous programing what try, catch and throw keywords are to synchronous programming.
+
+<pre><code class="ruby">
+require 'rubygems'
+require 'celluloid-promise'
+
+def asyncGreet(name)
+	deferred = Celluloid::Q.defer
+	
+	Thread.new do
+		sleep 10
+		deferred.resolve("Hello #{name}")
+	end
+	
+	deferred.promise
+end
+
+
+asyncGreet('Robin Hood').then(proc { |greeting|
+	p "Success: #{greeting}"
+}, proc { |reason|
+	p "Failed: #{reason}"
+})
+
+asyncGreet('The Dude').then do |greeting|
+	p "Jeff '#{greeting}' Lebowski"
+end
+
+
+</code></pre>
+
+
+h2. Start using it now
+
+# Read the "Documentation":http://rubydoc.info/gems/celluloid-promise/Celluloid/Promise
+# Then @gem install celluloid-promise@
+
+
+h2. Use case
+
+Celluloid provides a toolkit for building concurrent applications however coordinating complex chains of concurrent events can be difficult.
+Celluloid-Promise provides the following:
+
+* allows you to track a mash up of events across Actors
+* guarantees serial execution of callbacks
+* callback chains are spread across multiple threads
+** So multiple promise chains can be executed concurrently
+
+Of course passing blocks around is a fairly "dangerous exercise":https://github.com/celluloid/celluloid/wiki/Blocks#proposal-for-fixing-blocks, so do the following and you'll be safe
+
+* use Celluloid-Promise for flow control
+* resolve and reject promises with locally scoped variables
+* call Actor methods to change state or class variables

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+desc "Run all RSpec tests"
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+task :test => [:spec]

data/lib/celluloid-promise/q.rb

@@ -0,0 +1,348 @@
+module Celluloid
+	module Promise
+
+		#
+		# Used to serialise the chaining of promises on a thread
+		# Allowing the promise to safely be called on any other thread
+		#
+		class Reactor
+			include ::Celluloid
+			
+			def task
+				yield if block_given?
+			end
+		end
+		
+		
+		
+		# @abstract
+		class Promise
+			private_class_method :new
+		end
+		
+		
+		#
+		# A new promise instance is created when a deferred instance is created and can be
+		# retrieved by calling deferred.promise
+		#
+		class DeferredPromise < Promise
+			public_class_method :new
+			
+			def initialize(defer, reactor)
+				raise ArgumentError unless defer.is_a?(Deferred)
+				super()
+				
+				@defer = defer
+				@reactor = reactor
+			end
+			
+			#
+			# regardless of when the promise was or will be resolved / rejected, calls one of
+			# the success or error callbacks asynchronously as soon as the result is available.
+			# The callbacks are called with a single argument, the result or rejection reason.
+			#
+			# @param [Proc, Proc, &blk] callbacks success, error, success_block
+			# @return [Promise] Returns an unresolved promise for chaining
+			def then(callback = nil, errback = nil, &blk)
+				result = Q.defer
+				
+				callback ||= blk
+				
+				wrappedCallback = proc { |val|
+					begin
+						if callback.nil?
+							result.resolve(val)
+						else
+							result.resolve(callback.call(val))
+						end
+					rescue => e
+						#warn "\nUnhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
+						result.reject(e);
+					end
+				}
+				
+				wrappedErrback = proc { |reason|
+					begin
+						if errback.nil?
+							result.resolve(ResolvedPromise.new(@reactor, reason, true))
+						else
+							result.resolve(errback.call(reason))
+						end
+					rescue => e
+						#warn "Unhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
+						result.reject(e);
+					end
+				}
+				
+				#
+				# Schedule as we are touching shared state
+				#	Everything else is locally scoped
+				#
+				@reactor.task! do
+					pending_array = pending
+					
+					if pending_array.nil?
+						value.then(wrappedCallback, wrappedErrback)
+					else
+						pending_array << [wrappedCallback, wrappedErrback]
+					end
+				end
+				
+				result.promise
+			end
+			
+			
+			private
+			
+			
+			def pending
+				@defer.instance_eval { @pending }
+			end
+			
+			def value
+				@defer.instance_eval { @value }
+			end
+		end
+		
+		
+		class ResolvedPromise < Promise
+			public_class_method :new
+			
+			def initialize(reactor, response, error = false)
+				raise ArgumentError if error && response.is_a?(Promise)
+				super()
+				
+				@error = error
+				@response = response
+				@reactor = reactor
+			end
+			
+			def then(callback = nil, errback = nil, &blk)
+				result = Q.defer
+				
+				callback ||= blk
+				
+				@reactor.task! do
+					if @error
+						if errback.nil?
+							result.resolve(ResolvedPromise.new(@reactor, @response, true))
+						else
+							result.resolve(errback.call(@response))
+						end
+					else
+						if callback.nil?
+							result.resolve(@response)
+						else
+							result.resolve(callback.call(@response))
+						end
+					end
+				end
+				
+				result.promise
+			end
+		end
+		
+		
+		
+		#
+		# The purpose of the deferred object is to expose the associated Promise instance as well
+		# as APIs that can be used for signalling the successful or unsuccessful completion of a task.
+		#
+		class Deferred
+			
+			def initialize(reactor)
+				super()
+				
+				@reactor = reactor
+				@pending = []
+				@value = nil
+			end
+			
+			#
+			# resolves the derived promise with the value. If the value is a rejection constructed via
+			# Q.reject, the promise will be rejected instead.
+			#
+			# @param [Object] val constant, message or an object representing the result.
+			def resolve(val = nil)
+				@reactor.task! do
+					if not @pending.nil?
+						callbacks = @pending
+						@pending = nil
+						@value = ref(val)
+						
+						if callbacks.length > 0
+							callbacks.each do |callback|
+								@value.then(callback[0], callback[1])
+							end
+						end
+					end
+				end
+			end
+			
+			#
+			# rejects the derived promise with the reason. This is equivalent to resolving it with a rejection
+			# constructed via Q.reject.
+			#
+			# @param [Object] reason constant, message, exception or an object representing the rejection reason.
+			def reject(reason = nil)
+				resolve(ResolvedPromise.new(@reactor, reason, true))
+			end
+			
+			#
+			# Creates a promise object associated with this deferred
+			#
+			def promise
+				DeferredPromise.new( self, @reactor )
+			end
+			
+			
+			private
+			
+			
+			def ref(value)
+				return value if value.is_a?(Promise)
+				return ResolvedPromise.new( @reactor, value )			# A resolved success promise
+			end
+		end
+		
+		
+		class Coordinator
+			include ::Celluloid
+			
+
+			def initialize
+				@reactors = []
+				@current = -1	# So we pick 0 first
+				threads = ::Celluloid.cores
+				threads += 1 if threads == 1
+				threads.times { @reactors << Reactor.new_link }	# Have a thread for each core and link promises to each thread for serialisation 
+			end
+			
+
+			#
+			# Creates a Deferred object which represents a task which will finish in the future.
+			#
+			# @return [Deferred] Returns a new instance of Deferred
+			def defer
+				return Deferred.new(next_reactor)
+			end
+			
+
+			#
+			# Creates a promise that is resolved as rejected with the specified reason. This api should be
+			# used to forward rejection in a chain of promises. If you are dealing with the last promise in
+			# a promise chain, you don't need to worry about it.
+			#
+			# When comparing deferreds/promises to the familiar behaviour of try/catch/throw, think of
+			# reject as the raise keyword in Ruby. This also means that if you "catch" an error via
+			# a promise error callback and you want to forward the error to the promise derived from the
+			# current promise, you have to "rethrow" the error by returning a rejection constructed via
+			# reject.
+			#
+			# @example handling rejections
+			#
+			#   #!/usr/bin/env ruby
+			#
+			#   require 'rubygems' # or use Bundler.setup
+			#   require 'celluloid-promise'
+			#
+			#   promiseB = promiseA.then(lambda {|result|
+			#     # success: do something and resolve promiseB with the old or a new result
+			#     return result
+			#   }, lambda {|reason|
+			#     # error: handle the error if possible and resolve promiseB with newPromiseOrValue,
+			#     #        otherwise forward the rejection to promiseB
+			#     if canHandle(reason)
+			#       # handle the error and recover
+			#       return newPromiseOrValue
+			#     end
+			#     return Q.reject(reason)
+			#   })
+			#
+			# @param [Object] reason constant, message, exception or an object representing the rejection reason.
+			# @return [Promise] Returns a promise that was already resolved as rejected with the reason
+			def reject(reason = nil)
+				return ResolvedPromise.new(next_reactor, reason, true)	# A resolved failed promise
+			end
+
+
+			#
+			# Combines multiple promises into a single promise that is resolved when all of the input
+			# promises are resolved.
+			#
+			# @param [*Promise] Promises a number of promises that will be combined into a single promise
+			# @return [Promise] Returns a single promise that will be resolved with an array of values,
+			#   each value corresponding to the promise at the same index in the `promises` array. If any of
+			#   the promises is resolved with a rejection, this resulting promise will be resolved with the
+			#   same rejection.
+			def all(*promises)
+				reactor = next_reactor
+				deferred = Deferred.new(reactor)
+				counter = promises.length
+				results = []
+				
+				if counter > 0
+					promises.each_index do |index|
+						ref(promises[index], reactor).then(proc {|result|
+							if results[index].nil?
+								results[index] = result
+								counter -= 1
+								deferred.resolve(results) if counter <= 0
+							end
+							result
+						}, proc {|reason|
+							if results[index].nil?
+								deferred.reject(reason)
+							end
+							reason
+						})
+					end
+				else
+					deferred.resolve(results)
+				end
+				
+				return deferred.promise
+			end
+			
+			
+			private
+
+
+			def ref(value, reactor)
+				return value if value.is_a?(Promise)
+				return ResolvedPromise.new( reactor, value )		# A resolved success promise
+			end
+			
+			
+			#
+			# Promises are placed on reactor threads in a round robin
+			# I would have used pool however Celluloid::IO allows us to run
+			# multiple concurrent promise chains on each reactor, pool can't.
+			#
+			def next_reactor
+				@current = @current >= (@reactors.length - 1) ? 0 : @current + 1
+				selected = @reactors[@current]
+				selected != Celluloid::Actor.current ? selected : next_reactor
+			end
+		end
+	end
+
+	#
+	# This is the primary interface for creating promises
+	# The coordinator selects the reactor for the current promise chain
+	#
+	Actor[:Q] = Promise::Coordinator.new
+	module Q
+		def self.defer
+			Actor[:Q].defer
+		end
+		
+		def self.reject(reason = nil)
+			Actor[:Q].reject(reason)
+		end
+
+		def self.all(*promises)
+			Actor[:Q].all(*promises)
+		end
+	end
+end

data/lib/celluloid-promise/version.rb

@@ -0,0 +1,6 @@
+module Celluloid
+	module Promise
+		VERSION = "1.0.0"
+	end
+end
+

data/lib/celluloid-promise.rb

@@ -0,0 +1,2 @@
+require 'celluloid'
+require 'celluloid-promise/q.rb'

data/spec/promise_spec.rb

@@ -0,0 +1,517 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'celluloid-promise'
+require 'atomic'
+
+
+
+describe Celluloid::Q do
+
+	before :all do
+		@defer = Celluloid::Promise::Reactor.pool
+	end
+
+	before :each do
+		@deferred = Celluloid::Q.defer
+		@promise = @deferred.promise
+		@log = []
+		@finish = proc {
+			while(@mutex.locked?); end
+			@mutex.synchronize {
+				@resource.signal
+			}
+		}
+		@default_fail = proc { |reason|
+			fail(reason)
+			@finish.call
+		}
+		@mutex = Mutex.new
+		@resource = ConditionVariable.new
+	end
+
+
+
+	describe Celluloid::Promise::Coordinator do
+		
+		
+		describe 'resolve' do
+			
+			
+			it "should call the callback in the next turn" do
+				@mutex.synchronize {
+					@promise.then(proc {|result|
+						@log << result
+						@finish.call
+					}, @default_fail)
+					
+					@deferred.resolve(:foo)
+					@resource.wait(@mutex)
+				}
+				
+				@log.should == [:foo]
+			end
+			
+			
+			it "should fulfill success callbacks in the registration order" do
+				@mutex.synchronize {
+					@promise.then(proc {|result|
+						@log << :first
+					}, @default_fail)
+					
+					@promise.then(proc {|result|
+						@log << :second
+						@finish.call
+					}, @default_fail)
+
+					@deferred.resolve(:foo)
+					@resource.wait(@mutex)
+				}
+				
+				@log.should == [:first, :second]
+			end
+			
+			
+			it "should do nothing if a promise was previously resolved" do
+				@mutex.synchronize {
+					@promise.then(proc {|result|
+						@log << result
+						@log.should == [:foo]
+						@deferred.resolve(:bar)
+						@finish.call
+					}, @default_fail)
+					
+					@deferred.resolve(:foo)
+					@deferred.reject(:baz)
+					@resource.wait(@mutex)
+				}
+				
+				@log.should == [:foo]
+			end
+			
+
+			it "should allow deferred resolution with a new promise" do
+				deferred2 = Celluloid::Q.defer
+				@mutex.synchronize {
+					@promise.then(proc {|result|
+						result.should == :foo
+						@finish.call
+					}, @default_fail)
+					
+					@deferred.resolve(deferred2.promise)
+					deferred2.resolve(:foo)
+
+					@resource.wait(@mutex)
+				}
+			end
+			
+			
+			it "should not break if a callbacks registers another callback" do
+				@mutex.synchronize {
+					@promise.then(proc {|result|
+						@log << :outer
+						@promise.then(proc {|result|
+							@log << :inner
+							@finish.call
+						}, @default_fail)
+					}, @default_fail)
+					
+					@deferred.resolve(:foo)
+					
+					@resource.wait(@mutex)
+					@log.should == [:outer, :inner]
+				}
+			end
+
+
+			it "can modify the result of a promise before returning" do
+				@mutex.synchronize {
+					proc { |name|
+						@defer.task! {
+							@deferred.resolve("Hello #{name}")
+						}
+						@promise.then(proc {|result|
+							result.should == 'Hello Robin Hood'
+							result += "?"
+							result
+						})
+					}.call('Robin Hood').then(proc { |greeting|
+						greeting.should == 'Hello Robin Hood?'
+						@finish.call
+					}, @default_fail)
+
+					@resource.wait(@mutex)
+				}
+			end
+			
+		end
+
+
+
+		describe 'reject' do
+			it "should reject the promise and execute all error callbacks" do
+				@mutex.synchronize {
+					@promise.then(@default_fail, proc {|result|
+						@log << :first
+					})
+					@promise.then(@default_fail, proc {|result|
+						@log << :second
+						@finish.call
+					})
+					
+					@deferred.reject(:foo)
+					
+					@resource.wait(@mutex)
+				}
+
+				@log.should == [:first, :second]
+			end
+			
+			
+			it "should do nothing if a promise was previously rejected" do
+				@mutex.synchronize {
+					@promise.then(@default_fail, proc {|result|
+						@log << result
+						@log.should == [:baz]
+						@deferred.resolve(:bar)
+
+						@finish.call
+					})
+					
+					@deferred.reject(:baz)
+					@deferred.resolve(:foo)
+					
+
+					@resource.wait(@mutex)
+				}
+
+				@log.should == [:baz]
+			end
+			
+			
+			it "should not defer rejection with a new promise" do
+				deferred2 = Celluloid::Q.defer
+				@promise.then(@default_fail, @default_fail)
+				begin
+					@deferred.reject(deferred2.promise)
+				rescue => e
+					e.is_a?(ArgumentError).should == true
+				end
+			end
+
+			
+			it "should package a string into a rejected promise" do
+				@mutex.synchronize {
+					rejectedPromise = Celluloid::Q.reject('not gonna happen')
+					
+					@promise.then(nil, proc {|reason|
+						@log << reason
+						@finish.call
+					})
+					
+					@deferred.resolve(rejectedPromise)
+					
+					@resource.wait(@mutex)
+					@log.should == ['not gonna happen']
+				}
+			end
+			
+			
+			it "should return a promise that forwards callbacks if the callbacks are missing" do
+				@mutex.synchronize {
+					rejectedPromise = Celluloid::Q.reject('not gonna happen')
+					
+					@promise.then(nil, proc {|reason|
+						@log << reason
+						@finish.call
+					})
+					
+					@deferred.resolve(rejectedPromise.then())
+					
+					@resource.wait(@mutex)
+					@log.should == ['not gonna happen']
+				}
+			end
+			
+		end
+
+
+		describe 'all' do
+			
+			it "should resolve all of nothing" do
+				@mutex.synchronize {
+					Celluloid::Q.all.then(proc {|result|
+						@log << result
+						@finish.call
+					}, @default_fail)
+					
+
+					@resource.wait(@mutex)
+				}
+
+				@log.should == [[]]
+			end
+			
+			it "should take an array of promises and return a promise for an array of results" do
+				@mutex.synchronize {
+					deferred1 = Celluloid::Q.defer
+					deferred2 = Celluloid::Q.defer
+					
+					Celluloid::Q.all(@promise, deferred1.promise, deferred2.promise).then(proc {|result|
+						result.should == [:foo, :bar, :baz]
+						@finish.call
+					}, @default_fail)
+					
+					@defer.task! { @deferred.resolve(:foo) }
+					@defer.task! { deferred2.resolve(:baz) }
+					@defer.task! { deferred1.resolve(:bar) }
+
+					@resource.wait(@mutex)
+				}
+			end
+			
+			
+			it "should reject the derived promise if at least one of the promises in the array is rejected" do
+				@mutex.synchronize {
+					deferred1 = Celluloid::Q.defer
+					deferred2 = Celluloid::Q.defer
+					
+					Celluloid::Q.all(@promise, deferred1.promise, deferred2.promise).then(@default_fail, proc {|reason|
+						reason.should == :baz
+						@finish.call
+					})
+					
+					@defer.task! { @deferred.resolve(:foo) }
+					@defer.task! { deferred2.reject(:baz) }
+
+					@resource.wait(@mutex)
+				}
+			end
+			
+		end
+
+	end
+
+
+	describe Celluloid::Promise do
+
+		describe 'then' do
+				
+			it "should allow registration of a success callback without an errback and resolve" do
+				@mutex.synchronize {
+					@promise.then(proc {|result|
+						@log << result
+					})
+					@promise.then(proc {
+						@finish.call
+					}, @default_fail)
+
+					@deferred.resolve(:foo)
+					
+					@resource.wait(@mutex)
+					@log.should == [:foo]
+				}
+			end
+			
+			
+			it "should allow registration of a success callback without an errback and reject" do
+				@mutex.synchronize {
+					@promise.then(proc {|result|
+						@log << result
+					})
+					@promise.then(@default_fail, proc {
+						@finish.call
+					})
+
+					@deferred.reject(:foo)
+					
+					@resource.wait(@mutex)
+					@log.should == []
+				}
+			end
+			
+			
+			it "should allow registration of an errback without a success callback and reject" do
+				@mutex.synchronize {
+					@promise.then(nil, proc {|reason|
+						@log << reason
+					})
+					@promise.then(@default_fail, proc {
+						@finish.call
+					})
+
+					@deferred.reject(:foo)
+					
+					@resource.wait(@mutex)
+					@log.should == [:foo]
+				}
+			end
+			
+			
+			it "should allow registration of an errback without a success callback and resolve" do
+				@mutex.synchronize {
+					@promise.then(nil, proc {|reason|
+						@log << reason
+					})
+					@promise.then(proc {
+						@finish.call
+					}, @default_fail)
+
+					@deferred.resolve(:foo)
+					
+					@resource.wait(@mutex)
+					@log.should == []
+				}
+			end
+			
+			
+			it "should resolve all callbacks with the original value" do
+				@mutex.synchronize {
+					@promise.then(proc {|result|
+						@log << result
+						:alt1
+					}, @default_fail)
+					@promise.then(proc {|result|
+						@log << result
+						'ERROR'
+					}, @default_fail)
+					@promise.then(proc {|result|
+						@log << result
+						EM::Q.reject('some reason')
+					}, @default_fail)
+					@promise.then(proc {|result|
+						@log << result
+						:alt2
+					}, @default_fail)
+					@promise.then(proc {
+						@finish.call
+					}, @default_fail)
+					
+					@deferred.resolve(:foo)
+					
+					@resource.wait(@mutex)
+					@log.should == [:foo, :foo, :foo, :foo]
+				}
+			end
+			
+			
+			it "should reject all callbacks with the original reason" do
+				@mutex.synchronize {
+					@promise.then(@default_fail, proc {|result|
+						@log << result
+						:alt1
+					})
+					@promise.then(@default_fail, proc {|result|
+						@log << result
+						'ERROR'
+					})
+					@promise.then(@default_fail, proc {|result|
+						@log << result
+						EM::Q.reject('some reason')
+					})
+					@promise.then(@default_fail, proc {|result|
+						@log << result
+						:alt2
+					})
+					@promise.then(@default_fail, proc {|result|
+						@finish.call
+					})
+					
+					@deferred.reject(:foo)
+					
+					@resource.wait(@mutex)
+					@log.should == [:foo, :foo, :foo, :foo]
+				}
+			end
+			
+			
+			it "should propagate resolution and rejection between dependent promises" do
+				@mutex.synchronize {
+					@promise.then(proc {|result|
+						@log << result
+						:bar
+					}, @default_fail).then(proc {|result|
+						@log << result
+						raise 'baz'
+					}, @default_fail).then(@default_fail, proc {|result|
+						@log << result.message
+						raise 'bob'
+					}).then(@default_fail, proc {|result|
+						@log << result.message
+						:done
+					}).then(proc {|result|
+						@log << result
+						@finish.call
+					}, @default_fail)
+					
+					@deferred.resolve(:foo)
+					
+					@resource.wait(@mutex)
+					@log.should == [:foo, :bar, 'baz', 'bob', :done]
+				}
+			end
+			
+			
+			it "should call error callback even if promise is already rejected" do
+				@mutex.synchronize {
+					@deferred.reject(:foo)
+					
+					@promise.then(nil, proc {|reason|
+						@log << reason
+						@finish.call
+					})
+					
+					@resource.wait(@mutex)
+					@log.should == [:foo]
+				}
+			end
+			
+			
+			class BlockingActor
+				include ::Celluloid
+				
+				def wait
+					sleep (10..20).to_a.sample
+				end
+			end
+			
+			
+			it "should not block when waiting for other promises to finish" do
+				@mutex.synchronize {
+					
+					actor = BlockingActor.new
+					count = Atomic.new(0)
+					cores = ::Celluloid.cores
+					deferreds = cores * 2
+					deferred_store = []
+					
+					args = [proc {|val|
+						actor.wait
+						count.update {|v| v + 1}
+					}, @default_fail]
+					
+					
+					deferreds.times {
+						defer = Celluloid::Q.defer
+						defer.promise.then(*args)
+						deferred_store << defer
+						defer.resolve()
+					}
+					
+					@promise.then(proc {|result|
+						(!!(count.value < cores)).should == true
+						@finish.call
+					}, @default_fail)
+					
+					
+					@deferred.resolve()
+					@resource.wait(@mutex)
+				}
+			end
+			
+		end
+
+	end
+
+end
+

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: celluloid-promise
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Stephen von Takach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: atomic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Celluloid based multi-threaded promise implementation
+email:
+- steve@cotag.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/celluloid-promise/q.rb
+- lib/celluloid-promise/version.rb
+- lib/celluloid-promise.rb
+- MIT-LICENSE
+- Rakefile
+- README.textile
+- spec/promise_spec.rb
+homepage: https://github.com/cotag/celluloid-promise
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Celluloid based multi-threaded promise implementation
+test_files:
+- spec/promise_spec.rb