nio4r 1.2.1-java → 2.0.0-java

data/lib/nio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NIO
-  VERSION = "1.2.1".freeze
+  VERSION = "2.0.0"
 end

data/nio4r.gemspec

@@ -1,28 +1,34 @@
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
 require File.expand_path("../lib/nio/version", __FILE__)
 
-Gem::Specification.new do |gem|
-  gem.authors       = ["Tony Arcieri"]
-  gem.email         = ["tony.arcieri@gmail.com"]
-  gem.description   = "New IO for Ruby"
-  gem.summary       = "NIO provides a high performance selector API for monitoring IO objects"
-  gem.homepage      = "https://github.com/celluloid/nio4r"
-  gem.license       = "MIT"
+Gem::Specification.new do |spec|
+  spec.authors       = ["Tony Arcieri"]
+  spec.email         = ["bascule@gmail.com"]
+  spec.homepage      = "https://github.com/socketry/nio4r"
+  spec.license       = "MIT"
+  spec.summary       = "New IO for Ruby"
+  spec.description   = <<-DESCRIPTION.strip.gsub(/\s+/, " ")
+     Cross-platform asynchronous I/O primitives for scalable network clients
+     and servers. Inspired by the Java NIO API, but simplified for ease-of-use.
+  DESCRIPTION
+
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.name          = "nio4r"
+  spec.require_paths = ["lib"]
+  spec.version       = NIO::VERSION
 
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  gem.files         = `git ls-files`.split("\n")
-  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.name          = "nio4r"
-  gem.require_paths = ["lib"]
-  gem.version       = NIO::VERSION
+  spec.required_ruby_version = ">= 2.2.2"
 
   if defined? JRUBY_VERSION
-    gem.files << "lib/nio4r_ext.jar"
-    gem.platform = "java"
+    spec.files << "lib/nio4r_ext.jar"
+    spec.platform = "java"
   else
-    gem.extensions = ["ext/nio4r/extconf.rb"]
+    spec.extensions = ["ext/nio4r/extconf.rb"]
   end
 
-  gem.add_development_dependency "rake"
-  gem.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "bundler"
 end

data/spec/nio/acceptables_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe "NIO acceptables" do
@@ -15,16 +17,16 @@ RSpec.describe "NIO acceptables" do
   end
 
   describe TCPServer do
-    let(:tcp_port) { 23_456 }
+    let(:port) { next_available_tcp_port }
 
     let :acceptable_subject do
-      server = TCPServer.new("localhost", tcp_port)
-      TCPSocket.open("localhost", tcp_port)
+      server = TCPServer.new("localhost", port)
+      TCPSocket.open("localhost", port)
       server
     end
 
     let :unacceptable_subject do
-      TCPServer.new("localhost", tcp_port + 1)
+      TCPServer.new("localhost", port + 1)
     end
 
     it_behaves_like "an NIO acceptable"

data/spec/nio/bytebuffer_spec.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe NIO::ByteBuffer do
+  let(:capacity)       { 256 }
+  let(:example_string) { "Testing 1 2 3..." }
+  subject(:bytebuffer) { described_class.new(capacity) }
+
+  describe "#initialize" do
+    it "raises TypeError if given a bogus argument" do
+      expect { described_class.new(:symbols_are_bogus) }.to raise_error(TypeError)
+    end
+  end
+
+  describe "#clear" do
+    it "clears the buffer" do
+      bytebuffer << example_string
+      bytebuffer.clear
+
+      expect(bytebuffer.remaining).to eq capacity
+    end
+  end
+
+  describe "#position" do
+    it "defaults to zero" do
+      expect(bytebuffer.position).to be_zero
+    end
+  end
+
+  describe "#position=" do
+    let(:example_position) { 42 }
+
+    it "sets the buffer's position to a valid value" do
+      expect(bytebuffer.position).to be_zero
+      bytebuffer.position = example_position
+      expect(bytebuffer.position).to eq example_position
+    end
+
+    it "raises ArgumentError if the specified position is less than zero" do
+      expect { bytebuffer.position = -1 }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError if the specified position exceeds the limit" do
+      expect { bytebuffer.position = capacity + 1 }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#limit" do
+    it "defaults to the buffer's capacity" do
+      expect(bytebuffer.limit).to eq capacity
+    end
+  end
+
+  describe "#limit=" do
+    it "sets the buffer's limit to a valid value" do
+      bytebuffer.flip
+      expect(bytebuffer.limit).to be_zero
+
+      new_limit = capacity / 2
+      bytebuffer.limit = new_limit
+      expect(bytebuffer.limit).to eq new_limit
+    end
+
+    it "preserves position and mark if they're less than the new limit" do
+      bytebuffer << "four"
+      bytebuffer.mark
+      bytebuffer << "more"
+
+      bytebuffer.limit = capacity / 2
+      expect(bytebuffer.position).to eq 8
+      bytebuffer.reset
+      expect(bytebuffer.position).to eq 4
+    end
+
+    it "sets position to the new limit if the previous position is beyond the limit" do
+      bytebuffer << "four"
+      bytebuffer.limit = 2
+      expect(bytebuffer.position).to eq 2
+    end
+
+    it "clears the mark if the new limit is before the current mark" do
+      bytebuffer << "four"
+      bytebuffer.mark
+      bytebuffer.limit = 2
+      expect { bytebuffer.reset }.to raise_error(NIO::ByteBuffer::MarkUnsetError)
+    end
+
+    it "raises ArgumentError if specified limit is less than zero" do
+      expect { bytebuffer.limit = -1 }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError if specified limit exceeds capacity" do
+      expect { bytebuffer.limit = capacity }.not_to raise_error
+      expect { bytebuffer.limit = capacity + 1 }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#capacity" do
+    it "has the requested capacity" do
+      expect(bytebuffer.capacity).to eq capacity
+    end
+  end
+
+  describe "#remaining" do
+    it "calculates the number of bytes remaining" do
+      expect(bytebuffer.remaining).to eq capacity
+      bytebuffer << example_string
+      expect(bytebuffer.remaining).to eq(capacity - example_string.length)
+    end
+  end
+
+  describe "#full?" do
+    it "returns false when there is space remaining in the buffer" do
+      expect(bytebuffer).not_to be_full
+    end
+
+    it "returns true when the buffer is full" do
+      bytebuffer << "X" * capacity
+      expect(bytebuffer).to be_full
+    end
+  end
+
+  describe "#get" do
+    it "reads all remaining data if no length is given" do
+      bytebuffer << example_string
+      bytebuffer.flip
+
+      expect(bytebuffer.get).to eq example_string
+    end
+
+    it "reads zeroes from a newly initialized buffer" do
+      expect(bytebuffer.get(capacity)).to eq("\0" * capacity)
+    end
+
+    it "advances position as data is read" do
+      bytebuffer << "First"
+      bytebuffer << "Second"
+      bytebuffer << "Third"
+      bytebuffer.flip
+
+      expect(bytebuffer.position).to be_zero
+      expect(bytebuffer.get(10)).to eq "FirstSecon"
+      expect(bytebuffer.position).to eq 10
+    end
+
+    it "raises NIO::ByteBuffer::UnderflowError if there is not enough data in the buffer" do
+      bytebuffer << example_string
+      bytebuffer.flip
+
+      expect { bytebuffer.get(example_string.length + 1) }.to raise_error(NIO::ByteBuffer::UnderflowError)
+      expect(bytebuffer.get(example_string.length)).to eq example_string
+    end
+  end
+
+  describe "#[]" do
+    it "obtains bytes at a given index without altering position" do
+      bytebuffer << example_string
+      expect(bytebuffer[7]).to eq example_string.bytes[7]
+      expect(bytebuffer.position).to eq example_string.length
+    end
+
+    it "raises ArgumentError if the index is less than zero" do
+      expect { bytebuffer[-1] }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError if the index exceeds the limit" do
+      bytebuffer << example_string
+      bytebuffer.flip
+      expect(bytebuffer[bytebuffer.limit - 1]).to eq example_string.bytes.last
+      expect { bytebuffer[bytebuffer.limit] }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#<<" do
+    it "adds strings to the buffer" do
+      bytebuffer << example_string
+      expect(bytebuffer.position).to eq example_string.length
+      expect(bytebuffer.limit).to eq capacity
+    end
+
+    it "raises NIO::ByteBuffer::OverflowError if the buffer is full" do
+      bytebuffer << "X" * (capacity - 1)
+      expect { bytebuffer << "X" }.not_to raise_error
+      expect { bytebuffer << "X" }.to raise_error(NIO::ByteBuffer::OverflowError)
+    end
+  end
+
+  describe "#flip" do
+    it "flips the bytebuffer" do
+      bytebuffer << example_string
+      expect(bytebuffer.position).to eql example_string.length
+
+      expect(bytebuffer.flip).to eq bytebuffer
+
+      expect(bytebuffer.position).to be_zero
+      expect(bytebuffer.limit).to eq example_string.length
+      expect(bytebuffer.get).to eq example_string
+    end
+
+    it "sets remaining to the previous position" do
+      bytebuffer << example_string
+      previous_position = bytebuffer.position
+      expect(bytebuffer.remaining).to eq(capacity - previous_position)
+      expect(bytebuffer.flip.remaining).to eq previous_position
+    end
+
+    it "sets limit to the previous position" do
+      bytebuffer << example_string
+      expect(bytebuffer.limit).to eql(capacity)
+
+      previous_position = bytebuffer.position
+      expect(bytebuffer.flip.limit).to eql previous_position
+    end
+  end
+
+  describe "#rewind" do
+    it "rewinds the buffer leaving the limit intact" do
+      bytebuffer << example_string
+      expect(bytebuffer.rewind).to eq bytebuffer
+
+      expect(bytebuffer.position).to be_zero
+      expect(bytebuffer.limit).to eq capacity
+    end
+  end
+
+  describe "#mark" do
+    it "returns self" do
+      expect(bytebuffer.mark).to eql bytebuffer
+    end
+  end
+
+  describe "#reset" do
+    it "returns to a previously marked position" do
+      bytebuffer << "First"
+      expected_position = bytebuffer.position
+
+      expect(bytebuffer.mark).to eq bytebuffer
+      bytebuffer << "Second"
+      expect(bytebuffer.position).not_to eq expected_position
+      expect(bytebuffer.reset.position).to eq expected_position
+    end
+
+    it "raises NIO::ByteBuffer::MarkUnsetError unless mark has been set" do
+      expect { bytebuffer.reset }.to raise_error(NIO::ByteBuffer::MarkUnsetError)
+    end
+  end
+
+  describe "#compact" do
+    let(:first_string)  { "CompactMe" }
+    let(:second_string) { "Leftover" }
+
+    it "copies data from the current position to the beginning of the buffer" do
+      bytebuffer << first_string << second_string
+      bytebuffer.position = first_string.length
+      bytebuffer.limit = first_string.length + second_string.length
+      bytebuffer.compact
+
+      expect(bytebuffer.position).to eq second_string.length
+      expect(bytebuffer.limit).to eq capacity
+      expect(bytebuffer.flip.get).to eq second_string
+    end
+  end
+
+  describe "#each" do
+    it "iterates over data in the buffer" do
+      bytebuffer << example_string
+      bytebuffer.flip
+
+      bytes = []
+      bytebuffer.each { |byte| bytes << byte }
+      expect(bytes).to eq example_string.bytes
+    end
+  end
+
+  describe "#inspect" do
+    it "inspects the buffer offsets" do
+      regex = /\A#<NIO::ByteBuffer:.*? @position=0 @limit=#{capacity} @capacity=#{capacity}>\z/
+      expect(bytebuffer.inspect).to match(regex)
+    end
+  end
+
+  context "I/O" do
+    let(:addr)   { "localhost" }
+    let(:port)   { next_available_tcp_port }
+    let(:server) { TCPServer.new(addr, port) }
+    let(:client) { TCPSocket.new(addr, port) }
+    let(:peer)   { server_thread.value }
+
+    let(:server_thread) do
+      server
+
+      thread = Thread.new { server.accept }
+      Thread.pass while thread.status && thread.status != "sleep"
+
+      thread
+    end
+
+    before do
+      server_thread
+      client
+    end
+
+    after do
+      server_thread.kill if server_thread.alive?
+
+      server.close rescue nil
+      client.close rescue nil
+      peer.close rescue nil
+    end
+
+    describe "#read_from" do
+      it "reads data into the buffer" do
+        client.write(example_string)
+        expect(bytebuffer.read_from(peer)).to eq example_string.length
+        bytebuffer.flip
+
+        expect(bytebuffer.get).to eq example_string
+      end
+
+      it "raises NIO::ByteBuffer::OverflowError if the buffer is already full" do
+        client.write(example_string)
+        bytebuffer << "X" * capacity
+        expect { bytebuffer.read_from(peer) }.to raise_error(NIO::ByteBuffer::OverflowError)
+      end
+
+      it "returns 0 if no data is available" do
+        expect(bytebuffer.read_from(peer)).to eq 0
+      end
+    end
+
+    describe "#write_to" do
+      it "writes data from the buffer" do
+        bytebuffer << example_string
+        bytebuffer.flip
+
+        expect(bytebuffer.write_to(client)).to eq example_string.length
+        client.close
+
+        expect(peer.read(example_string.length)).to eq example_string
+      end
+
+      it "raises NIO::ByteBuffer::UnderflowError if the buffer is out of data" do
+        bytebuffer.flip
+        expect { bytebuffer.write_to(peer) }.to raise_error(NIO::ByteBuffer::UnderflowError)
+      end
+    end
+  end
+end

data/spec/nio/monitor_spec.rb

@@ -1,113 +1,156 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "socket"
 
 RSpec.describe NIO::Monitor do
-  let(:example_peers) do
-    address   = "127.0.0.1"
-    base_port = 12_345
-    tries     = 10
-
-    server = tries.times do |n|
-      begin
-        break TCPServer.new(address, base_port + n)
-      rescue Errno::EADDRINUSE
-        retry
-      end
-    end
-
-    fail Errno::EADDRINUSE, "couldn't find an open port" unless server
-    client = TCPSocket.new(address, server.addr[1])
-    [server, client]
-  end
+  let(:addr) { "localhost" }
+  let(:port) { next_available_tcp_port }
 
-  let(:reader) { example_peers.first }
-  let(:writer) { example_peers.last }
+  let(:reader) { TCPServer.new(addr, port) }
+  let(:writer) { TCPSocket.new(addr, port) }
 
   let(:selector) { NIO::Selector.new }
 
-  subject    { selector.register(reader, :r) }
-  let(:peer) { selector.register(writer, :rw) }
-  after      { selector.close }
+  subject(:monitor) { selector.register(writer, :rw) }
+  subject(:peer)    { selector.register(reader, :r) }
 
-  before     { example_peers } # open server and client automatically
-  after      { reader.close }
-  after      { writer.close }
+  before { reader }
+  before { writer }
+  after  { reader.close }
+  after  { writer.close }
+  after  { selector.close }
 
-  it "knows its interests" do
-    expect(subject.interests).to eq(:r)
-    expect(peer.interests).to eq(:rw)
+  describe "#interests" do
+    it "knows its interests" do
+      expect(peer.interests).to eq(:r)
+      expect(monitor.interests).to eq(:rw)
+    end
   end
 
-  it "changes the interest set" do
-    expect(peer.interests).not_to eq(:w)
-    peer.interests = :w
-    expect(peer.interests).to eq(:w)
-  end
+  describe "#interests=" do
+    it "changes the interest set" do
+      expect(monitor.interests).not_to eq(:w)
+      monitor.interests = :w
+      expect(monitor.interests).to eq(:w)
+    end
 
-  it "knows its IO object" do
-    expect(subject.io).to eq(reader)
+    it "raises EOFError if interests are changed after the monitor is closed" do
+      monitor.close
+      expect { monitor.interests = :rw }.to raise_error(EOFError)
+    end
   end
 
-  it "knows its selector" do
-    expect(subject.selector).to eq(selector)
-  end
+  describe "#add_interest" do
+    it "sets a new interest if it isn't currently registered" do
+      monitor.interests = :r
+      expect(monitor.interests).to eq(:r)
+
+      expect(monitor.add_interest(:w)).to eq(:rw)
+      expect(monitor.interests).to eq(:rw)
+    end
+
+    it "acts idempotently" do
+      monitor.interests = :r
+      expect(monitor.interests).to eq(:r)
+
+      expect(monitor.add_interest(:r)).to eq(:r)
+      expect(monitor.interests).to eq(:r)
+    end
 
-  it "stores arbitrary values" do
-    subject.value = 42
-    expect(subject.value).to eq(42)
+    it "raises ArgumentError if given a bogus option" do
+      expect { monitor.add_interest(:derp) }.to raise_error(ArgumentError)
+    end
   end
 
-  it "knows what operations IO objects are ready for" do
-    # For whatever odd reason this breaks unless we eagerly evaluate subject
-    reader_monitor = subject
-    writer_monitor = peer
+  describe "#remove_interest" do
+    it "removes an interest from the set" do
+      expect(monitor.interests).to eq(:rw)
+
+      expect(monitor.remove_interest(:r)).to eq(:w)
+      expect(monitor.interests).to eq(:w)
+    end
 
-    selected = selector.select(0)
-    expect(selected).to include(writer_monitor)
+    it "can clear the last interest" do
+      monitor.interests = :w
+      expect(monitor.interests).to eq(:w)
 
-    expect(writer_monitor.readiness).to eq(:w)
-    expect(writer_monitor).not_to be_readable
-    expect(writer_monitor).to be_writable
+      expect(monitor.remove_interest(:w)).to be_nil
+      expect(monitor.interests).to be_nil
+    end
 
-    writer << "testing 1 2 3"
+    it "acts idempotently" do
+      monitor.interests = :w
+      expect(monitor.interests).to eq(:w)
 
-    selected = selector.select(0)
-    expect(selected).to include(reader_monitor)
+      expect(monitor.remove_interest(:r)).to eq(:w)
+      expect(monitor.interests).to eq(:w)
+    end
 
-    expect(reader_monitor.readiness).to eq(:r)
-    expect(reader_monitor).to be_readable
-    expect(reader_monitor).not_to be_writable
+    it "raises ArgumentError if given a bogus option" do
+      expect { monitor.add_interest(:derp) }.to raise_error(ArgumentError)
+    end
   end
 
-  it "changes current interests with #interests=" do
-    client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-    monitor = selector.register(client, :r)
-    expect(monitor.interests).to eq(:r)
-    monitor.interests = :w
-    expect(monitor.interests).to eq(:w)
+  describe "#io" do
+    it "knows its IO object" do
+      expect(monitor.io).to eq(writer)
+    end
   end
 
-  it "closes" do
-    expect(subject).not_to be_closed
-    expect(selector.registered?(reader)).to be_truthy
+  describe "#selector" do
+    it "knows its selector" do
+      expect(monitor.selector).to eq(selector)
+    end
+  end
 
-    subject.close
-    expect(subject).to be_closed
-    expect(selector.registered?(reader)).to be_falsey
+  describe "#value=" do
+    it "stores arbitrary values" do
+      monitor.value = 42
+      expect(monitor.value).to eq(42)
+    end
   end
 
-  it "closes even if the selector has been shutdown" do
-    expect(subject).not_to be_closed
-    selector.close # forces shutdown
-    expect(subject).not_to be_closed
-    subject.close
-    expect(subject).to be_closed
+  describe "#readiness" do
+    it "knows what operations IO objects are ready for" do
+      # For whatever odd reason this breaks unless we eagerly evaluate monitor
+      reader_peer = peer
+      writer_peer = monitor
+
+      selected = selector.select(0)
+      expect(selected).to include(writer_peer)
+
+      expect(writer_peer.readiness).to eq(:w)
+      expect(writer_peer).not_to be_readable
+      expect(writer_peer).to be_writable
+
+      writer << "testing 1 2 3"
+
+      selected = selector.select(0)
+      expect(selected).to include(reader_peer)
+
+      expect(reader_peer.readiness).to eq(:r)
+      expect(reader_peer).to be_readable
+      expect(reader_peer).not_to be_writable
+    end
   end
 
-  it "changes the interest set after monitor closed" do
-    # check for changing the interests on the go after closed expected to fail
-    expect(subject.interests).not_to eq(:rw)
-    subject.close # forced shutdown
-    expect { subject.interests = :rw }.to raise_error(TypeError)
+  describe "#close" do
+    it "closes" do
+      expect(monitor).not_to be_closed
+      expect(selector.registered?(writer)).to be_truthy
+
+      monitor.close
+      expect(monitor).to be_closed
+      expect(selector.registered?(writer)).to be_falsey
+    end
+
+    it "closes even if the selector has been shutdown" do
+      expect(monitor).not_to be_closed
+      selector.close # forces shutdown
+      expect(monitor).not_to be_closed
+      monitor.close
+      expect(monitor).to be_closed
+    end
   end
 end