uvrb 0.1.0

data/lib/uv/assertions.rb

@@ -0,0 +1,24 @@
+module UV
+  module Assertions
+    def assert_block(proc, msg = "no block given")
+      raise ArgumentError, msg, caller if proc.nil?
+    end
+
+    def assert_arity(expected, proc, msg = nil)
+      actual = proc.arity
+      arg  = expected == 1 ? "argument" : "arguments"
+      msg  ||= "block must accept #{expected} #{arg}, but accepts #{actual}"
+      raise ArgumentError, msg, caller if expected != actual
+    end
+
+    def assert_type(type, actual, msg = nil)
+      msg ||= "value #{actual.inspect} is not a valid #{type}"
+      raise ArgumentError, msg, caller unless actual.kind_of?(type)
+    end
+
+    def assert_boolean(actual, msg = nil)
+      msg ||= "value #{actual.inspect} is not a valid Boolean"
+      raise ArgumentError, msg, caller unless actual.kind_of?(TrueClass) || actual.kind_of?(FalseClass)
+    end
+  end
+end

data/lib/uv/async.rb

@@ -0,0 +1,24 @@
+module UV
+  class Async
+    include Handle
+
+    def initialize(loop, async_ptr, &block)
+      @async_block = block
+
+      super(loop, async_ptr)
+    end
+
+    def call
+      check_result UV.async_send(handle)
+
+      self
+    end
+
+    private
+    def on_async(handle, status)
+      @async_block.call(check_result(status))
+    end
+
+    public :callback
+  end
+end

data/lib/uv/check.rb

@@ -0,0 +1,27 @@
+module UV
+  class Check
+    include Handle
+
+    def start(&block)
+      assert_block(block)
+      assert_arity(1, block)
+
+      @check_block = block
+
+      check_result! UV.check_start(handle, callback(:on_check))
+
+      self
+    end
+
+    def stop
+      check_result! UV.check_stop(handle)
+
+      self
+    end
+
+    private
+    def on_check(handle, status)
+      @check_block.call(check_result(status))
+    end
+  end
+end

data/lib/uv/error.rb

@@ -0,0 +1,58 @@
+module UV
+  class Error < StandardError
+    class UNKNOWN < Error; end
+    class OK < Error; end
+    class EOF < Error; end
+    class EADDRINFO < Error; end
+    class EACCES < Error; end
+    class EAGAIN < Error; end
+    class EADDRINUSE < Error; end
+    class EADDRNOTAVAIL < Error; end
+    class EAFNOSUPPORT < Error; end
+    class EALREADY < Error; end
+    class EBADF < Error; end
+    class EBUSY < Error; end
+    class ECONNABORTED < Error; end
+    class ECONNREFUSED < Error; end
+    class ECONNRESET < Error; end
+    class EDESTADDRREQ < Error; end
+    class EFAULT < Error; end
+    class EHOSTUNREACH < Error; end
+    class EINTR < Error; end
+    class EINVAL < Error; end
+    class EISCONN < Error; end
+    class EMFILE < Error; end
+    class EMSGSIZE < Error; end
+    class ENETDOWN < Error; end
+    class ENETUNREACH < Error; end
+    class ENFILE < Error; end
+    class ENOBUFS < Error; end
+    class ENOMEM < Error; end
+    class ENOTDIR < Error; end
+    class EISDIR < Error; end
+    class ENONET < Error; end
+    class ENOTCONN < Error; end
+    class ENOTSOCK < Error; end
+    class ENOTSUP < Error; end
+    class ENOENT < Error; end
+    class ENOSYS < Error; end
+    class EPIPE < Error; end
+    class EPROTO < Error; end
+    class EPROTONOSUPPORT < Error; end
+    class EPROTOTYPE < Error; end
+    class ETIMEDOUT < Error; end
+    class ECHARSE < Error; end
+    class EAIFAMNOSUPPORT < Error; end
+    class EAISERVICE < Error; end
+    class EAISOCKTYPE < Error; end
+    class ESHUTDOWN < Error; end
+    class EEXIST < Error; end
+    class ESRCH < Error; end
+    class ENAMETOOLONG < Error; end
+    class EPERM < Error; end
+    class ELOOP < Error; end
+    class EXDEV < Error; end
+    class ENOTEMPTY < Error; end
+    class ENOSPC < Error; end
+  end
+end

data/lib/uv/file.rb

