libuv 0.12.2 → 0.12.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eeeff8f0622e2ab797a7a2687e12b5c5bd8ee677
-  data.tar.gz: a451d8e71e0249ed03941f78dc87cd3cf9cd3313
+  metadata.gz: 926a9cc1569e2c71b0881c94d233cbd35bf92f26
+  data.tar.gz: 945117ade8eac5e366c0d073660ef45e4f317648
 SHA512:
-  metadata.gz: 071316fc01a0486e4d3dfba8544a2ff1f9681b653622beff3e756b26301e068ba7c55d13fb204d542b0a8791d2ce408ed23b2eca04105126059f6b05a6b671d5
-  data.tar.gz: 05b5e1d5199578c27f4e7170c5dedf86d6e50f1b872c0e101f3ee5ea16eb5a1734591541f5758de25c6ac1f20b61ded85162d5124a60f078ba229414f68f871a
+  metadata.gz: ab328f0f71c9d038cf7f64efecd094eac250c3713faa5f7320de71e0dda8f2c92dcb98d5ddcf5f779adcf5f8bf1be7fac0f3fc818b9517509d2944243bf81fa3
+  data.tar.gz: 5e2a9f0b8ad7f488bbfb3def370fa6e5a4617c93ca77619dc94f8411b428386924143da52dc6e5280c63f215440316675a823ca1c2421745fa473813f81040e9

data/lib/libuv/async.rb

@@ -30,17 +30,11 @@ module Libuv
         private
 
 
-        def on_async(handle, status)
-            e = check_result(status)
-
-            if e
-                reject(e)
-            else
-                begin
-                    @callback.call
-                rescue Exception => e
-                    @loop.log :error, :async_cb, e
-                end
+        def on_async(handle)
+            begin
+                @callback.call
+            rescue Exception => e
+                @loop.log :error, :async_cb, e
             end
         end
     end

data/lib/libuv/check.rb

@@ -39,17 +39,11 @@ module Libuv
         private
 
 
-        def on_check(handle, status)
-            e = check_result(status)
-
-            if e
-                reject(e)
-            else
-                begin
-                    @callback.call
-                rescue Exception => e
-                    @loop.log :error, :check_cb, e
-                end
+        def on_check(handle)
+            begin
+                @callback.call
+            rescue Exception => e
+                @loop.log :error, :check_cb, e
             end
         end
     end

data/lib/libuv/error.rb

@@ -65,6 +65,7 @@ module Libuv
         class EPROTOTYPE < Error; end
         class ERANGE < Error; end
         class ENXIO < Error; end
+        class EMLINK < Error; end
         class EROFS < Error; end
         class ESHUTDOWN < Error; end
         class ESPIPE < Error; end

data/lib/libuv/ext/types.rb

@@ -219,12 +219,12 @@ module Libuv
         callback :uv_connection_cb,  [:uv_stream_t, :status],                            :void
         callback :uv_close_cb,       [:uv_handle_t],                                     :void
         callback :uv_poll_cb,        [:uv_poll_t, :status, :events],                     :void
-        callback :uv_timer_cb,       [:uv_timer_t, :status],                             :void
+        callback :uv_timer_cb,       [:uv_timer_t],                                      :void
         callback :uv_signal_cb,      [:uv_signal_t, :signal],                            :void
-        callback :uv_async_cb,       [:uv_async_t, :status],                             :void
-        callback :uv_prepare_cb,     [:uv_prepare_t, :status],                           :void
-        callback :uv_check_cb,       [:uv_check_t, :status],                             :void
-        callback :uv_idle_cb,        [:uv_idle_t, :status],                              :void
+        callback :uv_async_cb,       [:uv_async_t],                                      :void
+        callback :uv_prepare_cb,     [:uv_prepare_t],                                    :void
+        callback :uv_check_cb,       [:uv_check_t],                                      :void
+        callback :uv_idle_cb,        [:uv_idle_t],                                       :void
         callback :uv_getaddrinfo_cb, [:uv_getaddrinfo_t, :status, UvAddrinfo.by_ref],    :void
         callback :uv_exit_cb,        [:uv_process_t, :int, :int],                        :void
         callback :uv_walk_cb,        [:uv_handle_t, :pointer],                           :void

