@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-5

package/lib/ruby/3.4.11/delegate.rb

@@ -1,444 +0,0 @@
-# frozen_string_literal: true
-# = delegate -- Support for the Delegation Pattern
-#
-# Documentation by James Edward Gray II and Gavin Sinclair
-
-##
-# This library provides three different ways to delegate method calls to an
-# object.  The easiest to use is SimpleDelegator.  Pass an object to the
-# constructor and all methods supported by the object will be delegated.  This
-# object can be changed later.
-#
-# Going a step further, the top level DelegateClass method allows you to easily
-# setup delegation through class inheritance.  This is considerably more
-# flexible and thus probably the most common use for this library.
-#
-# Finally, if you need full control over the delegation scheme, you can inherit
-# from the abstract class Delegator and customize as needed.  (If you find
-# yourself needing this control, have a look at Forwardable which is also in
-# the standard library.  It may suit your needs better.)
-#
-# SimpleDelegator's implementation serves as a nice example of the use of
-# Delegator:
-#
-#   require 'delegate'
-#
-#   class SimpleDelegator < Delegator
-#     def __getobj__
-#       @delegate_sd_obj # return object we are delegating to, required
-#     end
-#
-#     def __setobj__(obj)
-#       @delegate_sd_obj = obj # change delegation object,
-#                              # a feature we're providing
-#     end
-#   end
-#
-# == Notes
-#
-# Be advised, RDoc will not detect delegated methods.
-#
-class Delegator < BasicObject
-  VERSION = "0.4.0"
-
-  kernel = ::Kernel.dup
-  kernel.class_eval do
-    alias __raise__ raise
-    [:to_s, :inspect, :!~, :===, :<=>, :hash].each do |m|
-      undef_method m
-    end
-    private_instance_methods.each do |m|
-      if /\Ablock_given\?\z|\Aiterator\?\z|\A__.*__\z/ =~ m
-        next
-      end
-      undef_method m
-    end
-  end
-  include kernel
-
-  # :stopdoc:
-  def self.const_missing(n)
-    ::Object.const_get(n)
-  end
-  # :startdoc:
-
-  ##
-  # :method: raise
-  # Use #__raise__ if your Delegator does not have a object to delegate the
-  # #raise method call.
-  #
-
-  #
-  # Pass in the _obj_ to delegate method calls to.  All methods supported by
-  # _obj_ will be delegated to.
-  #
-  def initialize(obj)
-    __setobj__(obj)
-  end
-
-  #
-  # Handles the magic of delegation through \_\_getobj\_\_.
-  #
-  ruby2_keywords def method_missing(m, *args, &block)
-    r = true
-    target = self.__getobj__ {r = false}
-
-    if r && target_respond_to?(target, m, false)
-      target.__send__(m, *args, &block)
-    elsif ::Kernel.method_defined?(m) || ::Kernel.private_method_defined?(m)
-      ::Kernel.instance_method(m).bind_call(self, *args, &block)
-    else
-      super(m, *args, &block)
-    end
-  end
-
-  #
-  # Checks for a method provided by this the delegate object by forwarding the
-  # call through \_\_getobj\_\_.
-  #
-  def respond_to_missing?(m, include_private)
-    r = true
-    target = self.__getobj__ {r = false}
-    r &&= target_respond_to?(target, m, include_private)
-    if r && include_private && !target_respond_to?(target, m, false)
-      warn "delegator does not forward private method \##{m}", uplevel: 3
-      return false
-    end
-    r
-  end
-
-  KERNEL_RESPOND_TO = ::Kernel.instance_method(:respond_to?)
-  private_constant :KERNEL_RESPOND_TO
-
-  # Handle BasicObject instances
-  private def target_respond_to?(target, m, include_private)
-    case target
-    when Object
-      target.respond_to?(m, include_private)
-    else
-      if KERNEL_RESPOND_TO.bind_call(target, :respond_to?)
-        target.respond_to?(m, include_private)
-      else
-        KERNEL_RESPOND_TO.bind_call(target, m, include_private)
-      end
-    end
-  end
-
-  #
-  # Returns the methods available to this delegate object as the union
-  # of this object's and \_\_getobj\_\_ methods.
-  #
-  def methods(all=true)
-    __getobj__.methods(all) | super
-  end
-
-  #
-  # Returns the methods available to this delegate object as the union
-  # of this object's and \_\_getobj\_\_ public methods.
-  #
-  def public_methods(all=true)
-    __getobj__.public_methods(all) | super
-  end
-
-  #
-  # Returns the methods available to this delegate object as the union
-  # of this object's and \_\_getobj\_\_ protected methods.
-  #
-  def protected_methods(all=true)
-    __getobj__.protected_methods(all) | super
-  end
-
-  # Note: no need to specialize private_methods, since they are not forwarded
-
-  #
-  # Returns true if two objects are considered of equal value.
-  #
-  def ==(obj)
-    return true if obj.equal?(self)
-    self.__getobj__ == obj
-  end
-
-  #
-  # Returns true if two objects are not considered of equal value.
-  #
-  def !=(obj)
-    return false if obj.equal?(self)
-    __getobj__ != obj
-  end
-
-  #
-  # Returns true if two objects are considered of equal value.
-  #
-  def eql?(obj)
-    return true if obj.equal?(self)
-    obj.eql?(__getobj__)
-  end
-
-  #
-  # Delegates ! to the \_\_getobj\_\_
-  #
-  def !
-    !__getobj__
-  end
-
-  #
-  # This method must be overridden by subclasses and should return the object
-  # method calls are being delegated to.
-  #
-  def __getobj__
-    __raise__ ::NotImplementedError, "need to define '__getobj__'"
-  end
-
-  #
-  # This method must be overridden by subclasses and change the object delegate
-  # to _obj_.
-  #
-  def __setobj__(obj)
-    __raise__ ::NotImplementedError, "need to define '__setobj__'"
-  end
-
-  #
-  # Serialization support for the object returned by \_\_getobj\_\_.
-  #
-  def marshal_dump
-    ivars = instance_variables.reject {|var| /\A@delegate_/ =~ var}
-    [
-      :__v2__,
-      ivars, ivars.map {|var| instance_variable_get(var)},
-      __getobj__
-    ]
-  end
-
-  #
-  # Reinitializes delegation from a serialized object.
-  #
-  def marshal_load(data)
-    version, vars, values, obj = data
-    if version == :__v2__
-      vars.each_with_index {|var, i| instance_variable_set(var, values[i])}
-      __setobj__(obj)
-    else
-      __setobj__(data)
-    end
-  end
-
-  def initialize_clone(obj, freeze: nil) # :nodoc:
-    self.__setobj__(obj.__getobj__.clone(freeze: freeze))
-  end
-  def initialize_dup(obj) # :nodoc:
-    self.__setobj__(obj.__getobj__.dup)
-  end
-  private :initialize_clone, :initialize_dup
-
-  ##
-  # :method: freeze
-  # Freeze both the object returned by \_\_getobj\_\_ and self.
-  #
-  def freeze
-    __getobj__.freeze
-    super()
-  end
-
-  @delegator_api = self.public_instance_methods
-  def self.public_api # :nodoc:
-    @delegator_api
-  end
-end
-
-##
-# A concrete implementation of Delegator, this class provides the means to
-# delegate all supported method calls to the object passed into the constructor
-# and even to change the object being delegated to at a later time with
-# #__setobj__.
-#
-#   class User
-#     def born_on
-#       Date.new(1989, 9, 10)
-#     end
-#   end
-#
-#   require 'delegate'
-#
-#   class UserDecorator < SimpleDelegator
-#     def birth_year
-#       born_on.year
-#     end
-#   end
-#
-#   decorated_user = UserDecorator.new(User.new)
-#   decorated_user.birth_year  #=> 1989
-#   decorated_user.__getobj__  #=> #<User: ...>
-#
-# A SimpleDelegator instance can take advantage of the fact that SimpleDelegator
-# is a subclass of +Delegator+ to call <tt>super</tt> to have methods called on
-# the object being delegated to.
-#
-#   class SuperArray < SimpleDelegator
-#     def [](*args)
-#       super + 1
-#     end
-#   end
-#
-#   SuperArray.new([1])[0]  #=> 2
-#
-# Here's a simple example that takes advantage of the fact that
-# SimpleDelegator's delegation object can be changed at any time.
-#
-#   class Stats
-#     def initialize
-#       @source = SimpleDelegator.new([])
-#     end
-#
-#     def stats(records)
-#       @source.__setobj__(records)
-#
-#       "Elements:  #{@source.size}\n" +
-#       " Non-Nil:  #{@source.compact.size}\n" +
-#       "  Unique:  #{@source.uniq.size}\n"
-#     end
-#   end
-#
-#   s = Stats.new
-#   puts s.stats(%w{James Edward Gray II})
-#   puts
-#   puts s.stats([1, 2, 3, nil, 4, 5, 1, 2])
-#
-# Prints:
-#
-#   Elements:  4
-#    Non-Nil:  4
-#     Unique:  4
-#
-#   Elements:  8
-#    Non-Nil:  7
-#     Unique:  6
-#
-class SimpleDelegator < Delegator
-  # Returns the current object method calls are being delegated to.
-  def __getobj__
-    unless defined?(@delegate_sd_obj)
-      return yield if block_given?
-      __raise__ ::ArgumentError, "not delegated"
-    end
-    @delegate_sd_obj
-  end
-
-  #
-  # Changes the delegate object to _obj_.
-  #
-  # It's important to note that this does *not* cause SimpleDelegator's methods
-  # to change.  Because of this, you probably only want to change delegation
-  # to objects of the same type as the original delegate.
-  #
-  # Here's an example of changing the delegation object.
-  #
-  #   names = SimpleDelegator.new(%w{James Edward Gray II})
-  #   puts names[1]    # => Edward
-  #   names.__setobj__(%w{Gavin Sinclair})
-  #   puts names[1]    # => Sinclair
-  #
-  def __setobj__(obj)
-    __raise__ ::ArgumentError, "cannot delegate to self" if self.equal?(obj)
-    @delegate_sd_obj = obj
-  end
-end
-
-def Delegator.delegating_block(mid) # :nodoc:
-  lambda do |*args, &block|
-    target = self.__getobj__
-    target.__send__(mid, *args, &block)
-  end.ruby2_keywords
-end
-
-#
-# The primary interface to this library.  Use to setup delegation when defining
-# your class.
-#
-#   class MyClass < DelegateClass(ClassToDelegateTo) # Step 1
-#     def initialize
-#       super(obj_of_ClassToDelegateTo)              # Step 2
-#     end
-#   end
-#
-# or:
-#
-#   MyClass = DelegateClass(ClassToDelegateTo) do    # Step 1
-#     def initialize
-#       super(obj_of_ClassToDelegateTo)              # Step 2
-#     end
-#   end
-#
-# Here's a sample of use from Tempfile which is really a File object with a
-# few special rules about storage location and when the File should be
-# deleted.  That makes for an almost textbook perfect example of how to use
-# delegation.
-#
-#   class Tempfile < DelegateClass(File)
-#     # constant and class member data initialization...
-#
-#     def initialize(basename, tmpdir=Dir::tmpdir)
-#       # build up file path/name in var tmpname...
-#
-#       @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)
-#
-#       # ...
-#
-#       super(@tmpfile)
-#
-#       # below this point, all methods of File are supported...
-#     end
-#
-#     # ...
-#   end
-#
-def DelegateClass(superclass, &block)
-  klass = Class.new(Delegator)
-  ignores = [*::Delegator.public_api, :to_s, :inspect, :=~, :!~, :===]
-  protected_instance_methods = superclass.protected_instance_methods
-  protected_instance_methods -= ignores
-  public_instance_methods = superclass.public_instance_methods
-  public_instance_methods -= ignores
-  klass.module_eval do
-    def __getobj__ # :nodoc:
-      unless defined?(@delegate_dc_obj)
-        return yield if block_given?
-        __raise__ ::ArgumentError, "not delegated"
-      end
-      @delegate_dc_obj
-    end
-    def __setobj__(obj)  # :nodoc:
-      __raise__ ::ArgumentError, "cannot delegate to self" if self.equal?(obj)
-      @delegate_dc_obj = obj
-    end
-    protected_instance_methods.each do |method|
-      define_method(method, Delegator.delegating_block(method))
-      protected method
-    end
-    public_instance_methods.each do |method|
-      define_method(method, Delegator.delegating_block(method))
-    end
-  end
-  klass.define_singleton_method :public_instance_methods do |all=true|
-    super(all) | superclass.public_instance_methods
-  end
-  klass.define_singleton_method :protected_instance_methods do |all=true|
-    super(all) | superclass.protected_instance_methods
-  end
-  klass.define_singleton_method :instance_methods do |all=true|
-    super(all) | superclass.instance_methods
-  end
-  klass.define_singleton_method :public_instance_method do |name|
-    super(name)
-  rescue NameError
-    raise unless self.public_instance_methods.include?(name)
-    superclass.public_instance_method(name)
-  end
-  klass.define_singleton_method :instance_method do |name|
-    super(name)
-  rescue NameError
-    raise unless self.instance_methods.include?(name)
-    superclass.instance_method(name)
-  end
-  klass.module_eval(&block) if block
-  return klass
-end

package/lib/ruby/3.4.11/did_you_mean/core_ext/name_error.rb

@@ -1,57 +0,0 @@
-module DidYouMean
-  module Correctable
-    if Exception.method_defined?(:detailed_message)
-      # just for compatibility
-      def original_message
-        # we cannot use alias here because
-        to_s
-      end
-
-      def detailed_message(highlight: true, did_you_mean: true, **)
-        msg = super.dup
-
-        return msg unless did_you_mean
-
-        suggestion = DidYouMean.formatter.message_for(corrections)
-
-        if highlight
-          suggestion = suggestion.gsub(/.+/) { "\e[1m" + $& + "\e[m" }
-        end
-
-        msg << suggestion
-        msg
-      rescue
-        super
-      end
-    else
-      SKIP_TO_S_FOR_SUPER_LOOKUP = true
-      private_constant :SKIP_TO_S_FOR_SUPER_LOOKUP
-
-      def original_message
-        meth = method(:to_s)
-        while meth.owner.const_defined?(:SKIP_TO_S_FOR_SUPER_LOOKUP)
-          meth = meth.super_method
-        end
-        meth.call
-      end
-
-      def to_s
-        msg = super.dup
-        suggestion = DidYouMean.formatter.message_for(corrections)
-
-        msg << suggestion if !msg.include?(suggestion)
-        msg
-      rescue
-        super
-      end
-    end
-
-    def corrections
-      @corrections ||= spell_checker.corrections
-    end
-
-    def spell_checker
-      DidYouMean.spell_checkers[self.class.to_s].new(self)
-    end
-  end
-end

package/lib/ruby/3.4.11/did_you_mean/did_you_mean.gemspec

@@ -1,25 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-begin
-  require_relative "lib/did_you_mean/version"
-rescue LoadError # Fallback to load version file in ruby core repository
-  require_relative "version"
-end
-
-Gem::Specification.new do |spec|
-  spec.name          = "did_you_mean"
-  spec.version       = DidYouMean::VERSION
-  spec.authors       = ["Yuki Nishijima"]
-  spec.email         = ["mail@yukinishijima.net"]
-  spec.summary       = '"Did you mean?" experience in Ruby'
-  spec.description   = 'The gem that has been saving people from typos since 2014.'
-  spec.homepage      = "https://github.com/ruby/did_you_mean"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/).reject{|path| path.start_with?('evaluation/') }
-  spec.test_files    = spec.files.grep(%r{^(test)/})
-  spec.require_paths = ["lib"]
-
-  spec.required_ruby_version = '>= 2.5.0'
-end

package/lib/ruby/3.4.11/did_you_mean/experimental.rb

@@ -1,2 +0,0 @@
-warn "Experimental features in the did_you_mean gem has been removed " \
-     "and `require \"did_you_mean/experimental\"' has no effect."

package/lib/ruby/3.4.11/did_you_mean/formatter.rb