@@ -0,0 +1,221 @@
+module UV
+  class File
+    include Assertions, Resource, Listener
+
+    def initialize(loop, fd)
+      @loop = loop
+      @fd = Integer(fd)
+    end
+
+    def close(&block)
+      assert_block(block)
+      assert_arity(1, block)
+
+      @close_block = block
+
+      check_result! UV.fs_close(loop.to_ptr, UV.create_request(:uv_fs), @fd, callback(:on_close))
+
+      self
+    end
+
+    def read(length, offset = 0, &block)
+      assert_block(block)
+      assert_arity(2, block)
+      assert_type(Integer, length, "length must be an Integer")
+      assert_type(Integer, offset, "offset must be an Integer")
+
+      @read_block         = block
+      @read_buffer_length = length
+      @read_buffer        = FFI::MemoryPointer.new(@read_buffer_length)
+
+      check_result! UV.fs_read(loop.to_ptr, UV.create_request(:uv_fs), @fd, @read_buffer, @read_buffer_length, offset, callback(:on_read))
+
+      self
+    end
+
+    def write(data, offset = 0, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(String, data, "data must be a String")
+      assert_type(Integer, offset, "offset must be an Integer")
+
+      @write_block = block
+      @write_buffer_length = data.respond_to?(:bytesize) ? data.bytesize : data.size
+      @write_buffer = FFI::MemoryPointer.from_string(data)
+
+      check_result! UV.fs_write(loop.to_ptr, UV.create_request(:uv_fs), @fd, @write_buffer, @write_buffer_length, offset, callback(:on_write))
+
+      self
+    end
+
+    def stat(&block)
+      assert_block(block)
+      assert_arity(2, block)
+
+      @stat_block = block
+
+      check_result! UV.fs_fstat(loop.to_ptr, UV.create_request(:uv_fs), @fd, callback(:on_stat))
+
+      self
+    end
+
+    def sync(&block)
+      assert_block(block)
+      assert_arity(1, block)
+
+      @sync_block = block
+
+      check_result! UV.fs_fsync(loop.to_ptr, UV.create_request(:uv_fs), @fd, callback(:on_sync))
+
+      self
+    end
+
+    def datasync(&block)
+      assert_block(block)
+      assert_arity(1, block)
+
+      @datasync_block = block
+
+      check_result! UV.fs_fdatasync(loop.to_ptr, UV.create_request(:uv_fs), @fd, callback(:on_datasync))
+
+      self
+    end
+
+    def truncate(offset, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(Integer, offset, "offset must be an Integer")
+
+      @truncate_block = block
+
+      check_result! UV.fs_ftruncate(loop.to_ptr, UV.create_request(:uv_fs), @fd, offset, callback(:on_truncate))
+
+      self
+    end
+
+    def utime(atime, mtime, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(Integer, atime, "atime must be an Integer")
+      assert_type(Integer, mtime, "mtime must be an Integer")
+
+      @utime_block = block
+
+      check_result! UV.fs_futime(loop.to_ptr, UV.create_request(:uv_fs), @fd, atime, mtime, callback(:on_utime))
+
+      self
+    end
+
+    def chmod(mode, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(Integer, mode, "mode must be an Integer")
+
+      @chmod_block = block
+
+      check_result! UV.fs_fchmod(loop.to_ptr, UV.create_request(:uv_fs), @fd, mode, callback(:on_chmod))
+
+      self
+    end
+
+    def chown(uid, gid, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(Integer, uid, "uid must be an Integer")
+      assert_type(Integer, gid, "gid must be an Integer")
+
+      @chown_block = block
+
+      check_result! UV.fs_fchown(loop.to_ptr, UV.create_request(:uv_fs), @fd, uid, gid, callback(:on_chown))
+
+      self
+    end
+
+    private
+
+    def on_close(req)
+      e = check_result(UV.fs_req_result(req))
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+      @close_block.call(e) if @close_block
+    end
+
+    def on_read(req)
+      e = check_result(UV.fs_req_result(req))
+      unless e
+        data = @read_buffer.read_string(@read_buffer_length)
+      end
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+      @read_buffer = nil
+      @read_buffer_length = nil
+      @read_block.call(e, data)
+    end
+
+    def on_write(req)
+      e = check_result(UV.fs_req_result(req))
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+      @write_buffer = nil
+      @write_buffer_length = nil
+      @write_block.call(e) if @write_block
+    end
+
+    def on_stat(req)
+      e = check_result(UV.fs_req_result(req))
+      unless e
+        uv_stat    = UV.fs_req_stat(req)
+        uv_members = uv_stat.members
+
+        values = Stat.members.map { |k| uv_members.include?(k) ? uv_stat[k] : nil }
+
+        stat = Stat.new(*values)
+      end
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+      @stat_block.call(e, stat)
+    end
+
+    def on_sync(req)
+      e = check_result(UV.fs_req_result(req))
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+      @sync_block.call(e)
+    end
+
+    def on_datasync(req)
+      e = check_result(UV.fs_req_result(req))
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+      @datasync_block.call(e)
+    end
+
+    def on_truncate(req)
+      e = check_result(UV.fs_req_result(req))
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+      @truncate_block.call(e)
+    end
+
+    def on_utime(req)
+      e = check_result(UV.fs_req_result(req))
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+      @utime_block.call(e)
+    end
+
+    def on_chmod(req)
+      e = check_result(UV.fs_req_result(req))
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+      @chmod_block.call(e)
+    end
+
+    def on_chown(req)
+      e = check_result(UV.fs_req_result(req))
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+      @chown_block.call(e)
+    end
+  end
+end

data/lib/uv/file/stat.rb

@@ -0,0 +1,35 @@
+module UV
+  class File
+    class Stat < Struct.new(:atime, :blksize, :blocks, :ctime, :dev, :ftype, :gid, :ino,
+                            :mode, :mtime, :nlink, :rdev, :size, :uid)
+      def blockdev?; end
+      def chardev?; end
+      def dev_major; end
+      def dev_minor; end
+      def directory?; end
+      def executable?; end
+      def executable_real?; end
+      def file?; end
+      def ftype; end
+      def grpowned?; end
+      def inspect; end
+      def owned?; end
+      def pipe?; end
+      def rdev_major; end
+      def rdev_minor; end
+      def readable?; end
+      def readable_real?; end
+      def setgid?; end
+      def setuid?; end
+      def size?; end
+      def socket?; end
+      def sticky?; end
+      def symlink?; end
+      def world_readable?; end
+      def world_writeable?; end
+      def writable?; end
+      def writable_real?; end
+      def zero?; end
+    end
+  end
+end

data/lib/uv/filesystem.rb

@@ -0,0 +1,335 @@
+module UV
+  class Filesystem
+    include Assertions, Resource, Listener
+
+    def initialize(loop)
+      @loop = loop
+    end
+
+    def open(path, flags = 0, mode = 0, &block)
+      assert_block(block)
+      assert_arity(2, block)
+      assert_type(String, path, "path must be a String")
+      assert_type(Integer, flags, "flags must be an Integer")
+      assert_type(Integer, mode, "mode must be an Integer")
+
+      @open_block = block
+
+      check_result! UV.fs_open(loop.to_ptr, UV.create_request(:uv_fs), path, flags, mode, callback(:on_open))
+
+      self
+    end
+
+    def unlink(path, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(String, path, "path must be a String")
+
+      @unlink_block = block
+
+      check_result! UV.fs_unlink(loop.to_ptr, UV.create_request(:uv_fs), path, callback(:on_unlink))
+
+      self
+    end
+
+    def mkdir(path, mode = 0777, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(String, path, "path must be a String")
+      assert_type(Integer, mode, "mode must be an Integer")
+
+      @mkdir_block = block
+
+      check_result! UV.fs_mkdir(loop.to_ptr, UV.create_request(:uv_fs), path, mode, callback(:on_mkdir))
+
+      self
+    end
+
+    def rmdir(path, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(String, path, "path must be a String")
+
+      @rmdir_block = block
+
+      check_result! UV.fs_rmdir(loop.to_ptr, UV.create_request(:uv_fs), path, callback(:on_rmdir))
+
+      self
+    end
+
+    def readdir(path, &block)
+      assert_block(block)
+      assert_arity(2, block)
+      assert_type(String, path, "path must be a String")
+
+      @readdir_block = block
+
+      check_result! UV.fs_readdir(loop.to_ptr, UV.create_request(:uv_fs), path, 0, callback(:on_readdir))
+
+      self
+    end
+
+    def stat(path, &block)
+      assert_block(block)
+      assert_arity(2, block)
+      assert_type(String, path, "path must be a String")
+
+      @stat_block = block
+
+      check_result! UV.fs_stat(loop.to_ptr, UV.create_request(:uv_fs), path, callback(:on_stat))
+
+      self
+    end
+
+    def rename(old_path, new_path, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(String, old_path, "old_path must be a String")
+      assert_type(String, new_path, "new_path must be a String")
+
+      @rename_block = block
+
+      check_result! UV.fs_rename(loop.to_ptr, UV.create_request(:uv_fs), old_path, new_path, callback(:on_rename))
+
+      self
+    end
+
+    def chmod(path, mode, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(String, path, "path must be a String")
+      assert_type(Integer, mode, "mode must be an Integer")
+
+      @chmod_block = block
+
+      check_result! UV.fs_chmod(loop.to_ptr, UV.create_request(:uv_fs), path, mode, callback(:on_chmod))
+
+      self
+    end
+
+    def utime(path, atime, mtime, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      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_block = block
+
+      check_result! UV.fs_utime(loop.to_ptr, UV.create_request(:uv_fs), path, atime, mtime, callback(:on_utime))
+
+      self
+    end
+
+    def lstat(path, &block)
+      assert_block(block)
+      assert_arity(2, block)
+      assert_type(String, path, "path must be a String")
+
+      @lstat_block = block
+
+      check_result! UV.fs_lstat(loop.to_ptr, UV.create_request(:uv_fs), path, callback(:on_lstat))
+
+      self
+    end
+
+    def link(old_path, new_path, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(String, old_path, "old_path must be a String")
+      assert_type(String, new_path, "new_path must be a String")
+
+      @link_block = block
+
+      check_result! UV.fs_link(loop.to_ptr, UV.create_request(:uv_fs), old_path, new_path, callback(:on_link))
+
+      self
+    end
+
+    def symlink(old_path, new_path, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(String, old_path, "old_path must be a String")
+      assert_type(String, new_path, "new_path must be a String")
+
+      @symlink_block = block
+
+      check_result! UV.fs_symlink(loop.to_ptr, UV.create_request(:uv_fs), old_path, new_path, 0, callback(:on_symlink))
+
+      self
+    end
+
+    def readlink(path, &block)
+      assert_block(block)
+      assert_arity(2, block)
+      assert_type(String, path, "path must be a String")
+
+      @readlink_block = block
+
+      check_result! UV.fs_readlink(loop.to_ptr, UV.create_request(:uv_fs), path, callback(:on_readlink))
+
+      self
+    end
+
+    def chown(path, uid, gid, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      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_block = block
+
+      check_result! UV.fs_chown(loop.to_ptr, UV.create_request(:uv_fs), path, uid, gid, callback(:on_chown))
+
+      self
+    end
+
+    private
+    def on_open(req)
+      fd   = UV.fs_req_result(req)
+      e    = check_result(fd)
+      file = File.new(loop, fd) unless e
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @open_block.call(e, file)
+    end
+
+    def on_unlink(req)
+      e = check_result(UV.fs_req_result(req))
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @unlink_block.call(e)
+    end
+
+    def on_mkdir(req)
+      e = check_result(UV.fs_req_result(req))
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @mkdir_block.call(e)
+    end
+
+    def on_rmdir(req)
+      e = check_result(UV.fs_req_result(req))
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @rmdir_block.call(e)
+    end
+
+    def on_readdir(req)
+      e = check_result(UV.fs_req_result(req))
+
+      unless e
+        string_ptr = UV.fs_req_pointer(req)
+        files = string_ptr.null? ? [] : string_ptr.read_string().split("\0")
+      end
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @readdir_block.call(e, files)
+    end
+
+    def on_stat(req)
+      e = check_result(UV.fs_req_result(req))
+
+      unless e
+        stat = UV.fs_req_stat(req)
+      end
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @stat_block.call(e, stat)
+    end
+
+    def on_rename(req)
+      e = check_result(UV.fs_req_result(req))
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @rename_block.call(e)
+    end
+
+    def on_chmod(req)
+      e = check_result(UV.fs_req_result(req))
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @chmod_block.call(e)
+    end
+
+    def on_utime(req)
+      e = check_result(UV.fs_req_result(req))
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @utime_block.call(e)
+    end
+
+    def on_lstat(req)
+      e = check_result(UV.fs_req_result(req))
+
+      unless e
+        stat = UV.fs_req_stat(req)
+      end
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @lstat_block.call(e, stat)
+    end
+
+    def on_link(req)
+      e = check_result(UV.fs_req_result(req))
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @link_block.call(e)
+    end
+
+    def on_symlink(req)
+      e = check_result(UV.fs_req_result(req))
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @symlink_block.call(e)
+    end
+
+    def on_readlink(req)
+      e = check_result(UV.fs_req_result(req))
+
+      unless e
+        string_ptr = UV.fs_req_pointer(req)
+        path = string_ptr.read_string() unless string_ptr.null?
+      end
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @readlink_block.call(e, path)
+    end
+
+    def on_chown(req)
+      e = check_result(UV.fs_req_result(req))
+
+      UV.fs_req_cleanup(req)
+      UV.free(req)
+
+      @chown_block.call(e)
+    end
+  end
+end