data/lib/libuv/idle.rb

@@ -39,17 +39,11 @@ module Libuv
         private
 
 
-        def on_idle(handle, status)
-            e = check_result(status)
-
-            if e
-                reject(e)
-            else
-                begin
-                    @callback.call
-                rescue Exception => e
-                    @loop.log :error, :idle_cb, e
-                end
+        def on_idle(handle)
+            begin
+                @callback.call
+            rescue Exception => e
+                @loop.log :error, :idle_cb, e
             end
         end
     end

data/lib/libuv/loop.rb

@@ -97,6 +97,13 @@ module Libuv
         public
 
 
+        # Overwrite as errors in jRuby can literally hang VM when inspecting
+        # as many many classes will reference this class
+        def inspect
+            "#<#{self.class}:0x#{self.__id__.to_s(16)} NT=#{@run_queue.length}>"
+        end
+
+
         def handle; @pointer; end
 
         # Run the actual event loop. This method will block until the loop is stopped.
@@ -193,12 +200,17 @@ module Libuv
         # @return [::Libuv::Error]
         def lookup_error(err)
             name = ::Libuv::Ext.err_name(err)
-            msg  = ::Libuv::Ext.strerror(err)
 
-            ::Libuv::Error.const_get(name.to_sym).new(msg)
+            if name
+                msg  = ::Libuv::Ext.strerror(err)
+                ::Libuv::Error.const_get(name.to_sym).new(msg)
+            else
+                # We want a back-trace in this case
+                raise "error lookup failed for code #{err}"
+            end
         rescue Exception => e
             @loop.log :warn, :error_lookup_failed, e
-            ::Libuv::Error::UNKNOWN.new("error lookup failed for code #{err} #{name} #{msg}")
+            e
         end
 
         # Get a new TCP instance

data/lib/libuv/prepare.rb

@@ -39,17 +39,11 @@ module Libuv
         private
 
 
-        def on_prepare(handle, status)
-            e = check_result(status)
-
-            if e
-                reject(e)
-            else
-                begin
-                    @callback.call
-                rescue Exception => e
-                    @loop.log :error, :prepare_cb, e
-                end
+        def on_prepare(handle)
+            begin
+                @callback.call
+            rescue Exception => e
+                @loop.log :error, :prepare_cb, e
             end
         end
     end

data/lib/libuv/q.rb

@@ -1,454 +1,463 @@
 
 module Libuv
-	module Q
+    module Q
 
-		# @abstract
-		class Promise
-			private_class_method :new
+        # @abstract
+        class Promise
+            private_class_method :new
 
 
-			# Used by finally method
-			MAKE_PROMISE = proc { |value, resolved, loop|
-				result = Q.defer(loop)
-				if (resolved)
-					result.resolve(value)
-				else
-					result.reject(value)
-				end
-				result.promise
-			}.freeze
+            # Used by finally method
+            MAKE_PROMISE = proc { |value, resolved, loop|
+                result = Q.defer(loop)
+                if (resolved)
+                    result.resolve(value)
+                else
+                    result.reject(value)
+                end
+                result.promise
+            }.freeze
 
 
-			#
-			# regardless of when the promise was or will be resolved / rejected, calls
-			# the error callback asynchronously if the promise is rejected.
-			#
-			# @param [Proc, &blk] callbacks error, error_block
-			# @return [Promise] Returns an unresolved promise for chaining
-			def catch(callback = nil, &blk)
-				self.then(nil, callback || blk)
-			end
+            #
+            # regardless of when the promise was or will be resolved / rejected, calls
+            # the error callback asynchronously if the promise is rejected.
+            #
+            # @param [Proc, &blk] callbacks error, error_block
+            # @return [Promise] Returns an unresolved promise for chaining
+            def catch(callback = nil, &blk)
+                self.then(nil, callback || blk)
+            end
 
 
-			def progress(callback = nil, &blk)
-				self.then(nil, nil, callback || blk)
-			end
+            def progress(callback = nil, &blk)
+                self.then(nil, nil, callback || blk)
+            end
 
 
-			#
-			# allows you to observe either the fulfillment or rejection of a promise, but to do so
-			# without modifying the final value. This is useful to release resources or do some
-			# clean-up that needs to be done whether the promise was rejected or resolved.
-			#
-			# @param [Proc, &blk] callbacks finally, finally_block
-			# @return [Promise] Returns an unresolved promise for chaining
-			def finally(callback = nil, &blk)
-				callback ||= blk
+            #
+            # allows you to observe either the fulfillment or rejection of a promise, but to do so
+            # without modifying the final value. This is useful to release resources or do some
+            # clean-up that needs to be done whether the promise was rejected or resolved.
+            #
+            # @param [Proc, &blk] callbacks finally, finally_block
+            # @return [Promise] Returns an unresolved promise for chaining
+            def finally(callback = nil, &blk)
+                callback ||= blk
 
-				handleCallback = lambda {|value, isResolved|
-					callbackOutput = nil
-					begin
-						callbackOutput = callback.call
-					rescue Exception => e
-						@loop.log(:error, :q_finally_cb, e)
-						return MAKE_PROMISE.call(e, false, @loop)
-					end
+                handleCallback = lambda {|value, isResolved|
+                    callbackOutput = nil
+                    begin
+                        callbackOutput = callback.call
+                    rescue Exception => e
+                        @loop.log(:error, :q_finally_cb, e)
+                        return MAKE_PROMISE.call(e, false, @loop)
+                    end
 
-					if callbackOutput.is_a?(Promise)
-						return callbackOutput.then(proc {
-								MAKE_PROMISE.call(value, isResolved, @loop)
-							}, proc { |err|
-								MAKE_PROMISE.call(err, false, @loop)
-							})
-					else
-						return MAKE_PROMISE.call(value, isResolved, @loop)
-					end
-				}
+                    if callbackOutput.is_a?(Promise)
+                        return callbackOutput.then(proc {
+                                MAKE_PROMISE.call(value, isResolved, @loop)
+                            }, proc { |err|
+                                MAKE_PROMISE.call(err, false, @loop)
+                            })
+                    else
+                        return MAKE_PROMISE.call(value, isResolved, @loop)
+                    end
+                }
 
-				self.then(proc {|val|
-					handleCallback.call(val, true)
-				}, proc{|err|
-					handleCallback.call(err, false)
-				})
-			end
-		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(loop, defer)
-				raise ArgumentError unless defer.is_a?(Deferred)
-				super()
-				
-				@loop = loop
-				@defer = defer
-			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, Proc, &blk] callbacks error, success, progress, success_block
-			# @return [Promise] Returns an unresolved promise for chaining
-			def then(callback = nil, errback = nil, progback = nil, &blk)
-				result = Q.defer(@loop)
-				
-				callback ||= blk
-				
-				wrappedCallback = proc { |val|
-					begin
-						result.resolve(callback.nil? ? val : callback.call(val))
-					rescue Exception => e
-						#warn "\nUnhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
-						result.reject(e)
-						@loop.log(:error, :q_resolve_cb, e)
-					end
-				}
-				
-				wrappedErrback = proc { |reason|
-					begin
-						result.resolve(errback.nil? ? Q.reject(@loop, reason) : errback.call(reason))
-					rescue Exception => e
-						#warn "Unhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
-						result.reject(e)
-						@loop.log(:error, :q_reject_cb, e)
-					end
-				}
+                self.then(proc {|val|
+                    handleCallback.call(val, true)
+                }, proc{|err|
+                    handleCallback.call(err, false)
+                })
+            end
+        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(loop, defer)
+                raise ArgumentError unless defer.is_a?(Deferred)
+                super()
+                
+                @loop = loop
+                @defer = defer
+            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, Proc, &blk] callbacks error, success, progress, success_block
+            # @return [Promise] Returns an unresolved promise for chaining
+            def then(callback = nil, errback = nil, progback = nil, &blk)
+                result = Q.defer(@loop)
+                
+                callback ||= blk
+                
+                wrappedCallback = proc { |val|
+                    begin
+                        result.resolve(callback.nil? ? val : callback.call(val))
+                    rescue Exception => e
+                        #warn "\nUnhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
+                        result.reject(e)
+                        @loop.log(:error, :q_resolve_cb, e)
+                    end
+                }
+                
+                wrappedErrback = proc { |reason|
+                    begin
+                        result.resolve(errback.nil? ? Q.reject(@loop, reason) : errback.call(reason))
+                    rescue Exception => e
+                        #warn "Unhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
+                        result.reject(e)
+                        @loop.log(:error, :q_reject_cb, e)
+                    end
+                }
 
