libuv 0.10.0 → 0.10.2

data/lib/libuv/{assertions.rb → mixins/assertions.rb}

@@ -1,23 +1,23 @@
-module Libuv
-    module Assertions
-        MSG_NO_PROC = 'no block given'
-
-        def assert_block(proc, msg = MSG_NO_PROC)
-            raise ArgumentError, msg, caller if proc.nil?
-        end
-
-        def assert_type(type, actual, msg = nil)
-            if not actual.kind_of?(type)
-                msg ||= "value #{actual.inspect} is not a valid #{type}"
-                raise ArgumentError, msg, caller
-            end
-        end
-
-        def assert_boolean(actual, msg = nil)
-            if not (actual.kind_of?(TrueClass) || actual.kind_of?(FalseClass))
-                msg ||= "value #{actual.inspect} is not a valid Boolean"
-                raise ArgumentError, msg, caller
-            end
-        end
-    end
-end
+module Libuv
+    module Assertions
+        MSG_NO_PROC = 'no block given'
+
+        def assert_block(proc, msg = MSG_NO_PROC)
+            raise ArgumentError, msg, caller if proc.nil?
+        end
+
+        def assert_type(type, actual, msg = nil)
+            if not actual.kind_of?(type)
+                msg ||= "value #{actual.inspect} is not a valid #{type}"
+                raise ArgumentError, msg, caller
+            end
+        end
+
+        def assert_boolean(actual, msg = nil)
+            if not (actual.kind_of?(TrueClass) || actual.kind_of?(FalseClass))
+                msg ||= "value #{actual.inspect} is not a valid Boolean"
+                raise ArgumentError, msg, caller
+            end
+        end
+    end
+end

data/lib/libuv/mixins/fs_checks.rb

@@ -0,0 +1,55 @@
+
+module Libuv
+    module FsChecks
+
+
+        def stat
+            @stat_deferred = @loop.defer
+
+            request = ::Libuv::Ext.create_request(:uv_fs)
+            pre_check @stat_deferred, request, ::Libuv::Ext.fs_fstat(@loop.handle, request, @fileno, callback(:on_stat))
+            @stat_deferred.promise
+        end
+
+
+        private
+
+
+        def on_stat(req)
+            if post_check(req, @stat_deferred)
+                uv_stat = req[:stat]
+                uv_members = uv_stat.members
+                values = UvStat.members.map { |k| uv_members.include?(k) ? uv_stat[k] : nil }
+                uv_stat = UvStat.new(*values)
+
+                cleanup(req)
+                @stat_deferred.resolve(uv_stat)
+            end
+            @stat_deferred = nil
+        end
+
+        def pre_check(deferrable, request, result)
+            error = check_result result
+            if error
+                ::Libuv::Ext.free(request)
+                deferrable.reject(error)
+            end
+        end
+
+        def cleanup(req)
+            ::Libuv::Ext.fs_req_cleanup(req)
+            ::Libuv::Ext.free(req)
+        end
+
+        def post_check(req, deferrable)
+            error = check_result(req[:result])
+            if error
+                cleanup(req)
+                deferrable.reject(error)
+                false
+            else
+                true
+            end
+        end
+    end
+end

data/lib/libuv/{listener.rb → mixins/listener.rb}

@@ -1,34 +1,34 @@
-require 'thread_safe'
-require 'set'
-
-module Libuv
-    module Listener
-
-
-        private
-
-
-        CALLBACKS = ThreadSafe::Cache.new
-
-
-        def callbacks
-            @callbacks ||= Set.new
-        end
-
-        def callback(name)
-            const_name = "#{name}_#{object_id}".to_sym
-            unless CALLBACKS[const_name]
-                callbacks << const_name
-                CALLBACKS[const_name] = method(name)
-            end
-            CALLBACKS[const_name]
-        end
-
-        def clear_callbacks
-            callbacks.each do |name|
-                CALLBACKS.delete(name)
-            end
-            callbacks.clear
-        end
-    end
-end
+require 'thread_safe'
+require 'set'
+
+module Libuv
+    module Listener
+
+
+        private
+
+
+        CALLBACKS = ThreadSafe::Cache.new
+
+
+        def callbacks
+            @callbacks ||= Set.new
+        end
+
+        def callback(name)
+            const_name = "#{name}_#{object_id}".to_sym
+            unless CALLBACKS[const_name]
+                callbacks << const_name
+                CALLBACKS[const_name] = method(name)
+            end
+            CALLBACKS[const_name]
+        end
+
+        def clear_callbacks
+            callbacks.each do |name|
+                CALLBACKS.delete(name)
+            end
+            callbacks.clear
+        end
+    end
+end

data/lib/libuv/{net.rb → mixins/net.rb}

@@ -1,38 +1,38 @@
-require 'socket'
-
-module Libuv
-    module Net
-
-
-        IP_ARGUMENT_ERROR = "ip must be a String".freeze                # Arguments specifying an IP address
-        PORT_ARGUMENT_ERROR = "port must be an Integer".freeze          # Arguments specifying an IP port
-
-
-        private
-
-
-        def get_sockaddr_and_len
-            sockaddr = FFI::MemoryPointer.new(UV::Sockaddr)
-            len = FFI::MemoryPointer.new(:int)
-            len.put_int(0, UV::Sockaddr.size)
-            [sockaddr, len]
-        end
-
-        def get_ip_and_port(sockaddr, len=nil)
-            if sockaddr[:sa_family] == Socket::Constants::AF_INET6
-                len ||= Socket::Constants::INET6_ADDRSTRLEN
-                sockaddr_in6 = UV::SockaddrIn6.new(sockaddr.pointer)
-                ip_ptr = FFI::MemoryPointer.new(:char, len)
-                ::Libuv::Ext.ip6_name(sockaddr_in6, ip_ptr, len)
-                port = ::Libuv::Ext.ntohs(sockaddr_in6[:sin6_port])
-            else
-                len ||= Socket::Constants::INET_ADDRSTRLEN
-                sockaddr_in = UV::SockaddrIn.new(sockaddr.pointer)
-                ip_ptr = FFI::MemoryPointer.new(:char, len)
-                ::Libuv::Ext.ip4_name(sockaddr_in, ip_ptr, len)
-                port = ::Libuv::Ext.ntohs(sockaddr_in[:sin_port])
-            end
-            [ip_ptr.read_string, port]
-        end
-    end
+require 'socket'
+
+module Libuv
+    module Net
+
+
+        IP_ARGUMENT_ERROR = "ip must be a String".freeze                # Arguments specifying an IP address
+        PORT_ARGUMENT_ERROR = "port must be an Integer".freeze          # Arguments specifying an IP port
+
+
+        private
+
+
+        def get_sockaddr_and_len
+            sockaddr = FFI::MemoryPointer.new(UV::Sockaddr)
+            len = FFI::MemoryPointer.new(:int)
+            len.put_int(0, UV::Sockaddr.size)
+            [sockaddr, len]
+        end
+
+        def get_ip_and_port(sockaddr, len=nil)
+            if sockaddr[:sa_family] == Socket::Constants::AF_INET6
+                len ||= Socket::Constants::INET6_ADDRSTRLEN
+                sockaddr_in6 = UV::SockaddrIn6.new(sockaddr.pointer)
+                ip_ptr = FFI::MemoryPointer.new(:char, len)
+                ::Libuv::Ext.ip6_name(sockaddr_in6, ip_ptr, len)
+                port = ::Libuv::Ext.ntohs(sockaddr_in6[:sin6_port])
+            else
+                len ||= Socket::Constants::INET_ADDRSTRLEN
+                sockaddr_in = UV::SockaddrIn.new(sockaddr.pointer)
+                ip_ptr = FFI::MemoryPointer.new(:char, len)
+                ::Libuv::Ext.ip4_name(sockaddr_in, ip_ptr, len)
+                port = ::Libuv::Ext.ntohs(sockaddr_in[:sin_port])
+            end
+            [ip_ptr.read_string, port]
+        end
+    end
 end

data/lib/libuv/{resource.rb → mixins/resource.rb}

@@ -1,28 +1,28 @@
-module Libuv
-    module Resource
-
-
-        def resolve(deferred, rc)
-            if rc.nil? || rc >= 0
-                deferred.resolve(nil)
-            else
-                deferred.reject(@loop.lookup_error(rc))
-            end
-        end
-
-        def check_result!(rc)
-            e = @loop.lookup_error(rc) unless rc.nil? || rc >= 0
-            raise e if e
-        end
-
-        def check_result(rc)
-            @loop.lookup_error(rc) unless rc.nil? || rc >= 0
-        end
-
-        def to_ptr
-            @pointer
-        end
-
-
-    end
+module Libuv
+    module Resource
+
+
+        def resolve(deferred, rc)
+            if rc.nil? || rc >= 0
+                deferred.resolve(nil)
+            else
+                deferred.reject(@loop.lookup_error(rc))
+            end
+        end
+
+        def check_result!(rc)
+            e = @loop.lookup_error(rc) unless rc.nil? || rc >= 0
+            raise e if e
+        end
+
+        def check_result(rc)
+            @loop.lookup_error(rc) unless rc.nil? || rc >= 0
+        end
+
+        def to_ptr
+            @pointer
+        end
+
+
+    end
 end

data/lib/libuv/{stream.rb → mixins/stream.rb}

@@ -1,124 +1,144 @@
-module Libuv
-    module Stream
-
-
-        BACKLOG_ERROR = "backlog must be an Integer".freeze
-        WRITE_ERROR = "data must be a String".freeze
-
-
-        def listen(backlog)
-            return if @closed
-            assert_type(Integer, backlog, BACKLOG_ERROR)
-            error = check_result ::Libuv::Ext.listen(handle, Integer(backlog), callback(:on_listen))
-            reject(error) if error
-        end
-
-        # Starts reading from the handle
-        def start_read
-            error = check_result ::Libuv::Ext.read_start(handle, callback(:on_allocate), callback(:on_read))
-            reject(error) if error
-        end
-
-        # Stops reading from the handle
-        def stop_read
-            error = check_result ::Libuv::Ext.read_stop(handle)
-            reject(error) if error
-        end
-
-        # Shutsdown the writes on the handle waiting until the last write is complete before triggering the callback
-        def shutdown
-            error = check_result ::Libuv::Ext.shutdown(::Libuv::Ext.create_request(:uv_shutdown), handle, callback(:on_shutdown))
-            reject(error) if error
-        end
-
-        def write(data)
-            deferred = @loop.defer
-            begin
-                assert_type(String, data, WRITE_ERROR)
-
-                size         = data.respond_to?(:bytesize) ? data.bytesize : data.size
-                buffer       = ::Libuv::Ext.buf_init(FFI::MemoryPointer.from_string(data), size)
-
-                # local as this variable will be avaliable until the handle is closed
-                @write_callbacks = @write_callbacks || []
-
-                #
-                # create the curried callback
-                #
-                callback = FFI::Function.new(:void, [:pointer, :int]) do |req, status|
-                    ::Libuv::Ext.free(req)
-                    # remove the callback from the array
-                    # assumes writes are done in order
-                    promise = @write_callbacks.shift[0]
-                    resolve promise, status
-                end
-
-
-                @write_callbacks << [deferred, callback]
-                req = ::Libuv::Ext.create_request(:uv_write)
-                error = check_result ::Libuv::Ext.write(req, handle, buffer, 1, callback)
-
-                if error
-                    @write_callbacks.pop
-                    ::Libuv::Ext.free(req)
-                    deferred.reject(error)
-
-                    reject(error)       # close the handle
-                end
-            rescue Exception => e
-                deferred.reject(e)  # this write exception may not be fatal
-            end
-            deferred.promise
-        end
-
-        def readable?
-            ::Libuv::Ext.is_readable(handle) > 0
-        end
-
-        def writable?
-            ::Libuv::Ext.is_writable(handle) > 0
-        end
-
-
-        private
-
-
-        def on_listen(server, status)
-            e = check_result(status)
-
-            if e
-                reject(e)   # is this cause for closing the handle?
-            else
-                begin
-                    @on_listen.call(self)
-                rescue Exception => e
-                    @loop.log :error, :stream_listen_cb, e
-                end
-            end
-        end
-
-        def on_allocate(client, suggested_size)
-            ::Libuv::Ext.buf_init(::Libuv::Ext.malloc(suggested_size), suggested_size)
-        end
-
-        def on_read(handle, nread, buf)
-            e = check_result(nread)
-            base = buf[:base]
-
-            if e
-                ::Libuv::Ext.free(base)
-                reject(e)
-            else
-                data = base.read_string(nread)
-                ::Libuv::Ext.free(base)
-                defer.notify(data)   # stream the data
-            end
-        end
-
-        def on_shutdown(req, status)
-            ::Libuv::Ext.free(req)
-            @close_error = check_result(status)
-            close
-        end
-    end
+module Libuv
+    module Stream
+
+
+        BACKLOG_ERROR = "backlog must be an Integer".freeze
+        WRITE_ERROR = "data must be a String".freeze
+        STREAM_CLOSED_ERROR = "unable to write to a closed stream".freeze
+        CLOSED_HANDLE_ERROR = "handle closed before accept called".freeze
+
+
+        def listen(backlog)
+            return if @closed
+            assert_type(Integer, backlog, BACKLOG_ERROR)
+            error = check_result ::Libuv::Ext.listen(handle, Integer(backlog), callback(:on_listen))
+            reject(error) if error
+        end
+
+        # Starts reading from the handle
+        def start_read
+            return if @closed
+            error = check_result ::Libuv::Ext.read_start(handle, callback(:on_allocate), callback(:on_read))
+            reject(error) if error
+        end
+
+        # Stops reading from the handle
+        def stop_read
+            return if @closed
+            error = check_result ::Libuv::Ext.read_stop(handle)
+            reject(error) if error
+        end
+
+        # Shutsdown the writes on the handle waiting until the last write is complete before triggering the callback
+        def shutdown
+            return if @closed
+            error = check_result ::Libuv::Ext.shutdown(::Libuv::Ext.create_request(:uv_shutdown), handle, callback(:on_shutdown))
+            reject(error) if error
+        end
+
+        def write(data)
+            # NOTE:: Similar to udp.rb -> write
+            deferred = @loop.defer
+            if !@closed
+                begin
+                    assert_type(String, data, WRITE_ERROR)
+
+                    size         = data.respond_to?(:bytesize) ? data.bytesize : data.size
+                    buffer       = ::Libuv::Ext.buf_init(FFI::MemoryPointer.from_string(data), size)
+
+                    # local as this variable will be avaliable until the handle is closed
+                    @write_callbacks ||= []
+
+                    #
+                    # create the curried callback
+                    #
+                    callback = FFI::Function.new(:void, [:pointer, :int]) do |req, status|
+                        ::Libuv::Ext.free(req)
+                        # remove the callback from the array
+                        # assumes writes are done in order
+                        promise = @write_callbacks.shift[0]
+                        resolve promise, status
+                    end
+
+
+                    @write_callbacks << [deferred, callback]
+                    req = ::Libuv::Ext.create_request(:uv_write)
+                    error = check_result ::Libuv::Ext.write(req, handle, buffer, 1, callback)
+
+                    if error
+                        @write_callbacks.pop
+                        ::Libuv::Ext.free(req)
+                        deferred.reject(error)
+
+                        reject(error)       # close the handle
+                    end
+                rescue Exception => e
+                    deferred.reject(e)  # this write exception may not be fatal
+                end
+            else
+                deferred.reject(RuntimeError.new(STREAM_CLOSED_ERROR))
+            end
+            deferred.promise
+        end
+
+        def readable?
+            return false if @closed
+            ::Libuv::Ext.is_readable(handle) > 0
+        end
+
+        def writable?
+            return false if @closed
+            ::Libuv::Ext.is_writable(handle) > 0
+        end
+
+        def progress(callback = nil, &blk)
+            @progress = callback || blk
+        end
+
+
+        private
+
+
+        def on_listen(server, status)
+            e = check_result(status)
+
+            if e
+                reject(e)   # is this cause for closing the handle?
+            else
+                begin
+                    @on_listen.call(self)
+                rescue Exception => e
+                    @loop.log :error, :stream_listen_cb, e
+                end
+            end
+        end
+
+        def on_allocate(client, suggested_size)
+            ::Libuv::Ext.buf_init(::Libuv::Ext.malloc(suggested_size), suggested_size)
+        end
+
+        def on_read(handle, nread, buf)
+            e = check_result(nread)
+            base = buf[:base]
+
+            if e
+                ::Libuv::Ext.free(base)
+                reject(e)
+            else
+                data = base.read_string(nread)
+                ::Libuv::Ext.free(base)
+                begin
+                    @progress.call data, self
+                rescue Exception => e
+                    @loop.log :error, :stream_progress_cb, e
+                end
+            end
+        end
+
+        def on_shutdown(req, status)
+            ::Libuv::Ext.free(req)
+            @close_error = check_result(status)
+            close
+        end
+    end
 end