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

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

@@ -1,57 +0,0 @@
-module DidYouMean
-  module Levenshtein # :nodoc:
-    # This code is based directly on the Text gem implementation
-    # Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher.
-    #
-    # Returns a value representing the "cost" of transforming str1 into str2
-    def distance(str1, str2)
-      n = str1.length
-      m = str2.length
-      return m if n.zero?
-      return n if m.zero?
-
-      d = (0..m).to_a
-      x = nil
-
-      # to avoid duplicating an enumerable object, create it outside of the loop
-      str2_codepoints = str2.codepoints
-
-      str1.each_codepoint.with_index(1) do |char1, i|
-        j = 0
-        while j < m
-          cost = (char1 == str2_codepoints[j]) ? 0 : 1
-          x = min3(
-            d[j+1] + 1, # insertion
-            i + 1,      # deletion
-            d[j] + cost # substitution
-          )
-          d[j] = i
-          i = x
-
-          j += 1
-        end
-        d[m] = x
-      end
-
-      x
-    end
-    module_function :distance
-
-    private
-
-    # detects the minimum value out of three arguments. This method is
-    # faster than `[a, b, c].min` and puts less GC pressure.
-    # See https://github.com/ruby/did_you_mean/pull/1 for a performance
-    # benchmark.
-    def min3(a, b, c)
-      if a < b && a < c
-        a
-      elsif b < c
-        b
-      else
-        c
-      end
-    end
-    module_function :min3
-  end
-end

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

@@ -1,46 +0,0 @@
-# frozen-string-literal: true
-
-require_relative "levenshtein"
-require_relative "jaro_winkler"
-
-module DidYouMean
-  class SpellChecker
-    def initialize(dictionary:)
-      @dictionary = dictionary
-    end
-
-    def correct(input)
-      normalized_input = normalize(input)
-      threshold = normalized_input.length > 3 ? 0.834 : 0.77
-
-      words = @dictionary.select { |word| JaroWinkler.distance(normalize(word), normalized_input) >= threshold }
-      words.reject! { |word| input.to_s == word.to_s }
-      words.sort_by! { |word| JaroWinkler.distance(word.to_s, normalized_input) }
-      words.reverse!
-
-      # Correct mistypes
-      threshold   = (normalized_input.length * 0.25).ceil
-      corrections = words.select { |c| Levenshtein.distance(normalize(c), normalized_input) <= threshold }
-
-      # Correct misspells
-      if corrections.empty?
-        corrections = words.select do |word|
-          word   = normalize(word)
-          length = normalized_input.length < word.length ? normalized_input.length : word.length
-
-          Levenshtein.distance(word, normalized_input) < length
-        end.first(1)
-      end
-
-      corrections
-    end
-
-    private
-
-    def normalize(str_or_symbol) #:nodoc:
-      str = str_or_symbol.to_s.downcase
-      str.tr!("@", "")
-      str
-    end
-  end
-end

package/lib/ruby/3.4.11/did_you_mean/spell_checkers/key_error_checker.rb

@@ -1,28 +0,0 @@
-require_relative "../spell_checker"
-
-module DidYouMean
-  class KeyErrorChecker
-    def initialize(key_error)
-      @key = key_error.key
-      @keys = key_error.receiver.keys
-    end
-
-    def corrections
-      @corrections ||= exact_matches.empty? ? SpellChecker.new(dictionary: @keys).correct(@key).map(&:inspect) : exact_matches
-    end
-
-    private
-
-    def exact_matches
-      @exact_matches ||= @keys.select { |word| @key == word.to_s }.map { |obj| format_object(obj) }
-    end
-
-    def format_object(symbol_or_object)
-      if symbol_or_object.is_a?(Symbol)
-        ":#{symbol_or_object}"
-      else
-        symbol_or_object.to_s
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/did_you_mean/spell_checkers/method_name_checker.rb

@@ -1,79 +0,0 @@
-require_relative "../spell_checker"
-
-module DidYouMean
-  class MethodNameChecker
-    attr_reader :method_name, :receiver
-
-    NAMES_TO_EXCLUDE = { NilClass => nil.methods }
-    NAMES_TO_EXCLUDE.default = []
-    Ractor.make_shareable(NAMES_TO_EXCLUDE) if defined?(Ractor)
-
-    # +MethodNameChecker::RB_RESERVED_WORDS+ is the list of reserved words in
-    # Ruby that take an argument. Unlike
-    # +VariableNameChecker::RB_RESERVED_WORDS+, these reserved words require
-    # an argument, and a +NoMethodError+ is raised due to the presence of the
-    # argument.
-    #
-    # The +MethodNameChecker+ will use this list to suggest a reversed word if
-    # a +NoMethodError+ is raised and found closest matches.
-    #
-    # Also see +VariableNameChecker::RB_RESERVED_WORDS+.
-    RB_RESERVED_WORDS = %i(
-      alias
-      case
-      def
-      defined?
-      elsif
-      end
-      ensure
-      for
-      rescue
-      super
-      undef
-      unless
-      until
-      when
-      while
-      yield
-    )
-
-    Ractor.make_shareable(RB_RESERVED_WORDS) if defined?(Ractor)
-
-    def initialize(exception)
-      @method_name  = exception.name
-      @receiver     = exception.receiver
-      @private_call = exception.respond_to?(:private_call?) ? exception.private_call? : false
-    end
-
-    def corrections
-      @corrections ||= begin
-                         dictionary = method_names
-                         dictionary = RB_RESERVED_WORDS + dictionary if @private_call
-
-                         SpellChecker.new(dictionary: dictionary).correct(method_name) - names_to_exclude
-                       end
-    end
-
-    def method_names
-      if Object === receiver
-        method_names = receiver.methods + receiver.singleton_methods
-        method_names += receiver.private_methods if @private_call
-        method_names.uniq!
-        # Assume that people trying to use a writer are not interested in a reader
-        # and vice versa
-        if method_name.match?(/=\Z/)
-          method_names.select! { |name| name.match?(/=\Z/) }
-        else
-          method_names.reject! { |name| name.match?(/=\Z/) }
-        end
-        method_names
-      else
-        []
-      end
-    end
-
-    def names_to_exclude
-      Object === receiver ? NAMES_TO_EXCLUDE[receiver.class] : []
-    end
-  end
-end

package/lib/ruby/3.4.11/did_you_mean/spell_checkers/name_error_checkers/class_name_checker.rb

@@ -1,49 +0,0 @@
-# frozen-string-literal: true
-
-require_relative "../../spell_checker"
-
-module DidYouMean
-  class ClassNameChecker
-    attr_reader :class_name
-
-    def initialize(exception)
-      @class_name, @receiver, @original_message = exception.name, exception.receiver, exception.original_message
-    end
-
-    def corrections
-      @corrections ||= SpellChecker.new(dictionary: class_names)
-                         .correct(class_name)
-                         .map(&:full_name)
-                         .reject {|qualified_name| @original_message.include?(qualified_name) }
-    end
-
-    def class_names
-      scopes.flat_map do |scope|
-        scope.constants.map do |c|
-          ClassName.new(c, scope == Object ? "" : "#{scope}::")
-        end
-      end
-    end
-
-    def scopes
-      @scopes ||= @receiver.to_s.split("::").inject([Object]) do |_scopes, scope|
-        _scopes << _scopes.last.const_get(scope)
-      end.uniq
-    end
-
-    class ClassName < String
-      attr :namespace
-
-      def initialize(name, namespace = '')
-        super(name.to_s)
-        @namespace = namespace
-      end
-
-      def full_name
-        self.class.new("#{namespace}#{self}")
-      end
-    end
-
-    private_constant :ClassName
-  end
-end

package/lib/ruby/3.4.11/did_you_mean/spell_checkers/name_error_checkers/variable_name_checker.rb

@@ -1,85 +0,0 @@
-# frozen-string-literal: true
-
-require_relative "../../spell_checker"
-
-module DidYouMean
-  class VariableNameChecker
-    attr_reader :name, :method_names, :lvar_names, :ivar_names, :cvar_names
-
-    NAMES_TO_EXCLUDE = { 'foo' => [:fork, :for] }
-    NAMES_TO_EXCLUDE.default = []
-    Ractor.make_shareable(NAMES_TO_EXCLUDE) if defined?(Ractor)
-
-    # +VariableNameChecker::RB_RESERVED_WORDS+ is the list of all reserved
-    # words in Ruby. They could be declared like methods are, and a typo would
-    # cause Ruby to raise a +NameError+ because of the way they are declared.
-    #
-    # The +:VariableNameChecker+ will use this list to suggest a reversed word
-    # if a +NameError+ is raised and found closest matches, excluding:
-    #
-    #   * +do+
-    #   * +if+
-    #   * +in+
-    #   * +or+
-    #
-    # Also see +MethodNameChecker::RB_RESERVED_WORDS+.
-    RB_RESERVED_WORDS = %i(
-      BEGIN
-      END
-      alias
-      and
-      begin
-      break
-      case
-      class
-      def
-      defined?
-      else
-      elsif
-      end
-      ensure
-      false
-      for
-      module
-      next
-      nil
-      not
-      redo
-      rescue
-      retry
-      return
-      self
-      super
-      then
-      true
-      undef
-      unless
-      until
-      when
-      while
-      yield
-      __LINE__
-      __FILE__
-      __ENCODING__
-    )
-
-    Ractor.make_shareable(RB_RESERVED_WORDS) if defined?(Ractor)
-
-    def initialize(exception)
-      @name       = exception.name.to_s.tr("@", "")
-      @lvar_names = exception.respond_to?(:local_variables) ? exception.local_variables : []
-      receiver    = exception.receiver
-
-      @method_names = receiver.methods + receiver.private_methods
-      @ivar_names   = receiver.instance_variables
-      @cvar_names   = receiver.class.class_variables
-      @cvar_names  += receiver.class_variables if receiver.kind_of?(Module)
-    end
-
-    def corrections
-      @corrections ||= SpellChecker
-                     .new(dictionary: (RB_RESERVED_WORDS + lvar_names + method_names + ivar_names + cvar_names))
-                     .correct(name).uniq - NAMES_TO_EXCLUDE[@name]
-    end
-  end
-end

package/lib/ruby/3.4.11/did_you_mean/spell_checkers/name_error_checkers.rb

@@ -1,20 +0,0 @@
-require_relative 'name_error_checkers/class_name_checker'
-require_relative 'name_error_checkers/variable_name_checker'
-
-module DidYouMean
-  class << (NameErrorCheckers = Object.new)
-    def new(exception)
-      case exception.original_message
-      when /uninitialized constant/
-        ClassNameChecker
-      when /undefined local variable or method/,
-           /undefined method/,
-           /uninitialized class variable/,
-           /no member '.*' in struct/
-        VariableNameChecker
-      else
-        NullChecker
-      end.new(exception)
-    end
-  end
-end

package/lib/ruby/3.4.11/did_you_mean/spell_checkers/null_checker.rb

@@ -1,6 +0,0 @@
-module DidYouMean
-  class NullChecker
-    def initialize(*);  end
-    def corrections; [] end
-  end
-end

package/lib/ruby/3.4.11/did_you_mean/spell_checkers/pattern_key_name_checker.rb

@@ -1,28 +0,0 @@
-require_relative "../spell_checker"
-
-module DidYouMean
-  class PatternKeyNameChecker
-    def initialize(no_matching_pattern_key_error)
-      @key = no_matching_pattern_key_error.key
-      @keys = no_matching_pattern_key_error.matchee.keys
-    end
-
-    def corrections
-      @corrections ||= exact_matches.empty? ? SpellChecker.new(dictionary: @keys).correct(@key).map(&:inspect) : exact_matches
-    end
-
-    private
-
-    def exact_matches
-      @exact_matches ||= @keys.select { |word| @key == word.to_s }.map { |obj| format_object(obj) }
-    end
-
-    def format_object(symbol_or_object)
-      if symbol_or_object.is_a?(Symbol)
-        ":#{symbol_or_object}"
-      else
-        symbol_or_object.to_s
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/did_you_mean/spell_checkers/require_path_checker.rb

@@ -1,39 +0,0 @@
-# frozen-string-literal: true
-
-require_relative "../spell_checker"
-require_relative "../tree_spell_checker"
-require "rbconfig"
-
-module DidYouMean
-  class RequirePathChecker
-    attr_reader :path
-
-    INITIAL_LOAD_PATH = $LOAD_PATH.dup.freeze
-    Ractor.make_shareable(INITIAL_LOAD_PATH) if defined?(Ractor)
-
-    ENV_SPECIFIC_EXT = ".#{RbConfig::CONFIG["DLEXT"]}"
-    Ractor.make_shareable(ENV_SPECIFIC_EXT) if defined?(Ractor)
-
-    private_constant :INITIAL_LOAD_PATH, :ENV_SPECIFIC_EXT
-
-    def self.requireables
-      @requireables ||= INITIAL_LOAD_PATH
-                          .flat_map {|path| Dir.glob("**/???*{.rb,#{ENV_SPECIFIC_EXT}}", base: path) }
-                          .map {|path| path.chomp!(".rb") || path.chomp!(ENV_SPECIFIC_EXT) }
-    end
-
-    def initialize(exception)
-      @path = exception.path
-    end
-
-    def corrections
-      @corrections ||= begin
-                         threshold     = path.size * 2
-                         dictionary    = self.class.requireables.reject {|str| str.size >= threshold }
-                         spell_checker = path.include?("/") ? TreeSpellChecker : SpellChecker
-
-                         spell_checker.new(dictionary: dictionary).correct(path).uniq
-                       end
-    end
-  end
-end

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

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module DidYouMean
-  # spell checker for a dictionary that has a tree
-  # structure, see doc/tree_spell_checker_api.md
-  class TreeSpellChecker
-    attr_reader :dictionary, :separator, :augment
-
-    def initialize(dictionary:, separator: '/', augment: nil)
-      @dictionary = dictionary
-      @separator = separator
-      @augment = augment
-    end
-
-    def correct(input)
-      plausibles = plausible_dimensions(input)
-      return fall_back_to_normal_spell_check(input) if plausibles.empty?
-
-      suggestions = find_suggestions(input, plausibles)
-      return fall_back_to_normal_spell_check(input) if suggestions.empty?
-
-      suggestions
-    end
-
-    def dictionary_without_leaves
-      @dictionary_without_leaves ||= dictionary.map { |word| word.split(separator)[0..-2] }.uniq
-    end
-
-    def tree_depth
-      @tree_depth ||= dictionary_without_leaves.max { |a, b| a.size <=> b.size }.size
-    end
-
-    def dimensions
-      @dimensions ||= tree_depth.times.map do |index|
-                        dictionary_without_leaves.map { |element| element[index] }.compact.uniq
-                      end
-    end
-
-    def find_leaves(path)
-      path_with_separator = "#{path}#{separator}"
-
-      dictionary
-        .select {|str| str.include?(path_with_separator) }
-        .map {|str| str.gsub(path_with_separator, '') }
-    end
-
-    def plausible_dimensions(input)
-      input.split(separator)[0..-2]
-        .map
-        .with_index { |element, index| correct_element(dimensions[index], element) if dimensions[index] }
-        .compact
-    end
-
-    def possible_paths(states)
-      states.map { |state| state.join(separator) }
-    end
-
-    private
-
-    def find_suggestions(input, plausibles)
-      states = plausibles[0].product(*plausibles[1..-1])
-      paths  = possible_paths(states)
-      leaf   = input.split(separator).last
-
-      find_ideas(paths, leaf)
-    end
-
-    def fall_back_to_normal_spell_check(input)
-      return [] unless augment
-
-      ::DidYouMean::SpellChecker.new(dictionary: dictionary).correct(input)
-    end
-
-    def find_ideas(paths, leaf)
-      paths.flat_map do |path|
-        names = find_leaves(path)
-        ideas = correct_element(names, leaf)
-
-        ideas_to_paths(ideas, leaf, names, path)
-      end.compact
-    end
-
-    def ideas_to_paths(ideas, leaf, names, path)
-      if ideas.empty?
-        nil
-      elsif names.include?(leaf)
-        ["#{path}#{separator}#{leaf}"]
-      else
-        ideas.map {|str| "#{path}#{separator}#{str}" }
-      end
-    end
-
-    def correct_element(names, element)
-      return names if names.size == 1
-
-      str = normalize(element)
-
-      return [str] if names.include?(str)
-
-      ::DidYouMean::SpellChecker.new(dictionary: names).correct(str)
-    end
-
-    def normalize(str)
-      str.downcase!
-      str.tr!('@', ' ') if str.include?('@')
-      str
-    end
-  end
-end

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

@@ -1,2 +0,0 @@
-warn "The verbose formatter has been removed and now `require 'did_you_mean/verbose'` has no effect. Please " \
-     "remove this call."

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

@@ -1,3 +0,0 @@
-module DidYouMean
-  VERSION = "2.0.0".freeze
-end

package/lib/ruby/3.4.11/did_you_mean.rb

@@ -1,131 +0,0 @@
-require_relative "did_you_mean/version"
-require_relative "did_you_mean/core_ext/name_error"
-
-require_relative "did_you_mean/spell_checker"
-require_relative 'did_you_mean/spell_checkers/name_error_checkers'
-require_relative 'did_you_mean/spell_checkers/method_name_checker'
-require_relative 'did_you_mean/spell_checkers/key_error_checker'
-require_relative 'did_you_mean/spell_checkers/null_checker'
-require_relative 'did_you_mean/spell_checkers/require_path_checker'
-require_relative 'did_you_mean/spell_checkers/pattern_key_name_checker'
-require_relative 'did_you_mean/formatter'
-require_relative 'did_you_mean/tree_spell_checker'
-
-# The +DidYouMean+ gem adds functionality to suggest possible method/class
-# names upon errors such as +NameError+ and +NoMethodError+. In Ruby 2.3 or
-# later, it is automatically activated during startup.
-#
-# @example
-#
-#   methosd
-#   # => NameError: undefined local variable or method `methosd' for main:Object
-#   #   Did you mean?  methods
-#   #                  method
-#
-#   OBject
-#   # => NameError: uninitialized constant OBject
-#   #    Did you mean?  Object
-#
-#   @full_name = "Yuki Nishijima"
-#   first_name, last_name = full_name.split(" ")
-#   # => NameError: undefined local variable or method `full_name' for main:Object
-#   #    Did you mean?  @full_name
-#
-#   @@full_name = "Yuki Nishijima"
-#   @@full_anme
-#   # => NameError: uninitialized class variable @@full_anme in Object
-#   #    Did you mean?  @@full_name
-#
-#   full_name = "Yuki Nishijima"
-#   full_name.starts_with?("Y")
-#   # => NoMethodError: undefined method `starts_with?' for "Yuki Nishijima":String
-#   #    Did you mean?  start_with?
-#
-#   hash = {foo: 1, bar: 2, baz: 3}
-#   hash.fetch(:fooo)
-#   # => KeyError: key not found: :fooo
-#   #    Did you mean?  :foo
-#
-#
-# == Disabling +did_you_mean+
-#
-# Occasionally, you may want to disable the +did_you_mean+ gem for e.g.
-# debugging issues in the error object itself. You can disable it entirely by
-# specifying +--disable-did_you_mean+ option to the +ruby+ command:
-#
-#   $ ruby --disable-did_you_mean -e "1.zeor?"
-#   -e:1:in `<main>': undefined method `zeor?' for 1:Integer (NameError)
-#
-# When you do not have direct access to the +ruby+ command (e.g.
-# +rails console+, +irb+), you could applyoptions using the +RUBYOPT+
-# environment variable:
-#
-#   $ RUBYOPT='--disable-did_you_mean' irb
-#   irb:0> 1.zeor?
-#   # => NoMethodError (undefined method `zeor?' for 1:Integer)
-#
-#
-# == Getting the original error message
-#
-# Sometimes, you do not want to disable the gem entirely, but need to get the
-# original error message without suggestions (e.g. testing). In this case, you
-# could use the +#original_message+ method on the error object:
-#
-#   no_method_error = begin
-#                       1.zeor?
-#                     rescue NoMethodError => error
-#                       error
-#                     end
-#
-#   no_method_error.message
-#   # => NoMethodError (undefined method `zeor?' for 1:Integer)
-#   #    Did you mean?  zero?
-#
-#   no_method_error.original_message
-#   # => NoMethodError (undefined method `zeor?' for 1:Integer)
-#
-module DidYouMean
-  # Map of error types and spell checker objects.
-  @spell_checkers = Hash.new(NullChecker)
-
-  # Returns a sharable hash map of error types and spell checker objects.
-  def self.spell_checkers
-    @spell_checkers
-  end
-
-  # Adds +DidYouMean+ functionality to an error using a given spell checker
-  def self.correct_error(error_class, spell_checker)
-    if defined?(Ractor)
-      new_mapping = { **@spell_checkers, error_class.to_s => spell_checker }
-      new_mapping.default = NullChecker
-
-      @spell_checkers = Ractor.make_shareable(new_mapping)
-    else
-      spell_checkers[error_class.to_s] = spell_checker
-    end
-
-    error_class.prepend(Correctable) if error_class.is_a?(Class) && !(error_class < Correctable)
-  end
-
-  correct_error NameError, NameErrorCheckers
-  correct_error KeyError, KeyErrorChecker
-  correct_error NoMethodError, MethodNameChecker
-  correct_error LoadError, RequirePathChecker if RUBY_VERSION >= '2.8.0'
-  correct_error NoMatchingPatternKeyError, PatternKeyNameChecker if defined?(::NoMatchingPatternKeyError)
-
-  # Returns the currently set formatter. By default, it is set to +DidYouMean::Formatter+.
-  def self.formatter
-    if defined?(Ractor)
-      Ractor.current[:__did_you_mean_formatter__] || Formatter
-    else
-      Formatter
-    end
-  end
-
-  # Updates the primary formatter used to format the suggestions.
-  def self.formatter=(formatter)
-    if defined?(Ractor)
-      Ractor.current[:__did_you_mean_formatter__] = formatter
-    end
-  end
-end