nio4r 0.3.1 → 0.3.2

data/CHANGES.md

@@ -1,3 +1,13 @@
+0.3.2
+-----
+* NIO::Selector#select_each removed
+* Remove event buffer
+* Patch GIL unlock directly into libev
+
+0.3.1
+-----
+* Prevent CancelledKeyExceptions on JRuby
+
 0.3.0
 -----
 * NIO::Selector#select now takes a block and behaves like select_each

data/examples/echo_server.rb

@@ -17,7 +17,7 @@ class EchoServer
 
   def run
     while true
-      @selector.select_each { |monitor| monitor.value.call(monitor) }
+      @selector.select { |monitor| monitor.value.call(monitor) }
     end
   end
 

data/ext/libev/ev.c

@@ -37,6 +37,10 @@
  * either the BSD or the GPL.
  */
 
+/* ########## NIO4R PATCHERY HO! ########## */
+#include "ruby.h"
+/* ######################################## */
+
 /* this big block deduces configuration from config.h */
 #ifndef EV_STANDALONE
 # ifdef EV_CONFIG_H
@@ -2926,9 +2930,32 @@ time_update (EV_P_ ev_tstamp max_block)
     }
 }
 
+/* ########## NIO4R PATCHERY HO! ########## */
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+struct ev_poll_args {
+  struct ev_loop *loop;
+  ev_tstamp waittime;
+};
+
+static
+VALUE ev_backend_poll(void *ptr)
+{
+  struct ev_poll_args *args = (struct ev_poll_args *)ptr;
+  struct ev_loop *loop = args->loop;
+  backend_poll (EV_A_ args->waittime);
+}
+#endif
+/* ######################################## */
+
 void
 ev_run (EV_P_ int flags)
 {
+/* ########## NIO4R PATCHERY HO! ########## */
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+    struct ev_poll_args poll_args;
+#endif
+/* ######################################## */
+
 #if EV_FEATURE_API
   ++loop_depth;
 #endif
@@ -3046,7 +3073,50 @@ ev_run (EV_P_ int flags)
         ++loop_count;
 #endif
         assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
+
+/*
+########################## NIO4R PATCHERY HO! ##########################
+
+According to the grandwizards of Ruby, locking and unlocking of the global
+interpreter lock are apparently too powerful a concept for a mere mortal to
+wield (although redefining what + and - do to numbers is totally cool).
+And so it came to pass that the only acceptable way to release the global
+interpreter lock is through a convoluted callback system that thakes a
+function pointer. While the grandwizard of libev foresaw this sort of scenario,
+he too attempted to place an API with callbacks on it, one that runs before
+the system call, and one that runs immediately after.
+
+And so it came to pass that trying to wrap everything up in callbacks created
+two incompatible APIs, Ruby's which releases the global interpreter lock and
+reacquires it when the callback returns, and libev's, which wants two
+callbacks, one which runs before the polling operation starts, and one which
+runs after it finishes.
+
+These two systems are incompatible as they both want to use callbacks to
+solve the same problem, however libev wants to use before/after callbacks,
+and Ruby wants to use an "around" callback. This presents a significant
+problem as these two patterns of callbacks are diametrical opposites of each
+other and thus cannot be composed.
+
+And thus we are left with no choice but to patch the internals of libev in
+order to release a mutex at just the precise moment.
+
+Let this be a lesson to the all: CALLBACKS FUCKING BLOW
+
+#######################################################################
+*/
+
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+        poll_args.loop = loop;
+        poll_args.waittime = waittime;
+        rb_thread_blocking_region(ev_backend_poll, (void *)&poll_args, RUBY_UBF_IO, 0);
+#else
         backend_poll (EV_A_ waittime);
+#endif
+/*
+############################# END PATCHERY ############################
+*/
+
         assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
 
         pipe_write_wanted = 0; /* just an optimisation, no fence needed */

data/ext/nio4r/monitor.c

@@ -4,7 +4,6 @@
  */
 
 #include "nio4r.h"
-#include <assert.h>
 
 static VALUE mNIO = Qnil;
 static VALUE cNIO_Monitor = Qnil;
@@ -101,7 +100,7 @@ static VALUE NIO_Monitor_initialize(VALUE self, VALUE io, VALUE interests, VALUE
     }
 
     GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
-    ev_io_init(&monitor->ev_io, NIO_Monitor_callback, FPTR_TO_FD(fptr), monitor->interests);
+    ev_io_init(&monitor->ev_io, NIO_Selector_monitor_callback, FPTR_TO_FD(fptr), monitor->interests);
 
     rb_ivar_set(self, rb_intern("io"), io);
     rb_ivar_set(self, rb_intern("interests"), interests);
@@ -215,15 +214,4 @@ static VALUE NIO_Monitor_is_writable(VALUE self)
     } 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

@@ -19,8 +19,8 @@ struct NIO_Selector
     int wakeup_reader, wakeup_writer;
     int closed, selecting;
     int ready_count;
-    int ready_buffer_size;
-    VALUE *ready_buffer;
+
+    VALUE ready_array;
 };
 
 struct NIO_callback_data
@@ -50,6 +50,6 @@ struct NIO_Monitor
 #endif /* GetReadFile */
 
 /* Thunk between libev callbacks in NIO::Monitors and NIO::Selectors */
-void NIO_Selector_handle_event(struct NIO_Selector *selector, VALUE monitor, int revents);
+void NIO_Selector_monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
 
 #endif /* NIO4R_H */

data/ext/nio4r/org/nio4r/Nio4r.java

@@ -134,13 +134,13 @@ public class Nio4r implements Library {
         @JRubyMethod
         public IRubyObject register(ThreadContext context, IRubyObject io, IRubyObject interests) {
             Ruby runtime = context.getRuntime();
-            Channel raw_channel = RubyIO.convertToIO(context, io).getChannel();
+            Channel rawChannel = RubyIO.convertToIO(context, io).getChannel();
 
-            if(!(raw_channel instanceof SelectableChannel)) {
+            if(!(rawChannel instanceof SelectableChannel)) {
                 throw runtime.newArgumentError("not a selectable IO object");
             }
 
-            SelectableChannel channel = (SelectableChannel)raw_channel;
+            SelectableChannel channel = (SelectableChannel)rawChannel;
 
             try {
                 channel.configureBlocking(false);
@@ -175,13 +175,13 @@ public class Nio4r implements Library {
         @JRubyMethod
         public IRubyObject deregister(ThreadContext context, IRubyObject io) {
             Ruby runtime = context.getRuntime();
-            Channel raw_channel = RubyIO.convertToIO(context, io).getChannel();
+            Channel rawChannel = RubyIO.convertToIO(context, io).getChannel();
 
-            if(!(raw_channel instanceof SelectableChannel)) {
+            if(!(rawChannel instanceof SelectableChannel)) {
                 throw runtime.newArgumentError("not a selectable IO object");
             }
 
-            SelectableChannel channel = (SelectableChannel)raw_channel;
+            SelectableChannel channel = (SelectableChannel)rawChannel;
             SelectionKey key = channel.keyFor(this.selector);
 
             if(key == null)
@@ -197,13 +197,13 @@ public class Nio4r implements Library {
         @JRubyMethod(name = "registered?")
         public IRubyObject isRegistered(ThreadContext context, IRubyObject io) {
             Ruby runtime = context.getRuntime();
-            Channel raw_channel = RubyIO.convertToIO(context, io).getChannel();
+            Channel rawChannel = RubyIO.convertToIO(context, io).getChannel();
 
-            if(!(raw_channel instanceof SelectableChannel)) {
+            if(!(rawChannel instanceof SelectableChannel)) {
                 throw runtime.newArgumentError("not a selectable IO object");
             }
 
-            SelectableChannel channel = (SelectableChannel)raw_channel;
+            SelectableChannel channel = (SelectableChannel)rawChannel;
             SelectionKey key = channel.keyFor(this.selector);
 
             if(key == null)
@@ -256,40 +256,9 @@ public class Nio4r implements Library {
             }
         }
 
-        @JRubyMethod
-        public synchronized IRubyObject select_each(ThreadContext context, Block block) {
-            return select_each(context, context.nil, block);
-        }
-
-        @JRubyMethod
-        public synchronized IRubyObject select_each(ThreadContext context, IRubyObject timeout, Block block) {
-            Ruby runtime = context.getRuntime();
-            int ready = doSelect(runtime, timeout);
-
-            /* Timeout or wakeup */
-            if(ready <= 0)
-                return context.nil;
-
-            Iterator selectedKeys = this.selector.selectedKeys().iterator();
-            while (selectedKeys.hasNext()) {
-                SelectionKey key = (SelectionKey)selectedKeys.next();
-                processKey(key);
-                selectedKeys.remove();
-                block.call(context, (IRubyObject)key.attachment());
-            }
-
-            return context.nil;
-        }
-
+        /* Run the selector */
         private int doSelect(Ruby runtime, IRubyObject timeout) {
-            Iterator cancelledKeys = this.cancelledKeys.entrySet().iterator();
-            while(cancelledKeys.hasNext()) {
-                Map.Entry entry = (Map.Entry)cancelledKeys.next();
-                SelectionKey key = (SelectionKey)entry.getValue();
-                key.cancel();
-                cancelledKeys.remove();
-            }
-
+            cancelKeys();
             try {
                 if(timeout.isNil()) {
                     return this.selector.select();
@@ -308,6 +277,17 @@ public class Nio4r implements Library {
             }
         }
 
+        /* Flush our internal buffer of cancelled keys */
+        private void cancelKeys() {
+            Iterator cancelledKeys = this.cancelledKeys.entrySet().iterator();
+            while(cancelledKeys.hasNext()) {
+                Map.Entry entry = (Map.Entry)cancelledKeys.next();
+                SelectionKey key = (SelectionKey)entry.getValue();
+                key.cancel();
+                cancelledKeys.remove();
+            }
+        }
+
         // Remove connect interest from connected sockets
         // See: http://stackoverflow.com/questions/204186/java-nio-select-returns-without-selected-keys-why
         private void processKey(SelectionKey key) {

data/ext/nio4r/selector.c

@@ -7,6 +7,7 @@
 #include "rubysig.h"
 #include <unistd.h>
 #include <fcntl.h>
+#include <assert.h>
 
 static VALUE mNIO = Qnil;
 static VALUE cNIO_Monitor  = Qnil;
@@ -24,7 +25,6 @@ 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);
@@ -35,9 +35,7 @@ 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 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);
 static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
 
@@ -59,7 +57,6 @@ 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);
@@ -99,8 +96,7 @@ static VALUE NIO_Selector_allocate(VALUE klass)
     ev_io_start(selector->ev_loop, &selector->wakeup);
 
     selector->closed = selector->selecting = selector->ready_count = 0;
-    selector->ready_buffer_size = INITIAL_READY_BUFFER;
-    selector->ready_buffer = (VALUE *)xmalloc(sizeof(VALUE) * INITIAL_READY_BUFFER);
+    selector->ready_array = Qnil;
 
     return Data_Wrap_Struct(klass, NIO_Selector_mark, NIO_Selector_free, selector);
 }
@@ -108,6 +104,9 @@ static VALUE NIO_Selector_allocate(VALUE klass)
 /* NIO selectors store all Ruby objects in instance variables so mark is a stub */
 static void NIO_Selector_mark(struct NIO_Selector *selector)
 {
+    if(selector->ready_array != Qnil) {
+        rb_gc_mark(selector->ready_array);
+    }
 }
 
 /* Free a Selector's system resources.
@@ -133,8 +132,6 @@ static void NIO_Selector_shutdown(struct NIO_Selector *selector)
 static void NIO_Selector_free(struct NIO_Selector *selector)
 {
     NIO_Selector_shutdown(selector);
-
-    xfree(selector->ready_buffer);
     xfree(selector);
 }
 
@@ -271,81 +268,36 @@ 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);
-
-    if(timeout != Qnil && NUM2DBL(timeout) < 0) {
-        rb_raise(rb_eArgError, "time interval must be positive");
-    }
-
-    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)
 {
+    int i, ready;
+    VALUE ready_array;
     struct NIO_Selector *selector;
-    int i, ready = NIO_Selector_fill_ready_buffer(args);
 
     Data_Get_Struct(args[0], struct NIO_Selector, selector);
+    if(!rb_block_given_p()) {
+        selector->ready_array = rb_ary_new();
+    }
 
+    ready = NIO_Selector_run(selector, args[1]);
     if(ready > 0) {
         if(rb_block_given_p()) {
-            for(i = 0; i < ready; i++) {
-                rb_yield(selector->ready_buffer[i]);
-            }
-
             return INT2NUM(ready);
         } else {
-            /* new4 memcpys the ready buffer */
-            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]);
+            ready_array = selector->ready_array;
+            selector->ready_array = Qnil;
+            return ready_array;
         }
-
-        return INT2NUM(ready);
     } else {
+        selector->ready_array = Qnil;
         return Qnil;
     }
 }
 
-static int NIO_Selector_fill_ready_buffer(VALUE *args)
+static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
 {
-    VALUE self, timeout;
-    struct NIO_Selector *selector;
     int result;
-
-    self = args[0];
-    timeout = args[1];
-
-    Data_Get_Struct(self, struct NIO_Selector, selector);
     selector->selecting = 1;
 
 #if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_ALONE)
@@ -363,8 +315,8 @@ static int NIO_Selector_fill_ready_buffer(VALUE *args)
 #endif
 
 #if defined(HAVE_RB_THREAD_BLOCKING_REGION)
-    /* Ruby 1.9 lets us release the GIL and make a blocking I/O call */
-    rb_thread_blocking_region(NIO_Selector_run_evloop, selector, RUBY_UBF_IO, 0);
+    /* 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)
     /* If we're the only thread we can make a blocking system call */
     if(rb_thread_alone()) {
@@ -375,7 +327,7 @@ static int NIO_Selector_fill_ready_buffer(VALUE *args)
 
 #if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
         TRAP_BEG;
-        NIO_Selector_run_evloop(selector);
+        ev_loop(selector->ev_loop, EVLOOP_ONESHOT);
         TRAP_END;
     } else {
         /* We need to busy wait as not to stall the green thread scheduler
@@ -386,7 +338,7 @@ static int NIO_Selector_fill_ready_buffer(VALUE *args)
         /* Loop until we receive events */
         while(selector->selecting && !selector->ready_count) {
             TRAP_BEG;
-            NIO_Selector_run_evloop(selector);
+            ev_loop(selector->ev_loop, EVLOOP_ONESHOT);
             TRAP_END;
 
             /* Run the next green thread */
@@ -407,16 +359,6 @@ static int NIO_Selector_fill_ready_buffer(VALUE *args)
     return result;
 }
 
-/* Run the libev event loop */
-static VALUE NIO_Selector_run_evloop(void *ptr)
-{
-    struct NIO_Selector *selector = (struct NIO_Selector *)ptr;
-
-    ev_loop(selector->ev_loop, EVLOOP_ONESHOT);
-
-    return Qnil;
-}
-
 /* Wake the selector up from another thread */
 static VALUE NIO_Selector_wakeup(VALUE self)
 {
@@ -428,7 +370,6 @@ static VALUE NIO_Selector_wakeup(VALUE self)
     }
 
     write(selector->wakeup_writer, "\0", 1);
-
     return Qnil;
 }
 
@@ -470,27 +411,21 @@ static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_io *
     while(read(selector->wakeup_reader, buffer, 128) > 0);
 }
 
-/* This gets called from individual monitors. We must be careful here because
-   the GIL isn't held, so we must rely only on standard C and can't touch
-   anything Ruby-related.
-
-   It's scary because there's a VALUE here, and VALUEs are a Ruby thing,
-   however we're not going to dereference that VALUE or attempt to do anything
-   with it. We just treat it as completely opaque until we have the GIL back.
-
-   In order for this function to even get called, the monitor the VALUE points to
-   must be attached to this Selector, and if it's attached to this Selector
-   then we hold a reference to it in the @selectables instance variable, so
-   there's no danger of this monitor getting garbage collected before we have
-   the GIL back as we hold a reference. */
-void NIO_Selector_handle_event(struct NIO_Selector *selector, VALUE monitor, int revents)
+/* libev callback fired whenever a monitor gets an event */
+void NIO_Selector_monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents)
 {
-    /* Grow the ready buffer if it's too small */
-    if(selector->ready_count >= selector->ready_buffer_size) {
-      selector->ready_buffer_size *= 2;
-      selector->ready_buffer = (VALUE *)xrealloc(selector->ready_buffer, sizeof(VALUE) * selector->ready_buffer_size);
-    }
+    struct NIO_Monitor *monitor_data = (struct NIO_Monitor *)io->data;
+    struct NIO_Selector *selector = monitor_data->selector;
+    VALUE monitor = monitor_data->self;
 
-    selector->ready_buffer[selector->ready_count] = monitor;
+    assert(selector != 0);
     selector->ready_count++;
+    monitor_data->revents = revents;
+
+    if(rb_block_given_p()) {
+        rb_yield(monitor);
+    } else {
+        assert(selector->ready_array != Qnil);
+        rb_ary_push(selector->ready_array, monitor);
+    }
 }

data/lib/nio/selector.rb

@@ -107,14 +107,6 @@ module NIO
       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 a thread that's in the middle of selecting on this selector, if
     # any such thread exists.
     #

data/lib/nio/version.rb

@@ -1,3 +1,3 @@
 module NIO
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/spec/nio/selectables_spec.rb

@@ -39,14 +39,18 @@ describe "NIO selectables" do
   describe "IO.pipe" do
     let(:pair) { IO.pipe }
 
-    let :unreadable_subject do pair.first end
+    let :unreadable_subject do
+      pair.first
+    end
     let :readable_subject do
       pipe, peer = pair
       peer << "data"
       pipe
     end
 
-    let :writable_subject do pair.last end
+    let :writable_subject do
+      pair.last
+    end
     let :unwritable_subject do
       reader, pipe = IO.pipe
 

data/spec/nio/selector_spec.rb

@@ -138,45 +138,6 @@ 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nio4r
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-12 00:00:00.000000000 Z
+date: 2012-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: &70256512025560 !ruby/object:Gem::Requirement
+  requirement: &70242529573760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70256512025560
+  version_requirements: *70242529573760
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70256512024940 !ruby/object:Gem::Requirement
+  requirement: &70242529573340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70256512024940
+  version_requirements: *70242529573340
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70256512040740 !ruby/object:Gem::Requirement
+  requirement: &70242529572920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70256512040740
+  version_requirements: *70242529572920
 description: New IO for Ruby
 email:
 - tony.arcieri@gmail.com