em-promise 1.0.1 → 1.0.2

data/MIT-LICENSE

@@ -1,20 +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.
+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/lib/em-promise/defer.rb

@@ -24,9 +24,7 @@ module EventMachine
 					begin
 						result.resolve(callback.nil? ? value : callback.call(value))
 					rescue => e
-						#
-						# TODO:: add debugging output here
-						#
+						warn "\nUnhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
 						result.reject(e);
 					end
 				}
@@ -35,9 +33,7 @@ module EventMachine
 					begin
 						result.resolve(errback.nil? ? Defer.reject(reason) : errback.call(reason))
 					rescue => e
-						#
-						# TODO:: add debugging output here
-						#
+						warn "Unhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
 						result.reject(e);
 					end
 				}
@@ -75,6 +71,7 @@ module EventMachine
 		
 		class ResolvedPromise < Promise
 			def initialize(response, error = false)
+				raise ArgumentError if error && response.is_a?(Promise)
 				@error = error
 				@response = response
 			end
@@ -111,11 +108,9 @@ module EventMachine
 					@value = ref(val)
 					
 					if callbacks.length > 0
-						EM.next_tick {
-							callbacks.each do |callback|
-								@value.then(callback[0], callback[1])
-							end
-						}
+						callbacks.each do |callback|
+							@value.then(callback[0], callback[1])
+						end
 					end
 				end
 			end
@@ -168,14 +163,55 @@ module EventMachine
 			return ResolvedPromise.new( 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] a number of promises that will be combined into a single promise
+		# @returns [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 self.all(*promises)
+			deferred = Defer.new
+			counter = promises.length
+			results = []
+			
+			if counter > 0
+				promises.each_index do |index|
+					ref(promises[index]).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
+		
 		
 		protected
 		
 		
-		def ref(value)
+		def self.ref(value)
 			return value if value.is_a?(Promise)
 			return ResolvedPromise.new( value )			# A resolved success promise
 		end
+		
+		def ref(value)
+			Defer.ref(value)
+		end
 	end
 
 end

data/lib/em-promise/version.rb

@@ -1,5 +1,5 @@
 module EventMachine
 	class Defer
-		VERSION = "1.0.1"
+		VERSION = "1.0.2"
 	end
 end

data/spec/defer.rb

@@ -5,26 +5,482 @@ require 'em-promise'
 
 
 describe EventMachine::Defer do
+	
+	before :each do
+		@deferred = EM::Defer.new
+		@promise = @deferred.promise
+		@log = []
+		@default_fail = proc { |reason|
+			fail(reason)
+			EM.stop
+		}
+	end
+	
+	
+	describe 'resolve' do
+		
+		
+		it "should call the callback in the next turn" do
+			deferred2 = EM::Defer.new
+			EventMachine.run {
+				@promise.then(proc {|result|
+					@log << result
+				}, @default_fail)
+				
+				@deferred.resolve(:foo)
+				
+				EM.next_tick do
+					@log.should == [:foo]
+					EM.stop
+				end
+			}
+		end
+		
+		
+		it "should fulfill success callbacks in the registration order" do
+			EventMachine.run {
+				@promise.then(proc {|result|
+					@log << :first
+				}, @default_fail)
+				
+				@promise.then(proc {|result|
+					@log << :second
+				}, @default_fail)
+				
+				@deferred.resolve(:foo)
+				
+				EM.next_tick do
+					@log.should == [:first, :second]
+					EM.stop
+				end
+			}
+		end
+		
+		
+		it "should do nothing if a promise was previously resolved" do
+			EventMachine.run {
+				@promise.then(proc {|result|
+					@log << result
+					@log.should == [:foo]
+					@deferred.resolve(:bar)
+				}, @default_fail)
+				
+				@deferred.resolve(:foo)
+				@deferred.reject(:baz)
+				
+				#
+				# 4 ticks should detect any errors
+				#
+				EM.next_tick do
+					EM.next_tick do
+						EM.next_tick do
+							EM.next_tick do
+								@log.should == [:foo]
+								EM.stop
+							end
+						end
+					end
+				end
+			}
+		end
+		
+		
+		it "should allow deferred resolution with a new promise" do
+			deferred2 = EM::Defer.new
+			EventMachine.run {
+				@promise.then(proc {|result|
+					result.should == :foo
+					EM.stop
+				}, @default_fail)
+				
+				@deferred.resolve(deferred2.promise)
+				deferred2.resolve(:foo)
+			}
+		end
+		
+		
+		it "should not break if a callbacks registers another callback" do
+			EventMachine.run {
+				@promise.then(proc {|result|
+					@log << :outer
+					@promise.then(proc {|result|
+						@log << :inner
+					}, @default_fail)
+				}, @default_fail)
+				
+				@deferred.resolve(:foo)
+				
+				EM.next_tick do
+					EM.next_tick do
+						@log.should == [:outer, :inner]
+						EM.stop
+					end
+				end
+			}
+		end
+		
+		
+		
+		it "can modify the result of a promise before returning" do
+			EventMachine.run {
+				proc { |name|
+					EM.defer { @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?'
+					EM.stop
+				}, @default_fail)
+			}
+		end
+	
+	end
+	
+	
+	describe 'reject' do
+	
+		it "should reject the promise and execute all error callbacks" do
+			EventMachine.run {
+				@promise.then(@default_fail, proc {|result|
+					@log << :first
+				})
+				@promise.then(@default_fail, proc {|result|
+					@log << :second
+				})
+				
+				@deferred.reject(:foo)
+				
+				EM.next_tick do
+					@log.should == [:first, :second]
+					EM.stop
+				end
+			}
+		end
+		
+		
+		it "should do nothing if a promise was previously rejected" do
+			EventMachine.run {
+				@promise.then(@default_fail, proc {|result|
+					@log << result
+					@log.should == [:baz]
+					@deferred.resolve(:bar)
+				})
+				
+				@deferred.reject(:baz)
+				@deferred.resolve(:foo)
+				
+				#
+				# 4 ticks should detect any errors
+				#
+				EM.next_tick do
+					EM.next_tick do
+						EM.next_tick do
+							EM.next_tick do
+								@log.should == [:baz]
+								EM.stop
+							end
+						end
+					end
+				end
+			}
+		end
+		
+		
+		it "should not defer rejection with a new promise" do
+			deferred2 = EM::Defer.new
+			EventMachine.run {
+				@promise.then(@default_fail, @default_fail)
+				begin
+					@deferred.reject(deferred2.promise)
+				rescue => e
+					e.is_a?(ArgumentError).should == true
+					EM.stop
+				end
+			}
+		end
+		
+	end
+	
+	
+	describe EventMachine::Defer::Promise do
+		
+		describe 'then' do
+			
+			it "should allow registration of a success callback without an errback and resolve" do
+				EventMachine.run {
+					@promise.then(proc {|result|
+						@log << result
+					})
+
+					@deferred.resolve(:foo)
+					
+					EM.next_tick do
+						@log.should == [:foo]
+						EM.stop
+					end
+				}
+			end
+			
+			
+			it "should allow registration of a success callback without an errback and reject" do
+				EventMachine.run {
+					@promise.then(proc {|result|
+						@log << result
+					})
+
+					@deferred.reject(:foo)
+					
+					EM.next_tick do
+						@log.should == []
+						EM.stop
+					end
+				}
+			end
+			
+			
+			it "should allow registration of an errback without a success callback and reject" do
+				EventMachine.run {
+					@promise.then(nil, proc {|reason|
+						@log << reason
+					})
+
+					@deferred.reject(:foo)
+					
+					EM.next_tick do
+						@log.should == [:foo]
+						EM.stop
+					end
+				}
+			end
+			
+			
+			it "should allow registration of an errback without a success callback and resolve" do
+				EventMachine.run {
+					@promise.then(nil, proc {|reason|
+						@log << reason
+					})
 
+					@deferred.resolve(:foo)
+					
+					EM.next_tick do
+						@log.should == []
+						EM.stop
+					end
+				}
+			end
+			
+			
+			it "should resolve all callbacks with the original value" do
+				EventMachine.run {
+					@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::Defer.reject('some reason')
+					}, @default_fail)
+					@promise.then(proc {|result|
+						@log << result
+						:alt2
+					}, @default_fail)
+					
+					@deferred.resolve(:foo)
+					
+					EM.next_tick do
+						@log.should == [:foo, :foo, :foo, :foo]
+						EM.stop
+					end
+				}
+			end
+			
+			
+			it "should reject all callbacks with the original reason" do
+				EventMachine.run {
+					@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::Defer.reject('some reason')
+					})
+					@promise.then(@default_fail, proc {|result|
+						@log << result
+						:alt2
+					})
+					
+					@deferred.reject(:foo)
+					
+					EM.next_tick do
+						@log.should == [:foo, :foo, :foo, :foo]
+						EM.stop
+					end
+				}
+			end
+			
+			
+			it "should propagate resolution and rejection between dependent promises" do
+				EventMachine.run {
+					@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
+					}, @default_fail)
+					
+					@deferred.resolve(:foo)
+					
+					EM.next_tick do
+						EM.next_tick do
+							EM.next_tick do
+								EM.next_tick do
+									EM.next_tick do
+										@log.should == [:foo, :bar, 'baz', 'bob', :done]
+										EM.stop
+									end
+								end
+							end
+						end
+					end
+				}
+			end
+			
+			
+			it "should call error callback in the next turn even if promise is already rejected" do
+				EventMachine.run {
+					@deferred.reject(:foo)
+					
+					@promise.then(nil, proc {|reason|
+						@log << reason
+					})
+					
+					EM.next_tick do
+						@log.should == [:foo]
+						EM.stop
+					end
+				}
+			end
+			
+			
+		end
+		
+	end
+	
 	
-	it "should fulfill the promise and execute all success callbacks in the registration order" do
-		EventMachine.run {
-			proc { |name|
-				deferred = EM::Defer.new
-				EM.defer { deferred.resolve("Hello #{name}") }
-				deferred.promise.then(proc {|result|
-					result += "?"
-					result
+	
+	describe 'reject' do
+		
+		it "should package a string into a rejected promise" do
+			EventMachine.run {
+				rejectedPromise = EM::Defer.reject('not gonna happen')
+				
+				@promise.then(nil, proc {|reason|
+					@log << reason
 				})
-			}.call('Robin Hood').then(proc { |greeting|
-				greeting.should == 'Hello Robin Hood?'
-				EventMachine.stop
-			}, proc { |reason|
-				fail(reason)
-				EventMachine.stop
-			})
-		}
+				
+				@deferred.resolve(rejectedPromise)
+				
+				EM.next_tick do
+					@log.should == ['not gonna happen']
+					EM.stop
+				end
+			}
+		end
+		
+		
+		it "should return a promise that forwards callbacks if the callbacks are missing" do
+			EventMachine.run {
+				rejectedPromise = EM::Defer.reject('not gonna happen')
+				
+				@promise.then(nil, proc {|reason|
+					@log << reason
+				})
+				
+				@deferred.resolve(rejectedPromise.then())
+				
+				EM.next_tick do
+					EM.next_tick do
+						@log.should == ['not gonna happen']
+						EM.stop
+					end
+				end
+			}
+		end
+		
 	end
+	
+	
+	
+	describe 'all' do
+		
+		it "should resolve all of nothing" do
+			EventMachine.run {
+				EM::Defer.all().then(proc {|result|
+					@log << result
+				}, @default_fail)
+				
+				EM.next_tick do
+					@log.should == [[]]
+					EM.stop
+				end
+			}
+		end
+		
+		it "should take an array of promises and return a promise for an array of results" do
+			EventMachine.run {
+				deferred1 = EM::Defer.new
+				deferred2 = EM::Defer.new
+				
+				EM::Defer.all(@promise, deferred1.promise, deferred2.promise).then(proc {|result|
+					result.should == [:foo, :bar, :baz]
+					EM.stop
+				}, @default_fail)
+				
+				EM.defer { @deferred.resolve(:foo) }
+				EM.defer { deferred2.resolve(:baz) }
+				EM.defer { deferred1.resolve(:bar) }
+			}
+		end
+		
+		
+		it "should reject the derived promise if at least one of the promises in the array is rejected" do
+			EventMachine.run {
+				deferred1 = EM::Defer.new
+				deferred2 = EM::Defer.new
+				
+				EM::Defer.all(@promise, deferred1.promise, deferred2.promise).then(@default_fail, proc {|reason|
+					reason.should == :baz
+					EM.stop
+				})
+				
+				EM.defer { @deferred.resolve(:foo) }
+				EM.defer { deferred2.reject(:baz) }
+			}
+		end
+		
+	end
+	
 
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: em-promise
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-21 00:00:00.000000000 Z
+date: 2012-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine