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

package/lib/ruby/3.4.11/rubygems/commands/check_command.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../version_option"
-require_relative "../validator"
-require_relative "../doctor"
-
-class Gem::Commands::CheckCommand < Gem::Command
-  include Gem::VersionOption
-
-  def initialize
-    super "check", "Check a gem repository for added or missing files",
-          alien: true, doctor: false, dry_run: false, gems: true
-
-    add_option("-a", "--[no-]alien",
-               'Report "unmanaged" or rogue files in the',
-               "gem repository") do |value, options|
-      options[:alien] = value
-    end
-
-    add_option("--[no-]doctor",
-               "Clean up uninstalled gems and broken",
-               "specifications") do |value, options|
-      options[:doctor] = value
-    end
-
-    add_option("--[no-]dry-run",
-               "Do not remove files, only report what",
-               "would be removed") do |value, options|
-      options[:dry_run] = value
-    end
-
-    add_option("--[no-]gems",
-               "Check installed gems for problems") do |value, options|
-      options[:gems] = value
-    end
-
-    add_version_option "check"
-  end
-
-  def check_gems
-    say "Checking gems..."
-    say
-    gems = begin
-             get_all_gem_names
-           rescue StandardError
-             []
-           end
-
-    Gem::Validator.new.alien(gems).sort.each do |key, val|
-      if val.empty?
-        say "#{key} is error-free" if Gem.configuration.verbose
-      else
-        say "#{key} has #{val.size} problems"
-        val.each do |error_entry|
-          say "  #{error_entry.path}:"
-          say "    #{error_entry.problem}"
-        end
-      end
-      say
-    end
-  end
-
-  def doctor
-    say "Checking for files from uninstalled gems..."
-    say
-
-    Gem.path.each do |gem_repo|
-      doctor = Gem::Doctor.new gem_repo, options[:dry_run]
-      doctor.doctor
-    end
-  end
-
-  def execute
-    check_gems if options[:gems]
-    doctor if options[:doctor]
-  end
-
-  def arguments # :nodoc:
-    "GEMNAME       name of gem to check"
-  end
-
-  def defaults_str # :nodoc:
-    "--gems --alien"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The check command can list and repair problems with installed gems and
-specifications and will clean up gems that have been partially uninstalled.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} [OPTIONS] [GEMNAME ...]"
-  end
-end

package/lib/ruby/3.4.11/rubygems/commands/cleanup_command.rb

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../dependency_list"
-require_relative "../uninstaller"
-
-class Gem::Commands::CleanupCommand < Gem::Command
-  def initialize
-    super "cleanup",
-          "Clean up old versions of installed gems",
-          force: false, install_dir: Gem.dir,
-          check_dev: true
-
-    add_option("-n", "-d", "--dry-run",
-               "Do not uninstall gems") do |_value, options|
-      options[:dryrun] = true
-    end
-
-    add_option(:Deprecated, "--dryrun",
-               "Do not uninstall gems") do |_value, options|
-      options[:dryrun] = true
-    end
-    deprecate_option("--dryrun", extra_msg: "Use --dry-run instead")
-
-    add_option("-D", "--[no-]check-development",
-               "Check development dependencies while uninstalling",
-               "(default: true)") do |value, options|
-      options[:check_dev] = value
-    end
-
-    add_option("--[no-]user-install",
-               "Cleanup in user's home directory instead",
-               "of GEM_HOME.") do |value, options|
-      options[:user_install] = value
-    end
-
-    @candidate_gems  = nil
-    @default_gems    = []
-    @full            = nil
-    @gems_to_cleanup = nil
-    @primary_gems    = nil
-  end
-
-  def arguments # :nodoc:
-    "GEMNAME       name of gem to cleanup"
-  end
-
-  def defaults_str # :nodoc:
-    "--no-dry-run"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The cleanup command removes old versions of gems from GEM_HOME that are not
-required to meet a dependency.  If a gem is installed elsewhere in GEM_PATH
-the cleanup command won't delete it.
-
-If no gems are named all gems in GEM_HOME are cleaned.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} [GEMNAME ...]"
-  end
-
-  def execute
-    say "Cleaning up installed gems..."
-
-    if options[:args].empty?
-      done     = false
-      last_set = nil
-
-      until done do
-        clean_gems
-
-        this_set = @gems_to_cleanup.map(&:full_name).sort
-
-        done = this_set.empty? || last_set == this_set
-
-        last_set = this_set
-      end
-    else
-      clean_gems
-    end
-
-    say "Clean up complete"
-
-    verbose do
-      skipped = @default_gems.map(&:full_name)
-
-      "Skipped default gems: #{skipped.join ", "}"
-    end
-  end
-
-  def clean_gems
-    get_primary_gems
-    get_candidate_gems
-    get_gems_to_cleanup
-
-    @full = Gem::DependencyList.from_specs
-
-    deplist = Gem::DependencyList.new
-    @gems_to_cleanup.each {|spec| deplist.add spec }
-
-    deps = deplist.strongly_connected_components.flatten
-
-    deps.reverse_each do |spec|
-      uninstall_dep spec
-    end
-  end
-
-  def get_candidate_gems
-    @candidate_gems = if options[:args].empty?
-      Gem::Specification.to_a
-    else
-      options[:args].flat_map do |gem_name|
-        Gem::Specification.find_all_by_name gem_name
-      end
-    end
-  end
-
-  def get_gems_to_cleanup
-    gems_to_cleanup = @candidate_gems.select do |spec|
-      @primary_gems[spec.name].version != spec.version
-    end
-
-    default_gems, gems_to_cleanup = gems_to_cleanup.partition(&:default_gem?)
-
-    uninstall_from = options[:user_install] ? Gem.user_dir : Gem.dir
-
-    gems_to_cleanup = gems_to_cleanup.select do |spec|
-      spec.base_dir == uninstall_from
-    end
-
-    @default_gems += default_gems
-    @default_gems.uniq!
-    @gems_to_cleanup = gems_to_cleanup.uniq
-  end
-
-  def get_primary_gems
-    @primary_gems = {}
-
-    Gem::Specification.each do |spec|
-      if @primary_gems[spec.name].nil? ||
-         @primary_gems[spec.name].version < spec.version
-        @primary_gems[spec.name] = spec
-      end
-    end
-  end
-
-  def uninstall_dep(spec)
-    return unless @full.ok_to_remove?(spec.full_name, options[:check_dev])
-
-    if options[:dryrun]
-      say "Dry Run Mode: Would uninstall #{spec.full_name}"
-      return
-    end
-
-    say "Attempting to uninstall #{spec.full_name}"
-
-    uninstall_options = {
-      executables: false,
-      version: "= #{spec.version}",
-    }
-
-    uninstall_options[:user_install] = Gem.user_dir == spec.base_dir
-
-    uninstaller = Gem::Uninstaller.new spec.name, uninstall_options
-
-    begin
-      uninstaller.uninstall
-    rescue Gem::DependencyRemovalException, Gem::InstallError,
-           Gem::GemNotInHomeException, Gem::FilePermissionError => e
-      say "Unable to uninstall #{spec.full_name}:"
-      say "\t#{e.class}: #{e.message}"
-    end
-  end
-end

package/lib/ruby/3.4.11/rubygems/commands/contents_command.rb

@@ -1,196 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../version_option"
-
-class Gem::Commands::ContentsCommand < Gem::Command
-  include Gem::VersionOption
-
-  def initialize
-    super "contents", "Display the contents of the installed gems",
-          specdirs: [], lib_only: false, prefix: true,
-          show_install_dir: false
-
-    add_version_option
-
-    add_option("--all",
-               "Contents for all gems") do |all, options|
-      options[:all] = all
-    end
-
-    add_option("-s", "--spec-dir a,b,c", Array,
-               "Search for gems under specific paths") do |spec_dirs, options|
-      options[:specdirs] = spec_dirs
-    end
-
-    add_option("-l", "--[no-]lib-only",
-               "Only return files in the Gem's lib_dirs") do |lib_only, options|
-      options[:lib_only] = lib_only
-    end
-
-    add_option("--[no-]prefix",
-               "Don't include installed path prefix") do |prefix, options|
-      options[:prefix] = prefix
-    end
-
-    add_option("--[no-]show-install-dir",
-               "Show only the gem install dir") do |show, options|
-      options[:show_install_dir] = show
-    end
-
-    @path_kind = nil
-    @spec_dirs = nil
-    @version   = nil
-  end
-
-  def arguments # :nodoc:
-    "GEMNAME       name of gem to list contents for"
-  end
-
-  def defaults_str # :nodoc:
-    "--no-lib-only --prefix"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The contents command lists the files in an installed gem.  The listing can
-be given as full file names, file names without the installed directory
-prefix or only the files that are requireable.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} GEMNAME [GEMNAME ...]"
-  end
-
-  def execute
-    @version   = options[:version] || Gem::Requirement.default
-    @spec_dirs = specification_directories
-    @path_kind = path_description @spec_dirs
-
-    names = gem_names
-
-    names.each do |name|
-      found =
-        if options[:show_install_dir]
-          gem_install_dir name
-        else
-          gem_contents name
-        end
-
-      terminate_interaction 1 unless found || names.length > 1
-    end
-  end
-
-  def files_in(spec)
-    if spec.default_gem?
-      files_in_default_gem spec
-    else
-      files_in_gem spec
-    end
-  end
-
-  def files_in_gem(spec)
-    gem_path  = spec.full_gem_path
-    extra     = "/{#{spec.require_paths.join ","}}" if options[:lib_only]
-    glob      = "#{gem_path}#{extra}/**/*"
-    prefix_re = %r{#{Regexp.escape(gem_path)}/}
-
-    Dir[glob].map do |file|
-      [gem_path, file.sub(prefix_re, "")]
-    end
-  end
-
-  def files_in_default_gem(spec)
-    spec.files.filter_map do |file|
-      if file.start_with?("#{spec.bindir}/")
-        [RbConfig::CONFIG["bindir"], file.delete_prefix("#{spec.bindir}/")]
-      else
-        gem spec.name, spec.version
-
-        require_path = spec.require_paths.find do |path|
-          file.start_with?("#{path}/")
-        end
-
-        requirable_part = file.delete_prefix("#{require_path}/")
-
-        resolve = $LOAD_PATH.resolve_feature_path(requirable_part)&.last
-        next unless resolve
-
-        [resolve.delete_suffix(requirable_part), requirable_part]
-      end
-    end
-  end
-
-  def gem_contents(name)
-    spec = spec_for name
-
-    return false unless spec
-
-    files = files_in spec
-
-    show_files files
-
-    true
-  end
-
-  def gem_install_dir(name)
-    spec = spec_for name
-
-    return false unless spec
-
-    say spec.gem_dir
-
-    true
-  end
-
-  def gem_names # :nodoc:
-    if options[:all]
-      Gem::Specification.map(&:name)
-    else
-      get_all_gem_names
-    end
-  end
-
-  def path_description(spec_dirs) # :nodoc:
-    if spec_dirs.empty?
-      "default gem paths"
-    else
-      "specified path"
-    end
-  end
-
-  def show_files(files)
-    files.sort.each do |prefix, basename|
-      absolute_path = File.join(prefix, basename)
-      next if File.directory? absolute_path
-
-      if options[:prefix]
-        say absolute_path
-      else
-        say basename
-      end
-    end
-  end
-
-  def spec_for(name)
-    spec = Gem::Specification.find_all_by_name(name, @version).first
-
-    return spec if spec
-
-    say "Unable to find gem '#{name}' in #{@path_kind}"
-
-    if Gem.configuration.verbose
-      say "\nDirectories searched:"
-      @spec_dirs.sort.each {|dir| say dir }
-    end
-
-    nil
-  end
-
-  def specification_directories # :nodoc:
-    options[:specdirs].flat_map do |i|
-      [i, File.join(i, "specifications")]
-    end
-  end
-end

package/lib/ruby/3.4.11/rubygems/commands/dependency_command.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../local_remote_options"
-require_relative "../version_option"
-
-class Gem::Commands::DependencyCommand < Gem::Command
-  include Gem::LocalRemoteOptions
-  include Gem::VersionOption
-
-  def initialize
-    super "dependency",
-          "Show the dependencies of an installed gem",
-          version: Gem::Requirement.default, domain: :local
-
-    add_version_option
-    add_platform_option
-    add_prerelease_option
-
-    add_option("-R", "--[no-]reverse-dependencies",
-               "Include reverse dependencies in the output") do |value, options|
-      options[:reverse_dependencies] = value
-    end
-
-    add_option("-p", "--pipe",
-               "Pipe Format (name --version ver)") do |value, options|
-      options[:pipe_format] = value
-    end
-
-    add_local_remote_options
-  end
-
-  def arguments # :nodoc:
-    "REGEXP        show dependencies for gems whose names start with REGEXP"
-  end
-
-  def defaults_str # :nodoc:
-    "--local --version '#{Gem::Requirement.default}' --no-reverse-dependencies"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The dependency commands lists which other gems a given gem depends on.  For
-local gems only the reverse dependencies can be shown (which gems depend on
-the named gem).
-
-The dependency list can be displayed in a format suitable for piping for
-use with other commands.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} REGEXP"
-  end
-
-  def fetch_remote_specs(name, requirement, prerelease) # :nodoc:
-    fetcher = Gem::SpecFetcher.fetcher
-
-    specs_type = prerelease ? :complete : :released
-
-    ss = if name.nil?
-      fetcher.detect(specs_type) { true }
-    else
-      fetcher.detect(specs_type) do |name_tuple|
-        name === name_tuple.name && requirement.satisfied_by?(name_tuple.version)
-      end
-    end
-
-    ss.map {|tuple, source| source.fetch_spec(tuple) }
-  end
-
-  def fetch_specs(name_pattern, requirement, prerelease) # :nodoc:
-    specs = []
-
-    if local?
-      specs.concat Gem::Specification.stubs.find_all {|spec|
-        name_matches = name_pattern ? name_pattern =~ spec.name : true
-        version_matches = requirement.satisfied_by?(spec.version)
-
-        name_matches && version_matches
-      }.map(&:to_spec)
-    end
-
-    specs.concat fetch_remote_specs name_pattern, requirement, prerelease if remote?
-
-    ensure_specs specs
-
-    specs.uniq.sort
-  end
-
-  def display_pipe(specs) # :nodoc:
-    specs.each do |spec|
-      next if spec.dependencies.empty?
-      spec.dependencies.sort_by(&:name).each do |dep|
-        say "#{dep.name} --version '#{dep.requirement}'"
-      end
-    end
-  end
-
-  def display_readable(specs, reverse) # :nodoc:
-    response = String.new
-
-    specs.each do |spec|
-      response << print_dependencies(spec)
-      unless reverse[spec.full_name].empty?
-        response << "  Used by\n"
-        reverse[spec.full_name].each do |sp, dep|
-          response << "    #{sp} (#{dep})\n"
-        end
-      end
-      response << "\n"
-    end
-
-    say response
-  end
-
-  def execute
-    ensure_local_only_reverse_dependencies
-
-    pattern = name_pattern options[:args]
-    requirement = Gem::Requirement.new options[:version]
-
-    specs = fetch_specs pattern, requirement, options[:prerelease]
-
-    reverse = reverse_dependencies specs
-
-    if options[:pipe_format]
-      display_pipe specs
-    else
-      display_readable specs, reverse
-    end
-  end
-
-  def ensure_local_only_reverse_dependencies # :nodoc:
-    if options[:reverse_dependencies] && remote? && !local?
-      alert_error "Only reverse dependencies for local gems are supported."
-      terminate_interaction 1
-    end
-  end
-
-  def ensure_specs(specs) # :nodoc:
-    return unless specs.empty?
-
-    patterns = options[:args].join ","
-    say "No gems found matching #{patterns} (#{options[:version]})" if
-      Gem.configuration.verbose
-
-    terminate_interaction 1
-  end
-
-  def print_dependencies(spec, level = 0) # :nodoc:
-    response = String.new
-    response << "  " * level + "Gem #{spec.full_name}\n"
-    unless spec.dependencies.empty?
-      spec.dependencies.sort_by(&:name).each do |dep|
-        response << "  " * level + "  #{dep}\n"
-      end
-    end
-    response
-  end
-
-  def reverse_dependencies(specs) # :nodoc:
-    reverse = Hash.new {|h, k| h[k] = [] }
-
-    return reverse unless options[:reverse_dependencies]
-
-    specs.each do |spec|
-      reverse[spec.full_name] = find_reverse_dependencies spec
-    end
-
-    reverse
-  end
-
-  ##
-  # Returns an Array of [specification, dep] that are satisfied by +spec+.
-
-  def find_reverse_dependencies(spec) # :nodoc:
-    result = []
-
-    Gem::Specification.each do |sp|
-      sp.dependencies.each do |dep|
-        dep = Gem::Dependency.new(*dep) unless Gem::Dependency === dep
-
-        if spec.name == dep.name &&
-           dep.requirement.satisfied_by?(spec.version)
-          result << [sp.full_name, dep]
-        end
-      end
-    end
-
-    result
-  end
-
-  private
-
-  def name_pattern(args)
-    return if args.empty?
-
-    if args.length == 1 && args.first =~ /\A(.*)(i)?\z/m
-      flags = $2 ? Regexp::IGNORECASE : nil
-      Regexp.new $1, flags
-    else
-      /\A#{Regexp.union(*args)}/
-    end
-  end
-end