nio4r 0.1.0 → 0.2.0

data/CHANGES.md

@@ -0,0 +1,10 @@
+0.2.0
+-----
+* NIO::Monitor#readiness API to query readiness, along with #readable? and
+  #writable? helper methods
+* NIO::Selector#select_each API which avoids memory allocations if possible
+* Bugfixes for the JRuby implementation
+
+0.1.0
+-----
+* Initial release. Merry Christmas!

data/Gemfile

@@ -1,4 +1,4 @@
-source 'http://rubygems.org'
+source :rubygems
 
 # Specify your gem's dependencies in nio4r.gemspec
 gemspec

data/README.md

@@ -32,56 +32,104 @@ Platform notes:
 
 * MRI/YARV and Rubinius implement nio4j with a C extension based on libev,
   which provides a high performance binding to native IO APIs
-* JRuby uses a special backend based on Java NIO which provides good performance
-  even when monitoring large numbers of IO objects
+* JRuby uses a special backend based on the high performance Java NIO subsystem
 * A pure Ruby implementation is also provided for Ruby implementations which
   don't implement the MRI C extension API
 
 Usage
 -----
 
+### Selectors
+
 The NIO::Selector class is the main API provided by nio4r. Use it where you
 might otherwise use Kernel.select, but want to monitor the same set of IO
 objects across multiple select calls rather than having to reregister them
 every single time:
 
-	selector = NIO::Selector.new
-	reader, writer = IO.pipe
-	monitor = selector.register(reader, :r)
-
-You can monitor IO objects for read readiness (with the :r parameter), write
-readiness (with the :w parameter), or both (with :rw). After registering an
-IO object with the selector, you'll get a NIO::Monitor object which you can
-use for managing how a particular IO object is being monitored. Monitors will
-store an arbitrary value of your choice, which provides an easy way to implement
-callbacks:
-
-	>> monitor = selector.register(reader, :r)
-	 => #<NIO::Monitor:0xfbc>
-	>> monitor.value = proc { puts "Got some data: #{monitor.io.read_nonblock(4096)}" }
-	 => #<Proc:0x1000@(irb):4>
-	>> writer << "Hi there!"
-	 => #<IO:0x103c>
-	>> ready = selector.select
-	 => [#<NIO::Monitor:0xfbc>]
-	>> ready.each { |m| m.value.call }
-	Got some data: Hi there!
-	 => [#<NIO::Monitor:0xfbc>]
+```ruby
+require 'nio'
+
+selector = NIO::Selector.new
+```
+
+To monitor IO objects, attach them to the selector with the NIO::Selector#register
+method, monitoring them for read readiness with the :r parameter, write
+readiness with the :w parameter, or both with :rw.
+
+```ruby
+>> reader, writer = IO.pipe
+ => [#<IO:0xf30>, #<IO:0xf34>]
+>> monitor = selector.register(reader, :r)
+ => #<NIO::Monitor:0xfbc>
+```
+
+After registering an IO object with the selector, you'll get a NIO::Monitor
+object which you can use for managing how a particular IO object is being
+monitored. Monitors will store an arbitrary value of your choice, which
+provides an easy way to implement callbacks:
+
+```ruby
+>> monitor = selector.register(reader, :r)
+ => #<NIO::Monitor:0xfbc>
+>> monitor.value = proc { puts "Got some data: #{monitor.io.read_nonblock(4096)}" }
+ => #<Proc:0x1000@(irb):4>
+```
 
 The main method of importance is NIO::Selector#select, which monitors all
 registered IO objects and returns an array of monitors that are ready.
+
+```ruby
+>> writer << "Hi there!"
+ => #<IO:0x103c>
+>> ready = selector.select
+ => [#<NIO::Monitor:0xfbc>]
+>> ready.each { |m| m.value.call }
+Got some data: Hi there!
+ => [#<NIO::Monitor:0xfbc>]
+```
+
 By default, NIO::Selector#select will block indefinitely until one of the IO
 objects being monitored becomes ready. However, you can also pass a timeout to
 wait in seconds to NIO::Selector#select just like you can with Kernel.select:
 
-    ready = selector.select(15) # Wait 15 seconds
+```ruby
+ready = selector.select(15) # Wait 15 seconds
+```
 
 If a timeout occurs, ready will be nil.
 
+You can avoid allocating an array each time you call NIO::Selector#select by
+using NIO::Selector#select_each instead. This method successively yields ready
+NIO::Monitor objects:
+
+```ruby
+>> selector.select_each { |m| m.value.call }
+Got some data: Hi there!
+ => 1
+```
+
 When you're done monitoring a particular IO object, just deregister it from
 the selector:
 
-    selector.deregister(reader)
+```ruby
+selector.deregister(reader)
+```
+
+### Monitors
+
+Monitors provide methods which let you introspect on why a particular IO
+object was selected. These methods are not thread safe unless you are holding
+the selector lock (i.e. if you're in a #select_each callback). Only use them
+if you aren't concerned with thread safety, or you're within a #select_each
+callback:
+
+- ***#interests***: what this monitor is interested in (:r, :w, or :rw)
+- ***#readiness***: what the monitored IO object is ready for according to the last select operation
+- ***#readable?***: was the IO readable last time it was selected?
+- ***#writable?***: was the IO writable last time it was selected?
+
+Monitors also support a ***#value*** and ***#value=*** method for storing a
+handle to an arbitrary object of your choice (e.g. a proc)
 
 Concurrency
 -----------
@@ -108,7 +156,7 @@ to maintain a large codebase. As of the time of writing, the current
 implementation is a little over 100 lines of code for both the pure Ruby and
 JRuby backends. The native extension uses approximately 500 lines of C code.
 
-nio4r is also not a replacement for Kindler Gentler IO (KGIO), a set of
+nio4r is also not a replacement for Kinder Gentler IO (KGIO), a set of
 advanced Ruby IO APIs. At some point in the future nio4r might provide a
 cross-platform implementation that uses KGIO on CRubies, and Java NIO on JRuby,
 however this is not the case today.

data/examples/echo_server.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+$:.push File.expand_path('../../lib', __FILE__)
+require 'nio'
+require 'socket'
+
+class EchoServer
+  def initialize(host, port)
+    @selector = NIO::Selector.new
+
+    puts "Listening on #{host}:#{port}"
+    @server = TCPServer.new(host, port)
+
+    monitor = @selector.register(@server, :r)
+    monitor.value = proc { accept }
+  end
+
+  def run
+    while true
+      @selector.select_each { |monitor| monitor.value.call(monitor) }
+    end
+  end
+
+  def accept
+    socket = @server.accept
+    monitor = @selector.register(socket, :r)
+    monitor.value = proc { read(socket) }
+  end
+
+  def read(socket)
+    data = socket.read_nonblock(4096)
+    socket.write_nonblock(data)
+  end
+end
+
+if $0 == __FILE__
+  EchoServer.new("localhost", 1234).run
+end

data/ext/nio4r/monitor.c

@@ -20,8 +20,11 @@ static VALUE NIO_Monitor_close(VALUE self);
 static VALUE NIO_Monitor_is_closed(VALUE self);
 static VALUE NIO_Monitor_io(VALUE self);
 static VALUE NIO_Monitor_interests(VALUE self);
+static VALUE NIO_Monitor_is_readable(VALUE self);
+static VALUE NIO_Monitor_is_writable(VALUE self);
 static VALUE NIO_Monitor_value(VALUE self);
 static VALUE NIO_Monitor_set_value(VALUE self, VALUE obj);
+static VALUE NIO_Monitor_readiness(VALUE self);
 
 /* Internal functions */
 static void NIO_Monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
@@ -46,6 +49,10 @@ void Init_NIO_Monitor()
     rb_define_method(cNIO_Monitor, "interests", NIO_Monitor_interests, 0);
     rb_define_method(cNIO_Monitor, "value", NIO_Monitor_value, 0);
     rb_define_method(cNIO_Monitor, "value=", NIO_Monitor_set_value, 1);
+    rb_define_method(cNIO_Monitor, "readiness", NIO_Monitor_readiness, 0);
+    rb_define_method(cNIO_Monitor, "readable?", NIO_Monitor_is_readable, 0);
+    rb_define_method(cNIO_Monitor, "writable?", NIO_Monitor_is_writable, 0);
+    rb_define_method(cNIO_Monitor, "writeable?", NIO_Monitor_is_writable, 0);
 }
 
 static VALUE NIO_Monitor_allocate(VALUE klass)
@@ -68,7 +75,6 @@ static VALUE NIO_Monitor_initialize(VALUE self, VALUE selector_obj, VALUE io, VA
 {
     struct NIO_Monitor *monitor;
     struct NIO_Selector *selector;
-    int events;
     ID interests_id;
 
     #if HAVE_RB_IO_T
@@ -79,21 +85,21 @@ static VALUE NIO_Monitor_initialize(VALUE self, VALUE selector_obj, VALUE io, VA
 
     interests_id = SYM2ID(interests);
 
+    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+
     if(interests_id == rb_intern("r")) {
-        events = EV_READ;
+        monitor->interests = EV_READ;
     } else if(interests_id == rb_intern("w")) {
-        events = EV_WRITE;
+        monitor->interests = EV_WRITE;
     } else if(interests_id == rb_intern("rw")) {
-        events = EV_READ | EV_WRITE;
+        monitor->interests = EV_READ | EV_WRITE;
     } else {
         rb_raise(rb_eArgError, "invalid event type %s (must be :r, :w, or :rw)",
             RSTRING_PTR(rb_funcall(interests, rb_intern("inspect"), 0, 0)));
     }
 
-    Data_Get_Struct(self, struct NIO_Monitor, monitor);
-
     GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
-    ev_io_init(&monitor->ev_io, NIO_Monitor_callback, FPTR_TO_FD(fptr), events);
+    ev_io_init(&monitor->ev_io, NIO_Monitor_callback, FPTR_TO_FD(fptr), monitor->interests);
 
     rb_ivar_set(self, rb_intern("selector"), selector_obj);
     rb_ivar_set(self, rb_intern("io"), io);
@@ -154,11 +160,53 @@ static VALUE NIO_Monitor_set_value(VALUE self, VALUE obj)
     return rb_ivar_set(self, rb_intern("value"), obj);
 }
 
+static VALUE NIO_Monitor_readiness(VALUE self)
+{
+    struct NIO_Monitor *monitor;
+    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+
+    if((monitor->revents & (EV_READ | EV_WRITE)) == (EV_READ | EV_WRITE)) {
+        return ID2SYM(rb_intern("rw"));
+    } else if(monitor->revents & EV_READ) {
+        return ID2SYM(rb_intern("r"));
+    } else if(monitor->revents & EV_WRITE) {
+        return ID2SYM(rb_intern("w"));
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE NIO_Monitor_is_readable(VALUE self)
+{
+    struct NIO_Monitor *monitor;
+    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+
+    if(monitor->revents & EV_READ) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE NIO_Monitor_is_writable(VALUE self)
+{
+    struct NIO_Monitor *monitor;
+    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+
+    if(monitor->revents & EV_WRITE) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
 /* libev callback fired whenever this monitor gets events */
 static void NIO_Monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents)
 {
     struct NIO_Monitor *monitor = (struct NIO_Monitor *)io->data;
 
     assert(monitor->selector != 0);
+    monitor->revents = revents;
+
     NIO_Selector_handle_event(monitor->selector, monitor->self, revents);
 }

data/ext/nio4r/nio4r.h

@@ -31,6 +31,7 @@ struct NIO_callback_data
 struct NIO_Monitor
 {
     VALUE self;
+    int interests, revents;
     struct ev_io ev_io;
     struct NIO_Selector *selector;
 };

data/ext/nio4r/selector.c

@@ -23,6 +23,7 @@ static VALUE NIO_Selector_register(VALUE self, VALUE selectable, VALUE interest)
 static VALUE NIO_Selector_deregister(VALUE self, VALUE io);
 static VALUE NIO_Selector_is_registered(VALUE self, VALUE io);
 static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self);
+static VALUE NIO_Selector_select_each(int argc, VALUE *argv, VALUE self);
 static VALUE NIO_Selector_wakeup(VALUE self);
 static VALUE NIO_Selector_close(VALUE self);
 static VALUE NIO_Selector_closed(VALUE self);
@@ -33,6 +34,8 @@ static VALUE NIO_Selector_unlock(VALUE lock);
 static VALUE NIO_Selector_register_synchronized(VALUE *args);
 static VALUE NIO_Selector_deregister_synchronized(VALUE *args);
 static VALUE NIO_Selector_select_synchronized(VALUE *args);
+static VALUE NIO_Selector_select_each_synchronized(VALUE *args);
+static int NIO_Selector_fill_ready_buffer(VALUE *args);
 static VALUE NIO_Selector_run_evloop(void *ptr);
 static void NIO_Selector_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents);
 static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_async *async, int revents);
@@ -57,6 +60,7 @@ void Init_NIO_Selector()
     rb_define_method(cNIO_Selector, "deregister", NIO_Selector_deregister, 1);
     rb_define_method(cNIO_Selector, "registered?", NIO_Selector_is_registered, 1);
     rb_define_method(cNIO_Selector, "select", NIO_Selector_select, -1);
+    rb_define_method(cNIO_Selector, "select_each", NIO_Selector_select_each, -1);
     rb_define_method(cNIO_Selector, "wakeup", NIO_Selector_wakeup, 0);
     rb_define_method(cNIO_Selector, "close", NIO_Selector_close, 0);
     rb_define_method(cNIO_Selector, "closed?", NIO_Selector_closed, 0);
@@ -126,19 +130,35 @@ static VALUE NIO_Selector_initialize(VALUE self)
     return Qnil;
 }
 
-/* Synchronize the given function with the selector mutex */
+/* Synchronize around a reentrant selector lock */
 static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VALUE *args)
 {
-    VALUE lock;
+    VALUE current_thread, lock_holder, lock;
 
-    lock = rb_ivar_get(self, rb_intern("lock"));
-    rb_funcall(lock, rb_intern("lock"), 0, 0);
-    return rb_ensure(func, (VALUE)args, NIO_Selector_unlock, lock);
+    current_thread = rb_thread_current();
+    lock_holder = rb_ivar_get(self, rb_intern("lock_holder"));
+
+    if(lock_holder != rb_thread_current()) {
+        lock = rb_ivar_get(self, rb_intern("lock"));
+        rb_funcall(lock, rb_intern("lock"), 0, 0);
+        rb_ivar_set(self, rb_intern("lock_holder"), rb_thread_current());
+
+        /* We've acquired the lock, so ensure we unlock it */
+        return rb_ensure(func, (VALUE)args, NIO_Selector_unlock, self);
+    } else {
+        /* We already hold the selector lock, so no need to unlock it */
+        func(args);
+    }
 }
 
 /* Unlock the selector mutex */
-static VALUE NIO_Selector_unlock(VALUE lock)
+static VALUE NIO_Selector_unlock(VALUE self)
 {
+    VALUE lock;
+
+    rb_ivar_set(self, rb_intern("lock_holder"), Qnil);
+
+    lock = rb_ivar_get(self, rb_intern("lock"));
     rb_funcall(lock, rb_intern("unlock"), 0, 0);
 }
 
@@ -225,11 +245,63 @@ static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self)
     return NIO_Selector_synchronize(self, NIO_Selector_select_synchronized, args);
 }
 
+/* Select from all registered IO objects */
+static VALUE NIO_Selector_select_each(int argc, VALUE *argv, VALUE self)
+{
+    VALUE timeout, array;
+    VALUE args[2];
+
+    if(!rb_block_given_p()) {
+        rb_raise(rb_eArgError, "no block given");
+    }
+
+    rb_scan_args(argc, argv, "01", &timeout);
+
+    args[0] = self;
+    args[1] = timeout;
+
+    return NIO_Selector_synchronize(self, NIO_Selector_select_each_synchronized, args);
+}
+
 /* Internal implementation of select with the selector lock held */
 static VALUE NIO_Selector_select_synchronized(VALUE *args)
 {
-    VALUE self, timeout, result;
     struct NIO_Selector *selector;
+    int ready = NIO_Selector_fill_ready_buffer(args);
+
+    Data_Get_Struct(args[0], struct NIO_Selector, selector);
+
+    if(ready > 0) {
+        return rb_ary_new4(ready, selector->ready_buffer);
+    } else {
+        return Qnil;
+    }
+}
+
+/* Internal implementation of select with the selector lock held */
+static VALUE NIO_Selector_select_each_synchronized(VALUE *args)
+{
+    struct NIO_Selector *selector;
+    int i, ready = NIO_Selector_fill_ready_buffer(args);
+
+    Data_Get_Struct(args[0], struct NIO_Selector, selector);
+
+    if(ready > 0) {
+        for(i = 0; i < ready; i++) {
+            rb_yield(selector->ready_buffer[i]);
+        }
+
+        return INT2NUM(ready);
+    } else {
+        return Qnil;
+    }
+}
+
+static int NIO_Selector_fill_ready_buffer(VALUE *args)
+{
+    VALUE self, timeout;
+    struct NIO_Selector *selector;
+    int result;
 
     self = args[0];
     timeout = args[1];
@@ -289,11 +361,7 @@ static VALUE NIO_Selector_select_synchronized(VALUE *args)
     }
 #endif /* defined(HAVE_RB_THREAD_BLOCKING_REGION) */
 
-    if(!selector->ready_count) {
-        return Qnil;
-    }
-
-    result = rb_ary_new4(selector->ready_count, selector->ready_buffer);
+    result = selector->ready_count;
     selector->selecting = selector->ready_count = 0;
 
     return result;

data/lib/nio/jruby/monitor.rb

@@ -1,7 +1,7 @@
 module NIO
   # Monitors watch Channels for specific events
   class Monitor
-    attr_accessor :value
+    attr_accessor :value, :io
 
     # :nodoc
     def initialize(io, selection_key)
@@ -15,6 +15,22 @@ module NIO
       Selector.iops2sym @key.interestOps
     end
 
+    # What is the IO object ready for?
+    def readiness
+      Selector.iops2sym @key.readyOps
+    end
+
+    # Is the IO object readable?
+    def readable?
+      readiness == :r || readiness == :rw
+    end
+
+    # Is the IO object writable?
+    def writable?
+      readiness == :w || readiness == :rw
+    end
+    alias_method :writeable?, :writable?
+
     # Is this monitor closed?
     def closed?; @closed; end
 

data/lib/nio/jruby/selector.rb

@@ -5,14 +5,22 @@ module NIO
     java_import "java.nio.channels.SelectionKey"
 
     # Convert nio4r interest symbols to Java NIO interest ops
-    def self.sym2iops(interest)
+    def self.sym2iops(interest, channel)
       case interest
       when :r
-        interest = SelectionKey::OP_READ
+        if channel.validOps & SelectionKey::OP_ACCEPT != 0
+          SelectionKey::OP_ACCEPT
+        else
+          SelectionKey::OP_READ
+        end
       when :w
-        interest = SelectionKey::OP_WRITE
+        if channel.respond_to? :connected? and not channel.connected?
+          SelectionKey::OP_CONNECT
+        else
+          SelectionKey::OP_WRITE
+        end
       when :rw
-        interest = SelectionKey::OP_READ | SelectionKey::OP_WRITE
+        super(:r, channel) | super(:w, channel)
       else raise ArgumentError, "invalid interest type: #{interest}"
       end
     end
@@ -20,12 +28,13 @@ module NIO
     # Convert Java NIO interest ops to the corresponding Ruby symbols
     def self.iops2sym(interest_ops)
       case interest_ops
-      when SelectionKey::OP_READ
+      when SelectionKey::OP_READ, SelectionKey::OP_ACCEPT
         :r
-      when SelectionKey::OP_WRITE
+      when SelectionKey::OP_WRITE, SelectionKey::OP_CONNECT
         :w
       when SelectionKey::OP_READ | SelectionKey::OP_WRITE
         :rw
+      when 0 then nil
       else raise ArgumentError, "unknown interest op combination: 0x#{interest_ops.to_s(16)}"
       end
     end
@@ -44,15 +53,14 @@ module NIO
     def register(io, interest)
       java_channel = io.to_channel
       java_channel.configureBlocking(false)
-
-      interest_ops = self.class.sym2iops(interest)
+      interest_ops = self.class.sym2iops(interest, java_channel)
 
       begin
         selector_key = java_channel.register @java_selector, interest_ops
       rescue NativeException => ex
         case ex.cause
         when java.lang.IllegalArgumentException
-          raise ArgumentError, "invalid interest type for #{channel}: #{interest}"
+          raise ArgumentError, "invalid interest type for #{java_channel}: #{interest}"
         else raise
         end
       end
@@ -79,15 +87,32 @@ module NIO
 
     # Select which monitors are ready
     def select(timeout = nil)
+      selected = []
+      ready = select_each(timeout) { |monitor| selected << monitor }
+      return unless ready
+
+      selected
+    end
+
+    # Iterate across all selectable monitors
+    def select_each(timeout = nil)
       @select_lock.synchronize do
-        if timeout
+        if timeout == 0
+          # The Java NIO API thinks zero means you want to BLOCK FOREVER o_O
+          # How about we don't block at all instead?
+          ready = @java_selector.selectNow
+        elsif timeout
           ready = @java_selector.select(timeout * 1000)
         else
           ready = @java_selector.select
         end
 
         return unless ready > 0 # timeout or wakeup
-        @java_selector.selectedKeys.map { |key| key.attachment }
+
+        @java_selector.selectedKeys.each { |key| yield key.attachment }
+        @java_selector.selectedKeys.clear
+
+        ready
       end
     end
 

data/lib/nio/monitor.rb

@@ -2,7 +2,7 @@ module NIO
   # Monitors watch IO objects for specific events
   class Monitor
     attr_reader :io, :interests
-    attr_accessor :value
+    attr_accessor :value, :readiness
 
     # :nodoc
     def initialize(io, interests)
@@ -10,6 +10,17 @@ module NIO
       @closed = false
     end
 
+    # Is the IO object readable?
+    def readable?
+      readiness == :r || readiness == :rw
+    end
+
+    # Is the IO object writable?
+    def writable?
+      readiness == :w || readiness == :rw
+    end
+    alias_method :writeable?, :writable?
+
     # Is this monitor closed?
     def closed?; @closed; end
 

data/lib/nio/selector.rb

@@ -54,10 +54,8 @@ module NIO
         ready_readers, ready_writers = Kernel.select readers, writers, [], timeout
         return unless ready_readers # timeout or wakeup
 
-        results = ready_readers
-        results.concat ready_writers if ready_writers
-
-        results.map! do |io|
+        results = []
+        ready_readers.each do |io|
           if io == @wakeup
             # Clear all wakeup signals we've received by reading them
             # Wakeups should have level triggered behavior
@@ -71,12 +69,35 @@ module NIO
 
             return
           else
-            @selectables[io]
+            monitor = @selectables[io]
+            monitor.readiness = :r
+            results << monitor
+          end
+        end
+
+        ready_readwriters = ready_readers & ready_writers
+        ready_writers = ready_writers - ready_readwriters
+
+        [[ready_writers, :w], [ready_readwriters, :rw]].each do |ios, readiness|
+          ios.each do |io|
+            monitor = @selectables[io]
+            monitor.readiness = readiness
+            results << monitor
           end
         end
+
+        results
       end
     end
 
+    # Select for ready monitors, successively yielding each one in a block
+    def select_each(timeout = nil, &block)
+      selected = select(timeout)
+      return unless selected
+      selected.each(&block)
+      selected.size
+    end
+
     # Wake up other threads waiting on this selector
     def wakeup
       # Send the selector a signal in the form of writing data to a pipe

data/lib/nio/version.rb

@@ -1,3 +1,3 @@
 module NIO
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/nio4r.gemspec

@@ -14,9 +14,9 @@ Gem::Specification.new do |gem|
   gem.name          = "nio4r"
   gem.require_paths = ["lib"]
   gem.version       = NIO::VERSION
-  gem.extensions    = ["ext/nio4r/extconf.rb"] unless defined?(JRUBY_VERSION)
+  gem.extensions    = ["ext/nio4r/extconf.rb"]
 
   gem.add_development_dependency "rake-compiler", "~> 0.7.9"
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "rspec", ">= 2.7.0"
+  gem.add_development_dependency "rspec", "~> 2.7.0"
 end

data/spec/nio/monitor_spec.rb

@@ -1,23 +1,18 @@
 require 'spec_helper'
 
 describe NIO::Monitor do
-  let :readable_pipe do
-    pipe, peer = IO.pipe
-    peer << "data"
-    pipe
+  let :readable do
+    reader, writer = IO.pipe
+    writer << "have some data"
+    reader
   end
 
-  # let :unreadable_pipe do
-  #   pipe, _ = IO.pipe
-  #   pipe
-  # end
-
   let :selector do
     NIO::Selector.new
   end
 
   # Monitors are created by registering IO objects or channels with a selector
-  subject { selector.register(readable_pipe, :r) }
+  subject { selector.register(readable, :r) }
 
   it "knows its interests" do
     subject.interests.should == :r
@@ -28,6 +23,21 @@ describe NIO::Monitor do
     subject.value.should == 42
   end
 
+  it "knows what IO objects are ready for" do
+    # Perhaps let bindings are just confusing me but they're not producing
+    # what I want. Manually doing the setup here does
+    # FIXME: Hey RSpec wizards! Fix this!
+    reader, writer = IO.pipe
+    writer << "loldata"
+    selector = NIO::Selector.new
+    subject = selector.register(reader, :r)
+
+    # Here's where the spec really begins
+    selector.select(1).should include(subject)
+    subject.readiness.should == :r
+    subject.should be_readable
+  end
+
   it "closes" do
     subject.should_not be_closed
     subject.close

data/spec/nio/selector_spec.rb

@@ -67,6 +67,45 @@ describe NIO::Selector do
     end
   end
 
+  context "select_each" do
+    it "iterates across ready selectables" do
+      readable1, writer = IO.pipe
+      writer << "ohai"
+
+      readable2, writer = IO.pipe
+      writer << "ohai"
+
+      unreadable, _ = IO.pipe
+
+      monitor1 = subject.register(readable1, :r)
+      monitor2 = subject.register(readable2, :r)
+      monitor3 = subject.register(unreadable, :r)
+
+      readables = []
+      subject.select_each { |monitor| readables << monitor }
+
+      readables.should include(monitor1)
+      readables.should include(monitor2)
+      readables.should_not include(monitor3)
+    end
+
+    it "allows new monitors to be registered in the select_each block" do
+      server = TCPServer.new("localhost", 10001)
+
+      monitor = subject.register(server, :r)
+      connector = TCPSocket.open("localhost", 10001)
+
+      block_fired = false
+      subject.select_each do |monitor|
+        block_fired = true
+        socket = server.accept
+        subject.register(socket, :r).should be_a NIO::Monitor
+      end
+
+      block_fired.should be_true
+    end
+  end
+
   it "closes" do
     subject.close
     subject.should be_closed
@@ -139,8 +178,12 @@ describe NIO::Selector do
       end
 
       let :unreadable_subject do
-        TCPServer.new("localhost", tcp_port + 1)
-        TCPSocket.open("localhost", tcp_port + 1)
+        if defined?(JRUBY_VERSION) and ENV['TRAVIS']
+          pending "This is sporadically showing up readable on JRuby in CI"
+        else
+          TCPServer.new("localhost", tcp_port + 1)
+          TCPSocket.open("localhost", tcp_port + 1)
+        end
       end
 
       let :writable_subject do
@@ -194,4 +237,33 @@ describe NIO::Selector do
       it_behaves_like "an NIO selectable"
     end
   end
+
+  context "acceptables" do
+    shared_context "an NIO acceptable" do
+      it "selects for read readiness" do
+        waiting_monitor = subject.register(unacceptable_subject, :r)
+        ready_monitor   = subject.register(acceptable_subject, :r)
+
+        ready_monitors = subject.select
+        ready_monitors.should include ready_monitor
+        ready_monitors.should_not include waiting_monitor
+      end
+    end
+
+    context TCPServer do
+      let(:tcp_port) { 23456 }
+
+      let :acceptable_subject do
+        server = TCPServer.new("localhost", tcp_port)
+        TCPSocket.open("localhost", tcp_port)
+        server
+      end
+
+      let :unacceptable_subject do
+        TCPServer.new("localhost", tcp_port + 1)
+      end
+
+      it_behaves_like "an NIO acceptable"
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nio4r
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-26 00:00:00.000000000 Z
+date: 2012-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: &70311592959600 !ruby/object:Gem::Requirement
+  requirement: &70186951376840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.7.9
   type: :development
   prerelease: false
-  version_requirements: *70311592959600
+  version_requirements: *70186951376840
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70311592959040 !ruby/object:Gem::Requirement
+  requirement: &70186951376120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,18 +32,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70311592959040
+  version_requirements: *70186951376120
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70311592957620 !ruby/object:Gem::Requirement
+  requirement: &70186951375540 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
         version: 2.7.0
   type: :development
   prerelease: false
-  version_requirements: *70311592957620
+  version_requirements: *70186951375540
 description: New IO for Ruby
 email:
 - tony.arcieri@gmail.com
@@ -55,10 +55,12 @@ files:
 - .gitignore
 - .rspec
 - .travis.yml
+- CHANGES.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/echo_server.rb
 - ext/libev/Changes
 - ext/libev/LICENSE
 - ext/libev/README
@@ -120,3 +122,4 @@ test_files:
 - spec/nio/monitor_spec.rb
 - spec/nio/selector_spec.rb
 - spec/spec_helper.rb
+has_rdoc: