nio4r 1.2.1 → 2.5.3

data/lib/nio/version.rb

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

data/nio4r.gemspec

@@ -1,28 +1,42 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path("../lib/nio/version", __FILE__)
+# frozen_string_literal: true
 
-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"
+require File.expand_path("lib/nio/version", __dir__)
 
-  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
+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
+
+  spec.metadata = {
+    "bug_tracker_uri"   => "https://github.com/socketry/nio4r/issues",
+    "changelog_uri"     => "https://github.com/socketry/nio4r/blob/master/CHANGES.md",
+    "documentation_uri" => "https://www.rubydoc.info/gems/nio4r/#{spec.version}",
+    "source_code_uri"   => "https://github.com/socketry/nio4r/tree/v#{spec.version}",
+    "wiki_uri"          => "https://github.com/socketry/nio4r/wiki"
+  }
+
+  spec.required_ruby_version = ">= 2.4"
 
   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 "bundler"
+  spec.add_development_dependency "rake"
 end

data/{tasks → rakelib}/extension.rake

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 if defined? JRUBY_VERSION
   require "rake/javaextensiontask"
   Rake::JavaExtensionTask.new("nio4r_ext") do |ext|
     ext.ext_dir = "ext/nio4r"
+    ext.source_version = "1.8"
+    ext.target_version = "1.8"
   end
 else
   require "rake/extensiontask"

data/{tasks → rakelib}/rspec.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new

data/{tasks → rakelib}/rubocop.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rubocop/rake_task"
 
 RuboCop::RakeTask.new

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,14 @@ RSpec.describe "NIO acceptables" do
   end
 
   describe TCPServer do
-    let(:tcp_port) { 23_456 }
-
     let :acceptable_subject do
-      server = TCPServer.new("localhost", tcp_port)
-      TCPSocket.open("localhost", tcp_port)
+      server = TCPServer.new("127.0.0.1", 0)
+      TCPSocket.open("127.0.0.1", server.local_address.ip_port)
       server
     end
 
     let :unacceptable_subject do
-      TCPServer.new("localhost", tcp_port + 1)
+      TCPServer.new("127.0.0.1", 0)
     end
 
     it_behaves_like "an NIO acceptable"

data/spec/nio/bytebuffer_spec.rb

@@ -0,0 +1,354 @@
+# 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 TypeError if given a non-String type" do
+      expect { bytebuffer << 42 }.to raise_error(TypeError)
+      expect { bytebuffer << nil }.to raise_error(TypeError)
+    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)   { "127.0.0.1" }
+    let(:server) { TCPServer.new(addr, 0) }
+    let(:port)   { server.local_address.ip_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