uvrb 0.1.0

data/lib/uv/version.rb

@@ -0,0 +1,3 @@
+module UV
+  VERSION = '0.1.0'
+end

data/lib/uvrb.rb

@@ -0,0 +1 @@
+require 'uv'

data/spec/shared_examples/handle.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+shared_examples_for 'a handle' do
+  describe "#ref" do
+    it "calls UV.ref" do
+      UV.should_receive(:ref).with(pointer)
+
+      subject.ref
+    end
+  end
+
+  describe "#unref" do
+    it "calls UV.unref" do
+      UV.should_receive(:unref).with(pointer)
+
+      subject.unref
+    end
+  end
+
+  describe "#close" do
+    it "requires a block" do
+      expect { subject.close }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.close" do
+      UV.should_receive(:close).once.with(pointer, subject.method(:on_close))
+      subject.close {}
+    end
+  end
+
+  describe "#active?" do
+    it "is true for positive integers" do
+      UV.should_receive(:is_active).with(pointer).and_return(2)
+      subject.active?.should be_true
+    end
+
+    it "is false for integers less than 1" do
+      UV.should_receive(:is_active).with(pointer).and_return(0)
+      subject.active?.should be_false
+    end
+  end
+
+  describe "#closing?" do
+    it "is true for positive integers" do
+      UV.should_receive(:is_closing).with(pointer).and_return(1)
+      subject.closing?.should be_true
+    end
+
+    it "is false for integers less than 1" do
+      UV.should_receive(:is_closing).with(pointer).and_return(-1)
+      subject.closing?.should be_false
+    end
+  end
+end

data/spec/shared_examples/stream.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+shared_examples_for 'a stream' do
+  describe "#listen" do
+    it "raises if no block given" do
+      expect { subject.listen(128) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.listen" do
+      backlog = 128
+      UV.should_receive(:listen).once.with(pointer, backlog, subject.method(:on_listen))
+      subject.listen(backlog) { |e| }
+    end
+  end
+
+  describe "#accept" do
+    let(:client_pointer) { double() }
+    let(:client) { double() }
+
+    before(:each) do
+      client.stub(:handle) { client_pointer }
+    end
+
+    it "makes another stream and calls UV.accept with current and other pointers" do
+      loop.should_receive(handle_name).once.and_return(client)
+      UV.should_receive(:accept).with(pointer, client_pointer)
+      subject.accept.should == client
+    end
+  end
+
+  describe "#start_read" do
+    it "raises if no block given" do
+      expect { subject.start_read }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.read_start" do
+      UV.should_receive(:read_start).with(pointer, subject.method(:on_allocate), subject.method(:on_read))
+      subject.start_read { |e, data| }
+    end
+  end
+
+  describe "#stop_read" do
+    it "calls UV.read_stop" do
+      UV.should_receive(:read_stop).with(pointer)
+      subject.stop_read
+    end
+  end
+
+  describe "#write" do
+    let(:write_request) { double() }
+    let(:buffer) { double() }
+    let(:buffer_pointer) { double() }
+
+    it "raises if no block given" do
+      expect { subject.write("123") }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.write" do
+      data = "some random string"
+      size = data.size
+
+      FFI::MemoryPointer.should_receive(:from_string).with(data).and_return(buffer_pointer)
+      UV.should_receive(:buf_init).with(buffer_pointer, size).and_return(buffer)
+      UV.should_receive(:create_request).with(:uv_write).and_return(write_request)
+      UV.should_receive(:write).with(write_request, pointer, buffer, 1, subject.method(:on_write))
+
+      subject.write(data) { |e| }
+    end
+  end
+
+  describe "#shutdown" do
+    let(:shutdown_request) { double() }
+
+    it "raises if no block given" do
+      expect { subject.shutdown }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.shutdown" do
+      UV.should_receive(:create_request).with(:uv_shutdown).and_return(shutdown_request)
+      UV.should_receive(:shutdown).with(shutdown_request, pointer, subject.method(:on_shutdown))
+
+      subject.shutdown { |e| }
+    end
+  end
+
+  describe "#readable?" do
+    it "is true for positive integers" do
+      UV.should_receive(:is_readable).with(pointer).and_return(1)
+      subject.readable?.should be_true
+    end
+
+    it "is false for integers less than 1" do
+      UV.should_receive(:is_readable).with(pointer).and_return(-1)
+      subject.readable?.should be_false
+    end
+  end
+
+  describe "#writable?" do
+    it "is true for positive integers" do
+      UV.should_receive(:is_writable).with(pointer).and_return(1)
+      subject.writable?.should be_true
+    end
+
+    it "is false for integers less than 1" do
+      UV.should_receive(:is_writable).with(pointer).and_return(-1)
+      subject.writable?.should be_false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'uvrb'
+
+module UVHelper
+  def new_tcp
+    default_loop.tcp
+  end
+
+  def default_loop
+    UV::Loop.default
+  end
+
+  def run_loop
+    default_loop.run
+  end
+
+  def run_loop_once
+    default_loop.run_once
+  end
+end
+
+RSpec.configure do |c|
+  c.include UVHelper
+end
+
+require_relative 'shared_examples/handle'
+require_relative 'shared_examples/stream'

data/spec/uv/async_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe UV::Async do
+  let(:handle_name) { :async }
+  let(:loop) { double() }
+  let(:pointer) { double() }
+  subject { UV::Async.new(loop, pointer) { |e| } }
+
+  it_behaves_like 'a handle'
+
+  describe "#call" do
+    it "calls UV.async_send" do
+      UV.should_receive(:async_send).with(pointer)
+
+      subject.call
+    end
+  end
+end

data/spec/uv/check_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe UV::Check do
+  let(:handle_name) { :check }
+  let(:loop) { double() }
+  let(:pointer) { double() }
+  subject { UV::Check.new(loop, pointer) }
+
+  it_behaves_like 'a handle'
+
+  describe "#start" do
+    it "requires a block" do
+      expect { subject.start }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.check_start" do
+      UV.should_receive(:check_start).with(pointer, subject.method(:on_check))
+
+      subject.start { |e| }
+    end
+  end
+
+  describe "#stop" do
+    it "calls UV.check_stop" do
+      UV.should_receive(:check_stop).with(pointer)
+
+      subject.stop
+    end
+  end
+end

data/spec/uv/file_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe UV::File do
+  let(:loop) { double() }
+  let(:loop_pointer) { double() }
+  let(:fd) { rand(6555) }
+  subject { UV::File.new(loop, fd) }
+
+  before(:each) do
+    loop.stub(:to_ptr) { loop_pointer }
+  end
+
+  describe "#close" do
+    let(:close_request) { double() }
+
+    it "requires a block" do
+      expect { subject.close }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_close" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(close_request)
+      UV.should_receive(:fs_close).with(loop_pointer, close_request, fd, subject.method(:on_close))
+
+      subject.close { |e| }
+    end
+  end
+
+  describe "#read" do
+    let(:read_request) { double() }
+    let(:length) { 1024 }
+    let(:read_buffer) { double() }
+    let(:offset) { 0 }
+
+    it "requires a block" do
+      expect { subject.read(length, offset) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_read" do
+      FFI::MemoryPointer.should_receive(:new).with(length).and_return(read_buffer)
+      UV.should_receive(:create_request).with(:uv_fs).and_return(read_request)
+      UV.should_receive(:fs_read).with(loop_pointer, read_request, fd, read_buffer, length, offset, subject.method(:on_read))
+
+      subject.read(length, offset) { |e, data| }
+    end
+  end
+
+  describe "#write" do
+    let(:offset) { 0 }
+    let(:data) { "some payload" }
+    let(:write_buffer_length) { data.size }
+    let(:write_buffer) { double() }
+    let(:write_request) { double() }
+
+    it "requires a block" do
+      expect { subject.write(data, offset) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_write" do
+      FFI::MemoryPointer.should_receive(:from_string).with(data).and_return(write_buffer)
+      UV.should_receive(:create_request).with(:uv_fs).and_return(write_request)
+      UV.should_receive(:fs_write).with(loop_pointer, write_request, fd, write_buffer, write_buffer_length, offset, subject.method(:on_write))
+
+      subject.write(data, offset) { |e| }
+    end
+  end
+
+  describe "#stat" do
+    let(:stat_request) { double() }
+
+    it "requires a block" do
+      expect { subject.stat }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_fstat" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(stat_request)
+      UV.should_receive(:fs_fstat).with(loop_pointer, stat_request, fd, subject.method(:on_stat))
+
+      subject.stat { |e, stat| }
+    end
+  end
+
+  describe "#sync" do
+    let(:sync_request) { double() }
+
+    it "requires a block" do
+      expect { subject.sync }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_fsync" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(sync_request)
+      UV.should_receive(:fs_fsync).with(loop_pointer, sync_request, fd, subject.method(:on_sync))
+
+      subject.sync { |e| }
+    end
+  end
+
+  describe "#datasync" do
+    let(:datasync_request) { double() }
+
+    it "requires a block" do
+      expect { subject.datasync }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_fdatasync" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(datasync_request)
+      UV.should_receive(:fs_fdatasync).with(loop_pointer, datasync_request, fd, subject.method(:on_datasync))
+
+      subject.datasync { |e| }
+    end
+  end
+
+  describe "#truncate" do
+    let(:offset) { 0 }
+    let(:truncate_request) { double() }
+
+    it "requires a block" do
+      expect { subject.truncate(offset) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_ftruncate" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(truncate_request)
+      UV.should_receive(:fs_ftruncate).with(loop_pointer, truncate_request, fd, offset, subject.method(:on_truncate))
+
+      subject.truncate(offset) { |e| }
+    end
+  end
+
+  describe "#utime" do
+    let(:atime) { 1291404900 } # 2010-12-03 20:35:00
+    let(:mtime) { 400497753 }  # 1982-09-10 11:22:33
+    let(:utime_request) { double() }
+
+    it "requires a block" do
+      expect { subject.utime(atime, mtime) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_futime" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(utime_request)
+      UV.should_receive(:fs_futime).with(loop_pointer, utime_request, fd, atime, mtime, subject.method(:on_utime))
+
+      subject.utime(atime, mtime) { |e| }
+    end
+  end
+
+  describe "#chmod" do
+    let(:mode) { 0755 }
+    let(:chmod_request) { double() }
+
+    it "requires a block" do
+      expect { subject.chmod(mode) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_fchmod" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(chmod_request)
+      UV.should_receive(:fs_fchmod).with(loop_pointer, chmod_request, fd, mode, subject.method(:on_chmod))
+
+      subject.chmod(mode) { |e| }
+    end
+  end
+
+  describe "#chown" do
+    let(:uid) { 0 }
+    let(:gid) { 0 }
+    let(:chown_request) { double() }
+
+    it "requires a block" do
+      expect { subject.chown(uid, gid) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_fchown" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(chown_request)
+      UV.should_receive(:fs_fchown).with(loop_pointer, chown_request, fd, uid, gid, subject.method(:on_chown))
+
+      subject.chown(uid, gid) { |e| }
+    end
+  end
+end

data/spec/uv/filesystem_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+describe UV::Filesystem do
+  let(:loop) { double() }
+  let(:loop_pointer) { double() }
+  subject { UV::Filesystem.new(loop) }
+
+  before(:each) do
+    loop.stub(:to_ptr) { loop_pointer }
+  end
+
+  describe "#open" do
+    let(:path) { "/tmp/file" }
+    let(:mode) { 0755 }
+    let(:flags) { File::CREAT | File::EXCL | File::APPEND }
+    let(:open_request) { double() }
+
+    it "requires a block" do
+      expect { subject.open(path, flags, mode) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_open" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(open_request)
+      UV.should_receive(:fs_open).with(loop_pointer, open_request, path, flags, mode, subject.method(:on_open))
+
+      subject.open(path, flags, mode) { |e, file| }
+    end
+  end
+
+  describe "#unlink" do
+    let(:path) { "/tmp/file" }
+    let(:unlink_request) { double() }
+
+    it "requires a block" do
+      expect { subject.unlink(path) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_unlink" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(unlink_request)
+      UV.should_receive(:fs_unlink).with(loop_pointer, unlink_request, path, subject.method(:on_unlink))
+
+      subject.unlink(path) { |e| }
+    end
+  end
+
+  describe "#mkdir" do
+    let(:path) { "/tmp/dir" }
+    let(:mode) { 0777 }
+    let(:mkdir_request) { double() }
+
+    it "requires a block" do
+      expect { subject.mkdir(path) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_mkdir" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(mkdir_request)
+      UV.should_receive(:fs_mkdir).with(loop_pointer, mkdir_request, path, mode, subject.method(:on_mkdir))
+
+      subject.mkdir(path, mode) { |e| }
+    end
+  end
+
+  describe "#rmdir" do
+    let(:path) { "/tmp/dir" }
+    let(:rmdir_request) { double() }
+
+    it "requires a block" do
+      expect { subject.rmdir(path) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_rmdir" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(rmdir_request)
+      UV.should_receive(:fs_rmdir).with(loop_pointer, rmdir_request, path, subject.method(:on_rmdir))
+
+      subject.rmdir(path) { |e| }
+    end
+  end
+
+  describe "#readdir" do
+    let(:path) { '/tmp' }
+    let(:readdir_request) { double() }
+
+    it "requires a block" do
+      expect { subject.readdir(path) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_readdir" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(readdir_request)
+      UV.should_receive(:fs_readdir).with(loop_pointer, readdir_request, path, 0, subject.method(:on_readdir))
+
+      subject.readdir(path) { |e, files| }
+    end
+  end
+
+  describe "#stat" do
+    let(:path) { '/tmp/filename' }
+    let(:stat_request) { double() }
+
+    it "requires a block" do
+      expect { subject.stat(path) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_stat" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(stat_request)
+      UV.should_receive(:fs_stat).with(loop_pointer, stat_request, path, subject.method(:on_stat))
+
+      subject.stat(path) { |e, stat| }
+    end
+  end
+
+  describe "#rename" do
+    let(:old_path) { '/tmp/old_file' }
+    let(:new_path) { '/tmp/new_file' }
+    let(:rename_request) { double() }
+
+    it "requires a block" do
+      expect { subject.rename(old_path, new_path) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_rename" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(rename_request)
+      UV.should_receive(:fs_rename).with(loop_pointer, rename_request, old_path, new_path, subject.method(:on_rename))
+
+      subject.rename(old_path, new_path) { |e| }
+    end
+  end
+
+  describe "#chmod" do
+    let(:path) { '/tmp/somepath' }
+    let(:mode) { 0755 }
+    let(:chmod_request) { double() }
+
+    it "requires a block" do
+      expect { subject.chmod(path, mode) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_chmod" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(chmod_request)
+      UV.should_receive(:fs_chmod).with(loop_pointer, chmod_request, path, mode, subject.method(:on_chmod))
+
+      subject.chmod(path, mode) { |e| }
+    end
+  end
+
+  describe "#utime" do
+    let(:path) { '/tmp/filename' }
+    let(:atime) { 1291404900 } # 2010-12-03 20:35:00
+    let(:mtime) { 400497753 }  # 1982-09-10 11:22:33
+    let(:utime_request) { double() }
+
+    it "requires a block" do
+      expect { subject.utime(path, atime, mtime) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_utime" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(utime_request)
+      UV.should_receive(:fs_utime).with(loop_pointer, utime_request, path, atime, mtime, subject.method(:on_utime))
+
+      subject.utime(path, atime, mtime) { |e| }
+    end
+  end
+
+  describe "#lstat" do
+    let(:path) { '/tmp/filename' }
+    let(:lstat_request) { double() }
+
+    it "requires a block" do
+      expect { subject.lstat(path) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_lstat" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(lstat_request)
+      UV.should_receive(:fs_lstat).with(loop_pointer, lstat_request, path, subject.method(:on_lstat))
+
+      subject.lstat(path) { |e, stat| }
+    end
+  end
+
+  describe "#link" do
+    let(:old_path) { '/tmp/old_file' }
+    let(:new_path) { '/tmp/new_file' }
+    let(:link_request) { double() }
+
+    it "requires a block" do
+      expect { subject.link(old_path, new_path) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_link" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(link_request)
+      UV.should_receive(:fs_link).with(loop_pointer, link_request, old_path, new_path, subject.method(:on_link))
+
+      subject.link(old_path, new_path) { |e| }
+    end
+  end
+
+  describe "#symlink" do
+    let(:old_path) { '/tmp/old_file' }
+    let(:new_path) { '/tmp/new_file' }
+    let(:symlink_request) { double() }
+
+    it "requires a block" do
+      expect { subject.symlink(old_path, new_path) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_link" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(symlink_request)
+      UV.should_receive(:fs_symlink).with(loop_pointer, symlink_request, old_path, new_path, 0, subject.method(:on_symlink))
+
+      subject.symlink(old_path, new_path) { |e| }
+    end
+  end
+
+  describe "#readlink" do
+    let(:path) { '/tmp/symlink' }
+    let(:readlink_request) { double() }
+
+    it "requires a block" do
+      expect { subject.readlink(path) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_readlink" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(readlink_request)
+      UV.should_receive(:fs_readlink).with(loop_pointer, readlink_request, path, subject.method(:on_readlink))
+
+      subject.readlink(path) { |e, path| }
+    end
+  end
+
+  describe "#chown" do
+    let(:path) { '/tmp/chownable_file' }
+    let(:uid) { 0 }
+    let(:gid) { 0 }
+    let(:chown_request) { double() }
+
+    it "requires a block" do
+      expect { subject.chown(path, uid, gid) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_chown" do
+      UV.should_receive(:create_request).with(:uv_fs).and_return(chown_request)
+      UV.should_receive(:fs_chown).with(loop_pointer, chown_request, path, uid, gid, subject.method(:on_chown))
+
+      subject.chown(path, uid, gid) { |e| }
+    end
+  end
+end