libuv 2.0.12 → 3.0.0

data/lib/libuv/filesystem.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     class Filesystem
         include Assertions, Resource, Listener, FsChecks
@@ -21,125 +23,125 @@ module Libuv
         define_callback function: :on_chown, **fs_params
 
 
-        def initialize(thread)
-            @loop = thread
+        def initialize(reactor)
+            @reactor = reactor
         end
 
-        def unlink(path)
+        def unlink(path, wait: true)
             assert_type(String, path, "path must be a String")
-            @unlink_deferred = @loop.defer
+            @unlink_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @unlink_deferred, request, ::Libuv::Ext.fs_unlink(@loop, request, path, callback(:on_unlink, request.address))
-            @unlink_deferred.promise
+            pre_check @unlink_deferred, request, ::Libuv::Ext.fs_unlink(@reactor, request, path, callback(:on_unlink, request.address))
+            respond wait, @unlink_deferred.promise
         end
 
-        def mkdir(path, mode = 0777)
+        def mkdir(path, mode = 0777, wait: true)
             assert_type(String, path, "path must be a String")
             assert_type(Integer, mode, "mode must be an Integer")
-            @mkdir_deferred = @loop.defer
+            @mkdir_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @mkdir_deferred, request, ::Libuv::Ext.fs_mkdir(@loop, request, path, mode, callback(:on_mkdir, request.address))
-            @mkdir_deferred.promise
+            pre_check @mkdir_deferred, request, ::Libuv::Ext.fs_mkdir(@reactor, request, path, mode, callback(:on_mkdir, request.address))
+            respond wait, @mkdir_deferred.promise
         end
 
-        def rmdir(path)
+        def rmdir(path, wait: true)
             assert_type(String, path, "path must be a String")
-            @rmdir_deferred = @loop.defer
+            @rmdir_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @rmdir_deferred, request, ::Libuv::Ext.fs_rmdir(@loop, request, path, callback(:on_rmdir, request.address))
-            @rmdir_deferred.promise
+            pre_check @rmdir_deferred, request, ::Libuv::Ext.fs_rmdir(@reactor, request, path, callback(:on_rmdir, request.address))
+            respond wait, @rmdir_deferred.promise
         end
 
-        def readdir(path)
+        def readdir(path, wait: true)
             assert_type(String, path, "path must be a String")
-            @readdir_deferred = @loop.defer
+            @readdir_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @readdir_deferred, request, ::Libuv::Ext.fs_readdir(@loop, request, path, 0, callback(:on_readdir, request.address))
-            @readdir_deferred.promise
+            pre_check @readdir_deferred, request, ::Libuv::Ext.fs_readdir(@reactor, request, path, 0, callback(:on_readdir, request.address))
+            respond wait, @readdir_deferred.promise
         end
 
-        def rename(old_path, new_path)
+        def rename(old_path, new_path, wait: true)
             assert_type(String, old_path, "old_path must be a String")
             assert_type(String, new_path, "new_path must be a String")
-            @rename_deferred = @loop.defer
+            @rename_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @rename_deferred, request, ::Libuv::Ext.fs_rename(@loop, request, old_path, new_path, callback(:on_rename, request.address))
-            @rename_deferred.promise
+            pre_check @rename_deferred, request, ::Libuv::Ext.fs_rename(@reactor, request, old_path, new_path, callback(:on_rename, request.address))
+            respond wait, @rename_deferred.promise
         end
 
-        def chmod(path, mode)
+        def chmod(path, mode, wait: true)
             assert_type(String, path, "path must be a String")
             assert_type(Integer, mode, "mode must be an Integer")
-            @chmod_deferred = @loop.defer
+            @chmod_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @chmod_deferred, request, ::Libuv::Ext.fs_chmod(@loop, request, path, mode, callback(:on_chmod, request.address))
-            @chmod_deferred.promise
+            pre_check @chmod_deferred, request, ::Libuv::Ext.fs_chmod(@reactor, request, path, mode, callback(:on_chmod, request.address))
+            respond wait, @chmod_deferred.promise
         end
 
-        def utime(path, atime, mtime)
+        def utime(path, atime, mtime, wait: true)
             assert_type(String, path, "path must be a String")
             assert_type(Integer, atime, "atime must be an Integer")
             assert_type(Integer, mtime, "mtime must be an Integer")
-            @utime_deferred = @loop.defer
+            @utime_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @utime_deferred, request, ::Libuv::Ext.fs_utime(@loop, request, path, atime, mtime, callback(:on_utime, request.address))
-            @utime_deferred.promise
+            pre_check @utime_deferred, request, ::Libuv::Ext.fs_utime(@reactor, request, path, atime, mtime, callback(:on_utime, request.address))
+            respond wait, @utime_deferred.promise
         end
 
-        def lstat(path)
+        def lstat(path, wait: true)
             assert_type(String, path, "path must be a String")
-            @stat_deferred = @loop.defer
+            @stat_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @stat_deferred, request, ::Libuv::Ext.fs_lstat(@loop, request, path, callback(:on_stat, request.address))
-            @stat_deferred.promise
+            pre_check @stat_deferred, request, ::Libuv::Ext.fs_lstat(@reactor, request, path, callback(:on_stat, request.address))
+            respond wait, @stat_deferred.promise
         end
 
-        def link(old_path, new_path)
+        def link(old_path, new_path, wait: true)
             assert_type(String, old_path, "old_path must be a String")
             assert_type(String, new_path, "new_path must be a String")
-            @link_deferred = @loop.defer
+            @link_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @link_deferred, request, ::Libuv::Ext.fs_link(@loop, request, old_path, new_path, callback(:on_link, request.address))
-            @link_deferred.promise
+            pre_check @link_deferred, request, ::Libuv::Ext.fs_link(@reactor, request, old_path, new_path, callback(:on_link, request.address))
+            respond wait, @link_deferred.promise
         end
 
-        def symlink(old_path, new_path)
+        def symlink(old_path, new_path, wait: true)
             assert_type(String, old_path, "old_path must be a String")
             assert_type(String, new_path, "new_path must be a String")
-            @symlink_deferred = @loop.defer
+            @symlink_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @symlink_deferred, request, ::Libuv::Ext.fs_symlink(@loop, request, old_path, new_path, 0, callback(:on_symlink, request.address))
-            @symlink_deferred.promise
+            pre_check @symlink_deferred, request, ::Libuv::Ext.fs_symlink(@reactor, request, old_path, new_path, 0, callback(:on_symlink, request.address))
+            respond wait, @symlink_deferred.promise
         end
 
-        def readlink(path)
+        def readlink(path, wait: true)
             assert_type(String, path, "path must be a String")
-            @readlink_deferred = @loop.defer
+            @readlink_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @readlink_deferred, request, ::Libuv::Ext.fs_readlink(@loop, request, path, callback(:on_readlink, request.address))
-            @readlink_deferred.promise
+            pre_check @readlink_deferred, request, ::Libuv::Ext.fs_readlink(@reactor, request, path, callback(:on_readlink, request.address))
+            respond wait, @readlink_deferred.promise
         end
 
-        def chown(path, uid, gid)
+        def chown(path, uid, gid, wait: true)
             assert_type(String, path, "path must be a String")
             assert_type(Integer, uid, "uid must be an Integer")
             assert_type(Integer, gid, "gid must be an Integer")
-            @chown_deferred = @loop.defer
+            @chown_deferred = @reactor.defer
 
             request = ::Libuv::Ext.allocate_request_fs
-            pre_check @chown_deferred, request, ::Libuv::Ext.fs_chown(@loop, request, path, uid, gid, callback(:on_chown, request.address))
-            @chown_deferred.promise
+            pre_check @chown_deferred, request, ::Libuv::Ext.fs_chown(@reactor, request, path, uid, gid, callback(:on_chown, request.address))
+            respond wait, @chown_deferred.promise
         end
 
 
@@ -150,7 +152,7 @@ module Libuv
             if post_check(req, @unlink_deferred)
                 path = req[:path]
                 cleanup(req)
-                @unlink_deferred.resolve(path)
+                ::Fiber.new { @unlink_deferred.resolve(path) }.resume
             end
             @unlink_deferred = nil
         end
@@ -159,7 +161,7 @@ module Libuv
             if post_check(req, @mkdir_deferred)
                 path = req[:path]
                 cleanup(req)
-                @mkdir_deferred.resolve(path)
+                ::Fiber.new { @mkdir_deferred.resolve(path) }.resume
             end
             @mkdir_deferred = nil
         end
@@ -168,7 +170,7 @@ module Libuv
             if post_check(req, @rmdir_deferred)
                 path = req[:path]
                 cleanup(req)
-                @rmdir_deferred.resolve(path)
+                ::Fiber.new { @rmdir_deferred.resolve(path) }.resume
             end
             @rmdir_deferred = nil
         end
@@ -189,7 +191,7 @@ module Libuv
                 end
 
                 cleanup(req)
-                @readdir_deferred.resolve(files)
+                ::Fiber.new { @readdir_deferred.resolve(files) }.resume
             end
             @readdir_deferred = nil
         end
@@ -198,7 +200,7 @@ module Libuv
             if post_check(req, @rename_deferred)
                 path = req[:path]
                 cleanup(req)
-                @rename_deferred.resolve(path)
+                ::Fiber.new { @rename_deferred.resolve(path) }.resume
             end
             @rename_deferred = nil
         end
@@ -207,7 +209,7 @@ module Libuv
             if post_check(req, @chmod_deferred)
                 path = req[:path]
                 cleanup(req)
-                @chmod_deferred.resolve(path)
+                ::Fiber.new { @chmod_deferred.resolve(path) }.resume
             end
             @chmod_deferred = nil
         end
@@ -216,7 +218,7 @@ module Libuv
             if post_check(req, @utime_deferred)
                 path = req[:path]
                 cleanup(req)
-                @utime_deferred.resolve(path)
+                ::Fiber.new { @utime_deferred.resolve(path) }.resume
             end
             @utime_deferred = nil
         end
@@ -225,7 +227,7 @@ module Libuv
             if post_check(req, @link_deferred)
                 path = req[:path]
                 cleanup(req)
-                @link_deferred.resolve(path)
+                ::Fiber.new { @link_deferred.resolve(path) }.resume
             end
             @link_deferred = nil
         end
@@ -234,7 +236,7 @@ module Libuv
             if post_check(req, @symlink_deferred)
                 path = req[:path]
                 cleanup(req)
-                @symlink_deferred.resolve(path)
+                ::Fiber.new { @symlink_deferred.resolve(path) }.resume
             end
             @symlink_deferred = nil
         end
@@ -244,7 +246,7 @@ module Libuv
                 string_ptr = req[:ptr]
                 path = string_ptr.null? ? nil : string_ptr.read_string_to_null
                 cleanup(req)
-                @readlink_deferred.resolve(path)
+                ::Fiber.new { @readlink_deferred.resolve(path) }.resume
             end
             @readlink_deferred = nil
         end
@@ -253,7 +255,7 @@ module Libuv
             if post_check(req, @chown_deferred)
                 path = req[:path]
                 cleanup(req)
-                @chown_deferred.resolve(path)
+                ::Fiber.new { @chown_deferred.resolve(path) }.resume
             end
             @chown_deferred = nil
         end

data/lib/libuv/fs_event.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     class FSEvent < Handle
 
@@ -8,11 +10,11 @@ module Libuv
         EVENTS = {1 => :rename, 2 => :change}.freeze
 
 
-        def initialize(thread, path)
-            @loop = thread
+        def initialize(reactor, path)
+            @reactor = reactor
 
             fs_event_ptr = ::Libuv::Ext.allocate_handle_fs_event
-            error = check_result ::Libuv::Ext.fs_event_init(thread.handle, fs_event_ptr, path, callback(:on_fs_event, fs_event_ptr.address), 0)
+            error = check_result ::Libuv::Ext.fs_event_init(reactor.handle, fs_event_ptr, path, callback(:on_fs_event, fs_event_ptr.address), 0)
 
             super(fs_event_ptr, error)
         end
@@ -27,7 +29,8 @@ module Libuv
             if e
                 reject(e)
             else
-                defer.notify(filename, EVENTS[events])   # notify of a change
+                # notify of a change
+                ::Fiber.new { defer.notify(filename, EVENTS[events]) }.resume
             end
         end
     end

data/lib/libuv/handle.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     class Handle < Q::DeferredPromise
         include Assertions, Resource, Listener
@@ -5,7 +7,7 @@ module Libuv
 
         attr_accessor :storage  # A place for general storage
         attr_reader :closed
-        attr_reader :loop
+        attr_reader :reactor
 
 
         define_callback function: :on_close
@@ -16,7 +18,7 @@ module Libuv
             @instance_id = @pointer.address
 
             # Initialise the promise
-            super(loop, loop.defer)
+            super(reactor, reactor.defer)
 
             # clean up on init error (always raise here)
             if error
@@ -27,28 +29,35 @@ module Libuv
             end
         end
 
-        # Public: Increment internal ref counter for the handle on the loop. Useful for
-        # extending the loop with custom watchers that need to make loop not stop
+        # Public: Increment internal ref counter for the handle on the reactor. Useful for
+        # extending the reactor with custom watchers that need to make reactor not stop
         # 
         # Returns self
         def ref
-            return if @closed
+            return self if @closed
             ::Libuv::Ext.ref(handle)
+            self
         end
 
-        # Public: Decrement internal ref counter for the handle on the loop, useful to stop
-        # loop even when there are outstanding open handles
+        # Public: Decrement internal ref counter for the handle on the reactor, useful to stop
+        # reactor even when there are outstanding open handles
         # 
         # Returns self
         def unref
-            return if @closed
+            return self if @closed
             ::Libuv::Ext.unref(handle)
+            self
         end
 
         def close
-            return if @closed
+            return self if @closed
             @closed = true
             ::Libuv::Ext.close(handle, callback(:on_close))
+            self
+        end
+
+        def closed?
+            !!@closed
         end
 
         def active?
@@ -82,11 +91,18 @@ module Libuv
             #clear_callbacks
             cleanup_callbacks
 
-            if @close_error
-                defer.reject(@close_error)
-            else
-                defer.resolve(nil)
-            end
+            ::Fiber.new {
+                if @close_error
+                    defer.reject(@close_error)
+                else
+                    defer.resolve(nil)
+                end
+
+                if @coroutine
+                    @coroutine.resolve(self)
+                    @coroutine = nil
+                end
+            }.resume
         end
     end
 end

data/lib/libuv/idle.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Libuv
     class Idle < Handle
 
@@ -5,14 +7,14 @@ module Libuv
         define_callback function: :on_idle
 
 
-        # @param thread [::Libuv::Loop] loop this idle handler will be associated
-        # @param callback [Proc] callback to be called when the loop is idle
-        def initialize(thread, callback = nil, &blk)
-            @loop = thread
+        # @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)
+            @reactor = reactor
             @callback = callback || blk
 
             idle_ptr = ::Libuv::Ext.allocate_handle_idle
-            error = check_result(::Libuv::Ext.idle_init(thread.handle, idle_ptr))
+            error = check_result(::Libuv::Ext.idle_init(reactor.handle, idle_ptr))
 
             super(idle_ptr, error)
         end
@@ -22,6 +24,7 @@ module Libuv
             return if @closed
             error = check_result ::Libuv::Ext.idle_start(handle, callback(:on_idle))
             reject(error) if error
+            self
         end
 
         # Disables the idle handler.
@@ -29,6 +32,7 @@ module Libuv
             return if @closed
             error = check_result ::Libuv::Ext.idle_stop(handle)
             reject(error) if error
+            self
         end
 
         # Used to update the callback that will be triggered on idle
@@ -36,6 +40,7 @@ module Libuv
         # @param callback [Proc] the callback to be called on idle trigger
         def progress(callback = nil, &blk)
             @callback = callback || blk
+            self
         end
 
 
@@ -43,11 +48,13 @@ module Libuv
 
 
         def on_idle(handle)
-            begin
-                @callback.call
-            rescue Exception => e
-                @loop.log :error, :idle_cb, e
-            end
+            ::Fiber.new {
+                begin
+                    @callback.call
+                rescue Exception => e
+                    @reactor.log e, 'performing idle callback'
+                end
+            }.resume
         end
     end
 end