-				wrappedProgback = proc { |*progress|
-					begin
-						result.notify(progback.nil? ? progress : progback.call(*progress))
-					rescue Exception => e
-						#warn "Unhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
-						@loop.log(:error, :q_progress_cb, e)
-					end
-				}
-				
-				#
-				# Schedule as we are touching shared state
-				#	Everything else is locally scoped
-				#
-				@loop.schedule do
-					pending_array = pending
-					
-					if pending_array.nil?
-						value.then(wrappedCallback, wrappedErrback, wrappedProgback)
-					else
-						pending_array << [wrappedCallback, wrappedErrback, wrappedProgback]
-					end
-				end
-				
-				result.promise
-			end
+                wrappedProgback = proc { |*progress|
+                    begin
+                        result.notify(progback.nil? ? progress : progback.call(*progress))
+                    rescue Exception => e
+                        #warn "Unhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
+                        @loop.log(:error, :q_progress_cb, e)
+                    end
+                }
+                
+                #
+                # Schedule as we are touching shared state
+                #    Everything else is locally scoped
+                #
+                @loop.schedule do
+                    pending_array = pending
+                    
+                    if pending_array.nil?
+                        value.then(wrappedCallback, wrappedErrback, wrappedProgback)
+                    else
+                        pending_array << [wrappedCallback, wrappedErrback, wrappedProgback]
+                    end
+                end
+                
+                result.promise
+            end
 
-			def resolved?
-				pending.nil?
-			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(loop, response, error = false)
-				raise ArgumentError if error && response.is_a?(Promise)
-				super()
-				
-				@loop = loop
-				@error = error
-				@response = response
-			end
-			
-			def then(callback = nil, errback = nil, progback = nil, &blk)
-				result = Q.defer(@loop)
-				
-				callback ||= blk
-				
-				@loop.next_tick {
-					if @error
-						begin
-							result.resolve(errback.nil? ? Q.reject(@loop, @response) : errback.call(@response))
-						rescue Exception => e
-							#warn "Unhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
-							result.reject(e)
-							@loop.log(:error, :q_reject_cb, e)
-						end
-					else
-						begin
-							result.resolve(callback.nil? ? @response : callback.call(@response))
-						rescue Exception => e
-							#warn "\nUnhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
-							result.reject(e)
-							@loop.log(:error, :q_resolve_cb, e)
-						end
-					end
-				}
-				
-				result.promise
-			end
+            def resolved?
+                pending.nil?
+            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(loop, response, error = false)
+                raise ArgumentError if error && response.is_a?(Promise)
+                super()
+                
+                @loop = loop
+                @error = error
+                @response = response
+            end
+            
+            def then(callback = nil, errback = nil, progback = nil, &blk)
+                result = Q.defer(@loop)
+                
+                callback ||= blk
+                
+                @loop.next_tick {
+                    if @error
+                        begin
+                            result.resolve(errback.nil? ? Q.reject(@loop, @response) : errback.call(@response))
+                        rescue Exception => e
+                            #warn "Unhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
+                            result.reject(e)
+                            @loop.log(:error, :q_reject_cb, e)
+                        end
+                    else
+                        begin
+                            result.resolve(callback.nil? ? @response : callback.call(@response))
+                        rescue Exception => e
+                            #warn "\nUnhandled exception: #{e.message}\n#{e.backtrace.join("\n")}\n"
+                            result.reject(e)
+                            @loop.log(:error, :q_resolve_cb, e)
+                        end
+                    end
+                }
+                
+                result.promise
+            end
 
-			def resolved?
-				true
-			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
-			include Q
-			
-			def initialize(loop)
-				super()
-				
-				@pending = []
-				@value = nil
-				@loop = loop
-			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)
-				@loop.schedule do
-					if not @pending.nil?
-						callbacks = @pending
-						@pending = nil
-						@value = ref(@loop, val)
-						
-						if callbacks.length > 0
-							callbacks.each do |callback|
-								@value.then(callback[0], callback[1], callback[2])
-							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(Q.reject(@loop, reason))
-			end
-			
-			#
-			# Creates a promise object associated with this deferred
-			#
-			def promise
-				@promise ||= DeferredPromise.new(@loop, self)
-				@promise # Should only ever be one per deferred
-			end
+            def resolved?
+                true
+            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
+            include Q
+            
+            def initialize(loop)
+                super()
+                
+                @pending = []
+                @value = nil
+                @loop = loop
+            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)
+                @loop.schedule do
+                    if not @pending.nil?
+                        callbacks = @pending
+                        @pending = nil
+                        @value = ref(@loop, val)
+                        
+                        if callbacks.length > 0
+                            callbacks.each do |callback|
+                                @value.then(callback[0], callback[1], callback[2])
+                            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(Q.reject(@loop, reason))
+            end
+            
+            #
+            # Creates a promise object associated with this deferred
+            #
+            def promise
+                @promise ||= DeferredPromise.new(@loop, self)
+                @promise # Should only ever be one per deferred
+            end
 
-			#
-			# Provides an asynchronous callback mechanism
-			#
-			# @param [*Object] data you would like to send down the promise chain.
-			def notify(*args)
-				@loop.schedule do 	# just in case we are on a different event loop
-					if @pending && @pending.length > 0
-						callbacks = @pending
-						@loop.next_tick do
-							callbacks.each do |callback|
-								callback[2].call(*args)
-							end
-						end
-					end
-				end
-			end
+            #
+            # Provides an asynchronous callback mechanism
+            #
+            # @param [*Object] data you would like to send down the promise chain.
+            def notify(*args)
+                @loop.schedule do     # just in case we are on a different event loop
+                    if @pending && @pending.length > 0
+                        callbacks = @pending
+                        @loop.next_tick do
+                            callbacks.each do |callback|
+                                callback[2].call(*args)
+                            end
+                        end
+                    end
+                end
+            end
 
-			def resolved?
-				@pending.nil?
-			end
-		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(loop)
-			return Deferred.new(loop)
-		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 'em-promise'
-		#
-		#   promiseB = promiseA.then(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(loop, reason)
-		#   }, lambda {|result|
-		#     # success: do something and resolve promiseB with the old or a new result
-		#     return result
-		#   })
-		#
-		# @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(loop, reason = nil)
-			return ResolvedPromise.new(loop, 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(loop, *promises)
-			deferred = Q.defer(loop)
-			counter = promises.length
-			results = []
-			
-			if counter > 0
-				promises.each_index do |index|
-					ref(loop, 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
-						Q.reject(@loop, reason)	# Don't modify result
-					})
-				end
-			else
-				deferred.resolve(results)
-			end
-			
-			return deferred.promise
-		end
+            def resolved?
+                @pending.nil?
+            end
 
+            # Overwrite to prevent inspecting errors hanging the VM
+            def inspect
+                if @pending.nil?
+                    "#<#{self.class}:0x#{self.__id__.to_s(16)} @loop=#{@loop.inspect} @value=#{@value.inspect}>"
+                else
+					"#<#{self.class}:0x#{self.__id__.to_s(16)} @loop=#{@loop.inspect} @pending.count=#{@pending.length}>"
+                end
+            end
+        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(loop)
+            return Deferred.new(loop)
+        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 'em-promise'
+        #
+        #   promiseB = promiseA.then(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(loop, reason)
+        #   }, lambda {|result|
+        #     # success: do something and resolve promiseB with the old or a new result
+        #     return result
+        #   })
+        #
+        # @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(loop, reason = nil)
+            return ResolvedPromise.new(loop, 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(loop, *promises)
+            deferred = Q.defer(loop)
+            counter = promises.length
+            results = []
+            
+            if counter > 0
+                promises.each_index do |index|
+                    ref(loop, 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
+                        Q.reject(@loop, reason)    # Don't modify result
+                    })
+                end
+            else
+                deferred.resolve(results)
+            end
+            
+            return deferred.promise
+        end
 
-		#
-		# Combines multiple promises into a single promise that is resolved when any 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
-		def any(loop, *promises)
-			deferred = Q.defer(loop)
-			if promises.length > 0
-				promises.each_index do |index|
-					ref(loop, promises[index]).then(proc {|result|
-						deferred.resolve(true)
-						result
-					}, proc {|reason|
-						deferred.reject(false)
-						Q.reject(@loop, reason)	# Don't modify result
-					})
-				end
-			else
-				deferred.resolve(true)
-			end
-		end
 
+        #
+        # Combines multiple promises into a single promise that is resolved when any 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
+        def any(loop, *promises)
+            deferred = Q.defer(loop)
+            if promises.length > 0
+                promises.each_index do |index|
+                    ref(loop, promises[index]).then(proc {|result|
+                        deferred.resolve(true)
+                        result
+                    }, proc {|reason|
+                        deferred.reject(false)
+                        Q.reject(@loop, reason)    # Don't modify result
+                    })
+                end
+            else
+                deferred.resolve(true)
+            end
+        end
 
-		#
-		# Combines multiple promises into a single promise that is resolved when all of the input
-		# promises are resolved or rejected.
-		#
-		# @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 [result, wasResolved] value pair corresponding to a at the same index in the `promises` array.
-		def self.finally(loop, *promises)
-			deferred = Q.defer(loop)
-			counter = promises.length
-			results = []
-			
-			if counter > 0
-				promises.each_index do |index|
-					ref(loop, promises[index]).then(proc {|result|
-						if results[index].nil?
-							results[index] = [result, false]
-							counter -= 1
-							deferred.resolve(results) if counter <= 0
-						end
-						result
-					}, proc {|reason|
-						if results[index].nil?
-							results[index] = [reason, false]
-							counter -= 1
-							deferred.resolve(results) if counter <= 0
-						end
-						Q.reject(@loop, reason)	# Don't modify result
-					})
-				end
-			else
-				deferred.resolve(results)
-			end
-			
-			return deferred.promise
-		end
-		
-		
-		private
-		
-		
-		def ref(loop, value)
-			return value if value.is_a?(Promise)
-			return ResolvedPromise.new(loop, value)			# A resolved success promise
-		end
-		
-		
-		module_function :all, :reject, :defer, :ref, :any
-		private_class_method :ref
-	end
+
+        #
+        # Combines multiple promises into a single promise that is resolved when all of the input
+        # promises are resolved or rejected.
+        #
+        # @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 [result, wasResolved] value pair corresponding to a at the same index in the `promises` array.
+        def self.finally(loop, *promises)
+            deferred = Q.defer(loop)
+            counter = promises.length
+            results = []
+            
+            if counter > 0
+                promises.each_index do |index|
+                    ref(loop, promises[index]).then(proc {|result|
+                        if results[index].nil?
+                            results[index] = [result, false]
+                            counter -= 1
+                            deferred.resolve(results) if counter <= 0
+                        end
+                        result
+                    }, proc {|reason|
+                        if results[index].nil?
+                            results[index] = [reason, false]
+                            counter -= 1
+                            deferred.resolve(results) if counter <= 0
+                        end
+                        Q.reject(@loop, reason)    # Don't modify result
+                    })
+                end
+            else
+                deferred.resolve(results)
+            end
+            
+            return deferred.promise
+        end
+        
+        
+        private
+        
+        
+        def ref(loop, value)
+            return value if value.is_a?(Promise)
+            return ResolvedPromise.new(loop, value)            # A resolved success promise
+        end
+        
+        
+        module_function :all, :reject, :defer, :ref, :any
+        private_class_method :ref
+    end
 
 end

data/lib/libuv/timer.rb

@@ -68,17 +68,11 @@ module Libuv
         private
 
 
-        def on_timer(handle, status)
-            e = check_result(status)
-
-            if e
-                reject(e)
-            else
-                begin
-                    @callback.call
-                rescue Exception => e
-                    @loop.log :error, :timer_cb, e
-                end
+        def on_timer(handle)
+            begin
+                @callback.call
+            rescue Exception => e
+                @loop.log :error, :timer_cb, e
             end
         end
     end

data/lib/libuv/version.rb

@@ -1,3 +1,3 @@
 module Libuv
-    VERSION = '0.12.2'
+    VERSION = '0.12.3'
 end

data/spec/tcp_spec.rb

@@ -35,9 +35,9 @@ describe Libuv::TCP do
 			@loop.run { |logger|
 				logger.progress do |level, errorid, error|
 					begin
-						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
-					rescue Exception
-						@general_failure << 'error in logger'
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n") if error.backtrace}\n"
+					rescue Exception => e
+						@general_failure << "error in logger #{e.inspect}"
 					end
 				end
 
@@ -98,9 +98,9 @@ describe Libuv::TCP do
 		@loop.run { |logger|
 			logger.progress do |level, errorid, error|
 				begin
-					@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n") if error.backtrace}\n"
 				rescue Exception
-					@general_failure << 'error in logger'
+					@general_failure << "error in logger #{e.inspect}"
 				end
 			end
 
@@ -169,9 +169,9 @@ describe Libuv::TCP do
 				@loop2.run do  |logger|
 					logger.progress do |level, errorid, error|
 						begin
-							@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+							@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n") if error.backtrace}\n"
 						rescue Exception
-							@general_failure << 'error in logger'
+							@general_failure << "error in logger #{e.inspect}"
 						end
 					end
 			
@@ -209,9 +209,9 @@ describe Libuv::TCP do
 			@loop.run { |logger|
 				logger.progress do |level, errorid, error|
 					begin
-						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n") if error.backtrace}\n"
 					rescue Exception
-						@general_failure << 'error in logger'
+						@general_failure << "error in logger #{e.inspect}"
 					end
 				end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libuv
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 0.12.3
 platform: ruby
 authors:
 - Bulat Shakirzyanov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-01 00:00:00.000000000 Z
+date: 2014-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -175,6 +175,7 @@ files:
 - ext/libuv/common.gypi
 - ext/libuv/configure.ac
 - ext/libuv/gyp_uv.py
+- ext/libuv/include/android-ifaddrs.h
 - ext/libuv/include/pthread-fixes.h
 - ext/libuv/include/stdint-msvc2008.h
 - ext/libuv/include/tree.h
@@ -189,6 +190,7 @@ files:
 - ext/libuv/include/uv.h
 - ext/libuv/libuv.pc.in
 - ext/libuv/m4/.gitignore
+- ext/libuv/m4/as_case.m4
 - ext/libuv/m4/dtrace.m4
 - ext/libuv/samples/.gitignore
 - ext/libuv/samples/socks5-proxy/.gitignore
@@ -208,6 +210,7 @@ files:
 - ext/libuv/src/inet.c
 - ext/libuv/src/queue.h
 - ext/libuv/src/unix/aix.c
+- ext/libuv/src/unix/android-ifaddrs.c
 - ext/libuv/src/unix/async.c
 - ext/libuv/src/unix/atomic-ops.h
 - ext/libuv/src/unix/core.c
@@ -396,10 +399,13 @@ files:
 - ext/libuv/test/test-timer-from-check.c
 - ext/libuv/test/test-timer.c
 - ext/libuv/test/test-tty.c
+- ext/libuv/test/test-udp-bind.c
 - ext/libuv/test/test-udp-dgram-too-big.c
 - ext/libuv/test/test-udp-ipv6.c
 - ext/libuv/test/test-udp-multicast-interface.c
+- ext/libuv/test/test-udp-multicast-interface6.c
 - ext/libuv/test/test-udp-multicast-join.c
+- ext/libuv/test/test-udp-multicast-join6.c
 - ext/libuv/test/test-udp-multicast-ttl.c
 - ext/libuv/test/test-udp-open.c
 - ext/libuv/test/test-udp-options.c
@@ -428,7 +434,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: libuv bindings for Ruby