backports 3.20.1 → 3.22.1

data/lib/backports/2.1.0/module/singleton_class.rb

@@ -0,0 +1,8 @@
+if Module.method_defined? :singleton_class?
+  class Module
+    def singleton_class?
+      # Hacky...
+      inspect.start_with? '#<Class:#'
+    end
+  end
+end

data/lib/backports/2.3.0/struct/dig.rb

@@ -1,6 +1,8 @@
 unless Struct.method_defined? :dig
   class Struct
     def dig(key, *rest)
+      return self[key] if key.respond_to?(:to_int)
+
       return nil unless respond_to?(key)
       val = public_send(key)
       return val if rest.empty? || val == nil

data/lib/backports/2.4.0/string/unpack1.rb

@@ -0,0 +1,7 @@
+unless String.method_defined? :unpack1
+  class String
+    def unpack1(fmt)
+      unpack(fmt)[0]
+    end
+  end
+end

data/lib/backports/2.5.0/dir/children.rb

@@ -3,4 +3,8 @@ class Dir
   def self.children(*args)
     entries(*args) - Backports::EXCLUDED_CHILDREN
   end
+
+  def children
+    self.class.children(path)
+  end
 end unless Dir.respond_to? :children

data/lib/backports/2.5.0/dir/each_child.rb

@@ -4,4 +4,11 @@ class Dir
     return to_enum(__method__, *args) unless block_given?
     foreach(*args) { |f| yield f unless Backports::EXCLUDED_CHILDREN.include? f }
   end
+
+  def each_child(&block)
+    return to_enum(__method__) unless block_given?
+
+    Dir.each_child(path, &block)
+    self
+  end
 end unless Dir.respond_to? :each_child

data/lib/backports/2.5.0/integer/sqrt.rb

@@ -9,7 +9,7 @@ class Integer
     bits_shift = n.bit_length / 2 + 1
     bitn_mask = root = 1 << bits_shift
     loop do
-      root ^= bitn_mask if (root * root) > n # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+      root ^= bitn_mask if (root * root) > n
       bitn_mask >>= 1
       return root if bitn_mask == 0
       root |= bitn_mask

data/lib/backports/2.7.0/enumerable/tally.rb

@@ -1,10 +1,11 @@
-require 'backports/1.9.1/enumerable/each_with_object' unless Enumerable.method_defined? :each_with_object
-
 unless Enumerable.method_defined? :tally
   module Enumerable
     def tally
+      h = {}
       # NB: By spec, tally should return default-less hash
-      each_with_object(Hash.new(0)) { |item, res| res[item] += 1 }.tap { |h| h.default = nil }
+      each_entry { |item| h[item] = h.fetch(item, 0) + 1 }
+
+      h
     end
   end
 end

data/lib/backports/3.0.0/ractor.rb

@@ -1,5 +1,19 @@
 if RUBY_VERSION < '2'
   warn 'Ractor not backported to Ruby 1.x'
+elsif defined?(Ractor.current)
+  # all good
 else
-  require_relative '../ractor/ractor' unless defined?(Ractor.current)
+  # Cloner:
+  require_relative '../2.4.0/hash/transform_values'
+  require_relative '../2.5.0/hash/transform_keys'
+  # Queues & FilteredQueue
+  require_relative '../2.3.0/queue/close'
+
+  class Ractor
+  end
+
+  module Backports
+    Ractor = ::Ractor
+  end
+  require_relative '../ractor/ractor'
 end

data/lib/backports/3.1.0/array/intersect.rb

@@ -0,0 +1,16 @@
+unless Array.method_defined? :intersect?
+  require 'backports/tools/arguments'
+
+  class Array
+    def intersect?(array)
+      array = Backports.coerce_to_ary(array)
+
+      if size < array.size
+        smaller = self
+      else
+        smaller, array = array, self
+      end
+      (array & smaller).size > 0
+    end
+  end
+end

data/lib/backports/3.1.0/array.rb

@@ -0,0 +1,3 @@
+require 'backports/tools/require_relative_dir'
+
+Backports.require_relative_dir

data/lib/backports/3.1.0/class/descendants.rb

@@ -0,0 +1,11 @@
+unless Class.method_defined? :descendants
+  require 'backports/2.1.0/module/singleton_class'
+
+  class Class
+    def descendants
+      ObjectSpace.each_object(singleton_class).reject do |klass|
+        klass.singleton_class? || klass == self
+      end
+    end
+  end
+end

data/lib/backports/3.1.0/class/subclasses.rb

@@ -0,0 +1,11 @@
+unless Class.method_defined? :subclasses
+  require 'backports/2.1.0/module/singleton_class'
+
+  class Class
+    def subclasses
+      ObjectSpace.each_object(singleton_class).reject do |klass|
+        klass.superclass != self || klass.singleton_class?
+      end
+    end
+  end
+end

data/lib/backports/3.1.0/class.rb

@@ -0,0 +1,3 @@
+require 'backports/tools/require_relative_dir'
+
+Backports.require_relative_dir

data/lib/backports/3.1.0/enumerable/compact.rb

@@ -0,0 +1,5 @@
+module Enumerable
+  def compact
+    reject { |elem| nil == elem }
+  end
+end unless Enumerable.method_defined? :compact

data/lib/backports/3.1.0/enumerable/tally.rb

@@ -0,0 +1,18 @@
+unless ([].tally({}) rescue false)
+  require 'backports/tools/arguments'
+  require 'backports/2.7.0/enumerable/tally'
+  require 'backports/tools/alias_method_chain'
+
+  module Enumerable
+    def tally_with_hash_argument(h = ::Backports::Undefined)
+      return tally_without_hash_argument if h.equal? ::Backports::Undefined
+
+      h = ::Backports.coerce_to_hash(h)
+
+      each_entry { |item| h[item] = h.fetch(item, 0) + 1 }
+
+      h
+    end
+    ::Backports.alias_method_chain self, :tally, :hash_argument
+  end
+end

data/lib/backports/3.1.0/enumerable.rb

@@ -0,0 +1,3 @@
+require 'backports/tools/require_relative_dir'
+
+Backports.require_relative_dir

data/lib/backports/3.1.0/file/dirname.rb

@@ -0,0 +1,16 @@
+unless (File.dirname("", 0) rescue false)
+  require 'backports/tools/alias_method_chain'
+
+  class File
+    def self.dirname_with_depth(path, depth = 1)
+      return dirname_without_depth(path) if depth == 1
+
+      raise ArgumentError, "negative depth #{depth}" if depth < 0
+
+      depth.times { path = dirname_without_depth(path) }
+
+      path
+    end
+    Backports.alias_method_chain singleton_class, :dirname, :depth
+  end
+end

data/lib/backports/3.1.0/file.rb

@@ -0,0 +1,3 @@
+require 'backports/tools/require_relative_dir'
+
+Backports.require_relative_dir

data/lib/backports/3.1.0/match_data/match.rb

@@ -0,0 +1,5 @@
+class MatchData
+  def match(index)
+    self[index]
+  end
+end unless MatchData.method_defined? :match

data/lib/backports/3.1.0/match_data/match_length.rb

@@ -0,0 +1,6 @@
+class MatchData
+  def match_length(index)
+    m = self[index]
+    m && m.length
+  end
+end unless MatchData.method_defined? :match_length

data/lib/backports/3.1.0/match_data.rb

@@ -0,0 +1,3 @@
+require 'backports/tools/require_relative_dir'
+
+Backports.require_relative_dir

data/lib/backports/3.1.0/struct/keyword_init.rb

@@ -0,0 +1,5 @@
+unless Struct.respond_to?(:keyword_init?)
+  def Struct.keyword_init?
+    new(1) && false rescue true
+  end
+end

data/lib/backports/3.1.0/struct.rb

@@ -0,0 +1,3 @@
+require 'backports/tools/require_relative_dir'
+
+Backports.require_relative_dir

data/lib/backports/3.1.0.rb

@@ -0,0 +1,3 @@
+# require this file to load all the backports up to Ruby 3.0
+require 'backports/3.0.0'
+Backports.require_relative_dir if RUBY_VERSION < '3.1'

data/lib/backports/3.1.rb

@@ -0,0 +1 @@
+require 'backports/3.1.0'

data/lib/backports/latest.rb

@@ -1,4 +1,4 @@
 # require this file to load all the backports
 # NOTE: This is NOT recommended.
 # Best to require the specific backports you need
-require 'backports/2.7.0'
+require 'backports/3.1.0'

data/lib/backports/ractor/cloner.rb

@@ -1,91 +1,103 @@
-require_relative '../2.4.0/hash/transform_values'
-require_relative '../2.5.0/hash/transform_keys'
+# shareable_constant_value: literal
 
-class Ractor
-  module Cloner
-    extend self
+using ::RubyNext if defined?(::RubyNext)
 
-    def deep_clone(obj)
-      return obj if Ractor.ractor_shareable_self?(obj, false) { false }
+module Backports
+  class Ractor
+    class Cloner
+      class << self
+        def deep_clone(obj)
+          return obj if Ractor.ractor_shareable_self?(obj, false) { false }
 
-      @processed = {}.compare_by_identity
-      @changed = nil
-      result = process(obj) do |r|
-        copy_contents(r)
+          new.deep_clone(obj)
+        end
+
+        private :new
       end
-      return result if result
 
-      Ractor.ractor_mark_set_shareable(@processed)
-      obj
-    end
+      def initialize
+        @processed = {}.compare_by_identity
+        @changed = nil
+      end
 
-    # Yields a deep copy.
-    # If no deep copy is needed, `obj` is returned and
-    # nothing is yielded
-    private def clone_deeper(obj)
-      return obj if Ractor.ractor_shareable_self?(obj, false) { false }
+      def deep_clone(obj)
+        result = process(obj) do |r|
+          copy_contents(r)
+        end
+        return result if result
 
-      result = process(obj) do |r|
-        copy_contents(r)
+        Ractor.ractor_mark_set_shareable(@processed)
+        obj
       end
-      return obj unless result
 
-      yield result if block_given?
-      result
-    end
-
-    # Yields if `obj` is a new structure
-    # Returns the deep copy, or `false` if no deep copy is needed
-    private def process(obj)
-      @processed.fetch(obj) do
-        # For recursive structures, assume that we'll need a duplicate.
-        # If that's not the case, we will have duplicated the whole structure
-        # for nothing...
-        @processed[obj] = result = obj.dup
-        changed = track_change { yield result }
-        return false if obj.frozen? && !changed
+      # Yields a deep copy.
+      # If no deep copy is needed, `obj` is returned and
+      # nothing is yielded
+      private def clone_deeper(obj)
+        return obj if Ractor.ractor_shareable_self?(obj, false) { false }
 
-        @changed = true
-        result.freeze if obj.frozen?
+        result = process(obj) do |r|
+          copy_contents(r)
+        end
+        return obj unless result
 
+        yield result if block_given?
         result
       end
-    end
 
-    # returns if the block called `deep clone` and that the deep copy was needed
-    private def track_change
-      prev = @changed
-      @changed = false
-      yield
-      @changed
-    ensure
-      @changed = prev
-    end
+      # Yields if `obj` is a new structure
+      # Returns the deep copy, or `false` if no deep copy is needed
+      private def process(obj)
+        @processed.fetch(obj) do
+          # For recursive structures, assume that we'll need a duplicate.
+          # If that's not the case, we will have duplicated the whole structure
+          # for nothing...
+          @processed[obj] = result = obj.dup
+          changed = track_change { yield result }
+          return false if obj.frozen? && !changed
 
-    # modifies in place `obj` by calling `deep clone` on its contents
-    private def copy_contents(obj)
-      case obj
-      when ::Hash
-        if obj.default
-          clone_deeper(obj.default) do |copy|
-            obj.default = copy
-          end
-        end
-        obj.transform_keys! { |key| clone_deeper(key) }
-        obj.transform_values! { |value| clone_deeper(value) }
-      when ::Array
-        obj.map! { |item| clone_deeper(item) }
-      when ::Struct
-        obj.each_pair do |key, item|
-          clone_deeper(item) { |copy| obj[key] = copy }
+          @changed = true
+          result.freeze if obj.frozen?
+
+          result
         end
       end
-      obj.instance_variables.each do |var|
-        clone_deeper(obj.instance_variable_get(var)) do |copy|
-          obj.instance_variable_set(var, copy)
+
+      # returns if the block called `deep clone` and that the deep copy was needed
+      private def track_change
+        prev = @changed
+        @changed = false
+        yield
+        @changed
+      ensure
+        @changed = prev
+      end
+
+      # modifies in place `obj` by calling `deep clone` on its contents
+      private def copy_contents(obj)
+        case obj
+        when ::Hash
+          if obj.default
+            clone_deeper(obj.default) do |copy|
+              obj.default = copy
+            end
+          end
+          obj.transform_keys! { |key| clone_deeper(key) }
+          obj.transform_values! { |value| clone_deeper(value) }
+        when ::Array
+          obj.map! { |item| clone_deeper(item) }
+        when ::Struct
+          obj.each_pair do |key, item|
+            clone_deeper(item) { |copy| obj[key] = copy }
+          end
+        end
+        obj.instance_variables.each do |var|
+          clone_deeper(obj.instance_variable_get(var)) do |copy|
+            obj.instance_variable_set(var, copy)
+          end
         end
       end
     end
+    private_constant :Cloner
   end
-  private_constant :Cloner
 end

data/lib/backports/ractor/errors.rb

@@ -1,16 +1,20 @@
-class Ractor
-  class ClosedError < ::StopIteration
-  end
+# shareable_constant_value: literal
 
-  class Error < ::StandardError
-  end
+module Backports
+  class Ractor
+    class ClosedError < ::StopIteration
+    end
+
+    class Error < ::StandardError
+    end
 
-  class RemoteError < Error
-    attr_reader :ractor
+    class RemoteError < Error
+      attr_reader :ractor
 
-    def initialize(message = nil)
-      @ractor = Ractor.current
-      super
+      def initialize(message = nil)
+        @ractor = Ractor.current
+        super
+      end
     end
   end
 end

data/lib/backports/{tools → ractor}/filtered_queue.rb

@@ -1,10 +1,18 @@
+# shareable_constant_value: literal
+
 module Backports
+  # Like ::Queue, but with
+  # - filtering
+  # - timeout
+  # - raises on closed queues
+  #
+  # Independent from other Ractor related backports.
   class FilteredQueue
-    require 'backports/2.3.0/queue/close'
     CONSUME_ON_ESCAPE = true
 
     class ClosedQueueError < ::ClosedQueueError
     end
+
     class TimeoutError < ::ThreadError
     end
 
@@ -20,11 +28,6 @@ module Backports
     end
     private_constant :Message
 
-    # Like ::Queue, but with
-    # - filtering
-    # - timeout
-    # - raises on closed queues
-
     attr_reader :num_waiting
 
     # Timeout processing based on https://spin.atomicobject.com/2017/06/28/queue-pop-with-timeout-fixed/
@@ -69,7 +72,7 @@ module Backports
       msg = nil
       exclude = [] if block # exclusion list of messages rejected by this call
       timeout_time = timeout + Time.now.to_f if timeout
-      while true do
+      while true do # rubocop:disable Style/InfiniteLoop, Style/WhileUntilDo
         @mutex.synchronize do
           reenter if reentrant?
           msg = acquire!(timeout_time, exclude)
@@ -167,7 +170,7 @@ module Backports
     # private methods assume @mutex synchonized
     # adds to exclude list
     private def acquire!(timeout_time, exclude = nil)
-      while true do
+      while true do # rubocop:disable Style/InfiniteLoop, Style/WhileUntilDo
         if (msg = available!(exclude))
           msg.reserved = true
           exclude << msg if exclude

data/lib/backports/ractor/queues.rb

@@ -1,62 +1,66 @@
-require_relative '../tools/filtered_queue'
-
-class Ractor
-  # Standard ::Queue but raises if popping and closed
-  class BaseQueue < ::Backports::FilteredQueue
-    ClosedQueueError = ::Ractor::ClosedError
-
-    # yields message (if any)
-    def pop_non_blocking
-      yield pop(timeout: 0)
-    rescue TimeoutError
-      nil
+# shareable_constant_value: literal
+
+require_relative 'filtered_queue'
+
+module Backports
+  class Ractor
+    # Standard ::Queue but raises if popping and closed
+    class BaseQueue < FilteredQueue
+      ClosedQueueError = Ractor::ClosedError
+
+      # yields message (if any)
+      def pop_non_blocking
+        yield pop(timeout: 0)
+      rescue TimeoutError
+        nil
+      end
     end
-  end
 
-  class IncomingQueue < BaseQueue
-    TYPE = :incoming
+    class IncomingQueue < BaseQueue
+      TYPE = :incoming
 
-    protected def reenter
-      raise ::Ractor::Error, 'Can not reenter'
+      protected def reenter
+        raise Ractor::Error, 'Can not reenter'
+      end
     end
-  end
 
-  # * Wraps exception
-  # * Add `ack: ` to push (blocking)
-  class OutgoingQueue < BaseQueue
-    TYPE = :outgoing
+    # * Wraps exception
+    # * Add `ack: ` to push (blocking)
+    class OutgoingQueue < BaseQueue
+      TYPE = :outgoing
 
-    WrappedException = ::Struct.new(:exception, :ractor)
+      WrappedException = ::Struct.new(:exception, :ractor)
 
-    def initialize
-      @ack_queue = ::Queue.new
-      super
-    end
+      def initialize
+        @ack_queue = ::Queue.new
+        super
+      end
 
-    def pop(timeout: nil, ack: true)
-      r = super(timeout: timeout)
-      @ack_queue << :done if ack
-      raise r.exception if WrappedException === r
+      def pop(timeout: nil, ack: true)
+        r = super(timeout: timeout)
+        @ack_queue << :done if ack
+        raise r.exception if WrappedException === r
 
-      r
-    end
+        r
+      end
 
-    def close(how = :hard)
-      super()
-      return if how == :soft
+      def close(how = :hard)
+        super()
+        return if how == :soft
 
-      clear
-      @ack_queue.close
-    end
+        clear
+        @ack_queue.close
+      end
 
-    def push(obj, ack:)
-      super(obj)
-      if ack
-        r = @ack_queue.pop # block until popped
-        raise ClosedError, "The #{self.class::TYPE}-port is already closed" unless r == :done
+      def push(obj, ack:)
+        super(obj)
+        if ack
+          r = @ack_queue.pop # block until popped
+          raise ClosedError, "The #{self.class::TYPE}-port is already closed" unless r == :done
+        end
+        self
       end
-      self
     end
+    private_constant :BaseQueue, :OutgoingQueue, :IncomingQueue
   end
-  private_constant :BaseQueue, :OutgoingQueue, :IncomingQueue
 end