cool.io 1.2.3-x86-mingw32 → 1.4.1-x86-mingw32

data/lib/cool.io/loop.rb

@@ -15,17 +15,9 @@ end
 
 module Coolio
   class Loop
-    # In Ruby 1.9 we want a Coolio::Loop per thread, but Ruby 1.8 is unithreaded
-    if RUBY_VERSION >= "1.9.0"
-      # Retrieve the default event loop for the current thread
-      def self.default
-        Thread.current._coolio_loop
-      end
-    else
-      # Retrieve the default event loop
-      def self.default
-        @@_coolio_loop ||= Coolio::Loop.new
-      end
+    # Retrieve the default event loop for the current thread
+    def self.default
+      Thread.current._coolio_loop
     end
 
     # Create a new Coolio::Loop

data/lib/cool.io/meta.rb

@@ -11,7 +11,7 @@ module Coolio
     # an event to occur before the current watcher can be used in earnest,
     # such as making an outgoing TCP connection.
     def watcher_delegate(proxy_var)
-      %w{attach detach enable disable}.each do |method|
+      %w{attach attached? detach enable disable}.each do |method|
         module_eval <<-EOD
           def #{method}(*args)
             if defined? #{proxy_var} and #{proxy_var}
@@ -39,7 +39,7 @@ module Coolio
             end
 
             if defined? @#{method}_callback and @#{method}_callback
-              instance_exec(*args, &@#{method}_callback)
+              @#{method}_callback.call(*args)
             end
           end
         EOD

data/lib/cool.io/version.rb

@@ -1,5 +1,7 @@
 module Coolio
-  VERSION = "1.2.3"
+  VERSION = "1.4.1"
   
-  def self.version; VERSION; end
+  def self.version
+    VERSION
+  end
 end

data/spec/async_watcher_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path('../spec_helper', __FILE__)
 require 'tempfile'
 require 'fcntl'
 
-describe Cool.io::AsyncWatcher, :env => :win do
+describe Cool.io::AsyncWatcher, :env => :exclude_win do
 
   it "does not signal on spurious wakeups" do
     aw = Cool.io::AsyncWatcher.new
@@ -30,7 +30,7 @@ describe Cool.io::AsyncWatcher, :env => :win do
     end
 
     # ensure children are ready
-    nr_fork.times { rd.sysread(1).should == '.' }
+    nr_fork.times { expect(rd.sysread(1)).to eq('.') }
 
     # send our signals
     nr_signal.times { aw.signal }
@@ -41,15 +41,15 @@ describe Cool.io::AsyncWatcher, :env => :win do
     children.each do |pid|
       Process.kill(:TERM, pid)
       _, status = Process.waitpid2(pid)
-      status.exitstatus.should == 0
+      expect(status.exitstatus).to eq(0)
     end
 
     # we should've written a line for every signal we sent
     lines = tmp.readlines
-    lines.size.should == nr_signal
+    expect(lines.size).to eq(nr_signal)
 
     # theoretically a bad kernel scheduler could give us fewer...
-    lines.sort.uniq.size.should == nr_fork
+    expect(lines.sort.uniq.size).to eq(nr_fork)
 
     tmp.close!
   end

data/spec/dns_spec.rb

@@ -22,18 +22,22 @@ describe "DNS" do
   end
   
   it "connects to valid domains" do
-    ConnectorThingy.connect(VALID_DOMAIN, 80).attach(@loop)
-    
-    proc do
-      @loop.run
-    end.should raise_error(ItWorked)
+    begin
+      c = ConnectorThingy.connect(VALID_DOMAIN, 80).attach(@loop)
+      
+      expect do
+        @loop.run
+      end.to raise_error(ItWorked)
+    ensure
+      c.close
+    end
   end
   
   it "fires on_resolve_failed for invalid domains" do
     ConnectorThingy.connect(INVALID_DOMAIN, 80).attach(@loop)
     
-    proc do
+    expect do
       @loop.run
-    end.should raise_error(WontResolve)
+    end.to raise_error(WontResolve)
   end
 end

data/spec/iobuffer_spec.rb

@@ -0,0 +1,147 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+
+describe IO::Buffer do
+
+  let :buffer do
+    IO::Buffer.new
+  end
+  
+  it "provides a subset of the methods available in Strings" do
+    expect(buffer << "foo").to eq "foo"
+    expect(buffer << "bar").to eq "bar"
+    expect(buffer.to_str).to eq "foobar"
+    expect(buffer.to_str).to eq "foobar"
+    expect(buffer.size).to eq 6
+  end
+
+  it "provides append and prepend" do
+    expect(buffer.append "bar").to eq "bar"
+    expect(buffer.prepend "foo").to eq "foo"
+    expect(buffer.append "baz").to eq "baz"
+    expect(buffer.to_str).to eq "foobarbaz"
+  end
+  
+  context "#read" do
+    it "can be used to retrieve the contents of a buffer" do
+      expect(buffer << "foo").to eq "foo"
+      expect(buffer.read 2).to eq "fo"
+      expect(buffer << "bar").to eq "bar"
+      expect(buffer.read 2).to eq "ob"
+      expect(buffer << "baz").to eq "baz"
+      expect(buffer.read 3).to eq "arb"
+    end
+  end
+  
+  describe "provides methods for performing non-blocking I/O" do
+    require "tempfile"
+    
+    context "#read_from" do
+      context "using local file", :env => :exclude_win do
+        let :tmp do
+          t = Tempfile.open "read_from"
+          t << "foobar"
+          t.rewind
+          t
+        end
+        
+        it "will read as much data as possible" do
+          expect(buffer.read_from tmp).to eq 6
+          expect(buffer.to_str).to eq "foobar"
+        end
+      end
+      
+      context "using udp socket" do
+        before :each do
+          @receiver = UDPSocket.open
+          @receiver.bind nil, 0
+          
+          @sender = UDPSocket.open
+          @sender.connect "localhost", @receiver.addr[1]
+        end
+        after :each do
+          @receiver.close
+          @sender.close
+        end
+        
+        it "will read as much data as possible" do
+          select [], [@sender]
+          @sender.send "foo", 0
+          select [@receiver]
+          expect(buffer.read_from @receiver).to eq 3
+          expect(buffer.to_str).to eq "foo"
+          
+          select [], [@sender]
+          @sender.send "barbaz", 0
+          select [@receiver]
+          expect(buffer.read_from @receiver).to eq 6
+          expect(buffer.to_str).to eq "foobarbaz"
+        end
+      end
+    end
+    
+    context "#write_to" do
+      context "using local file", :env => :exclude_win do
+        let :tmp do
+          Tempfile.open "write_to"
+        end
+        it "writes the contents of the buffer" do
+          buffer << "foo"
+          expect(buffer.write_to tmp).to eq 3
+          tmp.rewind
+          expect(tmp.read 3).to eq "foo"
+        end
+      end
+      
+      context "using udp socket" do
+        before :each do
+          @receiver = UDPSocket.open
+          @receiver.bind nil, 0
+          
+          @sender = UDPSocket.open
+          @sender.connect "localhost", @receiver.addr[1]
+        end
+        after :each do
+          @receiver.close
+          @sender.close
+        end
+        
+        it "will read as much data as possible" do
+          buffer << "foo"
+          select [], [@sender]
+          expect(buffer.write_to @sender).to eq 3
+          select [@receiver]
+          expect(@receiver.recvfrom_nonblock(3)[0]).to eq "foo"
+        end
+      end
+    end
+  end
+  
+  context "#clear" do
+    it "clear all data" do
+      buffer << "foo"
+      expect(buffer.size).to eq 3
+      expect(buffer.empty?).to eq false
+      buffer.clear
+      expect(buffer.size).to eq 0
+      expect(buffer.empty?).to eq true
+    end
+  end
+  
+  context "#read_frame" do
+    it "Read up to and including the given frame marker" do
+      buffer << "foo\nbarbaz"
+      data = ""
+      expect(buffer.read_frame data, "\n".ord).to eq true
+      expect(buffer.empty?).to eq false
+      expect(data).to eq "foo\n"
+      expect(buffer.to_str).to eq "barbaz"
+      
+      expect(buffer.read_frame data, "\n".ord).to eq false
+      expect(buffer.empty?).to eq true
+      expect(data).to eq "foo\nbarbaz"
+      expect(buffer.to_str).to eq ""
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -12,8 +12,8 @@ def unused_port
 end
 
 RSpec.configure do |c|
-  if RUBY_PLATFORM =~ /mingw|win32/
+  if RUBY_PLATFORM =~ /mingw|mswin/
     $stderr.puts "Skip some specs on Windows"
-    c.filter_run_excluding :env => :win
+    c.filter_run_excluding :env => :exclude_win
   end
 end

data/spec/stat_watcher_spec.rb

@@ -62,16 +62,16 @@ describe Cool.io::StatWatcher do
   end
 
   it "fire on_change when the file it is watching is modified" do
-    watcher.accessed.should eql(true)
+    expect(watcher.accessed).to eq(true)
   end
 
   it "should pass previous and current file stat info given a stat watcher" do
-    watcher.previous.ino.should eql(watcher.current.ino)
+    expect(watcher.previous.ino).to eq(watcher.current.ino)
   end
 
   it "should raise when the handler does not take 2 parameters" do
     class MyStatWatcher < Cool.io::StatWatcher; def on_change; end; end
-    lambda { watcher.accessed }.should raise_error(ArgumentError)
+    expect { watcher.accessed }.to raise_error(ArgumentError)
   end
 
 end

data/spec/tcp_server_spec.rb

@@ -106,14 +106,14 @@ ensure
 end
 
 # This test should work on Windows
-describe Coolio::TCPServer, :env => :win do
+describe Coolio::TCPServer do
 
   it '#run' do
-    test_run("hello").should == "hello"
+    expect(test_run("hello")).to eq("hello")
   end
 
   it '#run_once' do
-    test_run_once("hello").should == "hello"
+    expect(test_run_once("hello")).to eq("hello")
   end
 
   it '#run_once(timeout)' do
@@ -125,8 +125,101 @@ describe Coolio::TCPServer, :env => :win do
   end
 
   it '#run(timeout)' do
-    test_run_timeout("hello").should == "hello"
+    expect(test_run_timeout("hello")).to eq("hello")
   end
 
+  describe "functionaltest" do
+    let :loop do
+      Coolio::Loop.new
+    end
+    
+    let :port do
+      unused_port
+    end
+    
+    context "#on_connect" do
+      class ServerOnConnect < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_connect
+          @cb.call
+        end
+      end
+      
+      it "connected socket called on_connect" do
+        begin
+          connected = false
+          server = Cool.io::TCPServer.new("localhost", port, ServerOnConnect, proc { connected = true })
+          loop.attach server
+          s = TCPSocket.open("localhost", port)
+          loop.run_once
+          s.close
+          expect(connected).to eq true
+        ensure
+          server.detach
+        end
+      end
+    end
+    
+    context "#on_close" do
+      class ServerOnClose < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_close
+          @cb.call
+        end
+      end
+      
+      it "closed socket called on_close" do
+        begin
+          closed = false
+          server = Cool.io::TCPServer.new("localhost", port, ServerOnConnect, proc { closed = true })
+          loop.attach server
+          s = TCPSocket.open("localhost", port)
+          loop.run_once
+          s.close
+          loop.run_once
+          expect(closed).to eq true
+        ensure
+          server.detach
+        end
+      end
+    end
+    
+    context "#on_read" do
+      class Echo < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_read(data)
+          @cb.call data
+          size = write(data + "fff")
+        end
+      end
+      
+      it "server socket received data" do
+        begin
+          data = "aaa"
+          server = Cool.io::TCPServer.new("localhost", port, Echo, proc { |d| data = d })
+          loop.attach server
+          thread = Thread.new { loop.run }
+          s = TCPSocket.open("localhost", port)
+          s.write "zzz"
+          sleep 0.1
+          expect(data).to eq "zzz"
+          expect(s.read 6).to eq "zzzfff"
+        ensure
+          s.close
+          loop.stop
+          server.detach
+          thread.join
+        end
+      end
+    end
+  end
 end
-

data/spec/tcp_socket_spec.rb

@@ -0,0 +1,185 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Coolio::TCPSocket do
+  let :loop do
+    Coolio::Loop.new
+  end
+  
+  before :each do
+    @echo = TCPServer.new("127.0.0.1", 0)
+    @host = @echo.addr[3]
+    @port = @echo.addr[1]
+    @running = true
+    @echo_thread = Thread.new do
+      socks = [@echo]
+      begin
+        serv socks
+      ensure
+        socks.each do |s|
+          s.close
+        end
+      end
+      Thread.pass
+    end
+  end
+  
+  def serv(socks)
+    while @running
+      selected = select(socks, [], [], 0.1)
+      next if selected.nil?
+      selected[0].each do |s|
+        if s == @echo
+          socks.push s.accept
+          next
+        end
+        begin
+          unless s.eof?
+            s.write(s.read_nonblock 1)
+          end
+        rescue SystemCallError, EOFError, IOError, SocketError
+        end
+      end
+    end
+  end
+  
+  def shutdown
+    if @running
+      @running = false
+      @echo_thread.join
+    end
+  end
+  
+  after :each do
+    shutdown
+  end
+
+  context "#close" do
+    it "detaches all watchers on #close before loop#run" do
+      client = Coolio::TCPSocket.connect(@host, @port)
+      loop.attach client
+      client.close
+      expect(loop.watchers.size).to eq 0
+    end
+  end
+
+  context "#on_connect" do
+    class OnConnect < Cool.io::TCPSocket
+      attr :connected
+      def on_connect
+        @connected = true
+      end
+    end
+    
+    it "connected client called on_connect" do
+      begin
+        c = OnConnect.connect(@host, @port)
+        loop.attach c
+        loop.run_once
+        expect(c.connected).to eq true
+      ensure
+        c.close
+      end
+    end
+  end
+
+  context "#on_connect_failed" do
+    class OnConnectFailed < Cool.io::TCPSocket
+      attr :connect_failed
+      def on_connect_failed
+        @connect_failed = true
+      end
+    end
+    
+    it "try to connect dead host" do
+      serv = TCPServer.new(0)
+      dead_host = serv.addr[3]
+      dead_port = serv.addr[1]
+      serv.close
+      
+      c = OnConnectFailed.connect(dead_host, dead_port)
+      loop.attach c
+      loop.run_once # on_connect_failed
+      expect(c.connect_failed).to eq true
+    end
+  end
+
+  context "#on_close" do
+    class Closed < StandardError; end
+    class OnClose < Cool.io::TCPSocket
+      def on_close
+        raise Closed
+      end
+    end
+    
+    let :client do
+      OnClose.connect(@host, @port)
+    end
+    
+    before :each do
+      loop.attach client
+      loop.run_once # on_connect
+      client.write "0"
+    end
+    
+    it "disconnect from client" do
+      expect { client.close }.to raise_error(Closed)
+    end
+
+    it "disconnect from server" do
+      shutdown
+      expect { loop.run }.to raise_error(Closed)
+    end
+  end
+  
+  context "#on_read" do
+    class Finished < StandardError; end
+    class OnRead < Cool.io::TCPSocket
+      attr :read_data, :times
+      def on_connect
+        @read_data = ""
+        @times = 0
+      end
+      def on_read(data)
+        @read_data += data
+        @times += 1
+        if @times < 5
+          write "#{@times}"
+        else
+          close
+          raise Finished
+        end
+      end
+    end
+    
+    it "receive 5 times" do
+      c = OnRead.connect(@host, @port)
+      loop.attach c
+      loop.run_once # on_connect
+      c.write "0"
+      expect { loop.run }.to raise_error(Finished)
+      
+      expect(c.times).to eq 5
+      expect(c.read_data).to eq "01234"
+    end
+  end
+  
+  context "#on_write_complete" do
+    class WriteComplete < StandardError; end
+    class OnWriteComplete < Cool.io::TCPSocket
+      attr :called
+      def on_write_complete
+        @called = true
+        close
+        raise WriteComplete
+      end
+    end
+    
+    it "on_write_complete is called" do
+      c = OnWriteComplete.connect(@host, @port)
+      loop.attach c
+      loop.run_once # on_connect
+      c.write "aaa"
+      expect { loop.run }.to raise_error(WriteComplete)
+    end
+  end
+end