ed-precompiled_nio4r 2.7.4-arm64-darwin

data/lib/nio/bytebuffer.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2016, by Upekshe Jayasekera.
+# Copyright, 2016-2017, by Tony Arcieri.
+# Copyright, 2020, by Thomas Dziedzic.
+# Copyright, 2023, by Samuel Williams.
+
+module NIO
+  # Efficient byte buffers for performant I/O operations
+  class ByteBuffer
+    include Enumerable
+
+    attr_reader :position, :limit, :capacity
+
+    # Insufficient capacity in buffer
+    OverflowError = Class.new(IOError)
+
+    # Not enough data remaining in buffer
+    UnderflowError = Class.new(IOError)
+
+    # 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
+
+    # 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
+
+    # 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
+
+      @mark = nil if @mark && @mark > new_position
+      @position = new_position
+    end
+
+    # 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
+
+      @position = new_limit if @position > new_limit
+      @mark = nil if @mark && @mark > new_limit
+      @limit = new_limit
+    end
+
+    # Number of bytes remaining in the buffer before the limit
+    #
+    # @return [Integer] number of bytes remaining
+    def remaining
+      @limit - @position
+    end
+
+    # Does the ByteBuffer have any space remaining?
+    #
+    # @return [true, false]
+    def full?
+      remaining.zero?
+    end
+
+    # 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
+
+    # 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
+
+    # Add a String to the buffer
+    #
+    # @param str [#to_str] data to add to the buffer
+    #
+    # @raise [TypeError] given a non-string type
+    # @raise [NIO::ByteBuffer::OverflowError] buffer is full
+    #
+    # @return [self]
+    def put(str)
+      raise TypeError, "expected String, got #{str.class}" unless str.respond_to?(:to_str)
+
+      str = str.to_str
+
+      raise OverflowError, "buffer is full" if str.length > @limit - @position
+
+      @buffer[@position...str.length] = str
+      @position += str.length
+      self
+    end
+    alias << put
+
+    # 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
+
+      self << bytes_read
+      bytes_read.length
+    end
+
+    # 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
+
+    # 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
+
+    # Set the buffer's current position to 0, leaving the limit unchanged
+    def rewind
+      @position = 0
+      @mark = nil
+      self
+    end
+
+    # Mark a position to return to using the `#reset` method
+    def mark
+      @mark = @position
+      self
+    end
+
+    # 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
+
+    # 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
+
+    # Iterate over the bytes in the buffer (as Integers)
+    #
+    # @return [self]
+    def each(&block)
+      @buffer[0...@limit].each_byte(&block)
+    end
+
+    # 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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2011-2018, by Tony Arcieri.
+# Copyright, 2015, by Upekshe Jayasekera.
+# Copyright, 2015, by Vladimir Kochnev.
+# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2019-2020, by Gregory Longtin.
+
+module NIO
+  # Monitors watch IO objects for specific events
+  class Monitor
+    attr_reader :io, :interests, :selector
+    attr_accessor :value, :readiness
+
+    # :nodoc:
+    def initialize(io, interests, selector)
+      unless defined?(::OpenSSL) && io.is_a?(::OpenSSL::SSL::SSLSocket)
+        unless io.is_a?(IO)
+          if IO.respond_to? :try_convert
+            io = IO.try_convert(io)
+          elsif io.respond_to? :to_io
+            io = io.to_io
+          end
+
+          raise TypeError, "can't convert #{io.class} into IO" unless io.is_a? IO
+        end
+      end
+
+      @io        = io
+      @interests = interests
+      @selector  = selector
+      @closed    = false
+    end
+
+    # Replace the existing interest set with a new one
+    #
+    # @param interests [:r, :w, :rw, nil] I/O readiness we're interested in (read/write/readwrite)
+    #
+    # @return [Symbol] new interests
+    def interests=(interests)
+      raise EOFError, "monitor is closed" if closed?
+      raise ArgumentError, "bad interests: #{interests}" unless [:r, :w, :rw, nil].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
+    end
+
+    # Is the IO object writable?
+    def writable?
+      readiness == :w || readiness == :rw
+    end
+    alias writeable? writable?
+
+    # Is this monitor closed?
+    def closed?
+      @closed
+    end
+
+    # Deactivate this monitor
+    def close(deregister = true)
+      @closed = true
+      @selector.deregister(io) if deregister
+    end
+  end
+end

data/lib/nio/selector.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2011-2017, by Tony Arcieri.
+# Copyright, 2012, by Logan Bowers.
+# Copyright, 2013, by Sadayuki Furuhashi.
+# Copyright, 2013, by Stephen von Takach.
+# Copyright, 2013, by Tim Carey-Smith.
+# Copyright, 2013, by Ravil Bayramgalin.
+# Copyright, 2014, by Sergey Avseyev.
+# Copyright, 2014, by John Thornton.
+# Copyright, 2015, by Vladimir Kochnev.
+# Copyright, 2015, by Upekshe Jayasekera.
+# Copyright, 2019-2020, by Gregory Longtin.
+# Copyright, 2020-2021, by Joao Fernandes.
+# Copyright, 2023, by Samuel Williams.
+
+require "set"
+
+module NIO
+  # Selectors monitor IO objects for events of interest
+  class Selector
+    # Return supported backends as symbols
+    #
+    # See `#backend` method definition for all possible backends
+    def self.backends
+      [:ruby]
+    end
+
+    # Create a new NIO::Selector
+    def initialize(backend = :ruby)
+      raise ArgumentError, "unsupported backend: #{backend}" unless [:ruby, nil].include?(backend)
+
+      @selectables = {}
+      @lock = Mutex.new
+
+      # Other threads can wake up a selector
+      @wakeup, @waker = IO.pipe
+      @closed = false
+    end
+
+    # Return a symbol representing the backend I/O multiplexing mechanism used.
+    # Supported backends are:
+    # * :ruby     - pure Ruby (i.e IO.select)
+    # * :java     - Java NIO on JRuby
+    # * :epoll    - libev w\ Linux epoll
+    # * :poll     - libev w\ POSIX poll
+    # * :kqueue   - libev w\ BSD kqueue
+    # * :select   - libev w\ SysV select
+    # * :port     - libev w\ I/O completion ports
+    # * :linuxaio - libev w\ Linux AIO io_submit (experimental)
+    # * :io_uring - libev w\ Linux io_uring (experimental)
+    # * :unknown  - libev w\ unknown backend
+    def backend
+      :ruby
+    end
+
+    # Register interest in an IO object with the selector for the given types
+    # of events. Valid event types for interest are:
+    # * :r - is the IO readable?
+    # * :w - is the IO writeable?
+    # * :rw - is the IO either readable or writeable?
+    def register(io, interest)
+      unless defined?(::OpenSSL) && io.is_a?(::OpenSSL::SSL::SSLSocket)
+        io = IO.try_convert(io)
+      end
+
+      @lock.synchronize do
+        raise IOError, "selector is closed" if closed?
+
+        monitor = @selectables[io]
+        raise ArgumentError, "already registered as #{monitor.interests.inspect}" if monitor
+
+        monitor = Monitor.new(io, interest, self)
+        @selectables[monitor.io] = monitor
+
+        monitor
+      end
+    end
+
+    # Deregister the given IO object from the selector
+    def deregister(io)
+      @lock.synchronize do
+        monitor = @selectables.delete IO.try_convert(io)
+        monitor.close(false) if monitor && !monitor.closed?
+        monitor
+      end
+    end
+
+    # Is the given IO object registered with the selector?
+    def registered?(io)
+      @lock.synchronize { @selectables.key? io }
+    end
+
+    # Select which monitors are ready
+    def select(timeout = nil)
+      selected_monitors = Set.new
+
+      @lock.synchronize do
+        readers = [@wakeup]
+        writers = []
+
+        @selectables.each do |io, monitor|
+          readers << io if monitor.interests == :r || monitor.interests == :rw
+          writers << io if monitor.interests == :w || monitor.interests == :rw
+          monitor.readiness = nil
+        end
+
+        ready_readers, ready_writers = Kernel.select(readers, writers, [], timeout)
+        return unless ready_readers # timeout
+
+        ready_readers.each do |io|
+          if io == @wakeup
+            # Clear all wakeup signals we've received by reading them
+            # Wakeups should have level triggered behavior
+            @wakeup.read(@wakeup.stat.size)
+          else
+            monitor = @selectables[io]
+            monitor.readiness = :r
+            selected_monitors << monitor
+          end
+        end
+
+        ready_writers.each do |io|
+          monitor = @selectables[io]
+          monitor.readiness = monitor.readiness == :r ? :rw : :w
+          selected_monitors << monitor
+        end
+      end
+
+      if block_given?
+        selected_monitors.each { |m| yield m }
+        selected_monitors.size
+      else
+        selected_monitors.to_a
+      end
+    end
+
+    # Wake up a thread that's in the middle of selecting on this selector, if
+    # any such thread exists.
+    #
+    # Invoking this method more than once between two successive select calls
+    # has the same effect as invoking it just once. In other words, it provides
+    # level-triggered behavior.
+    def wakeup
+      # Send the selector a signal in the form of writing data to a pipe
+      begin
+        @waker.write_nonblock "\0"
+      rescue IO::WaitWritable
+        # This indicates the wakeup pipe is full, which means the other thread
+        # has already received many wakeup calls, but not processed them yet.
+        # The other thread will completely drain this pipe when it wakes up,
+        # so it's ok to ignore this exception if it occurs: we know the other
+        # thread has already been signaled to wake up
+      end
+
+      nil
+    end
+
+    # Close this selector and free its resources
+    def close
+      @lock.synchronize do
+        return if @closed
+
+        begin
+          @wakeup.close
+        rescue IOError
+        end
+
+        begin
+          @waker.close
+        rescue IOError
+        end
+
+        @closed = true
+      end
+    end
+
+    # Is this selector closed?
+    def closed?
+      @closed
+    end
+
+    def empty?
+      @selectables.empty?
+    end
+  end
+end

data/lib/nio/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2011-2018, by Tony Arcieri.
+# Copyright, 2018-2024, by Samuel Williams.
+# Copyright, 2023, by Tsimnuj Hawj.
+
+module NIO
+  VERSION = "2.7.4"
+end

data/lib/nio.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2011-2017, by Tony Arcieri.
+# Copyright, 2013, by Stephen von Takach.
+# Copyright, 2013, by Per Lundberg.
+# Copyright, 2014, by Marek Kowalcze.
+# Copyright, 2016, by Upekshe Jayasekera.
+# Copyright, 2019-2023, by Samuel Williams.
+# Copyright, 2021, by Jun Jiang.
+
+require "socket"
+require "nio/version"
+
+# New I/O for Ruby
+module NIO
+  # NIO implementation, one of the following (as a string):
+  # * select: in pure Ruby using Kernel.select
+  # * libev: as a C extension using libev
+  # * java: using Java NIO
+  def self.engine
+    ENGINE
+  end
+
+  def self.pure?(env = ENV)
+    # The user has explicitly opted in to non-native implementation:
+    if env["NIO4R_PURE"] == "true"
+      return true
+    end
+
+    # Native Ruby on Windows is not supported:
+    if (Gem.win_platform? && !defined?(JRUBY_VERSION))
+      return true
+    end
+
+    # M1 native extension is crashing on M1 (arm64):
+    # if RUBY_PLATFORM =~ /darwin/ && RUBY_PLATFORM =~ /arm64/
+    #   return true
+    # end
+
+    return false
+  end
+end
+
+if NIO.pure?
+  require "nio/monitor"
+  require "nio/selector"
+  require "nio/bytebuffer"
+  NIO::ENGINE = "ruby"
+else
+  begin
+    ruby_version = /(\d+\.\d+)/.match(::RUBY_VERSION)
+    require "#{ruby_version}/nio4r_ext"
+  rescue LoadError
+    require "nio4r_ext"
+  end
+
+  if defined?(JRUBY_VERSION)
+    require "java"
+    require "jruby"
+    org.nio4r.Nio4r.new.load(JRuby.runtime, false)
+    NIO::ENGINE = "java"
+  else
+    NIO::ENGINE = "libev"
+  end
+end

data/lib/nio4r.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Phillip Aldridge.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative "nio"

data/license.md

@@ -0,0 +1,80 @@
+# MIT License
+
+Copyright, 2011-2020, by Tony Arcieri.  
+Copyright, 2012, by Bernd Ahlers.  
+Copyright, 2012, by Logan Bowers.  
+Copyright, 2012, by Dirkjan Bussink.  
+Copyright, 2013, by Sadayuki Furuhashi.  
+Copyright, 2013, by Shannon Skipper.  
+Copyright, 2013, by Stephen von Takach.  
+Copyright, 2013, by Tim Carey-Smith.  
+Copyright, 2013, by Per Lundberg.  
+Copyright, 2013, by Ravil Bayramgalin.  
+Copyright, 2013, by Luis Lavena.  
+Copyright, 2014, by Anatol Pomozov.  
+Copyright, 2014, by Hiroshi Shibata.  
+Copyright, 2014, by Marek Kowalcze.  
+Copyright, 2014, by Sergey Avseyev.  
+Copyright, 2014, by John Thornton.  
+Copyright, 2015-2017, by Tiago Cardoso.  
+Copyright, 2015, by Daniel Berger.  
+Copyright, 2015-2016, by Upekshe Jayasekera.  
+Copyright, 2015, by Vladimir Kochnev.  
+Copyright, 2016-2018, by Jun Aruga.  
+Copyright, 2016, by Omer Katz.  
+Copyright, 2016, by Denis Washington.  
+Copyright, 2016-2021, by Olle Jonsson.  
+Copyright, 2017, by Tao Luo.  
+Copyright, 2017, by Usaku Nakamura.  
+Copyright, 2017-2022, by Gregory Longtin.  
+Copyright, 2017, by Lars Kanis.  
+Copyright, 2017, by Tomoya Ishida.  
+Copyright, 2018-2024, by Samuel Williams.  
+Copyright, 2019, by Cédric Boutillier.  
+Copyright, 2019-2020, by Benoit Daloze.  
+Copyright, 2019, by Jesús Burgos Maciá.  
+Copyright, 2019, by Thomas Kuntz.  
+Copyright, 2019, by Orien Madgwick.  
+Copyright, 2019, by Zhang Kang.  
+Copyright, 2020, by Thomas Dziedzic.  
+Copyright, 2020, by Elad Eyal.  
+Copyright, 2020, by Pedro Paiva.  
+Copyright, 2020, by Boaz Segev.  
+Copyright, 2020, by Charles Oliver Nutter.  
+Copyright, 2020-2021, by Joao Fernandes.  
+Copyright, 2021, by Jun Jiang.  
+Copyright, 2021, by Pavel Lobashov.  
+Copyright, 2021, by Jeffrey Martin.  
+Copyright, 2023-2024, by Pavel Rosický.  
+Copyright, 2023, by Tsimnuj Hawj.  
+Copyright, 2023, by Phillip Aldridge.  
+Copyright, 2023, by Maxime Demolin.  
+Copyright, 2023-2024, by Vít Ondruch.  
+Copyright, 2023, by Jean Boussier.  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+## libev
+
+Released under the BSD-2-Clause OR GPL-2.0-or-later license.
+See [ext/libev/LICENSE] for details.
+
+Copyright, 2007-2019, by Marc Alexander Lehmann.
+
+[ext/libev/LICENSE]: https://github.com/socketry/nio4r/blob/master/ext/libev/LICENSE