celluloid-io 0.13.1 → 0.14.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 254d0a9575a6c73e8ef8f797a4fe8097857a51b3
+  data.tar.gz: 0b8068ae30da210730735944d34c3140463b3946
+SHA512:
+  metadata.gz: 37e40fac8272a4ac1890d36dbab41ba11a90405fa36bea9275cfbe2b31c678f61b634a5ca4bfea0b3dbe0f5968a875283cab1f08e4a6870ba5983b366cbb2a71
+  data.tar.gz: b126f30e30822caf88f8582b63eeb2ed0d1891821b8ffc81d6d60291360be709b3e76c6db6e2c632f7203da965847dcbfb0dab59eb076aebe2f85528a439c25a

data/CHANGES.md

@@ -1,8 +1,3 @@
-0.13.1 (2013-04-04)
--------------------
-* Fix major performance regression: I/O backpressure (i.e. EAGAIN
-  handling) was being double-dispatched through the actor protocol.
-
 0.13.0
 ------
 * Support for many, many more IO methods, particularly line-oriented

data/Gemfile

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'coveralls', require: false
-gem 'celluloid', github: 'celluloid/celluloid', branch: '0-13-stable'
+gem 'celluloid', github: 'celluloid/celluloid', branch: 'master'

data/README.md

@@ -2,7 +2,6 @@
 ================
 [![Gem Version](https://badge.fury.io/rb/celluloid-io.png)](http://rubygems.org/gems/celluloid-io)
 [![Build Status](https://secure.travis-ci.org/celluloid/celluloid-io.png?branch=master)](http://travis-ci.org/celluloid/celluloid-io)
-[![Dependency Status](https://gemnasium.com/celluloid/celluloid-io.png)](https://gemnasium.com/celluloid/celluloid-io)
 [![Code Climate](https://codeclimate.com/github/celluloid/celluloid-io.png)](https://codeclimate.com/github/celluloid/celluloid-io)
 [![Coverage Status](https://coveralls.io/repos/celluloid/celluloid-io/badge.png?branch=master)](https://coveralls.io/r/celluloid/celluloid-io)
 

data/examples/echo_server.rb

@@ -7,6 +7,7 @@ require 'celluloid/io'
 
 class EchoServer
   include Celluloid::IO
+  finalizer :finalize
 
   def initialize(host, port)
     puts "*** Starting echo server on #{host}:#{port}"

data/examples/echo_unix_client.rb

@@ -3,6 +3,7 @@ require 'celluloid/io'
 
 class EchoUNIXClient
   include Celluloid::IO
+  finalizer :finalize
 
   def initialize(socket_path)
     puts "*** connecting to #{socket_path}"
@@ -25,4 +26,4 @@ class EchoUNIXClient
 end
 
 c = EchoUNIXClient.new("/tmp/sock_test")
-c.echo("DATA")
+c.echo("DATA")

data/examples/echo_unix_server.rb

@@ -3,7 +3,8 @@ require 'celluloid/io'
 
 class EchoUNIXServer
   include Celluloid::IO
-    
+  finalizer :finalize
+
   attr_reader :socket_path, :server
 
   def initialize(socket_path)
@@ -23,7 +24,7 @@ class EchoUNIXServer
       puts "*** gets data #{data}"
       socket.write(data)
     end
-  
+
   rescue EOFError
     puts "*** disconnected"
 

data/lib/celluloid/io.rb

@@ -23,11 +23,16 @@ module Celluloid
       klass.mailbox_class Celluloid::IO::Mailbox
     end
 
+    def self.evented?
+      actor = Thread.current[:celluloid_actor]
+      actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
+    end
+
     def wait_readable(io)
       io = io.to_io
-      actor = Thread.current[:celluloid_actor]
-      if actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
-        actor.mailbox.reactor.wait_readable(io)
+      if IO.evented?
+        mailbox = Thread.current[:celluloid_mailbox]
+        mailbox.reactor.wait_readable(io)
       else
         Kernel.select([io])
       end
@@ -37,9 +42,9 @@ module Celluloid
 
     def wait_writable(io)
       io = io.to_io
-      actor = Thread.current[:celluloid_actor]
-      if actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
-        actor.mailbox.reactor.wait_writable(io)
+      if IO.evented?
+        mailbox = Thread.current[:celluloid_mailbox]
+        mailbox.reactor.wait_writable(io)
       else
         Kernel.select([], [io])
       end

data/lib/celluloid/io/mailbox.rb

@@ -1,79 +1,9 @@
 module Celluloid
   module IO
     # An alternative implementation of Celluloid::Mailbox using Reactor
-    class Mailbox < Celluloid::Mailbox
-      attr_reader :reactor
-
-      def initialize(reactor = nil)
-        super()
-        # @condition won't be used in the class.
-        @reactor = reactor || Reactor.new
-      end
-
-      # Add a message to the Mailbox
-      def <<(message)
-        @mutex.lock
-        begin
-          if message.is_a?(SystemEvent)
-            # Silently swallow system events sent to dead actors
-            return if @dead
-
-            # SystemEvents are high priority messages so they get added to the
-            # head of our message queue instead of the end
-            @messages.unshift message
-          else
-            raise MailboxError, "dead recipient" if @dead
-            @messages << message
-          end
-          
-          current_actor = Thread.current[:celluloid_actor]
-          @reactor.wakeup unless current_actor && current_actor.mailbox == self
-        rescue IOError
-          raise MailboxError, "dead recipient"
-        ensure
-          @mutex.unlock rescue nil
-        end
-        nil
-      end
-
-      # Receive a message from the Mailbox
-      def receive(timeout = nil, &block)
-        message = next_message(block)
-
-        until message
-          if timeout
-            now = Time.now
-            wait_until ||= now + timeout
-            wait_interval = wait_until - now
-            return if wait_interval < 0
-          else
-            wait_interval = nil
-          end
-          
-          @reactor.run_once(wait_interval)
-          message = next_message(block)
-        end
-
-        message
-      rescue IOError
-        shutdown # force shutdown of the mailbox
-        raise MailboxShutdown, "mailbox shutdown called during receive"
-      end
-      
-      # Obtain the next message from the mailbox that matches the given block
-      def next_message(block)
-        @mutex.lock
-        begin
-          super(&block)
-        ensure
-          @mutex.unlock rescue nil
-        end
-      end
-
-      # Cleanup any IO objects this Mailbox may be using
-      def shutdown
-        @reactor.shutdown
-        super
+    class Mailbox < Celluloid::EventedMailbox
+      def initialize
+        super(Reactor)
       end
     end
   end

data/lib/celluloid/io/ssl_server.rb

@@ -5,7 +5,7 @@ module Celluloid
     # SSLServer wraps a TCPServer to provide immediate SSL accept
     class SSLServer
       extend Forwardable
-      def_delegators :@tcp_server, :listen, :shutdown, :close, :closed?, :to_io, :evented?
+      def_delegators :@tcp_server, :listen, :shutdown, :close, :closed?, :to_io
 
       attr_accessor :start_immediately
       attr_reader :tcp_server

data/lib/celluloid/io/stream.rb

@@ -29,12 +29,6 @@ module Celluloid
         @write_latch = Latch.new
       end
 
-      # Are we inside of a Celluloid::IO actor?
-      def evented?
-        actor = Thread.current[:celluloid_actor]
-        actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
-      end
-
       # Wait until the current object is readable
       def wait_readable; Celluloid::IO.wait_readable(self); end
 
@@ -195,7 +189,11 @@ module Celluloid
       # See also #gets
       def readlines(eol=$/)
         ary = []
-        ary << line while line = self.gets(eol)
+
+        while line = self.gets(eol)
+          ary << line
+        end
+
         ary
       end
 
@@ -215,7 +213,9 @@ module Celluloid
 
       # Calls the given block once for each byte in the stream.
       def each_byte # :yields: byte
-        yield(c.ord) while c = getc
+        while c = getc
+          yield(c.ord)
+        end
       end
 
       # Reads a one-character string from the stream.  Raises an EOFError at end

data/lib/celluloid/io/tcp_server.rb

@@ -24,12 +24,6 @@ module Celluloid
         @server
       end
 
-      # Are we inside a Celluloid ::IO actor?
-      def evented?
-        actor = Thread.current[:celluloid_actor]
-        actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
-      end
-
       # Convert a Ruby TCPServer into a Celluloid::IO::TCPServer
       def self.from_ruby_server(ruby_server)
         server = allocate

data/lib/celluloid/io/tcp_socket.rb

@@ -7,7 +7,7 @@ module Celluloid
     class TCPSocket < Stream
       extend Forwardable
 
-      def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?
+      def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :close_read, :close_write, :closed?
       def_delegators :@socket, :addr, :peeraddr, :setsockopt
 
       # Open a TCP socket, yielding it to the given block and closing it

data/lib/celluloid/io/udp_socket.rb

@@ -9,12 +9,6 @@ module Celluloid
         @socket = ::UDPSocket.new
       end
 
-      # Are we inside of a Celluloid::IO actor?
-      def evented?
-        actor = Thread.current[:celluloid_actor]
-        actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
-      end
-
       # Wait until the socket is readable
       def wait_readable; Celluloid::IO.wait_readable(self); end
 

data/lib/celluloid/io/unix_server.rb

@@ -27,12 +27,6 @@ module Celluloid
       def to_io
         @server
       end
-
-      # Are we inside a Celluloid ::IO actor?
-      def evented?
-        actor = Thread.current[:celluloid_actor]
-        actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
-      end
     end
   end
 end

data/lib/celluloid/io/version.rb

@@ -1,5 +1,5 @@
 module Celluloid
   module IO
-    VERSION = "0.13.1"
+    VERSION = "0.14.0.pre"
   end
 end

data/spec/celluloid/io/ssl_server_spec.rb

@@ -25,7 +25,7 @@ describe Celluloid::IO::SSLServer do
     context "inside Celluloid::IO" do
       it "should be evented" do
         with_ssl_server do |subject|
-          within_io_actor { subject.evented? }.should be_true
+          within_io_actor { Celluloid::IO.evented? }.should be_true
         end
       end
 
@@ -33,7 +33,7 @@ describe Celluloid::IO::SSLServer do
         with_ssl_server do |subject|
           thread = Thread.new do
             raw = TCPSocket.new(example_addr, example_ssl_port)
-            ssl = OpenSSL::SSL::SSLSocket.new(raw, client_context).connect
+            OpenSSL::SSL::SSLSocket.new(raw, client_context).connect
           end
           peer = within_io_actor { subject.accept }
           peer.should be_a Celluloid::IO::SSLSocket
@@ -48,7 +48,7 @@ describe Celluloid::IO::SSLServer do
     context "outside Celluloid::IO" do
       it "should be blocking" do
         with_ssl_server do |subject|
-          subject.should_not be_evented
+          Celluloid::IO.should_not be_evented
         end
       end
 
@@ -56,7 +56,7 @@ describe Celluloid::IO::SSLServer do
         with_ssl_server do |subject|
           thread = Thread.new do
             raw = TCPSocket.new(example_addr, example_ssl_port)
-            ssl = OpenSSL::SSL::SSLSocket.new(raw, client_context).connect
+            OpenSSL::SSL::SSLSocket.new(raw, client_context).connect
           end
           peer = subject.accept
           peer.should be_a Celluloid::IO::SSLSocket

data/spec/celluloid/io/ssl_socket_spec.rb

@@ -64,34 +64,35 @@ describe Celluloid::IO::SSLSocket do
       with_ssl_sockets do |ssl_client, ssl_peer|
         within_io_actor do
           ssl_peer << request
-          ssl_client.read(request.size).should == request
+          ssl_client.read(request.size).should eq(request)
 
           ssl_client << response
-          ssl_peer.read(response.size).should == response
+          ssl_peer.read(response.size).should eq(response)
         end
       end
     end
 
     it "starts SSL on a connected TCP socket" do
+      pending "JRuby support" if defined?(JRUBY_VERSION)
       with_raw_sockets do |client, peer|
         within_io_actor do
           peer << request
-          client.read(request.size).should == request
+          client.read(request.size).should eq(request)
 
           client << response
-          peer.read(response.size).should == response
+          peer.read(response.size).should eq(response)
 
           # now that we've written bytes, upgrade to SSL
           client_thread = Thread.new { OpenSSL::SSL::SSLSocket.new(client).connect }
           ssl_peer = Celluloid::IO::SSLSocket.new peer, server_context
-          ssl_peer.should == ssl_peer.accept
+          ssl_peer.should eq(ssl_peer.accept)
           ssl_client = client_thread.value
 
           ssl_peer << request
-          ssl_client.read(request.size).should == request
+          ssl_client.read(request.size).should eq(request)
 
           ssl_client << response
-          ssl_peer.read(response.size).should == response
+          ssl_peer.read(response.size).should eq(response)
         end
       end
     end
@@ -101,32 +102,33 @@ describe Celluloid::IO::SSLSocket do
     it "connects to SSL servers over TCP" do
       with_ssl_sockets do |ssl_client, ssl_peer|
         ssl_peer << request
-        ssl_client.read(request.size).should == request
+        ssl_client.read(request.size).should eq(request)
 
         ssl_client << response
-        ssl_peer.read(response.size).should == response
+        ssl_peer.read(response.size).should eq(response)
       end
     end
 
     it "starts SSL on a connected TCP socket" do
+      pending "JRuby support" if defined?(JRUBY_VERSION)
       with_raw_sockets do |client, peer|
         peer << request
-        client.read(request.size).should == request
+        client.read(request.size).should eq(request)
 
         client << response
-        peer.read(response.size).should == response
+        peer.read(response.size).should eq(response)
 
         # now that we've written bytes, upgrade to SSL
         client_thread = Thread.new { OpenSSL::SSL::SSLSocket.new(client).connect }
         ssl_peer = Celluloid::IO::SSLSocket.new peer, server_context
-        ssl_peer.should == ssl_peer.accept
+        ssl_peer.should eq(ssl_peer.accept)
         ssl_client = client_thread.value
 
         ssl_peer << request
-        ssl_client.read(request.size).should == request
+        ssl_client.read(request.size).should eq(request)
 
         ssl_client << response
-        ssl_peer.read(response.size).should == response
+        ssl_peer.read(response.size).should eq(response)
       end
     end
   end
@@ -135,13 +137,13 @@ describe Celluloid::IO::SSLSocket do
     # FIXME: seems bad? o_O
     pending "wtf is wrong with this on JRuby" if defined? JRUBY_VERSION
     with_ssl_sockets do |ssl_client|
-      ssl_client.cert.to_der.should == client_cert.to_der
+      ssl_client.cert.to_der.should eq(client_cert.to_der)
     end
   end
 
   it "knows its peer_cert" do
     with_ssl_sockets do |ssl_client|
-      ssl_client.peer_cert.to_der.should == ssl_client.to_io.peer_cert.to_der
+      ssl_client.peer_cert.to_der.should eq(ssl_client.to_io.peer_cert.to_der)
     end
   end
 
@@ -155,7 +157,7 @@ describe Celluloid::IO::SSLSocket do
 
   it "knows its cipher" do
     with_ssl_sockets do |ssl_client|
-      ssl_client.cipher.should == ssl_client.to_io.cipher
+      ssl_client.cipher.should eq(ssl_client.to_io.cipher)
     end
   end
 
@@ -164,7 +166,7 @@ describe Celluloid::IO::SSLSocket do
     pending "jruby-openssl support" if defined? JRUBY_VERSION
 
     with_ssl_sockets do |ssl_client|
-      ssl_client.client_ca.should == ssl_client.to_io.client_ca
+      ssl_client.client_ca.should eq(ssl_client.to_io.client_ca)
     end
   end
 
@@ -173,7 +175,7 @@ describe Celluloid::IO::SSLSocket do
     pending "jruby-openssl support" if defined? JRUBY_VERSION
 
     with_ssl_sockets do |ssl_client, ssl_peer|
-      ssl_client.verify_result.should == OpenSSL::X509::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT
+      ssl_client.verify_result.should eq(OpenSSL::X509::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT)
     end
   end
 

data/spec/celluloid/io/tcp_server_spec.rb

@@ -7,7 +7,7 @@ describe Celluloid::IO::TCPServer do
     context "inside Celluloid::IO" do
       it "should be evented" do
         with_tcp_server do |subject|
-          within_io_actor { subject.evented? }.should be_true
+          within_io_actor { Celluloid::IO.evented? }.should be_true
         end
       end
 
@@ -26,7 +26,7 @@ describe Celluloid::IO::TCPServer do
       context "outside Celluloid::IO" do
         it "should be blocking" do
           with_tcp_server do |subject|
-            subject.should_not be_evented
+            Celluloid::IO.should_not be_evented
           end
         end
 

data/spec/celluloid/io/tcp_socket_spec.rb

@@ -20,7 +20,7 @@ describe Celluloid::IO::TCPSocket do
 
     it "should be evented" do
       with_connected_sockets do |subject|
-        within_io_actor { subject.evented? }.should be_true
+        within_io_actor { Celluloid::IO.evented? }.should be_true
       end
     end
 
@@ -108,6 +108,7 @@ describe Celluloid::IO::TCPSocket do
       end
 
       it "raises IOError when partial reading from a socket the peer closed" do
+        pending "async block running on receiver"
         with_connected_sockets do |subject, peer|
           actor = ExampleActor.new
           begin
@@ -140,7 +141,7 @@ describe Celluloid::IO::TCPSocket do
 
     it "should be blocking" do
       with_connected_sockets do |subject|
-        subject.should_not be_evented
+        Celluloid::IO.should_not be_evented
       end
     end
 

data/spec/celluloid/io/udp_socket_spec.rb

@@ -12,18 +12,20 @@ describe Celluloid::IO::UDPSocket do
 
   context "inside Celluloid::IO" do
     it "should be evented" do
-      within_io_actor { subject.evented? }.should be_true
+      within_io_actor { Celluloid::IO.evented? }.should be_true
     end
 
     it "sends and receives packets" do
-      subject.send payload, 0, example_addr, example_port
-      subject.recvfrom(payload.size).first.should == payload
+      within_io_actor do
+        subject.send payload, 0, example_addr, example_port
+        subject.recvfrom(payload.size).first.should == payload
+      end
     end
   end
 
   context "outside Celluloid::IO" do
     it "should be blocking" do
-      subject.should_not be_evented
+      Celluloid::IO.should_not be_evented
     end
 
     it "sends and receives packets" do

data/spec/celluloid/io/unix_server_spec.rb

@@ -11,7 +11,7 @@ describe Celluloid::IO::UNIXServer do
     context "inside Celluloid::IO" do
       it "should be evented" do
         with_unix_server do |subject|
-          within_io_actor { subject.evented? }.should be_true
+          within_io_actor { Celluloid::IO.evented? }.should be_true
         end
       end
 
@@ -40,7 +40,7 @@ describe Celluloid::IO::UNIXServer do
       context "outside Celluloid::IO" do
         it "should be blocking" do
           with_unix_server do |subject|
-            subject.should_not be_evented
+            Celluloid::IO.should_not be_evented
           end
         end
 

data/spec/celluloid/io/unix_socket_spec.rb

@@ -25,7 +25,7 @@ describe Celluloid::IO::UNIXSocket do
 
     it "should be evented" do
       with_connected_unix_sockets do |subject|
-        within_io_actor { subject.evented? }.should be_true
+        within_io_actor { Celluloid::IO.evented? }.should be_true
       end
     end
 
@@ -112,7 +112,7 @@ describe Celluloid::IO::UNIXSocket do
 
     it "should be blocking" do
       with_connected_unix_sockets do |subject|
-        subject.should_not be_evented
+        Celluloid::IO.should_not be_evented
       end
     end
 

data/spec/spec_helper.rb

@@ -8,15 +8,25 @@ Coveralls.wear!
 logfile = File.open(File.expand_path("../../log/test.log", __FILE__), 'a')
 Celluloid.logger = Logger.new(logfile)
 
+RSpec.configure do |config|
+  config.before do
+    Celluloid.shutdown
+    Celluloid.boot
+    FileUtils.rm("/tmp/cell_sock") if File.exist?("/tmp/cell_sock")
+  end
+end
+
 # FIXME: Hax until test termination can be cleaned up
 module Celluloid
   class << self
+    undef :shutdown
     def shutdown; end # hax: noop!
   end
 end
 
 class ExampleActor
   include Celluloid::IO
+  execute_block_on_receiver :wrap
 
   def wrap
     yield

metadata

@@ -1,116 +1,102 @@
 --- !ruby/object:Gem::Specification
 name: celluloid-io
 version: !ruby/object:Gem::Version
-  version: 0.13.1
-  prerelease: 
+  version: 0.14.0.pre
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-05 00:00:00.000000000 Z
+date: 2013-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.13.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.13.0
 - !ruby/object:Gem::Dependency
   name: nio4r
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark_suite
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rb-fsevent
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -118,7 +104,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -180,27 +165,26 @@ files:
 - tasks/rspec.task
 homepage: http://github.com/celluloid/celluloid-io
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Celluloid::IO allows you to monitor multiple IO objects within a Celluloid
   actor
 test_files:
@@ -219,4 +203,3 @@ test_files:
 - spec/fixtures/server.crt
 - spec/fixtures/server.key
 - spec/spec_helper.rb
-has_rdoc: