libuv 3.3.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '092646a6b10dd6f3b39277326714b7087447d159'
-  data.tar.gz: a774a2227b1b970fa38616cdd8d03c9ccc971935
+  metadata.gz: b07182db4afe88a245218f486d7f29091a6facf5
+  data.tar.gz: b90adcd03a747e4af99e02befa38901befea1351
 SHA512:
-  metadata.gz: 7de8cf263154b94ca967ac1be2969e833ba3128d7f8891690a0d951562214b2ed253f57c7854297cb9011386e2157d6d496ced5344ea38df10a3cea8ad5951a5
-  data.tar.gz: 5992ba91e3296e41751fa3d61f6ff433f21718673b62af60e8c8a40fca47ee105e7d15875604d74b83bf9d53a2d4a73047a943105568d387179ec7304e15904f
+  metadata.gz: e1a90d594b27b9d198781340e7ed1478e40fa41bf2e0b83e4bda195b5791445c12726df0d5e76f8318f6b1117ea145692fe9bd034b735004e866163a921186f7
+  data.tar.gz: 68c23d23198477dee0f5b31c04c8b2589b3af3adc79383a2e8a97a05c0fa3b859990e64147e2445ef6cb6d225ec03151fe5458111accc63f75aa7583584d5234

data/lib/libuv.rb

@@ -70,7 +70,11 @@ end
 class Object
     private
     
-    def reactor(&blk)
-        Libuv.reactor &blk
+    def reactor
+        if block_given?
+            Libuv.reactor { |thread| yield(thread) }
+        else
+            Libuv.reactor
+        end
     end
 end

data/lib/libuv/async.rb

@@ -8,9 +8,8 @@ module Libuv
 
 
         # @param reactor [::Libuv::Reactor] reactor this async callback will be associated
-        def initialize(reactor, callback = nil, &blk)
+        def initialize(reactor)
             @reactor = reactor
-            @callback = callback || blk
 
             async_ptr = ::Libuv::Ext.allocate_handle_async
             on_async = callback(:on_async, async_ptr.address)
@@ -30,8 +29,8 @@ module Libuv
         # Used to update the callback that will be triggered when async is called
         #
         # @param callback [Proc] the callback to be called on reactor prepare
-        def progress(callback = nil, &blk)
-            @callback = callback || blk
+        def progress(&callback)
+            @callback = callback
             self
         end
 

data/lib/libuv/check.rb

@@ -9,9 +9,8 @@ module Libuv
 
         # @param reactor [::Libuv::Reactor] reactor this check will be associated
         # @param callback [Proc] callback to be called on reactor check
-        def initialize(reactor, callback = nil, &blk)
+        def initialize(reactor)
             @reactor = reactor
-            @callback = callback || blk
 
             check_ptr = ::Libuv::Ext.allocate_handle_check
             error = check_result(::Libuv::Ext.check_init(reactor.handle, check_ptr))
@@ -38,8 +37,8 @@ module Libuv
         # Used to update the callback that will be triggered on reactor check
         #
         # @param callback [Proc] the callback to be called on reactor check
-        def progress(callback = nil, &blk)
-            @callback = callback || blk
+        def progress(&callback)
+            @callback = callback
             self
         end
 

data/lib/libuv/coroutines.rb

@@ -6,17 +6,14 @@ class CoroutineRejection < RuntimeError
     attr_accessor :value
 end
 
-class Object
-    private
-
-
+module Libuv
     # Takes a Promise response and turns it into a co-routine
     # for code execution without using callbacks
     #
     # @param *promises [::Libuv::Q::Promise] a number of promises that will be combined into a single promise
     # @return [Object] Returns the result of a single promise or an array of results if provided multiple promises
     # @raise [Exception] if the promise is rejected
-    def co(*yieldable, &block)
+    def co(*yieldable)
         on_reactor = Libuv::Reactor.current
         raise 'must be running on a reactor thread to use coroutines' unless on_reactor
 
@@ -27,7 +24,7 @@ class Object
         if yieldable.length == 1
             promise = yieldable[0]
             # Passed independently as this is often overwritten for performance
-            promise.progress(block) if block_given?
+            promise.progress &Proc.new if block_given?
         else
             promise = on_reactor.all(*yieldable)
         end
@@ -77,4 +74,6 @@ class Object
         end
         result
     end
+
+    module_function :co
 end

data/lib/libuv/dns.rb

@@ -52,7 +52,7 @@ module Libuv
                 @defer.reject(error)
             end
 
-            co(@defer.promise) if wait
+            @defer.promise.value if wait
         end
 
         # Indicates if the lookup has completed yet or not.

data/lib/libuv/file.rb

@@ -29,7 +29,7 @@ module Libuv
         attr_reader :fileno, :closed
 
 
-        def initialize(thread, path, flags = 0, mode: 0, wait: true, &blk)
+        def initialize(thread, path, flags = 0, mode: 0)
             super(thread, thread.defer)
 
             @fileno = -1
@@ -41,10 +41,10 @@ module Libuv
             pre_check @defer, request, ::Libuv::Ext.fs_open(@reactor, request, @path, @flags, @mode, callback(:on_open, request.address))
 
             if block_given?
-                self.progress blk
-            elsif wait
+                self.progress &Proc.new
+            else
                 @coroutine = @reactor.defer
-                co @coroutine.promise
+                @coroutine.promise.value
             end
         end
 
@@ -67,7 +67,7 @@ module Libuv
             @request_refs[request.address] = [deferred, buffer1]
 
             promise = pre_check(deferred, request, ::Libuv::Ext.fs_read(@reactor.handle, request, @fileno, buffer, 1, offset, callback(:on_read, request.address)))
-            wait ? co(promise) : promise
+            wait ? promise.value : promise
         end
 
         def write(data, offset = 0, wait: true)
@@ -123,7 +123,7 @@ module Libuv
             @request_refs[request.address] = deferred
 
             promise = pre_check deferred, request, ::Libuv::Ext.fs_futime(@reactor.handle, request, @fileno, atime, mtime, callback(:on_utime, request.address))
-            wait ? co(promise) : promise
+            wait ? promise.value : promise
         end
 
         def chmod(mode, wait: true)
@@ -148,10 +148,12 @@ module Libuv
         end
 
         def send_file(stream, using: :raw, chunk_size: 4096, wait: true)
-            @transmit_failure ||= method(:transmit_failure)
-            @transmit_data ||= method(:transmit_data)
-            @start_transmit ||= method(:start_transmit)
-            @next_chunk ||= method(:next_chunk)
+            @transmit_failure ||= proc { |reason| @sending_file.reject(reason) }
+            @start_transmit ||= proc { |stats|
+                @file_stream_total = stats[:st_size]
+                next_chunk
+            }
+            @transmit_data ||= proc { |data| transmit_data(data) }
 
             @sending_file = @reactor.defer
             @file_stream = stream
@@ -162,7 +164,7 @@ module Libuv
             stat(wait: false).then @start_transmit, @transmit_failure
             
             promise = @sending_file.promise
-            promise.finally &method(:clean_up_send)
+            promise.finally { clean_up_send }
             respond wait, promise
         end
 
@@ -172,11 +174,6 @@ module Libuv
 
         ##
         # File transmit functions -------------
-        def start_transmit(stats)
-            @file_stream_total = stats[:st_size]
-            next_chunk
-        end
-
         def transmit_data(data)
             @file_chunk_count += 1
             if @file_stream_type == :http
@@ -186,11 +183,11 @@ module Libuv
                 resp << CRLF
                 data = resp
             end
-            @file_stream.write(data, wait: :promise).then @next_chunk, @transmit_failure
+            @file_stream.write(data, wait: :promise).then(proc { next_chunk }, @transmit_failure)
             nil
         end
 
-        def next_chunk(*args)
+        def next_chunk
             next_size = @file_chunk_size
             next_offset = @file_chunk_size * @file_chunk_count
             
@@ -211,10 +208,6 @@ module Libuv
             nil
         end
 
-        def transmit_failure(reason)
-            @sending_file.reject(reason)
-        end
-
         def clean_up_send
             @sending_file = nil
             @file_stream = nil

data/lib/libuv/idle.rb

@@ -9,9 +9,8 @@ module Libuv
 
         # @param reactor [::Libuv::Reactor] reactor this idle handler will be associated
         # @param callback [Proc] callback to be called when the reactor is idle
-        def initialize(reactor, callback = nil, &blk)
+        def initialize(reactor)
             @reactor = reactor
-            @callback = callback || blk
 
             idle_ptr = ::Libuv::Ext.allocate_handle_idle
             error = check_result(::Libuv::Ext.idle_init(reactor.handle, idle_ptr))
@@ -38,8 +37,8 @@ module Libuv
         # Used to update the callback that will be triggered on idle
         #
         # @param callback [Proc] the callback to be called on idle trigger
-        def progress(callback = nil, &blk)
-            @callback = callback || blk
+        def progress(&callback)
+            @callback = callback
             self
         end
 

data/lib/libuv/mixins/fs_checks.rb

@@ -22,7 +22,7 @@ module Libuv
             pre_check @stat_deferred, request, ::Libuv::Ext.fs_fstat(@reactor.handle, request, @fileno, callback(:on_stat, request.address))
             promise = @stat_deferred.promise
 
-            wait ? co(promise) : promise
+            wait ? promise.value : promise
         end
 
 
@@ -31,7 +31,7 @@ module Libuv
 
         def respond(wait, promise)
             if wait
-                co(promise)
+                promise.value
                 self
             else
                 promise

data/lib/libuv/mixins/stream.rb

@@ -104,7 +104,7 @@ module Libuv
 
             if wait
                 return deferred.promise if wait == :promise
-                co deferred.promise
+                deferred.promise.value
             end
 
             self
@@ -122,8 +122,8 @@ module Libuv
             ::Libuv::Ext.is_writable(handle) > 0
         end
 
-        def progress(callback = nil, &blk)
-            @progress = callback || blk
+        def progress(&blk)
+            @progress = blk
             self
         end
 
@@ -147,7 +147,7 @@ module Libuv
                 end
             end
 
-            co @read_defer.promise
+            @read_defer.promise.value
         end
         alias_method :read_nonblock, :read
 
@@ -158,7 +158,7 @@ module Libuv
 
             @flush_defer = @reactor.defer
             check_flush_buffer
-            co @flush_defer.promise
+            @flush_defer.promise.value
         end
 
 

data/lib/libuv/pipe.rb

@@ -22,10 +22,10 @@ module Libuv
             super(pipe_ptr, error)
         end
 
-        def bind(name, callback = nil, &blk)
+        def bind(name, &callback)
             return if @closed
-            @on_accept = callback || blk
-            @on_listen = method(:accept)
+            @on_accept = callback
+            @on_listen = proc { accept }
 
             assert_type(String, name, "name must be a String")
             name = windows_path name if FFI::Platform.windows?
@@ -36,8 +36,7 @@ module Libuv
             self
         end
 
-        def open(fileno, callback = nil, &blk)
-            @callback = callback || blk
+        def open(fileno)
             assert_type(Integer, fileno, 'fileno must be an integer file descriptor')
 
             begin
@@ -45,24 +44,25 @@ module Libuv
                 check_result! ::Libuv::Ext.pipe_open(handle, fileno)
 
                 # Emulate on_connect behavior
-                begin
-                    @callback.call(self) if @callback
-                rescue Exception => e
-                    @reactor.log e, 'performing pipe connect callback'
-                    raise e unless @callback
+                if block_given?
+                    begin
+                        yield(self)
+                    rescue Exception => e
+                        @reactor.log e, 'performing pipe connect callback'
+                    end
                 end
             rescue Exception => e
                 reject(e)
-                raise e unless @callback
+                raise e unless block_given?
             end
 
             self
         end
 
-        def connect(name, callback = nil, &blk)
+        def connect(name)
             return if @closed
-            @callback = callback || blk
             assert_type(String, name, "name must be a String")
+
             begin
                 name = windows_path name if FFI::Platform.windows?
                 req = ::Libuv::Ext.allocate_request_connect
@@ -71,9 +71,11 @@ module Libuv
                 reject(e)
             end
 
-            if @callback.nil?
+            if block_given?
+                @callback = Proc.new
+            else
                 @coroutine = @reactor.defer
-                co @coroutine.promise
+                @coroutine.promise.value
             end
 
             self
@@ -111,7 +113,7 @@ module Libuv
             
             if wait
                 return deferred.promise if wait == :promise
-                co deferred.promise
+                deferred.promise.value
             end
 
             self
@@ -156,7 +158,7 @@ module Libuv
         private
         
 
-        def accept(_)
+        def accept
             pipe = nil
             begin
                 raise RuntimeError, CLOSED_HANDLE_ERROR if @closed

data/lib/libuv/prepare.rb

@@ -9,9 +9,8 @@ module Libuv
 
         # @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)
+        def initialize(reactor)
             @reactor = reactor
-            @callback = callback || blk
 
             prepare_ptr = ::Libuv::Ext.allocate_handle_prepare
             error = check_result(::Libuv::Ext.prepare_init(reactor.handle, prepare_ptr))
@@ -38,8 +37,8 @@ module Libuv
         # Used to update the callback that will be triggered on reactor prepare
         #
         # @param callback [Proc] the callback to be called on reactor prepare
-        def progress(callback = nil, &blk)
-            @callback = callback || blk
+        def progress(&callback)
+            @callback = callback
             self
         end
 

data/lib/libuv/q.rb

@@ -13,36 +13,24 @@ module Libuv
             # Allows a backtrace to be included in any errors
             attr_accessor :trace
 
-            # Used by finally method
-            MAKE_PROMISE = proc { |value, resolved, reactor|
-                result = Q.defer(reactor)
-                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)
+            def catch(&blk)
+                self.then(nil, blk)
             end
 
 
-            def progress(callback = nil, &blk)
-                self.then(nil, nil, callback || blk)
+            def progress(&blk)
+                self.then(nil, nil, blk)
             end
 
             # A future that provides the value or raises an error if a rejection occurs
             def value
-                co self
+                ::Libuv.co(self)
             end
 
             #
@@ -52,26 +40,24 @@ module Libuv
             #
             # @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|
+            def finally
+                handleCallback = lambda { |value, isResolved|
                     callbackOutput = nil
                     begin
-                        callbackOutput = callback.call
+                        callbackOutput = yield
                     rescue Exception => e
                         @reactor.log e, 'performing promise finally callback', @trace
-                        return MAKE_PROMISE.call(e, false, @reactor)
+                        return make_promise(e, false, @reactor)
                     end
 
                     if callbackOutput.is_a?(Promise)
                         return callbackOutput.then(proc {
-                                MAKE_PROMISE.call(value, isResolved, @reactor)
+                                make_promise(value, isResolved, @reactor)
                             }, proc { |err|
-                                MAKE_PROMISE.call(err, false, @reactor)
+                                make_promise(err, false, @reactor)
                             })
                     else
-                        return MAKE_PROMISE.call(value, isResolved, @reactor)
+                        return make_promise(value, isResolved, @reactor)
                     end
                 }
 
@@ -81,6 +67,18 @@ module Libuv
                     handleCallback.call(err, false)
                 })
             end
+
+            protected
+
+            def make_promise(value, resolved, reactor)
+                result = Q.defer(reactor)
+                if (resolved)
+                    result.resolve(value)
+                else
+                    result.reject(value)
+                end
+                result.promise
+            end
         end
         
         
@@ -94,7 +92,7 @@ module Libuv
             def initialize(reactor, defer)
                 raise ArgumentError unless defer.is_a?(Deferred)
                 super()
-                
+
                 @reactor = reactor
                 @defer = defer
             end
@@ -106,14 +104,13 @@ 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)
+            def then(callback = nil, errback = nil, progback = nil)
                 result = Q.defer(@reactor)
-                
-                callback ||= blk
+                callback = Proc.new if block_given?
                 
                 wrappedCallback = proc { |val|
                     begin
-                        result.resolve(callback.nil? ? val : callback.call(val))
+                        result.resolve(callback ? callback.call(val) : val)
                     rescue Exception => e
                         result.reject(e)
                         @reactor.log e, 'performing promise resolution callback', @trace
@@ -122,7 +119,7 @@ module Libuv
                 
                 wrappedErrback = proc { |reason|
                     begin
-                        result.resolve(errback.nil? ? Q.reject(@reactor, reason) : errback.call(reason))
+                        result.resolve(errback ? errback.call(reason) : Q.reject(@reactor, reason))
                     rescue Exception => e
                         result.reject(e)
                         @reactor.log e, 'performing promise rejection callback', @trace
@@ -131,7 +128,7 @@ module Libuv
 
                 wrappedProgback = proc { |*progress|
                     begin
-                        result.notify(progback.nil? ? progress : progback.call(*progress))
+                        result.notify(progback ? progback.call(*progress) : progress)
                     rescue Exception => e
                         @reactor.log e, 'performing promise progress callback', @trace
                     end
@@ -150,7 +147,7 @@ module Libuv
                         pending_array << [wrappedCallback, wrappedErrback, wrappedProgback]
                     end
                 end
-                
+
                 result.promise
             end
 
@@ -185,22 +182,21 @@ module Libuv
                 @response = response
             end
 
-            def then(callback = nil, errback = nil, progback = nil, &blk)
+            def then(callback = nil, errback = nil, progback = nil)
                 result = Q.defer(@reactor)
-
-                callback ||= blk
+                callback = Proc.new if block_given?
 
                 @reactor.next_tick {
                     if @error
                         begin
-                            result.resolve(errback.nil? ? Q.reject(@reactor, @response) : errback.call(@response))
+                            result.resolve(errback ? errback.call(@response) : Q.reject(@reactor, @response))
                         rescue Exception => e
                             result.reject(e)
                             @reactor.log e, 'performing promise rejection callback', @trace
                         end
                     else
                         begin
-                            result.resolve(callback.nil? ? @response : callback.call(@response))
+                            result.resolve(callback ? callback.call(@response) : @response)
                         rescue Exception => e
                             result.reject(e)
                             @reactor.log e, 'performing promise resolution callback', @trace
@@ -296,7 +292,7 @@ module Libuv
             end
 
             def value
-                co self.promise
+                ::Libuv.co(self.promise)
             end
 
             # Overwrite to prevent inspecting errors hanging the VM

data/lib/libuv/reactor.rb

@@ -62,30 +62,30 @@ module Libuv
 
             # Create an async call for scheduling work from other threads
             @run_queue = Queue.new
-            @process_queue = @reactor.async method(:process_queue_cb)
+            @process_queue = @reactor.async { process_queue_cb }
             @process_queue.unref
 
             # Create a next tick timer
-            @next_tick = @reactor.timer method(:next_tick_cb)
+            @next_tick = @reactor.timer { next_tick_cb }
             @next_tick.unref
 
             # Create an async call for ending the reactor
-            @stop_reactor = @reactor.async method(:stop_cb)
+            @stop_reactor = @reactor.async { stop_cb }
             @stop_reactor.unref
 
             # Libuv can prevent the application shutting down once the main thread has ended
             # The addition of a prepare function prevents this from happening.
-            @reactor_prep = Libuv::Prepare.new(@reactor, method(:noop))
+            @reactor_prep = prepare {}
             @reactor_prep.unref
             @reactor_prep.start
 
             # LibUV ingnores program interrupt by default.
             # We provide normal behaviour and allow this to be overriden
             @on_signal = []
-            sig_callback = method(:signal_cb)
-            self.signal(:INT, sig_callback).unref
-            self.signal(:HUP, sig_callback).unref
-            self.signal(:TERM, sig_callback).unref
+            sig_callback = proc { signal_cb }
+            self.signal(:INT, &sig_callback).unref
+            self.signal(:HUP, &sig_callback).unref
+            self.signal(:TERM, &sig_callback).unref
 
             # Notify of errors
             @throw_on_exit = nil
@@ -101,8 +101,6 @@ module Libuv
         protected
 
 
-        def noop; end
-
         def stop_cb
             Thread.current.thread_variable_set(:reactor, nil)
             @reactor_running = false
@@ -110,7 +108,7 @@ module Libuv
             ::Libuv::Ext.stop(@pointer)
         end
 
-        def signal_cb(_)
+        def signal_cb
             if @on_signal.empty?
                 stop_cb
             else
@@ -226,8 +224,12 @@ module Libuv
         # Provides a promise notifier for receiving un-handled exceptions
         #
         # @return [::Libuv::Q::Promise]
-        def notifier(callback = nil, &blk)
-            @reactor_notify = callback || blk || @reactor_notify_default
+        def notifier
+            @reactor_notify = if block_given?
+                Proc.new
+            else
+                @reactor_notify_default
+            end
             self
         end
 
@@ -325,15 +327,15 @@ module Libuv
         # Get a new TCP instance
         # 
         # @return [::Libuv::TCP]
-        def tcp(callback = nil, **opts, &blk)
-            TCP.new(@reactor, progress: callback || blk, **opts)
+        def tcp(**opts, &callback)
+            TCP.new(@reactor, progress: callback, **opts)
         end
 
         # Get a new UDP instance
         #
         # @return [::Libuv::UDP]
-        def udp(callback = nil, **opts, &blk)
-            UDP.new(@reactor, progress: callback || blk, **opts)
+        def udp(**opts, &callback)
+            UDP.new(@reactor, progress: callback, **opts)
         end
 
         # Get a new TTY instance
@@ -359,56 +361,62 @@ module Libuv
         # 
         # @param callback [Proc] the callback to be called on timer trigger
         # @return [::Libuv::Timer]
-        def timer(callback = nil, &blk)
-            Timer.new(@reactor, callback || blk)
+        def timer
+            handle = Timer.new(@reactor)
+            handle.progress &Proc.new if block_given?
+            handle
         end
 
         # Get a new Prepare handle
         # 
         # @return [::Libuv::Prepare]
-        def prepare(callback = nil, &blk)
-            Prepare.new(@reactor, callback || blk)
+        def prepare
+            handle = Prepare.new(@reactor)
+            handle.progress &Proc.new if block_given?
+            handle
         end
 
         # Get a new Check handle
         # 
         # @return [::Libuv::Check]
-        def check(callback = nil, &blk)
-            Check.new(@reactor, callback || blk)
+        def check
+            handle = Check.new(@reactor)
+            handle.progress &Proc.new if block_given?
+            handle
         end
 
         # Get a new Idle handle
         # 
         # @param callback [Proc] the callback to be called on idle trigger
         # @return [::Libuv::Idle]
-        def idle(callback = nil, &block)
-            Idle.new(@reactor, callback || block)
+        def idle
+            handle = Idle.new(@reactor)
+            handle.progress &Proc.new if block_given?
+            handle
         end
 
         # Get a new Async handle
         # 
         # @return [::Libuv::Async]
-        def async(callback = nil, &block)
-            callback ||= block
+        def async
             handle = Async.new(@reactor)
-            handle.progress callback if callback
+            handle.progress &Proc.new if block_given?
             handle
         end
 
         # Get a new signal handler
         # 
         # @return [::Libuv::Signal]
-        def signal(signum = nil, callback = nil, &block)
-            callback ||= block
+        def signal(signum = nil)
             handle = Signal.new(@reactor)
-            handle.progress callback if callback
+            handle.progress &Proc.new if block_given?
             handle.start(signum) if signum
             handle
         end
 
         # Allows user defined behaviour when sig int is received
-        def on_program_interrupt(callback = nil, &block)
-            @on_signal << (callback || block)
+        def on_program_interrupt(&callback)
+            @on_signal << callback
             self
         end
 
@@ -417,10 +425,9 @@ module Libuv
         # @param callback [Proc] the callback to be called in the thread pool
         # @return [::Libuv::Work]
         # @raise [ArgumentError] if block is not given
-        def work(callback = nil, &block)
-            callback ||= block
+        def work(&callback)
             assert_block(callback)
-            Work.new(@reactor, callback)    # Work is a promise object
+            Work.new(@reactor, &callback)
         end
 
         # Lookup a hostname
@@ -429,13 +436,13 @@ module Libuv
         # @param port [Integer, String] the service being connected too
         # @param callback [Proc] the callback to be called on success
         # @return [::Libuv::Dns]
-        def lookup(hostname, hint = :IPv4, port = 9, wait: true, &block)
+        def lookup(hostname, hint = :IPv4, port = 9, wait: true)
             dns = Dns.new(@reactor, hostname, port, hint, wait: wait)    # Work is a promise object
-            if block_given? || !wait
-                dns.then block
-                dns
-            else
+            if wait
                 dns.results
+            else
+                dns.then &Proc.new if block_given?
+                dns
             end
         end
 

data/lib/libuv/tcp.rb

@@ -93,8 +93,8 @@ module Libuv
         end
 
         # Provide a callback once the TLS handshake has completed
-        def on_handshake(callback = nil, &blk)
-            @on_handshake = callback || blk
+        def on_handshake(&blk)
+            @on_handshake = blk
             self
         end
 
@@ -168,8 +168,8 @@ module Libuv
         end
 
         # Verify peers will be called for each cert in the chain
-        def verify_peer(callback = nil, &blk)
-            @on_verify = callback || blk
+        def verify_peer(&blk)
+            @on_verify = blk
             self
         end
 
@@ -187,7 +187,7 @@ module Libuv
 
                 if wait
                     return deferred.promise if wait == :promise
-                    co deferred.promise
+                    deferred.promise.value
                 end
 
                 self
@@ -199,7 +199,7 @@ module Libuv
         alias_method :do_shutdown, :shutdown
         def shutdown
             if @pending_writes && @pending_writes.length > 0
-                @pending_writes[-1][0].finally method(:do_shutdown)
+                @pending_writes[-1][0].finally { do_shutdown }
             else
                 do_shutdown
             end
@@ -228,11 +228,11 @@ module Libuv
         # --------------------------------------
         #
 
-        def bind(ip, port, callback = nil, **tls_options, &blk)
+        def bind(ip, port, **tls_options, &blk)
             return self if @closed
 
-            @on_accept = callback || blk
-            @on_listen = method(:accept)
+            @on_accept = blk
+            @on_listen = proc { accept }
 
             assert_type(String, ip, IP_ARGUMENT_ERROR)
             assert_type(Integer, port, PORT_ARGUMENT_ERROR)
@@ -249,27 +249,27 @@ module Libuv
             self
         end
 
-        def open(fd, binding = true, callback = nil, &blk)
+        def open(fd, binding = true)
             return self if @closed
 
             if binding
-                @on_listen = method(:accept)
-                @on_accept = callback || blk
+                @on_listen = proc { accept }
+                @on_accept = Proc.new
+            elsif block_given?
+                @callback = Proc.new
             else
-                @callback = callback || blk
-                @coroutine = @reactor.defer if @callback.nil?
+                @coroutine = @reactor.defer
             end
             error = check_result ::Libuv::Ext.tcp_open(handle, fd)
             reject(error) if error
-            co @coroutine.promise if @coroutine
+            @coroutine.promise.value if @coroutine
 
             self
         end
 
-        def connect(ip, port, callback = nil, &blk)
+        def connect(ip, port)
             return self if @closed
 
-            @callback = callback || blk
             assert_type(String, ip, IP_ARGUMENT_ERROR)
             assert_type(Integer, port, PORT_ARGUMENT_ERROR)
             
@@ -280,9 +280,11 @@ module Libuv
                 reject(e)
             end
 
-            if @callback.nil?
+            if block_given?
+                @callback = Proc.new
+            else
                 @coroutine = @reactor.defer
-                co @coroutine.promise
+                @coroutine.promise.value
             end
 
             self
@@ -380,7 +382,7 @@ module Libuv
             end
         end
 
-        def accept(_)
+        def accept
             begin
                 raise RuntimeError, CLOSED_HANDLE_ERROR if @closed
                 tcp = TCP.new(reactor, handle, **@tls_options)

data/lib/libuv/timer.rb

@@ -9,9 +9,8 @@ module Libuv
 
         # @param reactor [::Libuv::Reactor] reactor this timer will be associated
         # @param callback [Proc] callback to be called when the timer is triggered
-        def initialize(reactor, callback = nil, &blk)
+        def initialize(reactor)
             @reactor = reactor
-            @callback = callback || blk
             
             timer_ptr = ::Libuv::Ext.allocate_handle_timer
             error = check_result(::Libuv::Ext.timer_init(reactor.handle, timer_ptr))
@@ -86,9 +85,8 @@ module Libuv
         # Used to update the callback to be triggered by the timer
         #
         # @param callback [Proc] the callback to be called by the timer
-        def progress(callback = nil, &blk)
-            @callback = callback || blk
-
+        def progress(&callback)
+            @callback = callback
             self
         end
 

data/lib/libuv/udp.rb

@@ -167,7 +167,7 @@ module Libuv
 
             if wait
                 return deferred.promise if wait == :promise
-                co deferred.promise
+                deferred.promise.value
             end
 
             self
@@ -217,8 +217,8 @@ module Libuv
             self
         end
 
-        def progress(callback = nil, &blk)
-            @progress = callback || blk
+        def progress(&callback)
+            @progress = callback
             self
         end
 

data/lib/libuv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Libuv
-    VERSION = '3.3.0'
+    VERSION = '4.0.0'
 end

data/lib/libuv/work.rb

@@ -15,7 +15,7 @@ module Libuv
 
         # @param thread [::Libuv::Reactor] thread this work request will be associated
         # @param work [Proc] callback to be called in the thread pool
-        def initialize(thread, work)
+        def initialize(thread, &work)
             super(thread, thread.defer)
 
             @work = work

data/spec/async_spec.rb

@@ -54,9 +54,9 @@ describe Libuv::Async do
 				callback.close
 			end
 
-			@reactor.work(proc {
+			@reactor.work {
 				callback.call
-			}).catch do |err|
+			}.catch do |err|
 				@general_failure << err
 			end
 		}

data/spec/coroutines_spec.rb

@@ -31,10 +31,10 @@ if RUBY_PLATFORM != 'java'
 			it "should wait for work to complete and return the result" do
 				@reactor.run { |reactor|
 
-					@log << co(@reactor.work(proc {
+					@log << @reactor.work {
 						sleep 1
 						'work done'
-					}))
+					}.value
 					@log << 'after work'
 
 					@timeout.close
@@ -47,9 +47,9 @@ if RUBY_PLATFORM != 'java'
 			it "should raise an error if the promise is rejected" do
 				@reactor.run { |reactor|
 					begin
-						@log << co(@reactor.work(proc {
+						@log << @reactor.work {
 							raise 'rejected'
-						}))
+						}.value
 						@log << 'after work'
 					rescue => e
 						@log << e.message
@@ -64,18 +64,18 @@ if RUBY_PLATFORM != 'java'
 
 			it "should return the results of multiple promises" do
 				@reactor.run { |reactor|
-					job1 = @reactor.work(proc {
+					job1 = @reactor.work {
 						sleep 1
 						'job1'
-					})
+					}
 
-					job2 = @reactor.work(proc {
+					job2 = @reactor.work {
 						sleep 1
 						'job2'
-					})
+					}
 
 					# Job1 and Job2 are executed in parallel
-					result1, result2 = co(job1, job2)
+					result1, result2 = ::Libuv.co(job1, job2)
 
 					@log << result1
 					@log << result2
@@ -88,12 +88,11 @@ if RUBY_PLATFORM != 'java'
 				expect(@log).to eq(['job1', 'job2', 'after work'])
 			end
 
-
 			it "should provide a callback option for progress events" do
 				@reactor.run { |reactor|
 					timer = @reactor.timer
 					timer.start(0)
-					co(timer) do
+					::Libuv.co(timer) do
 						@log << 'in timer'
 						timer.close  # close will resolve the promise
 					end

data/spec/defer_spec.rb

@@ -312,9 +312,9 @@ describe Libuv::Q do
 			
 			it "should allow registration of an errback without a success callback and reject" do
 				@reactor.run {
-					@promise.catch(proc {|reason|
+					@promise.catch { |reason|
 						@log << reason
-					})
+					}
 
 					@deferred.reject(:foo)
 				}
@@ -325,9 +325,9 @@ describe Libuv::Q do
 			
 			it "should allow registration of an errback without a success callback and resolve" do
 				@reactor.run {
-					@promise.catch(proc {|reason|
+					@promise.catch { |reason|
 						@log << reason
-					})
+					}
 
 					@deferred.resolve(:foo)
 				}
@@ -447,22 +447,22 @@ describe Libuv::Q do
 					end
 
 
-					@promise.progress(proc { |result|
+					@promise.progress { |result|
 						@log << result
 						:bar
-					}).progress(proc { |result|
+					}.progress { |result|
 						@log << result
 						result
-					}).progress(proc {|result|
+					}.progress { |result|
 						@log << result
 						result
-					}).progress(proc {|result|
+					}.progress { |result|
 						@log << result
 						:done
-					}).progress(proc { |result|
+					}.progress { |result|
 						@log << result
 						result
-					})
+					}
 
 					
 					@deferred.notify(:foo)
@@ -479,23 +479,23 @@ describe Libuv::Q do
 					end
 
 
-					@promise.progress(proc { |result|
+					@promise.progress { |result|
 						@log << result
 						:bar
-					}).progress(proc { |result|
+					}.progress { |result|
 						@log << result
 						raise 'err'
 						result
-					}).progress(proc {|result|
+					}.progress {|result|
 						@log << result
 						result
-					}).progress(proc {|result|
+					}.progress {|result|
 						@log << result
 						:done
-					}).progress(proc { |result|
+					}.progress { |result|
 						@log << result
 						result
-					})
+					}
 
 					
 					@deferred.notify(:foo)
@@ -509,9 +509,9 @@ describe Libuv::Q do
 				@reactor.run {
 					@deferred.reject(:foo)
 					
-					@promise.catch(proc {|reason|
+					@promise.catch { |reason|
 						@log << reason
-					})
+					}
 					
 					@reactor.next_tick do
 						@reactor.stop
@@ -543,10 +543,10 @@ describe Libuv::Q do
 
 				it "should fulfill with the original value" do
 					@reactor.run {
-						@promise.finally(proc {
+						@promise.finally {
 							@log << :finally
 							:finally
-						}).then do |result|
+						}.then do |result|
 							@log << result
 						end
 						
@@ -559,25 +559,25 @@ describe Libuv::Q do
 
 				it "should fulfill with the original value (larger test)" do
 					@reactor.run {
-						@promise.then(proc { |result|
+						@promise.then { |result|
 							@log << result
 							result
-						}).finally(proc {
+						}.finally {
 							@log << :finally
 							:finally
-						}).then(proc { |result|
+						}.then { |result|
 							@log << result
 							:change
-						}).then(proc { |result|
+						}.then { |result|
 							@log << result
 							result
-						}).finally(proc {
+						}.finally {
 							@log << :finally
 							:finally
-						}).then(proc { |result|
+						}.then { |result|
 							@log << result
 							result
-						})
+						}
 						
 
 						@deferred.resolve(:foo)
@@ -589,10 +589,10 @@ describe Libuv::Q do
 				describe "when the callback throws an exception" do
 					it "should reject with this new exception" do
 						@reactor.run {
-							@promise.finally(proc {
+							@promise.finally {
 								@log << :finally
 								raise 'error'
-							}).catch do |reason|
+							}.catch do |reason|
 								@log.push reason.is_a?(Exception)
 							end
 							
@@ -608,10 +608,10 @@ describe Libuv::Q do
 						@reactor.run {
 							deferred2 = @reactor.defer
 
-							@promise.finally(proc {
+							@promise.finally {
 								@log << :finally
 								deferred2.promise
-							}).then do |result|
+							}.then do |result|
 								@log << result
 							end
 							
@@ -637,10 +637,10 @@ describe Libuv::Q do
 						@reactor.run {
 							deferred2 = @reactor.defer
 
-							@promise.finally(proc {
+							@promise.finally {
 								@log << :finally
 								deferred2.promise
-							}).catch do |result|
+							}.catch do |result|
 								@log << result
 							end
 							

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libuv
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Stephen von Takach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-18 00:00:00.000000000 Z
+date: 2017-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi