io_unblock 0.1.0

data/.autotest

@@ -0,0 +1,18 @@
+# vim: set filetype=ruby : 
+
+require 'autotest/restart'
+require 'autotest/growl'
+
+Autotest.add_hook :initialize do |at|
+  at.testlib = 'minitest/spec'
+  
+  at.clear_mappings
+  at.add_mapping(/^lib\/(.*)\.rb$/) { |f, m| "spec/#{m[1]}_spec.rb" }
+  at.add_mapping(/^spec\/.*_spec\.rb$/) { |f,_| f }
+  at.add_mapping(/^spec\/spec_helper\.rb$/) { |f,_|
+    at.files_matching(/^spec\/.*_spec\.rb$/)
+  }
+  
+  at.add_exception '.git'
+  at.add_exception 'coverage'
+end

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+coverage/*
+*~
+*.swp

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in io_unblock.gemspec
+gemspec
+
+group :test do
+  gem 'autotest'
+  gem 'minitest'
+  gem 'minitest-emoji'
+end
+
+group :human_testing do
+  gem 'autotest-growl'
+  gem 'simplecov'
+end

data/README.md

@@ -0,0 +1,10 @@
+# IoUnblock
+
+An IO stream, a thread, and a handful of callbacks.
+
+## Purpose
+
+This gem's primary purpose is to handle threaded non-blocking IO so
+that the OnStomp gem is less distracted from its primary duty of
+handling the STOMP protocol.
+

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
+end
+
+desc "Generate a coverage report from tests with simplecov"
+task :coverage do  
+  ENV['SCOV'] = '1'
+  Rake::Task['test'].invoke
+end
+
+task :default => [:test]

data/io_unblock.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "io_unblock/version"
+
+Gem::Specification.new do |s|
+  s.name        = "io_unblock"
+  s.version     = IoUnblock::VERSION
+  s.authors     = ["Ian D. Eccles"]
+  s.email       = ["ian.eccles@gmail.com"]
+  s.homepage    = "https://github.com/iande/io_unblock"
+  s.summary     = %q{Non-blocking IO reads/writes wrapped in a thread}
+  s.description = %q{Non-blocking IO reads/writes wrapped in a thread}
+
+  s.rubyforge_project = "io_unblock"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'rake'
+end

data/lib/io_unblock.rb

@@ -0,0 +1,10 @@
+require 'thread'
+require "io_unblock/version"
+
+module IoUnblock
+  class IoUnblockError < StandardError; end
+end
+
+require 'io_unblock/delegation'
+require 'io_unblock/buffer'
+require 'io_unblock/stream'

data/lib/io_unblock/buffer.rb

@@ -0,0 +1,50 @@
+module IoUnblock
+  # A very simple synchronized buffer.
+  #
+  # @api private
+  class Buffer
+    
+    def initialize
+      @buffer = []
+      @mutex = Mutex.new
+    end
+    
+    def push bytes, cb
+      synched { @buffer.push [bytes, cb] }
+    end
+    
+    def pop
+      synched { @buffer.pop }
+    end
+        
+    def unshift bytes, cb
+      synched { @buffer.unshift [bytes, cb] }
+    end
+    
+    def shift
+      synched { @buffer.shift }
+    end
+    
+    def first
+      synched { @buffer.first }
+    end
+    
+    def last
+      synched { @buffer.last }
+    end
+    
+    def empty?
+      # Should we lock?
+      @buffer.empty?
+    end
+    
+    def buffered?
+      !empty?
+    end
+
+private
+    def synched &block
+      @mutex.synchronize(&block)
+    end
+  end
+end

data/lib/io_unblock/delegation.rb

@@ -0,0 +1,91 @@
+module IoUnblock
+  # Handles delegating read and write methods to their non-blocking
+  # counterparts on the IO object. If the IO object does not support
+  # non-blocking methods, falls back to blocking ones.
+  #
+  # @api private
+  module Delegation
+    module NonBlockingWrites
+      def io_write bytes; io.write_nonblock bytes; end
+      private :io_write
+    end
+    
+    module BlockingWrites
+      def io_write bytes; io.write bytes; end
+      private :io_write
+    end
+    
+    module ForwardWriteable
+      def writeable?; io.writeable?; end
+      private :writeable?
+    end
+    
+    module SelectWriteable
+      def writeable?; !!IO.select(nil, io_selector, nil, select_delay); end
+      private :writeable?
+    end
+    
+    module NonBlockingReads
+      def io_read len; io.read_nonblock len; end
+      private :io_read
+    end
+    
+    module PartialReads
+      def io_read len; io.readpartial len; end
+      private :io_read
+    end
+    
+    module BlockingReads
+      def io_read len; io.read len; end
+      private :io_read
+    end
+    
+    module ForwardReadable
+      def readable?; io.readable?; end
+      private :readable?
+    end
+    
+    module SelectReadable
+      def readable?; !!IO.select(io_selector, nil, nil, select_delay); end
+      private :readable?
+    end
+    
+    class << self
+      def define_io_methods stream
+        define_io_write stream
+        define_io_read stream
+      end
+
+    private
+      def define_io_write stream
+        if stream.io.respond_to? :write_nonblock
+          stream.extend NonBlockingWrites
+        else
+          stream.extend BlockingWrites
+        end
+        
+        if stream.io.respond_to? :writeable?
+          stream.extend ForwardWriteable
+        else
+          stream.extend SelectWriteable
+        end
+      end
+
+      def define_io_read stream
+        if stream.io.respond_to? :read_nonblock
+          stream.extend NonBlockingReads
+        elsif stream.io.respond_to? :readpartial
+          stream.extend PartialReads
+        else
+          stream.extend BlockingReads
+        end
+        
+        if stream.io.respond_to? :readable?
+          stream.extend ForwardReadable
+        else
+          stream.extend SelectReadable
+        end
+      end
+    end
+  end
+end

data/lib/io_unblock/stream.rb

@@ -0,0 +1,158 @@
+module IoUnblock
+  class StreamError < IoUnblockError; end
+  
+  class Stream
+    MAX_BYTES_PER_WRITE = 1024 * 8
+    MAX_BYTES_PER_READ = 1024 * 4
+    
+    attr_reader :running, :connected, :io, :io_selector, :callbacks
+    attr_accessor :select_delay
+    alias :running? :running
+    alias :connected? :connected
+
+    # The given IO object, `io`, is assumed to be opened/connected.
+    # Global callbacks:
+    # - failed: called when IO access throws an exception that cannot
+    #            be recovered from (opening the IO fails,
+    #            TCP connection reset, unexpected EOF, etc.)
+    # - read:    called when any data is read from the underlying IO
+    #            object
+    # - wrote:   called when any data is written to the underlying IO
+    #            object
+    # - closed:  called when the underlying IO object is closed (even
+    #            if it is closed as a result of a failure)
+    # - started: called when the IO processing has started
+    # - stopped: called when the IO processing has stopped
+    # - looped:  called when each time the IO processing loops
+    def initialize io, callbacks=nil
+      @io = io
+      @io_selector = [@io]
+      @processor = nil
+      @s_mutex = Mutex.new
+      @w_buff = IoUnblock::Buffer.new
+      @running = false
+      @connected = true
+      @callbacks = callbacks || {}
+      @select_delay = 0.1
+      Delegation.define_io_methods self
+      yield self if block_given?
+    end
+    
+    def start &cb
+      @s_mutex.synchronize do
+        raise StreamError, "already started" if @running
+        @running = true
+        @processor = Thread.new do
+          trigger_callbacks :started, :start, &cb
+          read_and_write while running? && connected?
+          flush_and_close
+          trigger_callbacks :stopped, :stop, &cb
+        end
+      end
+      self
+    end
+    
+    def stop
+      @s_mutex.synchronize do
+        if @running
+          @running = false
+          @processor.join
+        end
+      end
+      self
+    end
+    
+    # The callback triggered here will be invoked only when all bytes
+    # have been written.
+    def write bytes, &cb
+      @w_buff.push bytes, cb
+      self
+    end
+    
+private
+    def trigger_callbacks named, *args, &other
+      other && other.call(*args)
+      @callbacks.key?(named) && @callbacks[named].call(*args)
+    end
+
+    def flush_and_close
+      _write while connected? && @w_buff.buffered?
+      io_close
+      self
+    end
+    
+    def read_and_write
+      _read if read?
+      _write if write?
+      trigger_callbacks :looped, self
+      self
+    end
+
+    def _read
+      begin
+        bytes = io_read MAX_BYTES_PER_READ
+        trigger_callbacks(:read, bytes) if bytes
+      rescue Errno::EINTR, Errno::EAGAIN, Errno::EWOULDBLOCK
+      rescue Exception
+        force_close $!
+      end
+    end
+    
+    def _write
+      written = 0
+      while written < MAX_BYTES_PER_WRITE
+        bytes, cb = @w_buff.shift
+        break unless bytes
+        begin
+          w = io_write bytes
+        rescue Errno::EINTR, Errno::EAGAIN, Errno::EWOULDBLOCK
+          # writing will either block, or cannot otherwise be completed,
+          # put data back and try again some other day
+          @w_buff.unshift bytes, cb
+          break
+        rescue Exception
+          force_close $!
+          break
+        end
+        written += w
+        if w < bytes.size
+          @w_buff.unshift bytes[w..-1], cb
+          trigger_callbacks :wrote, bytes, w
+        else
+          trigger_callbacks :wrote, bytes, w, &cb
+        end
+      end
+    end
+
+    def io_close
+      if connected?
+        @io.close rescue nil
+        @connected = false
+        trigger_callbacks :closed
+      end
+    end
+    
+    def force_close ex
+      io_close
+      trigger_callbacks :failed, ex
+    end
+    
+    def write?
+      begin
+        connected? && @w_buff.buffered? && writeable?
+      rescue Exception
+        force_close $!
+        false
+      end
+    end
+    
+    def read?
+      begin
+        connected? && readable?
+      rescue Exception
+        force_close $!
+        false
+      end
+    end
+  end
+end

data/lib/io_unblock/version.rb

@@ -0,0 +1,3 @@
+module IoUnblock
+  VERSION = "0.1.0"
+end

data/spec/io_unblock/buffer_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path("../../spec_helper.rb", __FILE__)
+
+describe IoUnblock::Buffer do
+  before do
+    @buffer = IoUnblock::Buffer.new
+  end
+  
+  it "should be empty when nothing is buffered" do
+    @buffer.push :a, 1
+    @buffer.pop
+    @buffer.empty?.must_equal true
+    @buffer.buffered?.must_equal false
+  end
+  
+  it "should not be empty when stuff is buffered" do
+    @buffer.push :a, 1
+    @buffer.empty?.must_equal false
+    @buffer.buffered?.must_equal true
+  end
+  
+  it "should push to the end of the buffer" do
+    @buffer.push :a, 1
+    @buffer.push :b, 2
+    @buffer.first.must_equal [:a, 1]
+    @buffer.last.must_equal [:b, 2]
+  end
+  
+  it "should unshift to the beginning of the buffer" do
+    @buffer.unshift :a, 1
+    @buffer.unshift :b, 2
+    @buffer.last.must_equal [:a, 1]
+    @buffer.first.must_equal [:b, 2]
+  end
+  
+  it "should shift from the beginning" do
+    @buffer.push :a, 1
+    @buffer.push :b, 2
+    @buffer.shift.must_equal [:a, 1]
+  end
+  
+  it "should pop from the end" do
+    @buffer.push :a, 1
+    @buffer.push :b, 2
+    @buffer.pop.must_equal [:b, 2]
+  end
+end

data/spec/io_unblock/delegation_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path("../../spec_helper.rb", __FILE__)
+
+describe IoUnblock::Delegation do
+  class FakeStream
+    attr_reader :io
+    def initialize io
+      @io = io
+    end
+    def io_selector; [@io]; end
+    def select_delay; 18; end
+  end
+  
+  before do
+    @mock_io = MiniTest::Mock.new
+    @stream = FakeStream.new @mock_io
+  end
+  
+  it "delegates to read_nonblock when available" do
+    @mock_io.expect(:read_nonblock, :reading, [42])
+    IoUnblock::Delegation.define_io_methods @stream
+    @stream.__send__ :io_read, 42
+    @mock_io.verify
+  end
+  
+  it "delegates to readpartial when available" do
+    @mock_io.expect(:readpartial, :reading, [42])
+    IoUnblock::Delegation.define_io_methods @stream
+    @stream.__send__ :io_read, 42
+    @mock_io.verify
+  end
+  
+  it "delegates to read if all else fails" do
+    @mock_io.expect(:read, :reading, [42])
+    IoUnblock::Delegation.define_io_methods @stream
+    @stream.__send__ :io_read, 42
+    @mock_io.verify
+  end
+  
+  it "delegates to write_nonblock when available" do
+    @mock_io.expect(:write_nonblock, :writing, ['hello'])
+    IoUnblock::Delegation.define_io_methods @stream
+    @stream.__send__ :io_write, 'hello'
+    @mock_io.verify
+  end
+  
+  it "delegates to write if all else fails" do
+    @mock_io.expect(:write, :writing, ['hello'])
+    IoUnblock::Delegation.define_io_methods @stream
+    @stream.__send__ :io_write, 'hello'
+    @mock_io.verify
+  end
+
+  it "delegates to IO.select when there is no readable? method" do
+    mocked = MiniTest::Mock.new
+    mocked.expect(:select, nil, [[@mock_io], nil, nil, 18])
+    real_io = IO
+    ::IO = mocked
+    IoUnblock::Delegation.define_io_methods @stream
+    @stream.__send__ :readable?
+    ::IO = real_io
+    mocked.verify
+  end
+
+  it "delegates to IO.select when there is no writeable? method" do
+    mocked = MiniTest::Mock.new
+    mocked.expect(:select, nil, [nil, [@mock_io], nil, 18])
+    real_io = IO
+    ::IO = mocked
+    IoUnblock::Delegation.define_io_methods @stream
+    @stream.__send__ :writeable?
+    ::IO = real_io
+    mocked.verify
+  end
+
+  it "delegates to readable? when the method is available" do
+    @mock_io.expect(:readable?, false, [])
+    IoUnblock::Delegation.define_io_methods @stream
+    @stream.__send__ :readable?
+    @mock_io.verify
+  end
+
+  it "delegates to writeable? when the method is available" do
+    @mock_io.expect(:writeable?, false, [])
+    IoUnblock::Delegation.define_io_methods @stream
+    @stream.__send__ :writeable?
+    @mock_io.verify
+  end
+end

data/spec/io_unblock/stream_spec.rb

@@ -0,0 +1,199 @@
+require File.expand_path("../../spec_helper.rb", __FILE__)
+require 'stringio'
+require 'logger'
+
+$log = Logger.new $stdout
+
+describe IoUnblock::Stream do
+  def dummy_io; @dummy_io ||= DummyIO.new; end
+  def stream; @stream ||= IoUnblock::Stream.new dummy_io; end
+  
+  it "raises an exception if started twice" do
+    stream.start
+    lambda {
+      stream.start
+    }.must_raise IoUnblock::StreamError
+    stream.stop
+  end
+  
+  it "reads only if the IO is ready for it" do
+    dummy_io.r_stream.string = 'test string'
+    dummy_io.readable = false
+    stream.start
+    Thread.pass until stream.running?
+    dummy_io.r_stream.pos.must_equal 0
+    dummy_io.readable = true
+    Thread.pass until dummy_io.r_stream.eof?
+    stream.stop
+    dummy_io.r_stream.pos.must_equal 11
+  end
+  
+  it "closes the io when stopping" do
+    dummy_io.closed?.must_equal false
+    stream.start
+    Thread.pass until stream.running?
+    stream.stop
+    dummy_io.closed?.must_equal true
+  end
+  
+  it "flushes all writes before stopping (even if io claims to be unwriteable)" do
+    dummy_io.writeable = false
+    stream.start
+    stream.write 'hello '
+    stream.write 'world.'
+    Thread.pass until stream.running?
+    dummy_io.w_stream.string.must_equal ''
+    stream.stop
+    dummy_io.w_stream.string.must_equal 'hello world.'
+  end
+
+  it "does not die on EINTER" do
+    dummy_io.raise_write = Errno::EINTR.new
+    dummy_io.raise_read = Errno::EINTR.new
+    stream.start
+    stream.write 'hello'
+    Thread.pass until dummy_io.raised_read?
+    stream.connected?.must_equal true
+    dummy_io.raise_read = nil
+    Thread.pass until dummy_io.raised_write?
+    stream.connected?.must_equal true
+    dummy_io.raise_write = nil
+    stream.stop
+    dummy_io.w_stream.string.must_equal 'hello'
+  end
+
+  it "does not die on EAGAIN" do
+    dummy_io.raise_write = Errno::EAGAIN.new
+    dummy_io.raise_read = Errno::EINTR.new
+    stream.start
+    stream.write 'hello'
+    Thread.pass until dummy_io.raised_read?
+    stream.connected?.must_equal true
+    dummy_io.raise_read = nil
+    Thread.pass until dummy_io.raised_write?
+    stream.connected?.must_equal true
+    dummy_io.raise_write = nil
+    stream.stop
+    dummy_io.w_stream.string.must_equal 'hello'
+  end
+
+  it "does not die on EWOULDBLOCK" do
+    dummy_io.raise_write = Errno::EWOULDBLOCK.new
+    dummy_io.raise_read = Errno::EINTR.new
+    stream.start
+    stream.write 'hello'
+    Thread.pass until dummy_io.raised_read?
+    stream.connected?.must_equal true
+    dummy_io.raise_read = nil
+    Thread.pass until dummy_io.raised_write?
+    stream.connected?.must_equal true
+    dummy_io.raise_write = nil
+    stream.stop
+    dummy_io.w_stream.string.must_equal 'hello'
+  end
+
+  describe "callbacks" do
+    def called_with; @calls_received ||= []; end
+    def callback; @callback ||= lambda { |*a| called_with << a }; end
+
+    def callback_stream cbs=nil
+      IoUnblock::Stream.new(dummy_io, cbs)
+    end
+
+    it "triggers started when starting" do
+      cb_stream = callback_stream(started: callback)
+      cb_stream.start
+      cb_stream.stop
+      called_with.must_equal [ [:start] ]
+    end
+
+    it "triggers stopped when stopping" do
+      cb_stream = callback_stream(stopped: callback)
+      cb_stream.start
+      cb_stream.stop
+      called_with.must_equal [ [:stop] ]
+    end
+
+    it "triggers looped after each read/write cycle" do
+      cb_stream = callback_stream(looped: callback)
+      cb_stream.start
+      Thread.pass while called_with.empty?
+      cb_stream.stop
+      called_with.first.must_equal [cb_stream]
+    end
+
+    it "triggers wrote when writing" do
+      dummy_io.max_write = 3
+      cb_stream = callback_stream(wrote: callback)
+      cb_stream.start
+      cb_stream.write "hello"
+      cb_stream.stop
+      called_with.must_equal [ ['hello', 3], ['lo', 2] ]
+    end
+
+    it "triggers read when reading" do
+      dummy_io.max_read = 3
+      dummy_io.r_stream.string = 'hello'
+      cb_stream = callback_stream(read: callback)
+      cb_stream.start
+      Thread.pass until dummy_io.r_stream.eof?
+      cb_stream.stop
+      called_with.must_equal [ ['hel'], ['lo'] ]
+    end
+
+    it "triggers closed when closing" do
+      cb_stream = callback_stream(closed: callback)
+      cb_stream.start
+      cb_stream.stop
+      called_with.must_equal [ [] ]
+    end
+
+    it "triggers failed when reading raises an error" do
+      err = RuntimeError.new "fail"
+      cb_stream = callback_stream(failed: callback)
+      dummy_io.raise_read = err
+      cb_stream.start
+      Thread.pass until cb_stream.running?
+      Thread.pass while cb_stream.connected?
+      cb_stream.stop
+      called_with.must_equal [ [err] ]
+    end
+
+    it "triggers failed when writing raises an error" do
+      err = RuntimeError.new "fail"
+      cb_stream = callback_stream(failed: callback)
+      dummy_io.raise_write = err
+      cb_stream.start
+      cb_stream.write "hello"
+      cb_stream.stop
+      called_with.must_equal [ [err] ]
+    end
+    
+    it "triggers the given callback when starting and stopping" do
+      stream.start(&callback)
+      stream.stop
+      called_with.must_equal [ [:start], [:stop]]
+    end
+
+    it "triggers the given callback after writing the full string" do
+      dummy_io.max_write = 3
+      stream.start
+      stream.write('hello', &callback)
+      stream.stop
+      called_with.must_equal [ ['lo', 2] ]
+    end
+    
+    it "is not connected when failed is triggered" do
+      is_connected = true
+      cb_stream = callback_stream(
+        failed: lambda { |ex| is_connected = cb_stream.connected? }
+      )
+      err = RuntimeError.new "fail"
+      dummy_io.raise_write = err
+      cb_stream.start
+      cb_stream.write "hello"
+      cb_stream.stop
+      is_connected.must_equal false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,81 @@
+if ENV['SCOV']
+  require 'simplecov'
+  SimpleCov.start do
+    puts "I am started?! #{Process.pid}"
+    add_filter "/spec/"
+  end
+end
+
+require 'minitest/autorun'
+require 'minitest/emoji'
+require 'io_unblock'
+require 'stringio'
+
+# Used to test IO stuff, using stringio objects for the write and
+# read stream.
+class DummyIO
+  attr_reader :closed, :w_stream, :r_stream, :raised_write, :raised_read
+  alias :closed? :closed
+  alias :raised_write? :raised_write
+  alias :raised_read? :raised_read
+  attr_accessor :readable, :writeable
+  attr_accessor :write_delay, :read_delay
+  attr_accessor :max_write, :max_read
+  attr_accessor :raise_read, :raise_write
+  alias :readable? :readable
+  alias :writeable? :writeable
+  
+  def initialize *args, &block
+    @r_stream = StringIO.new
+    @w_stream = StringIO.new
+    @readable = @writeable = true
+    @read_delay = @write_delay = 0
+    @max_write = 0
+    @max_read = 0
+    @closed = false
+    @raise_read = nil
+    @raise_write = nil
+    @raised_write = false
+    @raised_read = false
+  end
+  
+  def close
+    @closed = true
+    @w_stream.close
+    @r_stream.close
+  end
+  
+  def write_nonblock bytes
+    sleep(@write_delay) if @write_delay > 0
+    do_raise_write
+    if @max_write > 0 && bytes.size > @max_write
+      @w_stream.write bytes[0...@max_write]
+    else
+      @w_stream.write bytes
+    end
+  end
+  
+  def read_nonblock len
+    sleep(@read_delay) if @read_delay > 0
+    do_raise_read
+    if @max_read > 0 && len > @max_read
+      @r_stream.read @max_read
+    else
+      @r_stream.read len
+    end
+  end
+
+  def do_raise_write
+    if @raise_write
+      @raised_write = true
+      raise @raise_write
+    end
+  end
+
+  def do_raise_read
+    if @raise_read
+      @raised_read = true
+      raise @raise_read
+    end
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: io_unblock
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Ian D. Eccles
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &2161332520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161332520
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2161331860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161331860
+description: Non-blocking IO reads/writes wrapped in a thread
+email:
+- ian.eccles@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .autotest
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- io_unblock.gemspec
+- lib/io_unblock.rb
+- lib/io_unblock/buffer.rb
+- lib/io_unblock/delegation.rb
+- lib/io_unblock/stream.rb
+- lib/io_unblock/version.rb
+- spec/io_unblock/buffer_spec.rb
+- spec/io_unblock/delegation_spec.rb
+- spec/io_unblock/stream_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/iande/io_unblock
+licenses: []
+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'
+requirements: []
+rubyforge_project: io_unblock
+rubygems_version: 1.8.12
+signing_key: 
+specification_version: 3
+summary: Non-blocking IO reads/writes wrapped in a thread
+test_files:
+- spec/io_unblock/buffer_spec.rb
+- spec/io_unblock/delegation_spec.rb
+- spec/io_unblock/stream_spec.rb
+- spec/spec_helper.rb
+has_rdoc: