@ai-ecoverse/wasix-ruby 3.4.11-1

package/lib/ruby/3.4.11/rubygems/dependency_list.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require_relative "vendored_tsort"
+require_relative "deprecate"
+
+##
+# Gem::DependencyList is used for installing and uninstalling gems in the
+# correct order to avoid conflicts.
+#--
+# TODO: It appears that all but topo-sort functionality is being duplicated
+# (or is planned to be duplicated) elsewhere in rubygems.  Is the majority of
+# this class necessary anymore?  Especially #ok?, #why_not_ok?
+
+class Gem::DependencyList
+  attr_reader :specs
+
+  include Enumerable
+  include Gem::TSort
+
+  ##
+  # Allows enabling/disabling use of development dependencies
+
+  attr_accessor :development
+
+  ##
+  # Creates a DependencyList from the current specs.
+
+  def self.from_specs
+    list = new
+    list.add(*Gem::Specification.to_a)
+    list
+  end
+
+  ##
+  # Creates a new DependencyList.  If +development+ is true, development
+  # dependencies will be included.
+
+  def initialize(development = false)
+    @specs = []
+
+    @development = development
+  end
+
+  ##
+  # Adds +gemspecs+ to the dependency list.
+
+  def add(*gemspecs)
+    @specs.concat gemspecs
+  end
+
+  def clear
+    @specs.clear
+  end
+
+  ##
+  # Return a list of the gem specifications in the dependency list, sorted in
+  # order so that no gemspec in the list depends on a gemspec earlier in the
+  # list.
+  #
+  # This is useful when removing gems from a set of installed gems.  By
+  # removing them in the returned order, you don't get into as many dependency
+  # issues.
+  #
+  # If there are circular dependencies (yuck!), then gems will be returned in
+  # order until only the circular dependents and anything they reference are
+  # left.  Then arbitrary gemspecs will be returned until the circular
+  # dependency is broken, after which gems will be returned in dependency
+  # order again.
+
+  def dependency_order
+    sorted = strongly_connected_components.flatten
+
+    result = []
+    seen = {}
+
+    sorted.each do |spec|
+      if index = seen[spec.name]
+        if result[index].version < spec.version
+          result[index] = spec
+        end
+      else
+        seen[spec.name] = result.length
+        result << spec
+      end
+    end
+
+    result.reverse
+  end
+
+  ##
+  # Iterator over dependency_order
+
+  def each(&block)
+    dependency_order.each(&block)
+  end
+
+  def find_name(full_name)
+    @specs.find {|spec| spec.full_name == full_name }
+  end
+
+  def inspect # :nodoc:
+    format("%s %p>", super[0..-2], map(&:full_name))
+  end
+
+  ##
+  # Are all the dependencies in the list satisfied?
+
+  def ok?
+    why_not_ok?(:quick).empty?
+  end
+
+  def why_not_ok?(quick = false)
+    unsatisfied = Hash.new {|h,k| h[k] = [] }
+    each do |spec|
+      spec.runtime_dependencies.each do |dep|
+        inst = Gem::Specification.any? do |installed_spec|
+          dep.name == installed_spec.name &&
+            dep.requirement.satisfied_by?(installed_spec.version)
+        end
+
+        unless inst || @specs.find {|s| s.satisfies_requirement? dep }
+          unsatisfied[spec.name] << dep
+          return unsatisfied if quick
+        end
+      end
+    end
+
+    unsatisfied
+  end
+
+  ##
+  # It is ok to remove a gemspec from the dependency list?
+  #
+  # If removing the gemspec creates breaks a currently ok dependency, then it
+  # is NOT ok to remove the gemspec.
+
+  def ok_to_remove?(full_name, check_dev=true)
+    gem_to_remove = find_name full_name
+
+    # If the state is inconsistent, at least don't crash
+    return true unless gem_to_remove
+
+    siblings = @specs.find_all do |s|
+      s.name == gem_to_remove.name &&
+        s.full_name != gem_to_remove.full_name
+    end
+
+    deps = []
+
+    @specs.each do |spec|
+      check = check_dev ? spec.dependencies : spec.runtime_dependencies
+
+      check.each do |dep|
+        deps << dep if gem_to_remove.satisfies_requirement?(dep)
+      end
+    end
+
+    deps.all? do |dep|
+      siblings.any? do |s|
+        s.satisfies_requirement? dep
+      end
+    end
+  end
+
+  ##
+  # Remove everything in the DependencyList that matches but doesn't
+  # satisfy items in +dependencies+ (a hash of gem names to arrays of
+  # dependencies).
+
+  def remove_specs_unsatisfied_by(dependencies)
+    specs.reject! do |spec|
+      dep = dependencies[spec.name]
+      dep && !dep.requirement.satisfied_by?(spec.version)
+    end
+  end
+
+  ##
+  # Removes the gemspec matching +full_name+ from the dependency list
+
+  def remove_by_name(full_name)
+    @specs.delete_if {|spec| spec.full_name == full_name }
+  end
+
+  ##
+  # Return a hash of predecessors.  <tt>result[spec]</tt> is an Array of
+  # gemspecs that have a dependency satisfied by the named gemspec.
+
+  def spec_predecessors
+    result = Hash.new {|h,k| h[k] = [] }
+
+    specs = @specs.sort.reverse
+
+    specs.each do |spec|
+      specs.each do |other|
+        next if spec == other
+
+        other.dependencies.each do |dep|
+          if spec.satisfies_requirement? dep
+            result[spec] << other
+          end
+        end
+      end
+    end
+
+    result
+  end
+
+  def tsort_each_node(&block)
+    @specs.each(&block)
+  end
+
+  def tsort_each_child(node)
+    specs = @specs.sort.reverse
+
+    dependencies = node.runtime_dependencies
+    dependencies.push(*node.development_dependencies) if @development
+
+    dependencies.each do |dep|
+      specs.each do |spec|
+        if spec.satisfies_requirement? dep
+          yield spec
+          break
+        end
+      end
+    end
+  end
+
+  private
+
+  ##
+  # Count the number of gemspecs in the list +specs+ that are not in
+  # +ignored+.
+
+  def active_count(specs, ignored)
+    specs.count {|spec| ignored[spec.full_name].nil? }
+  end
+end

package/lib/ruby/3.4.11/rubygems/deprecate.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+##
+# Provides 3 methods for declaring when something is going away.
+#
+# +deprecate(name, repl, year, month)+:
+#     Indicate something may be removed on/after a certain date.
+#
+# +rubygems_deprecate(name, replacement=:none)+:
+#     Indicate something will be removed in the next major RubyGems version,
+#     and (optionally) a replacement for it.
+#
+# +rubygems_deprecate_command+:
+#     Indicate a RubyGems command (in +lib/rubygems/commands/*.rb+) will be
+#     removed in the next RubyGems version.
+#
+# Also provides +skip_during+ for temporarily turning off deprecation warnings.
+# This is intended to be used in the test suite, so deprecation warnings
+# don't cause test failures if you need to make sure stderr is otherwise empty.
+#
+#
+# Example usage of +deprecate+ and +rubygems_deprecate+:
+#
+#     class Legacy
+#       def self.some_class_method
+#         # ...
+#       end
+#
+#       def some_instance_method
+#         # ...
+#       end
+#
+#       def some_old_method
+#         # ...
+#       end
+#
+#       extend Gem::Deprecate
+#       deprecate :some_instance_method, "X.z", 2011, 4
+#       rubygems_deprecate :some_old_method, "Modern#some_new_method"
+#
+#       class << self
+#         extend Gem::Deprecate
+#         deprecate :some_class_method, :none, 2011, 4
+#       end
+#     end
+#
+#
+# Example usage of +rubygems_deprecate_command+:
+#
+#     class Gem::Commands::QueryCommand < Gem::Command
+#       extend Gem::Deprecate
+#       rubygems_deprecate_command
+#
+#       # ...
+#     end
+#
+#
+# Example usage of +skip_during+:
+#
+#     class TestSomething < Gem::Testcase
+#       def test_some_thing_with_deprecations
+#         Gem::Deprecate.skip_during do
+#           actual_stdout, actual_stderr = capture_output do
+#             Gem.something_deprecated
+#           end
+#           assert_empty actual_stdout
+#           assert_equal(expected, actual_stderr)
+#         end
+#       end
+#     end
+
+module Gem
+  module Deprecate
+    def self.skip # :nodoc:
+      @skip ||= false
+    end
+
+    def self.skip=(v) # :nodoc:
+      @skip = v
+    end
+
+    ##
+    # Temporarily turn off warnings. Intended for tests only.
+
+    def skip_during
+      original = Gem::Deprecate.skip
+      Gem::Deprecate.skip = true
+      yield
+    ensure
+      Gem::Deprecate.skip = original
+    end
+
+    def self.next_rubygems_major_version # :nodoc:
+      Gem::Version.new(Gem.rubygems_version.segments.first).bump
+    end
+
+    ##
+    # Simple deprecation method that deprecates +name+ by wrapping it up
+    # in a dummy method. It warns on each call to the dummy method
+    # telling the user of +repl+ (unless +repl+ is :none) and the
+    # year/month that it is planned to go away.
+
+    def deprecate(name, repl, year, month)
+      class_eval do
+        old = "_deprecated_#{name}"
+        alias_method old, name
+        define_method name do |*args, &block|
+          klass = is_a? Module
+          target = klass ? "#{self}." : "#{self.class}#"
+          msg = [
+            "NOTE: #{target}#{name} is deprecated",
+            repl == :none ? " with no replacement" : "; use #{repl} instead",
+            format(". It will be removed on or after %4d-%02d.", year, month),
+            "\n#{target}#{name} called from #{Gem.location_of_caller.join(":")}",
+          ]
+          warn "#{msg.join}." unless Gem::Deprecate.skip
+          send old, *args, &block
+        end
+        ruby2_keywords name if respond_to?(:ruby2_keywords, true)
+      end
+    end
+
+    ##
+    # Simple deprecation method that deprecates +name+ by wrapping it up
+    # in a dummy method. It warns on each call to the dummy method
+    # telling the user of +repl+ (unless +repl+ is :none) and the
+    # Rubygems version that it is planned to go away.
+
+    def rubygems_deprecate(name, replacement=:none)
+      class_eval do
+        old = "_deprecated_#{name}"
+        alias_method old, name
+        define_method name do |*args, &block|
+          klass = is_a? Module
+          target = klass ? "#{self}." : "#{self.class}#"
+          msg = [
+            "NOTE: #{target}#{name} is deprecated",
+            replacement == :none ? " with no replacement" : "; use #{replacement} instead",
+            ". It will be removed in Rubygems #{Gem::Deprecate.next_rubygems_major_version}",
+            "\n#{target}#{name} called from #{Gem.location_of_caller.join(":")}",
+          ]
+          warn "#{msg.join}." unless Gem::Deprecate.skip
+          send old, *args, &block
+        end
+        ruby2_keywords name if respond_to?(:ruby2_keywords, true)
+      end
+    end
+
+    # Deprecation method to deprecate Rubygems commands
+    def rubygems_deprecate_command(version = Gem::Deprecate.next_rubygems_major_version)
+      class_eval do
+        define_method "deprecated?" do
+          true
+        end
+
+        define_method "deprecation_warning" do
+          msg = [
+            "#{command} command is deprecated",
+            ". It will be removed in Rubygems #{version}.\n",
+          ]
+
+          alert_warning msg.join.to_s unless Gem::Deprecate.skip
+        end
+      end
+    end
+
+    module_function :rubygems_deprecate, :rubygems_deprecate_command, :skip_during
+  end
+end

package/lib/ruby/3.4.11/rubygems/doctor.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "../rubygems"
+require_relative "user_interaction"
+
+##
+# Cleans up after a partially-failed uninstall or for an invalid
+# Gem::Specification.
+#
+# If a specification was removed by hand this will remove any remaining files.
+#
+# If a corrupt specification was installed this will clean up warnings by
+# removing the bogus specification.
+
+class Gem::Doctor
+  include Gem::UserInteraction
+
+  ##
+  # Maps a gem subdirectory to the files that are expected to exist in the
+  # subdirectory.
+
+  REPOSITORY_EXTENSION_MAP = [ # :nodoc:
+    ["specifications", ".gemspec"],
+    ["build_info",     ".info"],
+    ["cache",          ".gem"],
+    ["doc",            ""],
+    ["extensions",     ""],
+    ["gems",           ""],
+    ["plugins",        ""],
+  ].freeze
+
+  missing =
+    Gem::REPOSITORY_SUBDIRECTORIES.sort -
+    REPOSITORY_EXTENSION_MAP.map {|(k,_)| k }.sort
+
+  raise "Update REPOSITORY_EXTENSION_MAP, missing: #{missing.join ", "}" unless
+    missing.empty?
+
+  ##
+  # Creates a new Gem::Doctor that will clean up +gem_repository+.  Only one
+  # gem repository may be cleaned at a time.
+  #
+  # If +dry_run+ is true no files or directories will be removed.
+
+  def initialize(gem_repository, dry_run = false)
+    @gem_repository = gem_repository
+    @dry_run        = dry_run
+
+    @installed_specs = nil
+  end
+
+  ##
+  # Specs installed in this gem repository
+
+  def installed_specs # :nodoc:
+    @installed_specs ||= Gem::Specification.map(&:full_name)
+  end
+
+  ##
+  # Are we doctoring a gem repository?
+
+  def gem_repository?
+    !installed_specs.empty?
+  end
+
+  ##
+  # Cleans up uninstalled files and invalid gem specifications
+
+  def doctor
+    @orig_home = Gem.dir
+    @orig_path = Gem.path
+
+    say "Checking #{@gem_repository}"
+
+    Gem.use_paths @gem_repository.to_s
+
+    unless gem_repository?
+      say "This directory does not appear to be a RubyGems repository, " \
+          "skipping"
+      say
+      return
+    end
+
+    doctor_children
+
+    say
+  ensure
+    Gem.use_paths @orig_home, *@orig_path
+  end
+
+  ##
+  # Cleans up children of this gem repository
+
+  def doctor_children # :nodoc:
+    REPOSITORY_EXTENSION_MAP.each do |sub_directory, extension|
+      doctor_child sub_directory, extension
+    end
+  end
+
+  ##
+  # Removes files in +sub_directory+ with +extension+
+
+  def doctor_child(sub_directory, extension) # :nodoc:
+    directory = File.join(@gem_repository, sub_directory)
+
+    Dir.entries(directory).sort.each do |ent|
+      next if [".", ".."].include?(ent)
+
+      child = File.join(directory, ent)
+      next unless File.exist?(child)
+
+      basename = File.basename(child, extension)
+      next if installed_specs.include? basename
+      next if /^rubygems-\d/.match?(basename)
+      next if sub_directory == "specifications" && basename == "default"
+      next if sub_directory == "plugins" && Gem.plugin_suffix_regexp =~ (basename)
+
+      type = File.directory?(child) ? "directory" : "file"
+
+      action = if @dry_run
+        "Extra"
+      else
+        FileUtils.rm_r(child)
+        "Removed"
+      end
+
+      say "#{action} #{type} #{sub_directory}/#{File.basename(child)}"
+    end
+  rescue Errno::ENOENT
+    # ignore
+  end
+end

package/lib/ruby/3.4.11/rubygems/errors.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+#--
+# This file contains all the various exceptions and other errors that are used
+# inside of RubyGems.
+#
+# DOC: Confirm _all_
+#++
+
+module Gem
+  ##
+  # Raised when RubyGems is unable to load or activate a gem.  Contains the
+  # name and version requirements of the gem that either conflicts with
+  # already activated gems or that RubyGems is otherwise unable to activate.
+
+  class LoadError < ::LoadError
+    # Name of gem
+    attr_accessor :name
+
+    # Version requirement of gem
+    attr_accessor :requirement
+  end
+
+  ##
+  # Raised when trying to activate a gem, and that gem does not exist on the
+  # system.  Instead of rescuing from this class, make sure to rescue from the
+  # superclass Gem::LoadError to catch all types of load errors.
+  class MissingSpecError < Gem::LoadError
+    def initialize(name, requirement, extra_message=nil)
+      @name        = name
+      @requirement = requirement
+      @extra_message = extra_message
+      super(message)
+    end
+
+    def message # :nodoc:
+      build_message +
+        "Checked in 'GEM_PATH=#{Gem.path.join(File::PATH_SEPARATOR)}' #{@extra_message}, execute `gem env` for more information"
+    end
+
+    private
+
+    def build_message
+      total = Gem::Specification.stubs.size
+      "Could not find '#{name}' (#{requirement}) among #{total} total gem(s)\n"
+    end
+  end
+
+  ##
+  # Raised when trying to activate a gem, and the gem exists on the system, but
+  # not the requested version. Instead of rescuing from this class, make sure to
+  # rescue from the superclass Gem::LoadError to catch all types of load errors.
+  class MissingSpecVersionError < MissingSpecError
+    attr_reader :specs
+
+    def initialize(name, requirement, specs)
+      @specs = specs
+      super(name, requirement)
+    end
+
+    private
+
+    def build_message
+      names = specs.map(&:full_name)
+      "Could not find '#{name}' (#{requirement}) - did find: [#{names.join ","}]\n"
+    end
+  end
+
+  # Raised when there are conflicting gem specs loaded
+
+  class ConflictError < LoadError
+    ##
+    # A Hash mapping conflicting specifications to the dependencies that
+    # caused the conflict
+
+    attr_reader :conflicts
+
+    ##
+    # The specification that had the conflict
+
+    attr_reader :target
+
+    def initialize(target, conflicts)
+      @target    = target
+      @conflicts = conflicts
+      @name      = target.name
+
+      reason = conflicts.map do |act, dependencies|
+        "#{act.full_name} conflicts with #{dependencies.join(", ")}"
+      end.join ", "
+
+      # TODO: improve message by saying who activated `con`
+
+      super("Unable to activate #{target.full_name}, because #{reason}")
+    end
+  end
+
+  class ErrorReason; end
+
+  # Generated when trying to lookup a gem to indicate that the gem
+  # was found, but that it isn't usable on the current platform.
+  #
+  # fetch and install read these and report them to the user to aid
+  # in figuring out why a gem couldn't be installed.
+  #
+  class PlatformMismatch < ErrorReason
+    ##
+    # the name of the gem
+    attr_reader :name
+
+    ##
+    # the version
+    attr_reader :version
+
+    ##
+    # The platforms that are mismatched
+    attr_reader :platforms
+
+    def initialize(name, version)
+      @name = name
+      @version = version
+      @platforms = []
+    end
+
+    ##
+    # append a platform to the list of mismatched platforms.
+    #
+    # Platforms are added via this instead of injected via the constructor
+    # so that we can loop over a list of mismatches and just add them rather
+    # than perform some kind of calculation mismatch summary before creation.
+    def add_platform(platform)
+      @platforms << platform
+    end
+
+    ##
+    # A wordy description of the error.
+    def wordy
+      format("Found %s (%s), but was for platform%s %s", @name, @version, @platforms.size == 1 ? "" : "s", @platforms.join(" ,"))
+    end
+  end
+
+  ##
+  # An error that indicates we weren't able to fetch some
+  # data from a source
+
+  class SourceFetchProblem < ErrorReason
+    ##
+    # Creates a new SourceFetchProblem for the given +source+ and +error+.
+
+    def initialize(source, error)
+      @source = source
+      @error = error
+    end
+
+    ##
+    # The source that had the fetch problem.
+
+    attr_reader :source
+
+    ##
+    # The fetch error which is an Exception subclass.
+
+    attr_reader :error
+
+    ##
+    # An English description of the error.
+
+    def wordy
+      "Unable to download data from #{Gem::Uri.redact(@source.uri)} - #{@error.message}"
+    end
+
+    ##
+    # The "exception" alias allows you to call raise on a SourceFetchProblem.
+
+    alias_method :exception, :error
+  end
+end