nio4r 2.0.0.pre-java → 2.1.0-java

data/lib/nio.rb

@@ -19,7 +19,7 @@ if ENV["NIO4R_PURE"] == "true" || (Gem.win_platform? && !defined?(JRUBY_VERSION)
   require "nio/monitor"
   require "nio/selector"
   require "nio/bytebuffer"
-  NIO::ENGINE = "ruby".freeze
+  NIO::ENGINE = "ruby"
 else
   require "nio4r_ext"
 
@@ -27,8 +27,8 @@ else
     require "java"
     require "jruby"
     org.nio4r.Nio4r.new.load(JRuby.runtime, false)
-    NIO::ENGINE = "java".freeze
+    NIO::ENGINE = "java"
   else
-    NIO::ENGINE = "libev".freeze
+    NIO::ENGINE = "libev"
   end
 end

data/lib/nio/bytebuffer.rb

@@ -1,175 +1,222 @@
+# frozen_string_literal: true
+
 module NIO
-  # rubocop:disable ClassLength
+  # Efficient byte buffers for performant I/O operations
   class ByteBuffer
-    def initialize(value, offset = nil, length = nil)
-      # value can be either STRING or INTEGER
-      fail "not a valid input" if value.nil?
-      @position = 0
-      @mark = -1
-      if value.is_a? Integer
-        @size = value
-        @byte_array = Array.new(value)
-      elsif value.is_a? String
-        @byte_array = str.bytes
-        @size = @byte_array.size
-      end
-      @limit = @size - 1
-      unless offset.nil?
-        @offset = offset
-        @position = offset
-        unless length.nil?
-          fail "Invalid Arguiments Exception" if offset + length >= value
-          @limit = offset + length
-        end
-      end
-    end
-
-    # put the provided string to the buffer
-    def <<(str)
-      temp_buffer = str.bytes
-      temp_buffer.each { |x| put_byte x }
-    end
+    include Enumerable
 
-    # return the remaining number positions to read/ write
-    def remaining
-      @limit + 1 - @position
-    end
+    attr_reader :position, :limit, :capacity
 
-    # has any space remaining
-    def remaining?
-      remaining > 0
-    end
+    # Insufficient capacity in buffer
+    OverflowError = Class.new(IOError)
+
+    # Not enough data remaining in buffer
+    UnderflowError = Class.new(IOError)
 
-    # this method is private
-    def put_byte(byte)
-      fail "Buffer Overflowed" if @position == @size
-      @byte_array[@position] = byte
-      @position += 1
+    # Mark has not been set
+    MarkUnsetError = Class.new(IOError)
+
+    # Create a new ByteBuffer, either with a specified capacity or populating
+    # it from a given string
+    #
+    # @param capacity [Integer] size of buffer in bytes
+    #
+    # @return [NIO::ByteBuffer]
+    def initialize(capacity)
+      raise TypeError, "no implicit conversion of #{capacity.class} to Integer" unless capacity.is_a?(Integer)
+      @capacity = capacity
+      clear
     end
 
-    # write content in the buffer to file
-    # call flip before calling this
-    # after write operation to the
-    # buffer
-    def write_to(file)
-      @file_to_write = file unless @file_to_write.eql? file
-      file.write get if remaining?
+    # Clear the buffer, resetting it to the default state
+    def clear
+      @buffer   = ("\0" * @capacity).force_encoding(Encoding::BINARY)
+      @position = 0
+      @limit    = @capacity
+      @mark     = nil
+
+      self
     end
 
-    # Fill the byteBuffer with content of the file
-    def read_from(file)
-      @file_to_read = file unless @file_to_read.eql? file
-      while (s = file.read(1)) && remaining?
-        put_byte(s)
-      end
+    # Set the position to the given value. New position must be less than limit.
+    # Preserves mark if it's less than the new position, otherwise clears it.
+    #
+    # @param new_position [Integer] position in the buffer
+    #
+    # @raise [ArgumentError] new position was invalid
+    def position=(new_position)
+      raise ArgumentError, "negative position given" if new_position < 0
+      raise ArgumentError, "specified position exceeds capacity" if new_position > @capacity
+
+      @position = new_position
+      @mark = nil if @mark && @mark > @position
+
+      new_position
     end
 
-    # flip from write to read mode
-    def flip
-      # need to avoid @position being negative
-      @limit = [@position - 1, 0].max
-      @position = 0
-      @mark = -1
+    # Set the limit to the given value. New limit must be less than capacity.
+    # Preserves limit and mark if they're less than the new limit, otherwise
+    # sets position to the new limit and clears the mark.
+    #
+    # @param new_limit [Integer] position in the buffer
+    #
+    # @raise [ArgumentError] new limit was invalid
+    def limit=(new_limit)
+      raise ArgumentError, "negative limit given" if new_limit < 0
+      raise ArgumentError, "specified limit exceeds capacity" if new_limit > @capacity
+
+      @limit = new_limit
+      @position = new_limit if @position > @limit
+      @mark = nil if @mark && @mark > @limit
+
+      new_limit
     end
 
-    # rewind read mode to write mode. limit stays unchanged
-    def rewind
-      @position = 0
-      @mark = -1
+    # Number of bytes remaining in the buffer before the limit
+    #
+    # @return [Integer] number of bytes remaining
+    def remaining
+      @limit - @position
     end
 
-    # reset the position to the previously marked position
-    def reset
-      fail "Invalid Mark Exception" if @mark < 0
-      @position = @mark
-      self
+    # Does the ByteBuffer have any space remaining?
+    #
+    # @return [true, false]
+    def full?
+      remaining.zero?
     end
 
-    # mark the current position in order to reset later
-    def mark
-      @mark = @position
+    # Obtain the requested number of bytes from the buffer, advancing the position.
+    # If no length is given, all remaining bytes are consumed.
+    #
+    # @raise [NIO::ByteBuffer::UnderflowError] not enough data remaining in buffer
+    #
+    # @return [String] bytes read from buffer
+    def get(length = remaining)
+      raise ArgumentError, "negative length given" if length < 0
+      raise UnderflowError, "not enough data in buffer" if length > @limit - @position
+
+      result = @buffer[@position...length]
+      @position += length
+      result
     end
 
-    # the current values are considered junk
-    def clear
-      @position = 0
-      @limit = @size - 1
-      @mark = -1
-      self
+    # Obtain the byte at a given index in the buffer as an Integer
+    #
+    # @raise [ArgumentError] index is invalid (either negative or larger than limit)
+    #
+    # @return [Integer] byte at the given index
+    def [](index)
+      raise ArgumentError, "negative index given" if index < 0
+      raise ArgumentError, "specified index exceeds limit" if index >= @limit
+
+      @buffer.bytes[index]
     end
 
-    def compact
-      # compact should be allowed only if there are content remaining in the buffer
-      return self unless remaining?
-      temp = @byte_array.slice(@position, @limit)
-      # if 1 remaining the replaced range should be @byte_array[0..0]
-      @byte_array[0..remaining - 1] = temp
-      @position = remaining
-      @limit = @size - 1
+    # Add a String to the buffer
+    #
+    # @raise [NIO::ByteBuffer::OverflowError] buffer is full
+    #
+    # @return [self]
+    def <<(str)
+      raise OverflowError, "buffer is full" if str.length > @limit - @position
+      @buffer[@position...str.length] = str
+      @position += str.length
       self
     end
 
-    # get the content of the byteBuffer. need to call rewind before calling get.
-    # return as a String
-    def get
-      return "" if @limit == 0
-      temp = @byte_array[@position..@limit].pack("c*")
-      # next position to be read. it should be always less than or equal to size-1
-      @position = [@limit + 1, @size].min
-      temp
-    end
+    # Perform a non-blocking read from the given IO object into the buffer
+    # Reads as much data as is immediately available and returns
+    #
+    # @param [IO] Ruby IO object to read from
+    #
+    # @return [Integer] number of bytes read (0 if none were available)
+    def read_from(io)
+      nbytes = @limit - @position
+      raise OverflowError, "buffer is full" if nbytes.zero?
+
+      bytes_read = IO.try_convert(io).read_nonblock(nbytes, exception: false)
+      return 0 if bytes_read == :wait_readable
 
-    def read_next(count)
-      fail "Illegal Argument" unless count > 0
-      fail "Less number of elements remaining" if count > remaining
-      temp = @byte_array[@position..@position + count - 1].pack("c*")
-      @position += count
-      temp
+      self << bytes_read
+      bytes_read.length
     end
 
-    # return the offset of the buffer
-    def offset?
-      @offset
+    # Perform a non-blocking write of the buffer's contents to the given I/O object
+    # Writes as much data as is immediately possible and returns
+    #
+    # @param [IO] Ruby IO object to write to
+    #
+    # @return [Integer] number of bytes written (0 if the write would block)
+    def write_to(io)
+      nbytes = @limit - @position
+      raise UnderflowError, "no data remaining in buffer" if nbytes.zero?
+
+      bytes_written = IO.try_convert(io).write_nonblock(@buffer[@position...@limit], exception: false)
+      return 0 if bytes_written == :wait_writable
+
+      @position += bytes_written
+      bytes_written
     end
 
-    # check whether the obj is the same bytebuffer as this bytebuffer
-    def equals?(obj)
-      self == obj
+    # Set the buffer's current position as the limit and set the position to 0
+    def flip
+      @limit = @position
+      @position = 0
+      @mark = nil
+      self
     end
 
-    # returns the capacity of the buffer. This value is fixed to the initial size
-    def capacity
-      @size
+    # Set the buffer's current position to 0, leaving the limit unchanged
+    def rewind
+      @position = 0
+      @mark = nil
+      self
     end
 
-    # Set the position to a different position
-    def position(new_position)
-      fail "Illegal Argument Exception" unless new_position <= @limit && new_position >= 0
-      @position = new_position
-      @mark = -1 if @mark > @position
+    # Mark a position to return to using the `#reset` method
+    def mark
+      @mark = @position
+      self
     end
 
-    def limit(new_limit)
-      fail "Illegal Argument Exception" if new_limit > @size || new_limit < 0
-      @limit = new_limit
-      @position = @limit if @position > @limit
-      @mark = -1 if @mark > @limit
+    # Reset position to the previously marked location
+    #
+    # @raise [NIO::ByteBuffer::MarkUnsetError] mark has not been set (call `#mark` first)
+    def reset
+      raise MarkUnsetError, "mark has not been set" unless @mark
+      @position = @mark
+      self
     end
 
-    def limit?
-      @limit
+    # Move data between the position and limit to the beginning of the buffer
+    # Sets the position to the end of the moved data, and the limit to the capacity
+    def compact
+      @buffer[0...(@limit - @position)] = @buffer[@position...@limit]
+      @position = @limit - @position
+      @limit = capacity
+      self
     end
 
-    def to_s
-      # convert String in byte form to the visible string
-      temp = "ByteBuffer "
-      temp += "[pos=" + @position.to_s
-      temp += " lim =" + @limit.to_s
-      temp += " cap=" + @size.to_s
-      temp += "]"
-      temp
+    # Iterate over the bytes in the buffer (as Integers)
+    #
+    # @return [self]
+    def each(&block)
+      @buffer[0...@limit].each_byte(&block)
     end
 
-    private :put_byte
+    # Inspect the state of the buffer
+    #
+    # @return [String] string describing the state of the buffer
+    def inspect
+      format(
+        "#<%s:0x%x @position=%d @limit=%d @capacity=%d>",
+        self.class,
+        object_id << 1,
+        @position,
+        @limit,
+        @capacity
+      )
+    end
   end
 end

data/lib/nio/monitor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NIO
   # Monitors watch IO objects for specific events
   class Monitor
@@ -13,7 +15,7 @@ module NIO
           io = io.to_io
         end
 
-        fail TypeError, "can't convert #{io.class} into IO" unless io.is_a? IO
+        raise TypeError, "can't convert #{io.class} into IO" unless io.is_a? IO
       end
 
       @io        = io
@@ -22,14 +24,72 @@ module NIO
       @closed    = false
     end
 
-    # set the interests set
+    # Replace the existing interest set with a new one
+    #
+    # @param interests [:r, :w, :rw] I/O readiness we're interested in (read/write/readwrite)
+    #
+    # @return [Symbol] new interests
     def interests=(interests)
-      fail TypeError, "monitor is already closed" if closed?
-      fail ArgumentError, "bad interests: #{interests}" unless [:r, :w, :rw].include?(interests)
+      raise EOFError, "monitor is closed" if closed?
+      raise ArgumentError, "bad interests: #{interests}" unless [:r, :w, :rw].include?(interests)
 
       @interests = interests
     end
 
+    # Add new interests to the existing interest set
+    #
+    # @param interests [:r, :w, :rw] new I/O interests (read/write/readwrite)
+    #
+    # @return [self]
+    def add_interest(interest)
+      case interest
+      when :r
+        case @interests
+        when :r  then @interests = :r
+        when :w  then @interests = :rw
+        when :rw then @interests = :rw
+        when nil then @interests = :r
+        end
+      when :w
+        case @interests
+        when :r  then @interests = :rw
+        when :w  then @interests = :w
+        when :rw then @interests = :rw
+        when nil then @interests = :w
+        end
+      when :rw
+        @interests = :rw
+      else raise ArgumentError, "bad interests: #{interest}"
+      end
+    end
+
+    # Remove interests from the existing interest set
+    #
+    # @param interests [:r, :w, :rw] I/O interests to remove (read/write/readwrite)
+    #
+    # @return [self]
+    def remove_interest(interest)
+      case interest
+      when :r
+        case @interests
+        when :r  then @interests = nil
+        when :w  then @interests = :w
+        when :rw then @interests = :w
+        when nil then @interests = nil
+        end
+      when :w
+        case @interests
+        when :r  then @interests = :r
+        when :w  then @interests = nil
+        when :rw then @interests = :r
+        when nil then @interests = nil
+        end
+      when :rw
+        @interests = nil
+      else raise ArgumentError, "bad interests: #{interest}"
+      end
+    end
+
     # Is the IO object readable?
     def readable?
       readiness == :r || readiness == :rw