nio4r 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8caeb8b7d6d5b461cb97472c6c7a540808ad8e5
-  data.tar.gz: 669ff217c7261624c5ba626723701397bfa785b2
+  metadata.gz: 47612304fa6cd2c81ad14e7bdb8af184ae90aea7
+  data.tar.gz: 81e44434ea267b78ffd498726fa27752a348ec99
 SHA512:
-  metadata.gz: b23efa474808fcf2ed6432537547e4e10cc23b7e0b7f3f8bbc2eff1d39b4da33fc10e1b2bff2ed19e056c9feb82230a4f5179f71b537ac3e5371a92461a1b1f7
-  data.tar.gz: df78f33b747ff374ded33c42fb705db55d11dbea978430baf89fca72912964e672447773ce6830c6a35e98960a823000e8a67b45f0c18c8800798c34a8efeb63
+  metadata.gz: 46832a57b9355a7ae7a52bb00fa8f6b545c4e0f40d1d9eaa5752628a7d6dccd06e577e57b41eaa2a7119474c64c51974aaa5503b24bf694a96a597eb20bbb2d8
+  data.tar.gz: 0acbe1b4cb4bee3fb3125f0ac5104c7e5221c8c8cae5c6d766d87c5675859efa788f04ff0ac027be19de06da4c7c45d0a671a050b3d60c96b7f41ab4136eee90

data/.rspec

@@ -1,4 +1,5 @@
 --color
 --format documentation
 --backtrace
---default_path spec
+--order random
+--warnings

data/.travis.yml

@@ -1,17 +1,17 @@
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.0
+  - 2.1.1
   - ruby-head
   - jruby
   - jruby-head
-  - rbx
+  - rbx-2
 
 matrix:
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
-    - rvm: rbx
+    - rvm: rbx-2
 
 notifications:
   irc: "irc.freenode.org#celluloid"

data/CHANGES.md

@@ -1,3 +1,12 @@
+1.0.1 (2014-09-01)
+------------------
+* Fix C compiler warnings
+* Eliminate Ruby warnings about @lock_holder
+* Windows improvements
+* Better support for Ruby 2.1
+* Automatically require 'set'
+* Update to RSpec 3
+
 1.0.0 (2014-01-14)
 ------------------
 * Have Selector#register obtain the actual IO from a Monitor object

data/README.md

@@ -137,13 +137,19 @@ if you aren't concerned with thread safety, or you're within a #select
 block:
 
 - ***#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
+- ***#readiness***: what I/O operations the monitored object is ready for
 - ***#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)
 
+### Flow Control
+
+For information on how to compose nio4r selectors inside of event loops,
+please read the [Flow Control Guide on the
+Wiki](https://github.com/celluloid/nio4r/wiki/Basic-Flow-Control)
+
 Concurrency
 -----------
 

data/ext/libev/ev.c

@@ -3242,7 +3242,7 @@ time_update (EV_P_ ev_tstamp max_block)
 }
 
 /* ########## NIO4R PATCHERY HO! ########## */
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
 struct ev_poll_args {
   struct ev_loop *loop;
   ev_tstamp waittime;
@@ -3262,7 +3262,7 @@ int
 ev_run (EV_P_ int flags)
 {
 /* ########## NIO4R PATCHERY HO! ########## */
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
     struct ev_poll_args poll_args;
 #endif
 /* ######################################## */
@@ -3425,10 +3425,24 @@ rb_thread_unsafe_dangerous_crazy_blocking_region_end(...);
 #######################################################################
 */
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+/*
+  simulate to rb_thread_call_without_gvl using rb_theread_blocking_region.
+  https://github.com/brianmario/mysql2/blob/master/ext/mysql2/client.h#L8
+*/
+
+#ifndef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+
+#define rb_thread_call_without_gvl(func, data1, ubf, data2) \
+  rb_thread_blocking_region((rb_blocking_function_t *)func, data1, ubf, data2)
+
+#endif
+#endif
+
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
         poll_args.loop = loop;
         poll_args.waittime = waittime;
-        rb_thread_blocking_region(ev_backend_poll, (void *)&poll_args, RUBY_UBF_IO, 0);
+        rb_thread_call_without_gvl(ev_backend_poll, (void *)&poll_args, RUBY_UBF_IO, 0);
 #else
         backend_poll (EV_A_ waittime);
 #endif

data/ext/nio4r/extconf.rb

@@ -4,6 +4,10 @@ if have_func('rb_thread_blocking_region')
   $defs << '-DHAVE_RB_THREAD_BLOCKING_REGION'
 end
 
+if have_func('rb_thread_call_without_gvl')
+  $defs << '-DHAVE_RB_THEREAD_CALL_WITHOUT_GVL'
+end
+
 if have_header('sys/select.h')
   $defs << '-DEV_USE_SELECT'
 end
@@ -28,6 +32,10 @@ if have_header('sys/resource.h')
   $defs << '-DHAVE_SYS_RESOURCE_H'
 end
 
+if RUBY_VERSION.to_f < 1.9
+  $defs << '-DHAVE_RUBYSIG_H'
+end
+
 dir_config 'nio4r_ext'
 create_makefile 'nio4r_ext'
 
@@ -41,4 +49,4 @@ if RUBY_PLATFORM =~ /mingw|win32/
 
   makefile_contents.gsub! 'LIBS = $(LIBRUBYARG_SHARED)', 'LIBS = -lws2_32 $(LIBRUBYARG_SHARED)'
   File.open('Makefile', 'w') { |f| f.write makefile_contents }
-end
+end

data/ext/nio4r/monitor.c

@@ -26,9 +26,6 @@ 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);
-
 #if HAVE_RB_IO_T
   rb_io_t *fptr;
 #else
@@ -214,4 +211,4 @@ static VALUE NIO_Monitor_is_writable(VALUE self)
     } else {
         return Qfalse;
     }
-}
+}

data/ext/nio4r/nio4r.h

@@ -7,7 +7,11 @@
 #define NIO4R_H
 
 #include "ruby.h"
-#include "rubyio.h"
+#if HAVE_RUBY_IO_H
+# include "ruby/io.h"
+#else
+# include "rubyio.h"
+#endif
 #include "libev.h"
 
 struct NIO_Selector

data/ext/nio4r/selector.c

@@ -4,7 +4,9 @@
  */
 
 #include "nio4r.h"
-#include "rubysig.h"
+#ifdef HAVE_RUBYSIG_H
+# include "rubysig.h"
+#endif
 #include <unistd.h>
 #include <fcntl.h>
 #include <assert.h>
@@ -36,8 +38,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_close_synchronized(VALUE self);
-static VALUE NIO_Selector_closed_synchronized(VALUE self);
+static VALUE NIO_Selector_close_synchronized(VALUE *args);
+static VALUE NIO_Selector_closed_synchronized(VALUE *args);
 
 static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout);
 static void NIO_Selector_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents);
@@ -146,9 +148,11 @@ static VALUE NIO_Selector_initialize(VALUE self)
     VALUE lock;
 
     rb_ivar_set(self, rb_intern("selectables"), rb_hash_new());
+    rb_ivar_set(self, rb_intern("lock_holder"), Qnil);
 
     lock = rb_class_new_instance(0, 0, rb_const_get(rb_cObject, rb_intern("Mutex")));
     rb_ivar_set(self, rb_intern("lock"), lock);
+    rb_ivar_set(self, rb_intern("lock_holder"), Qnil);
 
     return Qnil;
 }
@@ -161,10 +165,10 @@ static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VA
     current_thread = rb_thread_current();
     lock_holder = rb_ivar_get(self, rb_intern("lock_holder"));
 
-    if(lock_holder != rb_thread_current()) {
+    if(lock_holder != current_thread) {
         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());
+        rb_ivar_set(self, rb_intern("lock_holder"), current_thread);
 
         /* We've acquired the lock, so ensure we unlock it */
         return rb_ensure(func, (VALUE)args, NIO_Selector_unlock, self);
@@ -237,8 +241,7 @@ static VALUE NIO_Selector_deregister(VALUE self, VALUE io)
 /* Internal implementation of register after acquiring mutex */
 static VALUE NIO_Selector_deregister_synchronized(VALUE *args)
 {
-    VALUE self, io, interests, selectables, monitor;
-    VALUE monitor_args[3];
+    VALUE self, io, selectables, monitor;
 
     self = args[0];
     io = args[1];
@@ -265,7 +268,7 @@ static VALUE NIO_Selector_is_registered(VALUE self, VALUE io)
 /* Select from all registered IO objects */
 static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self)
 {
-    VALUE timeout, array;
+    VALUE timeout;
     VALUE args[2];
 
     rb_scan_args(argc, argv, "01", &timeout);
@@ -283,7 +286,7 @@ static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self)
 /* Internal implementation of select with the selector lock held */
 static VALUE NIO_Selector_select_synchronized(VALUE *args)
 {
-    int i, ready;
+    int ready;
     VALUE ready_array;
     struct NIO_Selector *selector;
 
@@ -312,7 +315,7 @@ static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
     int result;
     selector->selecting = 1;
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_ALONE)
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) || defined(HAVE_RB_THREAD_ALONE)
     /* Implement the optional timeout (if any) as a ev_timer */
     if(timeout != Qnil) {
         /* It seems libev is not a fan of timers being zero, so fudge a little */
@@ -326,7 +329,7 @@ static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
     ev_tstamp started_at = ev_now(selector->ev_loop);
 #endif
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
     /* libev is patched to release the GIL when it makes its system call */
     ev_loop(selector->ev_loop, EVLOOP_ONESHOT);
 #elif defined(HAVE_RB_THREAD_ALONE)
@@ -337,7 +340,7 @@ static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
     if(0) {
 #endif /* defined(HAVE_RB_THREAD_BLOCKING_REGION) */
 
-#if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#if !defined(HAVE_RB_THREAD_BLOCKING_REGION) && !defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
         TRAP_BEG;
         ev_loop(selector->ev_loop, EVLOOP_ONESHOT);
         TRAP_END;
@@ -388,12 +391,14 @@ static VALUE NIO_Selector_wakeup(VALUE self)
 /* Close the selector and free system resources */
 static VALUE NIO_Selector_close(VALUE self)
 {
-    return NIO_Selector_synchronize(self, NIO_Selector_close_synchronized, self);
+    VALUE args[1] = {self};
+    return NIO_Selector_synchronize(self, NIO_Selector_close_synchronized, args);
 }
 
-static VALUE NIO_Selector_close_synchronized(VALUE self)
+static VALUE NIO_Selector_close_synchronized(VALUE *args)
 {
     struct NIO_Selector *selector;
+    VALUE self = args[0];
     Data_Get_Struct(self, struct NIO_Selector, selector);
 
     NIO_Selector_shutdown(selector);
@@ -404,11 +409,14 @@ static VALUE NIO_Selector_close_synchronized(VALUE self)
 /* Is the selector closed? */
 static VALUE NIO_Selector_closed(VALUE self)
 {
-    return NIO_Selector_synchronize(self, NIO_Selector_closed_synchronized, self);
+    VALUE args[1] = {self};
+    return NIO_Selector_synchronize(self, NIO_Selector_closed_synchronized, args);
 }
 
-static VALUE NIO_Selector_closed_synchronized(VALUE self)
-{    struct NIO_Selector *selector;
+static VALUE NIO_Selector_closed_synchronized(VALUE *args)
+{
+    struct NIO_Selector *selector;
+    VALUE self = args[0];
     Data_Get_Struct(self, struct NIO_Selector, selector);
 
     return selector->closed ? Qtrue : Qfalse;

data/lib/nio.rb

@@ -11,7 +11,7 @@ module NIO
   def self.engine; ENGINE end
 end
 
-if ENV["NIO4R_PURE"] || (ENV["OS"] =~ /Windows/i && !defined?(JRUBY_VERSION))
+if ENV["NIO4R_PURE"] || (Gem.win_platform? && !defined?(JRUBY_VERSION))
   require 'nio/monitor'
   require 'nio/selector'
   NIO::ENGINE = 'select'

data/lib/nio/selector.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module NIO
   # Selectors monitor IO objects for events of interest
   class Selector

data/lib/nio/version.rb

@@ -1,3 +1,3 @@
 module NIO
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/nio4r.gemspec

@@ -7,6 +7,7 @@ Gem::Specification.new do |gem|
   gem.description   = "New IO for Ruby"
   gem.summary       = "NIO provides a high performance selector API for monitoring IO objects"
   gem.homepage      = "https://github.com/celluloid/nio4r"
+  gem.license       = "MIT"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
@@ -24,5 +25,5 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency "rake-compiler"
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rspec", "~> 3.0.0"
 end

data/spec/nio/acceptables_spec.rb

@@ -9,8 +9,8 @@ describe "NIO acceptables" do
       ready_monitor   = selector.register(acceptable_subject, :r)
 
       ready_monitors = selector.select
-      ready_monitors.should include ready_monitor
-      ready_monitors.should_not include waiting_monitor
+      expect(ready_monitors).to include ready_monitor
+      expect(ready_monitors).not_to include waiting_monitor
     end
   end
 

data/spec/nio/monitor_spec.rb

@@ -11,21 +11,21 @@ describe NIO::Monitor do
   after      { selector.close }
 
   it "knows its interests" do
-    subject.interests.should == :r
-    peer.interests.should == :rw
+    expect(subject.interests).to eq(:r)
+    expect(peer.interests).to eq(:rw)
   end
 
   it "knows its IO object" do
-    subject.io.should == reader
+    expect(subject.io).to eq(reader)
   end
 
   it "knows its selector" do
-    subject.selector.should == selector
+    expect(subject.selector).to eq(selector)
   end
 
   it "stores arbitrary values" do
     subject.value = 42
-    subject.value.should == 42
+    expect(subject.value).to eq(42)
   end
 
   it "knows what operations IO objects are ready for" do
@@ -33,29 +33,29 @@ describe NIO::Monitor do
     reader_monitor, writer_monitor = subject, peer
 
     selected = selector.select(0)
-    selected.should_not include(reader_monitor)
-    selected.should include(writer_monitor)
+    expect(selected).not_to include(reader_monitor)
+    expect(selected).to include(writer_monitor)
 
-    writer_monitor.readiness.should == :w
-    writer_monitor.should_not be_readable
-    writer_monitor.should be_writable
+    expect(writer_monitor.readiness).to eq(:w)
+    expect(writer_monitor).not_to be_readable
+    expect(writer_monitor).to be_writable
 
     writer << "loldata"
 
     selected = selector.select(0)
-    selected.should include(reader_monitor)
+    expect(selected).to include(reader_monitor)
 
-    reader_monitor.readiness.should == :r
-    reader_monitor.should be_readable
-    reader_monitor.should_not be_writable
+    expect(reader_monitor.readiness).to eq(:r)
+    expect(reader_monitor).to be_readable
+    expect(reader_monitor).not_to be_writable
   end
 
   it "closes" do
-    subject.should_not be_closed
-    selector.registered?(reader).should be_true
+    expect(subject).not_to be_closed
+    expect(selector.registered?(reader)).to be_truthy
 
     subject.close
-    subject.should be_closed
-    selector.registered?(reader).should be_false
+    expect(subject).to be_closed
+    expect(selector.registered?(reader)).to be_falsey
   end
 end

data/spec/nio/selectables/ssl_socket_spec.rb

@@ -111,7 +111,7 @@ describe OpenSSL::SSL::SSLSocket, :if => RUBY_VERSION >= "1.9.0" do
     begin
       _, writers = select [], [ssl_client], [], 0
       count = ssl_client.write_nonblock "X" * 1024
-      count.should_not == 0
+      expect(count).not_to eq(0)
     rescue IO::WaitReadable, IO::WaitWritable
       pending "SSL will report writable but not accept writes"
       raise if(writers.include? ssl_client)

data/spec/nio/selectables/tcp_socket_spec.rb

@@ -80,9 +80,9 @@ describe TCPSocket do
         client.connect_nonblock Socket.sockaddr_in(tcp_port, '127.0.0.1')
       end.to raise_exception Errno::EINPROGRESS
 
-      selector.select(0).should include monitor
+      expect(selector.select(0)).to include monitor
       result = client.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR)
-      result.unpack('i').first.should be_zero
+      expect(result.unpack('i').first).to be_zero
     end
   end
 end

data/spec/nio/selector_spec.rb

@@ -13,7 +13,7 @@ describe NIO::Selector do
   context "register" do
     it "registers IO objects" do
       monitor = subject.register(reader, :r)
-      monitor.should_not be_closed
+      expect(monitor).not_to be_closed
     end
 
     it "raises TypeError if asked to register non-IO objects" do
@@ -28,24 +28,24 @@ describe NIO::Selector do
 
   it "knows which IO objects are registered" do
     subject.register(reader, :r)
-    subject.should be_registered(reader)
-    subject.should_not be_registered(writer)
+    expect(subject).to be_registered(reader)
+    expect(subject).not_to be_registered(writer)
   end
 
   it "deregisters IO objects" do
     subject.register(reader, :r)
 
     monitor = subject.deregister(reader)
-    subject.should_not be_registered(reader)
-    monitor.should be_closed
+    expect(subject).not_to be_registered(reader)
+    expect(monitor).to be_closed
   end
 
   it "reports if it is empty" do
-    subject.should be_empty
+    expect(subject).to be_empty
 
     monitor = subject.register(reader, :r)
 
-    subject.should_not be_empty
+    expect(subject).not_to be_empty
   end
 
   # This spec might seem a bit silly, but this actually something the
@@ -54,14 +54,14 @@ describe NIO::Selector do
     monitor = subject.register(reader, :r)
     writer << "ohai"
 
-    subject.select.should include monitor
-    reader.read(4).should == "ohai"
+    expect(subject.select).to include monitor
+    expect(reader.read(4)).to eq("ohai")
     subject.deregister(reader)
 
     new_monitor = subject.register(reader, :r)
     writer << "thar"
-    subject.select.should include new_monitor
-    reader.read(4).should == "thar"
+    expect(subject.select).to include new_monitor
+    expect(reader.read(4)).to eq("thar")
   end
 
   context "timeouts" do
@@ -73,13 +73,13 @@ describe NIO::Selector do
 
       timeout = 0.5
       started_at = Time.now
-      subject.select(timeout).should include monitor
-      (Time.now - started_at).should be_within(TIMEOUT_PRECISION).of(0)
+      expect(subject.select(timeout)).to include monitor
+      expect(Time.now - started_at).to be_within(TIMEOUT_PRECISION).of(0)
       reader.read_nonblock(payload.size)
 
       started_at = Time.now
-      subject.select(timeout).should be_nil
-      (Time.now - started_at).should be_within(TIMEOUT_PRECISION).of(timeout)
+      expect(subject.select(timeout)).to be_nil
+      expect(Time.now - started_at).to be_within(TIMEOUT_PRECISION).of(timeout)
     end
 
     it "raises ArgumentError if given a negative timeout" do
@@ -95,7 +95,7 @@ describe NIO::Selector do
 
       thread = Thread.new do
         started_at = Time.now
-        subject.select.should be_nil
+        expect(subject.select).to be_nil
         Time.now - started_at
       end
 
@@ -103,12 +103,12 @@ describe NIO::Selector do
       sleep timeout
       subject.wakeup
 
-      thread.value.should be_within(TIMEOUT_PRECISION).of(timeout)
+      expect(thread.value).to be_within(TIMEOUT_PRECISION).of(timeout)
     end
 
     it "raises IOError if asked to wake up a closed selector" do
       subject.close
-      subject.should be_closed
+      expect(subject).to be_closed
 
       expect { subject.wakeup }.to raise_exception IOError
     end
@@ -123,21 +123,21 @@ describe NIO::Selector do
       unready_monitor = subject.register(unready, :r)
 
       selected = subject.select(0)
-      selected.size.should == 1
-      selected.should include reader_monitor
-      selected.should_not include unready_monitor
+      expect(selected.size).to eq(1)
+      expect(selected).to include reader_monitor
+      expect(selected).not_to include unready_monitor
     end
 
     it "selects closed IO objects" do
       monitor = subject.register(reader, :r)
-      subject.select(0).should be_nil
+      expect(subject.select(0)).to be_nil
 
       thread = Thread.new { subject.select }
       Thread.pass while thread.status && thread.status != "sleep"
 
       writer.close
       selected = thread.value
-      selected.should include monitor
+      expect(selected).to include monitor
     end
 
     it "iterates across selected objects with a block" do
@@ -155,16 +155,16 @@ describe NIO::Selector do
 
       readables = []
       result = subject.select { |monitor| readables << monitor }
-      result.should == 2
+      expect(result).to eq(2)
 
-      readables.should include monitor1
-      readables.should include monitor2
-      readables.should_not include monitor3
+      expect(readables).to include monitor1
+      expect(readables).to include monitor2
+      expect(readables).not_to include monitor3
     end
   end
 
   it "closes" do
     subject.close
-    subject.should be_closed
+    expect(subject).to be_closed
   end
 end

data/spec/support/selectable_examples.rb

@@ -4,25 +4,25 @@ shared_context "an NIO selectable" do
   it "selects readable objects" do
     monitor = selector.register(readable_subject, :r)
     ready = selector.select(0)
-    ready.should be_an Enumerable
-    ready.should include monitor
+    expect(ready).to be_an Enumerable
+    expect(ready).to include monitor
   end
 
   it "does not select unreadable objects" do
     monitor = selector.register(unreadable_subject, :r)
-    selector.select(0).should be_nil
+    expect(selector.select(0)).to be_nil
   end
 
   it "selects writable objects" do
     monitor = selector.register(writable_subject, :w)
     ready = selector.select(0)
-    ready.should be_an Enumerable
-    ready.should include monitor
+    expect(ready).to be_an Enumerable
+    expect(ready).to include monitor
   end
 
   it "does not select unwritable objects" do
     monitor = selector.register(unwritable_subject, :w)
-    selector.select(0).should be_nil
+    expect(selector.select(0)).to be_nil
   end
 end
 
@@ -32,12 +32,15 @@ shared_context "an NIO selectable stream" do
   let(:peer)     { pair.last }
 
   it "selects readable when the other end closes" do
+    # hax: this test is broken for OpenSSL sockets
+    skip 'broken for SSL ;_;' if peer.is_a? OpenSSL::SSL::SSLSocket
+
     monitor = selector.register(stream, :r)
-    selector.select(0).should be_nil
+    expect(selector.select(0)).to be_nil
 
     peer.close
     #Wait and give the TCP session time to close
-    selector.select(0.1).should include monitor
+    expect(selector.select(0.1)).to include monitor
   end
 end
 
@@ -49,7 +52,7 @@ shared_context "an NIO bidirectional stream" do
   it "selects readable and writable" do
     monitor = selector.register(readable_subject, :rw)
     selector.select(0) do |m|
-      m.readiness.should == :rw
+      expect(m.readiness).to eq(:rw)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nio4r
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-15 00:00:00.000000000 Z
+date: 2014-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -42,16 +42,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
 description: New IO for Ruby
 email:
 - tony.arcieri@gmail.com
@@ -109,7 +109,8 @@ files:
 - tasks/extension.rake
 - tasks/rspec.rake
 homepage: https://github.com/celluloid/nio4r
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -127,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: NIO provides a high performance selector API for monitoring IO objects