libuv 2.0.12 → 3.0.0

data/lib/libuv/prepare.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     class Prepare < Handle
 
@@ -5,14 +7,14 @@ module Libuv
         define_callback function: :on_prepare
 
 
-        # @param loop [::Libuv::Loop] loop this prepare handle will be associated
-        # @param callback [Proc] callback to be called on loop preparation
-        def initialize(loop, callback = nil, &blk)
-            @loop = loop
+        # @param reactor [::Libuv::Reactor] reactor this prepare handle will be associated
+        # @param callback [Proc] callback to be called on reactor preparation
+        def initialize(reactor, callback = nil, &blk)
+            @reactor = reactor
             @callback = callback || blk
 
             prepare_ptr = ::Libuv::Ext.allocate_handle_prepare
-            error = check_result(::Libuv::Ext.prepare_init(loop.handle, prepare_ptr))
+            error = check_result(::Libuv::Ext.prepare_init(reactor.handle, prepare_ptr))
 
             super(prepare_ptr, error)
         end
@@ -22,6 +24,7 @@ module Libuv
             return if @closed
             error = check_result ::Libuv::Ext.prepare_start(handle, callback(:on_prepare))
             reject(error) if error
+            self
         end
 
         # Disables the prepare handler.
@@ -29,13 +32,15 @@ module Libuv
             return if @closed
             error = check_result ::Libuv::Ext.prepare_stop(handle)
             reject(error) if error
+            self
         end
 
-        # Used to update the callback that will be triggered on loop prepare
+        # Used to update the callback that will be triggered on reactor prepare
         #
-        # @param callback [Proc] the callback to be called on loop prepare
+        # @param callback [Proc] the callback to be called on reactor prepare
         def progress(callback = nil, &blk)
             @callback = callback || blk
+            self
         end
 
 
@@ -43,11 +48,13 @@ module Libuv
 
 
         def on_prepare(handle)
-            begin
-                @callback.call
-            rescue Exception => e
-                @loop.log :error, :prepare_cb, e
-            end
+            ::Fiber.new {
+                begin
+                    @callback.call
+                rescue Exception => e
+                    @reactor.log e, 'performing prepare callback'
+                end
+            }.resume
         end
     end
 end

data/lib/libuv/q.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Libuv
     module Q
@@ -9,10 +10,12 @@ module Libuv
             # This allows subclasses to make use of the catch feature
             alias_method :ruby_catch, :catch
 
+            # Allows a backtrace to be included in any errors
+            attr_accessor :trace
 
             # Used by finally method
-            MAKE_PROMISE = proc { |value, resolved, loop|
-                result = Q.defer(loop)
+            MAKE_PROMISE = proc { |value, resolved, reactor|
+                result = Q.defer(reactor)
                 if (resolved)
                     result.resolve(value)
                 else
@@ -37,6 +40,10 @@ module Libuv
                 self.then(nil, nil, callback || blk)
             end
 
+            # A future that provides the value or raises an error if a rejection occurs
+            def value
+                co self
+            end
 
             #
             # allows you to observe either the fulfillment or rejection of a promise, but to do so
@@ -53,18 +60,18 @@ module Libuv
                     begin
                         callbackOutput = callback.call
                     rescue Exception => e
-                        @loop.log(:error, :q_finally_cb, e)
-                        return MAKE_PROMISE.call(e, false, @loop)
+                        @reactor.log e, 'performing promise finally callback', @trace
+                        return MAKE_PROMISE.call(e, false, @reactor)
                     end
 
                     if callbackOutput.is_a?(Promise)
                         return callbackOutput.then(proc {
-                                MAKE_PROMISE.call(value, isResolved, @loop)
+                                MAKE_PROMISE.call(value, isResolved, @reactor)
                             }, proc { |err|
-                                MAKE_PROMISE.call(err, false, @loop)
+                                MAKE_PROMISE.call(err, false, @reactor)
                             })
                     else
-                        return MAKE_PROMISE.call(value, isResolved, @loop)
+                        return MAKE_PROMISE.call(value, isResolved, @reactor)
                     end
                 }
 
@@ -84,11 +91,11 @@ module Libuv
         class DeferredPromise < Promise
             public_class_method :new
             
-            def initialize(loop, defer)
+            def initialize(reactor, defer)
                 raise ArgumentError unless defer.is_a?(Deferred)
                 super()
                 
-                @loop = loop
+                @reactor = reactor
                 @defer = defer
             end
             
@@ -100,7 +107,7 @@ module Libuv
             # @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)
+                result = Q.defer(@reactor)
                 
                 callback ||= blk
                 
@@ -108,19 +115,17 @@ module Libuv
                     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)
+                        @reactor.log e, 'performing promise resolution callback', @trace
                     end
                 }
                 
                 wrappedErrback = proc { |reason|
                     begin
-                        result.resolve(errback.nil? ? Q.reject(@loop, reason) : errback.call(reason))
+                        result.resolve(errback.nil? ? Q.reject(@reactor, 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)
+                        @reactor.log e, 'performing promise rejection callback', @trace
                     end
                 }
 
@@ -128,8 +133,7 @@ module Libuv
                     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)
+                        @reactor.log e, 'performing promise progress callback', @trace
                     end
                 }
                 
@@ -137,11 +141,11 @@ module Libuv
                 # Schedule as we are touching shared state
                 #    Everything else is locally scoped
                 #
-                @loop.schedule do
+                @reactor.schedule do
                     pending_array = pending
                     
                     if pending_array.nil?
-                        value.then(wrappedCallback, wrappedErrback, wrappedProgback)
+                        reference.then(wrappedCallback, wrappedErrback, wrappedProgback)
                     else
                         pending_array << [wrappedCallback, wrappedErrback, wrappedProgback]
                     end
@@ -153,59 +157,57 @@ module Libuv
             def resolved?
                 pending.nil?
             end
-            
-            
+
+
             private
-            
-            
+
+
             def pending
                 @defer.pending
             end
             
-            def value
-                @defer.value
+            def reference
+                @defer.reference
             end
         end
-        
-        
-        
+
+
+
         class ResolvedPromise < Promise
             public_class_method :new
-            
-            def initialize(loop, response, error = false)
+
+            def initialize(reactor, response, error = false)
                 raise ArgumentError if error && response.is_a?(Promise)
                 super()
-                
-                @loop = loop
+
+                @reactor = reactor
                 @error = error
                 @response = response
             end
-            
+
             def then(callback = nil, errback = nil, progback = nil, &blk)
-                result = Q.defer(@loop)
-                
+                result = Q.defer(@reactor)
+
                 callback ||= blk
-                
-                @loop.next_tick {
+
+                @reactor.next_tick {
                     if @error
                         begin
-                            result.resolve(errback.nil? ? Q.reject(@loop, @response) : errback.call(@response))
+                            result.resolve(errback.nil? ? Q.reject(@reactor, @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)
+                            @reactor.log e, 'performing promise rejection callback', @trace
                         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)
+                            @reactor.log e, 'performing promise resolution callback', @trace
                         end
                     end
                 }
-                
+
                 result.promise
             end
 
@@ -213,60 +215,61 @@ module Libuv
                 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)
+
+            def initialize(reactor)
                 super()
-                
+
                 @pending = []
-                @value = nil
-                @loop = loop
+                @reference = nil
+                @reactor = reactor
             end
 
-            attr_reader :pending, :value
-            
+            attr_reader :pending, :reference
+
             #
             # 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
+                @reactor.schedule do
                     if not @pending.nil?
                         callbacks = @pending
                         @pending = nil
-                        @value = ref(@loop, val)
+                        @reference = ref(@reactor, val)
                         
                         if callbacks.length > 0
                             callbacks.each do |callback|
-                                @value.then(callback[0], callback[1], callback[2])
+                                @reference.then(callback[0], callback[1], callback[2])
                             end
                         end
                     end
                 end
+                self
             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))
+                resolve(Q.reject(@reactor, reason))
             end
-            
+
             #
             # Creates a promise object associated with this deferred
             #
             def promise
-                @promise ||= DeferredPromise.new(@loop, self)
+                @promise ||= DeferredPromise.new(@reactor, self)
                 @promise # Should only ever be one per deferred
             end
 
@@ -275,46 +278,51 @@ module Libuv
             #
             # @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
+                @reactor.schedule do     # just in case we are on a different event reactor
                     if @pending && @pending.length > 0
                         callbacks = @pending
-                        @loop.next_tick do
+                        @reactor.next_tick do
                             callbacks.each do |callback|
                                 callback[2].call(*args)
                             end
                         end
                     end
                 end
+                self
             end
 
             def resolved?
                 @pending.nil?
             end
 
+            def value
+                co self.promise
+            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}>"
+                    "#<#{self.class}:0x#{self.__id__.to_s(16)} @reactor=#{@reactor.inspect} @reference=#{@reference.inspect}>"
                 else
-					"#<#{self.class}:0x#{self.__id__.to_s(16)} @loop=#{@loop.inspect} @pending.count=#{@pending.length}>"
+					"#<#{self.class}:0x#{self.__id__.to_s(16)} @reactor=#{@reactor.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)
+        def defer(reactor)
+            return Deferred.new(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
@@ -340,7 +348,7 @@ module Libuv
         #       # handle the error and recover
         #       return newPromiseOrValue
         #     end
-        #     return Q.reject(loop, reason)
+        #     return Q.reject(reactor, reason)
         #   }, lambda {|result|
         #     # success: do something and resolve promiseB with the old or a new result
         #     return result
@@ -348,10 +356,10 @@ module Libuv
         #
         # @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
+        def reject(reactor, reason = nil)
+            return ResolvedPromise.new(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.
@@ -361,14 +369,14 @@ module Libuv
         #   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)
+        def all(reactor, *promises)
+            deferred = Q.defer(reactor)
             counter = promises.length
             results = []
-            
+
             if counter > 0
                 promises.each_index do |index|
-                    ref(loop, promises[index]).then(proc {|result|
+                    ref(reactor, promises[index]).then(proc {|result|
                         if results[index].nil?
                             results[index] = result
                             counter -= 1
@@ -379,13 +387,13 @@ module Libuv
                         if results[index].nil?
                             deferred.reject(reason)
                         end
-                        Q.reject(@loop, reason)    # Don't modify result
+                        Q.reject(@reactor, reason)    # Don't modify result
                     })
                 end
             else
                 deferred.resolve(results)
             end
-            
+
             return deferred.promise
         end
 
@@ -396,16 +404,16 @@ module Libuv
         #
         # @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)
+        def any(reactor, *promises)
+            deferred = Q.defer(reactor)
             if promises.length > 0
                 promises.each_index do |index|
-                    ref(loop, promises[index]).then(proc {|result|
+                    ref(reactor, promises[index]).then(proc {|result|
                         deferred.resolve(true)
                         result
                     }, proc {|reason|
                         deferred.reject(false)
-                        Q.reject(@loop, reason)    # Don't modify result
+                        Q.reject(@reactor, reason)    # Don't modify result
                     })
                 end
             else
@@ -421,14 +429,14 @@ module Libuv
         # @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)
+        def self.finally(reactor, *promises)
+            deferred = Q.defer(reactor)
             counter = promises.length
             results = []
-            
+
             if counter > 0
                 promises.each_index do |index|
-                    ref(loop, promises[index]).then(proc {|result|
+                    ref(reactor, promises[index]).then(proc {|result|
                         if results[index].nil?
                             results[index] = [result, true]
                             counter -= 1
@@ -441,26 +449,26 @@ module Libuv
                             counter -= 1
                             deferred.resolve(results) if counter <= 0
                         end
-                        Q.reject(@loop, reason)    # Don't modify result
+                        Q.reject(@reactor, reason)    # Don't modify result
                     })
                 end
             else
                 deferred.resolve(results)
             end
-            
+
             return deferred.promise
         end
-        
-        
+
+
         private
-        
-        
-        def ref(loop, value)
+
+
+        def ref(reactor, value)
             return value if value.is_a?(Promise)
-            return ResolvedPromise.new(loop, value)            # A resolved success promise
+            return ResolvedPromise.new(reactor, value)            # A resolved success promise
         end
-        
-        
+
+
         module_function :all, :reject, :defer, :ref, :any
         private_class_method :ref
     end