@@ -1,44 +0,0 @@
-# frozen-string-literal: true
-
-module DidYouMean
-  # The +DidYouMean::Formatter+ is the basic, default formatter for the
-  # gem. The formatter responds to the +message_for+ method and it returns a
-  # human readable string.
-  class Formatter
-
-    # Returns a human readable string that contains +corrections+. This
-    # formatter is designed to be less verbose to not take too much screen
-    # space while being helpful enough to the user.
-    #
-    # @example
-    #
-    #   formatter = DidYouMean::Formatter.new
-    #
-    #   # displays suggestions in two lines with the leading empty line
-    #   puts formatter.message_for(["methods", "method"])
-    #
-    #   Did you mean?  methods
-    #                   method
-    #   # => nil
-    #
-    #   # displays an empty line
-    #   puts formatter.message_for([])
-    #
-    #   # => nil
-    #
-    def self.message_for(corrections)
-      corrections.empty? ? "" : "\nDid you mean?  #{corrections.join("\n               ")}"
-    end
-
-    def message_for(corrections)
-      warn "The instance method #message_for has been deprecated. Please use the class method " \
-           "DidYouMean::Formatter.message_for(...) instead."
-
-      self.class.message_for(corrections)
-    end
-  end
-
-  PlainFormatter = Formatter
-
-  deprecate_constant :PlainFormatter
-end

package/lib/ruby/3.4.11/did_you_mean/formatters/plain_formatter.rb

@@ -1,4 +0,0 @@
-require_relative '../formatter'
-
-warn "`require 'did_you_mean/formatters/plain_formatter'` is deprecated. Please `require 'did_you_mean/formatter'` " \
-     "instead."

package/lib/ruby/3.4.11/did_you_mean/formatters/verbose_formatter.rb

@@ -1,10 +0,0 @@
-# frozen-string-literal: true
-
-warn "`require 'did_you_mean/formatters/verbose_formatter'` is deprecated and falls back to the default formatter. "
-
-require_relative '../formatter'
-
-module DidYouMean
-  # For compatibility:
-  VerboseFormatter = Formatter
-end

package/lib/ruby/3.4.11/did_you_mean/jaro_winkler.rb

@@ -1,84 +0,0 @@
-module DidYouMean
-  module Jaro
-    module_function
-
-    def distance(str1, str2)
-      str1, str2 = str2, str1 if str1.length > str2.length
-      length1, length2 = str1.length, str2.length
-
-      m          = 0.0
-      t          = 0.0
-      range      = length2 > 3 ? length2 / 2 - 1 : 0
-      flags1     = 0
-      flags2     = 0
-
-      # Avoid duplicating enumerable objects
-      str1_codepoints = str1.codepoints
-      str2_codepoints = str2.codepoints
-
-      i = 0
-      while i < length1
-        last = i + range
-        j    = (i >= range) ? i - range : 0
-
-        while j <= last
-          if flags2[j] == 0 && str1_codepoints[i] == str2_codepoints[j]
-            flags2 |= (1 << j)
-            flags1 |= (1 << i)
-            m += 1
-            break
-          end
-
-          j += 1
-        end
-
-        i += 1
-      end
-
-      k = i = 0
-      while i < length1
-        if flags1[i] != 0
-          j = index = k
-
-          k = while j < length2
-            index = j
-            break(j + 1) if flags2[j] != 0
-
-            j += 1
-          end
-
-          t += 1 if str1_codepoints[i] != str2_codepoints[index]
-        end
-
-        i += 1
-      end
-      t = (t / 2).floor
-
-      m == 0 ? 0 : (m / length1 + m / length2 + (m - t) / m) / 3
-    end
-  end
-
-  module JaroWinkler
-    WEIGHT    = 0.1
-    THRESHOLD = 0.7
-
-    module_function
-
-    def distance(str1, str2)
-      jaro_distance = Jaro.distance(str1, str2)
-
-      if jaro_distance > THRESHOLD
-        codepoints2  = str2.codepoints
-        prefix_bonus = 0
-
-        str1.each_codepoint do |char1|
-          char1 == codepoints2[prefix_bonus] && prefix_bonus < 4 ? prefix_bonus += 1 : break
-        end
-
-        jaro_distance + (prefix_bonus * WEIGHT * (1 - jaro_distance))
-      else
-        jaro_distance
-      end
-    end
-  end
-end