celluloid-io 0.13.0.pre → 0.13.0.pre2

data/.coveralls.yml

@@ -0,0 +1 @@
+service-name: travis-pro

data/.travis.yml

@@ -1,6 +1,7 @@
 script: rake ci
 rvm:
   - 1.9.3
+  - 2.0.0
   - ruby-head
   - jruby-19mode
   - rbx-19mode
@@ -8,8 +9,10 @@ rvm:
 
 matrix:
   allow_failures:
+    - rvm: 2.0.0 # not ready for primetime :(
     - rvm: ruby-head
     - rvm: jruby-head
+    - rvm: rbx-19mode
 
 notifications:
   irc: "irc.freenode.org#celluloid"

data/CHANGES.md

@@ -1,7 +1,11 @@
-0.13.0.pre
-----------
+0.13.0.pre2
+-----------
+* Support for many, many more IO methods, particularly line-oriented
+  methods like #gets, #readline, and #readlines
 * Initial SSL support via Celluloid::IO::SSLSocket and
   Celluloid::IO::SSLServer
+* Concurrent writes between tasks of the same actor are now coordinated
+  using Celluloid::Conditions instead of signals
 * Celluloid 0.13 compatibility fixes
 
 0.12.0

data/Gemfile

@@ -1,6 +1,5 @@
-source :rubygems
-
-#gem 'celluloid', :git => 'git://github.com/celluloid/celluloid'
-
-# Specify your gem's dependencies in celluloid-io.gemspec
+source 'https://rubygems.org'
 gemspec
+
+gem 'coveralls', require: false
+gem 'celluloid', github: 'celluloid/celluloid'

data/README.md

@@ -1,8 +1,10 @@
 ![Celluloid](https://github.com/celluloid/celluloid-io/raw/master/logo.png)
 =============
+[![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/badge.png)](https://codeclimate.com/github/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)
 
 You don't have to choose between threaded and evented IO! Celluloid::IO
 provides an event-driven IO system for building fast, scalable network
@@ -162,15 +164,13 @@ classes instead of the core Ruby TCPSocket and TCPServer classes.
 Status
 ------
 
-The rudiments of TCPServer and TCPSocket are in place and ready to use. It is now
+The rudiments of TCPServer TCPSocket, and UNIXSocket are in place and ready to use. It is now
 fully nonblocking, including DNS resolution, which effectively makes Celluloid::IO
 feature complete as a nonblocking I/O system.
 
 Basic UDPSocket support is in place. On JRuby, recvfrom makes a blocking call
 as the underlying recvfrom_nonblock call is not supported by JRuby.
 
-No UNIXSocket support yet, sorry (patches welcome!)
-
 Contributing to Celluloid::IO
 -----------------------------
 

data/benchmarks/actor.rb

@@ -2,14 +2,14 @@
 
 require 'rubygems'
 require 'bundler/setup'
-require 'celluloid'
+require 'celluloid/io'
 require 'benchmark/ips'
 
 class ExampleActor
   include Celluloid::IO
 
   def initialize
-    @condition = Condition.new
+    @condition = Celluloid::Condition.new
   end
 
   def example_method; end
@@ -24,13 +24,13 @@ class ExampleActor
 end
 
 example_actor = ExampleActor.new
-mailbox = Celluloid::Mailbox.new
+mailbox = Celluloid::IO::Mailbox.new
 
 latch_in, latch_out = Queue.new, Queue.new
 latch = Thread.new do
   while true
     n = latch_in.pop
-    for i in 0..n; mailbox.receive; end
+    for i in 0...n; mailbox.receive; end
     latch_out << :done
   end
 end
@@ -49,9 +49,12 @@ Benchmark.ips do |ips|
     waiter.value
   end
 
+# Deadlocking o_O
+=begin
   ips.report("messages") do |n|
     latch_in << n
-    for i in 0..n; mailbox << :message; end
+    for i in 0...n; mailbox << :message; end
     latch_out.pop
   end
+=end
 end

data/examples/echo_server.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+#
+# Run this as: bundle exec examples/echo_server.rb
 
 require 'bundler/setup'
 require 'celluloid/io'
@@ -12,7 +14,7 @@ class EchoServer
     # Since we included Celluloid::IO, we're actually making a
     # Celluloid::IO::TCPServer here
     @server = TCPServer.new(host, port)
-    run!
+    async.run
   end
 
   def finalize
@@ -20,7 +22,7 @@ class EchoServer
   end
 
   def run
-    loop { handle_connection! @server.accept }
+    loop { async.handle_connection @server.accept }
   end
 
   def handle_connection(socket)

data/examples/echo_unix_server.rb

@@ -10,10 +10,11 @@ class EchoUNIXServer
     puts "*** start server #{socket_path}"
     @socket_path = socket_path
     @server = UNIXServer.open(socket_path)
+    async.run
   end
 
   def run
-    loop { handle_connection! @server.accept }
+    loop { async.handle_connection @server.accept }
   end
 
   def handle_connection(socket)
@@ -39,5 +40,6 @@ class EchoUNIXServer
 
 end
 
-s = EchoUNIXServer.new("/tmp/sock_test")
-s.run
+supervisor = EchoUNIXServer.supervise("/tmp/sock_test")
+trap("INT") { supervisor.terminate; exit }
+sleep

data/lib/celluloid/io/ssl_server.rb

@@ -25,7 +25,7 @@ module Celluloid
           ssl = Celluloid::IO::SSLSocket.new(sock, @ctx)
           ssl.accept if @start_immediately
           ssl
-        rescue SSLError
+        rescue OpenSSL::SSL::SSLError
           sock.close
           raise
         end

data/lib/celluloid/io/ssl_socket.rb

@@ -3,14 +3,14 @@ require 'openssl'
 module Celluloid
   module IO
     # SSLSocket with Celluloid::IO support
-    class SSLSocket
-      include CommonMethods
+    class SSLSocket < Stream
       extend Forwardable
 
       def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?,
         :cert, :cipher, :client_ca, :peer_cert, :peer_cert_chain, :verify_result
 
       def initialize(io, ctx = OpenSSL::SSL::SSLContext.new)
+        super()
         @context = ctx
         @socket = OpenSSL::SSL::SSLSocket.new(::IO.try_convert(io), @context)
       end

data/lib/celluloid/io/stream.rb

@@ -0,0 +1,422 @@
+# Partially adapted from Ruby's OpenSSL::Buffering
+# Originally from the 'OpenSSL for Ruby 2' project
+# Copyright (C) 2001 GOTOU YUUZOU <gotoyuzo@notwork.org>
+# All rights reserved.
+#
+# This program is licenced under the same licence as Ruby.
+
+module Celluloid
+  module IO
+    # Base class of all streams in Celluloid::IO
+    class Stream
+      include Enumerable
+
+      # The "sync mode" of the stream
+      #
+      # See IO#sync for full details.
+      attr_accessor :sync
+
+      # Default size to read from or write to the stream for buffer operations
+      BLOCK_SIZE = 1024*16
+
+      def initialize
+        @eof  = false
+        @sync = true # FIXME: hax
+        @read_buffer = ''.force_encoding(Encoding::ASCII_8BIT)
+        @write_buffer = ''.force_encoding(Encoding::ASCII_8BIT)
+
+        @read_latch  = Latch.new
+        @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
+        if evented?
+          Celluloid.current_actor.wait_readable(self.to_io)
+        else
+          Kernel.select([self.to_io])
+        end
+      end
+
+      # Wait until the current object is writable
+      def wait_writable
+        if evented?
+          Celluloid.current_actor.wait_writable(self.to_io)
+        else
+          Kernel.select([], [self.to_io])
+        end
+      end
+
+      # System read via the nonblocking subsystem
+      def sysread(length = nil, buffer = nil)
+        buffer ||= ''.force_encoding(Encoding::ASCII_8BIT)
+
+        @read_latch.synchronize do
+          begin
+            read_nonblock(length, buffer)
+          rescue ::IO::WaitReadable
+            wait_readable
+            retry
+          end
+        end
+
+        buffer
+      end
+
+      # System write via the nonblocking subsystem
+      def syswrite(string)
+        length = string.length
+        total_written = 0
+
+        remaining = string
+
+        @write_latch.synchronize do
+          while total_written < length
+            begin
+              written = write_nonblock(remaining)
+            rescue ::IO::WaitWritable
+              wait_writable
+              retry
+            rescue EOFError
+              return total_written
+            end
+
+            total_written += written
+
+            # FIXME: mutating the original buffer here. Seems bad.
+            remaining.slice!(0, written) if written < remaining.length
+          end
+        end
+
+        total_written
+      end
+
+      # Reads +size+ bytes from the stream.  If +buf+ is provided it must
+      # reference a string which will receive the data.
+      #
+      # See IO#read for full details.
+      def read(size=nil, buf=nil)
+        if size == 0
+          if buf
+            buf.clear
+            return buf
+          else
+            return ""
+          end
+        end
+
+        until @eof
+          break if size && size <= @read_buffer.size
+          fill_rbuff
+          break unless size
+        end
+
+        ret = consume_rbuff(size) || ""
+
+        if buf
+          buf.replace(ret)
+          ret = buf
+        end
+
+        (size && ret.empty?) ? nil : ret
+      end
+
+      # Reads at most +maxlen+ bytes from the stream.  If +buf+ is provided it
+      # must reference a string which will receive the data.
+      #
+      # See IO#readpartial for full details.
+      def readpartial(maxlen, buf=nil)
+        if maxlen == 0
+          if buf
+            buf.clear
+            return buf
+          else
+            return ""
+          end
+        end
+
+        if @read_buffer.empty?
+          begin
+            return sysread(maxlen, buf)
+          rescue Errno::EAGAIN
+            retry
+          end
+        end
+
+        ret = consume_rbuff(maxlen)
+
+        if buf
+          buf.replace(ret)
+          ret = buf
+        end
+
+        raise EOFError if ret.empty?
+        ret
+      end
+
+      # Reads the next "line+ from the stream.  Lines are separated by +eol+.  If
+      # +limit+ is provided the result will not be longer than the given number of
+      # bytes.
+      #
+      # +eol+ may be a String or Regexp.
+      #
+      # Unlike IO#gets the line read will not be assigned to +$_+.
+      #
+      # Unlike IO#gets the separator must be provided if a limit is provided.
+      def gets(eol=$/, limit=nil)
+        idx = @read_buffer.index(eol)
+
+        until @eof
+          break if idx
+          fill_rbuff
+          idx = @read_buffer.index(eol)
+        end
+
+        if eol.is_a?(Regexp)
+          size = idx ? idx+$&.size : nil
+        else
+          size = idx ? idx+eol.size : nil
+        end
+
+        if limit and limit >= 0
+          size = [size, limit].min
+        end
+
+        consume_rbuff(size)
+      end
+
+      # Executes the block for every line in the stream where lines are separated
+      # by +eol+.
+      #
+      # See also #gets
+      def each(eol=$/)
+        while line = self.gets(eol)
+          yield line
+        end
+      end
+      alias each_line each
+
+      # Reads lines from the stream which are separated by +eol+.
+      #
+      # See also #gets
+      def readlines(eol=$/)
+        ary = []
+        ary << line while line = self.gets(eol)
+        ary
+      end
+
+      # Reads a line from the stream which is separated by +eol+.
+      #
+      # Raises EOFError if at end of file.
+      def readline(eol=$/)
+        raise EOFError if eof?
+        gets(eol)
+      end
+
+      # Reads one character from the stream.  Returns nil if called at end of
+      # file.
+      def getc
+        read(1)
+      end
+
+      # Calls the given block once for each byte in the stream.
+      def each_byte # :yields: byte
+        yield(c.ord) while c = getc
+      end
+
+      # Reads a one-character string from the stream.  Raises an EOFError at end
+      # of file.
+      def readchar
+        raise EOFError if eof?
+        getc
+      end
+
+      # Pushes character +c+ back onto the stream such that a subsequent buffered
+      # character read will return it.
+      #
+      # Unlike IO#getc multiple bytes may be pushed back onto the stream.
+      #
+      # Has no effect on unbuffered reads (such as #sysread).
+      def ungetc(c)
+        @read_buffer[0,0] = c.chr
+      end
+
+      # Returns true if the stream is at file which means there is no more data to
+      # be read.
+      def eof?
+        fill_rbuff if !@eof && @read_buffer.empty?
+        @eof && @read_buffer.empty?
+      end
+      alias eof eof?
+
+      # Writes +s+ to the stream.  If the argument is not a string it will be
+      # converted using String#to_s.  Returns the number of bytes written.
+      def write(s)
+        do_write(s)
+        s.bytesize
+      end
+
+      # Writes +s+ to the stream.  +s+ will be converted to a String using
+      # String#to_s.
+      def << (s)
+        do_write(s)
+        self
+      end
+
+      # Writes +args+ to the stream along with a record separator.
+      #
+      # See IO#puts for full details.
+      def puts(*args)
+        s = ""
+        if args.empty?
+          s << "\n"
+        end
+
+        args.each do |arg|
+          s << arg.to_s
+          if $/ && /\n\z/ !~ s
+            s << "\n"
+          end
+        end
+
+        do_write(s)
+        nil
+      end
+
+      # Writes +args+ to the stream.
+      #
+      # See IO#print for full details.
+      def print(*args)
+        s = ""
+        args.each { |arg| s << arg.to_s }
+        do_write(s)
+        nil
+      end
+
+      # Formats and writes to the stream converting parameters under control of
+      # the format string.
+      #
+      # See Kernel#sprintf for format string details.
+      def printf(s, *args)
+        do_write(s % args)
+        nil
+      end
+
+      # Flushes buffered data to the stream.
+      def flush
+        osync = @sync
+        @sync = true
+        do_write ""
+        return self
+      ensure
+        @sync = osync
+      end
+
+      # Closes the stream and flushes any unwritten data.
+      def close
+        flush rescue nil
+        sysclose
+      end
+
+      #######
+      private
+      #######
+
+      # Fills the buffer from the underlying stream
+      def fill_rbuff
+        begin
+          @read_buffer << sysread(BLOCK_SIZE)
+        rescue Errno::EAGAIN
+          retry
+        rescue EOFError
+          @eof = true
+        end
+      end
+
+      # Consumes +size+ bytes from the buffer
+      def consume_rbuff(size=nil)
+        if @read_buffer.empty?
+          nil
+        else
+          size = @read_buffer.size unless size
+          ret = @read_buffer[0, size]
+          @read_buffer[0, size] = ""
+          ret
+        end
+      end
+
+      # Writes +s+ to the buffer.  When the buffer is full or #sync is true the
+      # buffer is flushed to the underlying stream.
+      def do_write(s)
+        @write_buffer << s
+        @write_buffer.force_encoding(Encoding::BINARY)
+        @sync ||= false
+
+        if @sync or @write_buffer.size > BLOCK_SIZE or idx = @write_buffer.rindex($/)
+          remain = idx ? idx + $/.size : @write_buffer.length
+          nwritten = 0
+
+          while remain > 0
+            str = @write_buffer[nwritten,remain]
+            begin
+              nwrote = syswrite(str)
+            rescue Errno::EAGAIN
+              retry
+            end
+            remain -= nwrote
+            nwritten += nwrote
+          end
+
+          @write_buffer[0,nwritten] = ""
+        end
+      end
+
+      # Perform an operation exclusively, uncontested by other tasks
+      class Latch
+        def initialize
+          @owner = nil
+          @waiters = 0
+          @condition = Celluloid::Condition.new
+        end
+
+        # Synchronize an operation across all tasks in the current actor
+        def synchronize
+          actor = Thread.current[:celluloid_actor]
+          return yield unless actor
+
+          # Silently acquire ownership at the actor level. This method should be
+          # replaced with an ownership system similar to conditions if this code
+          # is ever extracted into Celluloid itself
+          if @condition.owner != actor.proxy
+            @condition.owner = actor.proxy
+            @waiters = 0
+            @owner = nil
+          end
+
+          if @owner || @waiters > 0
+            @waiters += 1
+            @condition.wait
+            @waiters -= 1
+          end
+
+          @owner = Task.current
+
+          begin
+            ret = yield
+          ensure
+            @owner = nil
+            @condition.signal if @waiters > 0
+          end
+
+          ret
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/io/tcp_socket.rb

@@ -4,25 +4,49 @@ require 'resolv'
 module Celluloid
   module IO
     # TCPSocket with combined blocking and evented support
-    class TCPSocket
-      include CommonMethods
+    class TCPSocket < Stream
       extend Forwardable
 
       def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?
       def_delegators :@socket, :addr, :peeraddr, :setsockopt
 
+      # Open a TCP socket, yielding it to the given block and closing it
+      # automatically when done (if a block is given)
+      def self.open(*args, &block)
+        sock = new(*args)
+
+        if block_given?
+          begin
+            yield sock
+          ensure
+            sock.close
+          end
+        end
+
+        sock
+      end
+
       # Convert a Ruby TCPSocket into a Celluloid::IO::TCPSocket
+      # DEPRECATED: to be removed in a future release
       def self.from_ruby_socket(ruby_socket)
-        # Some hax here, but whatever ;)
-        socket = allocate
-        socket.instance_variable_set(:@socket, ruby_socket)
-        socket
+        new(ruby_socket)
       end
 
       # Opens a TCP connection to remote_host on remote_port. If local_host
       # and local_port are specified, then those parameters are used on the
       # local end to establish the connection.
-      def initialize(remote_host, remote_port, local_host = nil, local_port = nil)
+      def initialize(remote_host, remote_port = nil, local_host = nil, local_port = nil)
+        super()
+        
+        # Allow users to pass in a Ruby TCPSocket directly
+        if remote_host.is_a? ::TCPSocket
+          @addr = nil
+          @socket = remote_host
+          return
+        elsif remote_port.nil?
+          raise ArgumentError, "wrong number of arguments (1 for 2)"
+        end
+
         # Is it an IPv4 address?
         begin
           @addr = Resolv::IPv4.create(remote_host)

data/lib/celluloid/io/unix_socket.rb

@@ -3,27 +3,32 @@ require 'socket'
 module Celluloid
   module IO
     # UNIXSocket with combined blocking and evented support
-    class UNIXSocket
-      include CommonMethods
+    class UNIXSocket < Stream
       extend Forwardable
 
       def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?, :readline, :puts, :addr
 
-      # Convert a Ruby UNIXSocket into a Celluloid::IO::UNIXSocket
-      def self.from_ruby_socket(ruby_socket)
-        # Some hax here, but whatever ;)
-        socket = allocate
-        socket.instance_variable_set(:@socket, ruby_socket)
-        socket
-      end
-
       # Open a UNIX connection.
       def self.open(socket_path, &block)
         self.new(socket_path, &block)
       end
 
+      # Convert a Ruby UNIXSocket into a Celluloid::IO::UNIXSocket
+      # DEPRECATED: to be removed in a future release
+      def self.from_ruby_socket(ruby_socket)
+        new(ruby_socket)
+      end
+
       # Open a UNIX connection.
       def initialize(socket_path, &block)
+        super()
+        
+        # Allow users to pass in a Ruby UNIXSocket directly
+        if socket_path.is_a? ::UNIXSocket
+          @socket = socket_path
+          return
+        end
+
         # FIXME: not doing non-blocking connect
         @socket = if block
           ::UNIXSocket.open(socket_path, &block)

data/lib/celluloid/io/version.rb

@@ -1,5 +1,5 @@
 module Celluloid
   module IO
-    VERSION = "0.13.0.pre"
+    VERSION = "0.13.0.pre2"
   end
 end

data/lib/celluloid/io.rb

@@ -2,10 +2,10 @@ require 'forwardable'
 require 'celluloid/io/version'
 
 require 'celluloid'
-require 'celluloid/io/common_methods'
 require 'celluloid/io/dns_resolver'
 require 'celluloid/io/mailbox'
 require 'celluloid/io/reactor'
+require 'celluloid/io/stream'
 
 require 'celluloid/io/tcp_server'
 require 'celluloid/io/tcp_socket'

data/spec/celluloid/io/ssl_socket_spec.rb

@@ -14,7 +14,23 @@ describe Celluloid::IO::SSLSocket do
     end
   end
 
-  let(:client)     { TCPSocket.new example_addr, example_ssl_port }
+  let(:client) do
+    remaining_attempts = 3
+
+    begin
+      TCPSocket.new example_addr, example_ssl_port
+    rescue Errno::ECONNREFUSED
+      # HAX: sometimes this fails to connect? o_O
+      # This is quite likely due to the Thread.pass style spinlocks for startup
+      raise if remaining_attempts < 1
+      remaining_attempts -= 1
+
+      # Seems gimpy, but sleep and retry
+      sleep 0.1
+      retry
+    end
+  end
+
   let(:ssl_client) { Celluloid::IO::SSLSocket.new client, client_context }
 
   let(:server_cert) { OpenSSL::X509::Certificate.new fixture_dir.join("server.crt").read }
@@ -31,6 +47,7 @@ describe Celluloid::IO::SSLSocket do
   let(:server_thread) do
     Thread.new { ssl_server.accept }.tap do |thread|
       Thread.pass while thread.status && thread.status != "sleep"
+      thread.join unless thread.status
     end
   end
 
@@ -38,6 +55,7 @@ describe Celluloid::IO::SSLSocket do
   let(:raw_server_thread) do
     Thread.new { celluloid_server.accept }.tap do |thread|
       Thread.pass while thread.status && thread.status != "sleep"
+      thread.join unless thread.status
     end
   end
 
@@ -160,13 +178,14 @@ describe Celluloid::IO::SSLSocket do
   end
 
   def with_ssl_sockets
-    thread = server_thread
+    server_thread
     ssl_client.connect
 
     begin
-      ssl_peer = thread.value
+      ssl_peer = server_thread.value
       yield ssl_client, ssl_peer
     ensure
+      server_thread.join
       ssl_server.close
       ssl_client.close
       ssl_peer.close
@@ -174,16 +193,17 @@ describe Celluloid::IO::SSLSocket do
   end
 
   def with_raw_sockets
-    server_thread = raw_server_thread
-    raw_client = client
+    raw_server_thread
+    client
 
     begin
-      raw_peer = server_thread.value
-      yield raw_client, raw_peer
+      peer = raw_server_thread.value
+      yield client, peer
     ensure
+      raw_server_thread.join
       celluloid_server.close
-      raw_client.close
-      raw_peer.close
+      client.close
+      peer.close
     end
   end
 end

data/spec/celluloid/io/tcp_socket_spec.rb

@@ -45,10 +45,10 @@ describe Celluloid::IO::TCPSocket do
       end
     end
 
-    it "reads data in ASCII-8BIT encoding" do
+    it "reads data in binary encoding" do
       with_connected_sockets do |subject, peer|
         peer << payload
-        within_io_actor { subject.read(payload.size).encoding }.should eq Encoding::ASCII_8BIT
+        within_io_actor { subject.read(payload.size).encoding }.should eq Encoding::BINARY
       end
     end
 
@@ -59,10 +59,10 @@ describe Celluloid::IO::TCPSocket do
       end
     end
 
-    it "reads partial data in ASCII-8BIT encoding" do
+    it "reads partial data in binary encoding" do
       with_connected_sockets do |subject, peer|
         peer << payload * 2
-        within_io_actor { subject.readpartial(payload.size).encoding }.should eq Encoding::ASCII_8BIT
+        within_io_actor { subject.readpartial(payload.size).encoding }.should eq Encoding::BINARY
       end
     end
 
@@ -90,7 +90,7 @@ describe Celluloid::IO::TCPSocket do
       end
 
       it "raises IOError when active sockets are closed across threads" do
-	pending "not implemented :("
+	      pending "not implemented"
 
         with_connected_sockets do |subject, peer|
           actor = ExampleActor.new

data/spec/celluloid/io/unix_socket_spec.rb

@@ -50,10 +50,10 @@ describe Celluloid::IO::UNIXSocket do
       end
     end
 
-    it "reads data in ASCII-8BIT encoding" do
+    it "reads data in binary encoding" do
       with_connected_unix_sockets do |subject, peer|
         peer << payload
-        within_io_actor { subject.read(payload.size).encoding }.should eq Encoding::ASCII_8BIT
+        within_io_actor { subject.read(payload.size).encoding }.should eq Encoding::BINARY
       end
     end
 
@@ -64,10 +64,10 @@ describe Celluloid::IO::UNIXSocket do
       end
     end
 
-    it "reads partial data in ASCII-8BIT encoding" do
+    it "reads partial data in binary encoding" do
       with_connected_unix_sockets do |subject, peer|
         peer << payload * 2
-        within_io_actor { subject.readpartial(payload.size).encoding }.should eq Encoding::ASCII_8BIT
+        within_io_actor { subject.readpartial(payload.size).encoding }.should eq Encoding::BINARY
       end
     end
 

data/spec/spec_helper.rb

@@ -2,10 +2,19 @@ require 'rubygems'
 require 'bundler/setup'
 require 'celluloid/io'
 require 'celluloid/rspec'
+require 'coveralls'
+Coveralls.wear!
 
 logfile = File.open(File.expand_path("../../log/test.log", __FILE__), 'a')
 Celluloid.logger = Logger.new(logfile)
 
+# FIXME: Hax until test termination can be cleaned up
+module Celluloid
+  class << self
+    def shutdown; end # hax: noop!
+  end
+end
+
 class ExampleActor
   include Celluloid::IO
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid-io
 version: !ruby/object:Gem::Version
-  version: 0.13.0.pre
+  version: 0.13.0.pre2
   prerelease: 7
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-14 00:00:00.000000000 Z
+date: 2013-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -130,6 +130,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .coveralls.yml
 - .gitignore
 - .rspec
 - .travis.yml
@@ -146,12 +147,12 @@ files:
 - examples/echo_unix_client.rb
 - examples/echo_unix_server.rb
 - lib/celluloid/io.rb
-- lib/celluloid/io/common_methods.rb
 - lib/celluloid/io/dns_resolver.rb
 - lib/celluloid/io/mailbox.rb
 - lib/celluloid/io/reactor.rb
 - lib/celluloid/io/ssl_server.rb
 - lib/celluloid/io/ssl_socket.rb
+- lib/celluloid/io/stream.rb
 - lib/celluloid/io/tcp_server.rb
 - lib/celluloid/io/tcp_socket.rb
 - lib/celluloid/io/udp_socket.rb
@@ -191,7 +192,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -662471971010224791
+      hash: -1245022308244925467
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/lib/celluloid/io/common_methods.rb

@@ -1,146 +0,0 @@
-module Celluloid
-  module IO
-    # Common implementations of methods originall from the IO class
-    module CommonMethods
-      # 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
-        if evented?
-          Celluloid.current_actor.wait_readable(self.to_io)
-        else
-          Kernel.select([self.to_io])
-        end
-      end
-
-      # Wait until the current object is writable
-      def wait_writable
-        if evented?
-          Celluloid.current_actor.wait_writable(self.to_io)
-        else
-          Kernel.select([], [self.to_io])
-        end
-      end
-
-      # Request exclusive control for a particular operation
-      # Type should be one of :r (read) or :w (write)
-      def acquire_ownership(type)
-        return unless Thread.current[:celluloid_actor]
-
-        case type
-        when :r
-          ivar = :@read_owner
-        when :w
-          ivar = :@write_owner
-        else raise ArgumentError, "invalid ownership type: #{type}"
-        end
-
-        # Celluloid needs a better API here o_O
-        Thread.current[:celluloid_actor].wait(self) while instance_variable_defined?(ivar) && instance_variable_get(ivar)
-        instance_variable_set(ivar, Task.current)
-      end
-
-      # Release ownership for a particular operation
-      # Type should be one of :r (read) or :w (write)
-      def release_ownership(type)
-        return unless Thread.current[:celluloid_actor]
-
-        case type
-        when :r
-          ivar = :@read_owner
-        when :w
-          ivar = :@write_owner
-        else raise ArgumentError, "invalid ownership type: #{type}"
-        end
-
-        raise "not owner" unless instance_variable_defined?(ivar) && instance_variable_get(ivar) == Task.current
-        instance_variable_set(ivar, nil)
-        Thread.current[:celluloid_actor].signal(self)
-      end
-
-      def read(length = nil, buffer = nil)
-        buffer ||= ''.force_encoding(Encoding::ASCII_8BIT)
-        remaining = length
-
-        acquire_ownership :r
-        begin
-          if length
-            until remaining.zero?
-              begin
-                str = readpartial(remaining)
-              rescue EOFError
-                return if length == remaining
-                return buffer
-              end
-
-              buffer << str
-              remaining -= str.length
-            end
-          else
-            while true
-              begin
-                buffer << read_nonblock(Socket::SO_RCVBUF)
-              rescue Errno::EAGAIN, EOFError
-                return buffer
-              end
-            end
-          end
-        ensure
-          release_ownership :r
-        end
-
-        buffer
-      end
-
-      def readpartial(length, buffer = nil)
-        buffer ||= ''.force_encoding(Encoding::ASCII_8BIT)
-
-        begin
-          read_nonblock(length, buffer)
-        rescue ::IO::WaitReadable
-          wait_readable
-          retry
-        end
-
-        buffer
-      end
-
-      def write(string)
-        length = string.length
-        total_written = 0
-
-        remaining = string
-        acquire_ownership :w
-
-        begin
-          while total_written < length
-            begin
-              written = write_nonblock(remaining)
-            rescue ::IO::WaitWritable
-              wait_writable
-              retry
-            rescue EOFError
-              return total_written
-            end
-
-            total_written += written
-            remaining.slice!(0, written) if written < remaining.length
-          end
-        ensure
-          release_ownership :w
-        end
-
-        total_written
-      end
-      
-      def <<(string)
-        write string
-        self
-      end
-    end
-  end
-end