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

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

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../version_option"
-require_relative "../security_option"
-require_relative "../remote_fetcher"
-require_relative "../package"
-
-# forward-declare
-
-module Gem::Security # :nodoc:
-  class Policy # :nodoc:
-  end
-end
-
-class Gem::Commands::UnpackCommand < Gem::Command
-  include Gem::VersionOption
-  include Gem::SecurityOption
-
-  def initialize
-    require "fileutils"
-
-    super "unpack", "Unpack an installed gem to the current directory",
-          version: Gem::Requirement.default,
-          target: Dir.pwd
-
-    add_option("--target=DIR",
-               "target directory for unpacking") do |value, options|
-      options[:target] = value
-    end
-
-    add_option("--spec", "unpack the gem specification") do |_value, options|
-      options[:spec] = true
-    end
-
-    add_security_option
-    add_version_option
-  end
-
-  def arguments # :nodoc:
-    "GEMNAME       name of gem to unpack"
-  end
-
-  def defaults_str # :nodoc:
-    "--version '#{Gem::Requirement.default}'"
-  end
-
-  def description
-    <<-EOF
-The unpack command allows you to examine the contents of a gem or modify
-them to help diagnose a bug.
-
-You can add the contents of the unpacked gem to the load path using the
-RUBYLIB environment variable or -I:
-
-  $ gem unpack my_gem
-  Unpacked gem: '.../my_gem-1.0'
-  [edit my_gem-1.0/lib/my_gem.rb]
-  $ ruby -Imy_gem-1.0/lib -S other_program
-
-You can repackage an unpacked gem using the build command.  See the build
-command help for an example.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} GEMNAME"
-  end
-
-  #--
-  # TODO: allow, e.g., 'gem unpack rake-0.3.1'.  Find a general solution for
-  # this, so that it works for uninstall as well.  (And check other commands
-  # at the same time.)
-
-  def execute
-    security_policy = options[:security_policy]
-
-    get_all_gem_names.each do |name|
-      dependency = Gem::Dependency.new name, options[:version]
-      path = get_path dependency
-
-      unless path
-        alert_error "Gem '#{name}' not installed nor fetchable."
-        next
-      end
-
-      if @options[:spec]
-        spec, metadata = Gem::Package.raw_spec(path, security_policy)
-
-        if metadata.nil?
-          alert_error "--spec is unsupported on '#{name}' (old format gem)"
-          next
-        end
-
-        spec_file = File.basename spec.spec_file
-
-        FileUtils.mkdir_p @options[:target] if @options[:target]
-
-        destination = if @options[:target]
-          File.join @options[:target], spec_file
-        else
-          spec_file
-        end
-
-        File.open destination, "w" do |io|
-          io.write metadata
-        end
-      else
-        basename = File.basename path, ".gem"
-        target_dir = File.expand_path basename, options[:target]
-
-        package = Gem::Package.new path, security_policy
-        package.extract_files target_dir
-
-        say "Unpacked gem: '#{target_dir}'"
-      end
-    end
-  end
-
-  ##
-  #
-  # Find cached filename in Gem.path. Returns nil if the file cannot be found.
-  #
-  #--
-  # TODO: see comments in get_path() about general service.
-
-  def find_in_cache(filename)
-    Gem.path.each do |path|
-      this_path = File.join(path, "cache", filename)
-      return this_path if File.exist? this_path
-    end
-
-    nil
-  end
-
-  ##
-  # Return the full path to the cached gem file matching the given
-  # name and version requirement.  Returns 'nil' if no match.
-  #
-  # Example:
-  #
-  #   get_path 'rake', '> 0.4' # "/usr/lib/ruby/gems/1.8/cache/rake-0.4.2.gem"
-  #   get_path 'rake', '< 0.1' # nil
-  #   get_path 'rak'           # nil (exact name required)
-  #--
-
-  def get_path(dependency)
-    return dependency.name if /\.gem$/i.match?(dependency.name)
-
-    specs = dependency.matching_specs
-
-    selected = specs.max_by(&:version)
-
-    return Gem::RemoteFetcher.fetcher.download_to_cache(dependency) unless
-      selected
-
-    return unless /^#{selected.name}$/i.match?(dependency.name)
-
-    # We expect to find (basename).gem in the 'cache' directory.  Furthermore,
-    # the name match must be exact (ignoring case).
-
-    path = find_in_cache File.basename selected.cache_file
-
-    return Gem::RemoteFetcher.fetcher.download_to_cache(dependency) unless path
-
-    path
-  end
-end

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

@@ -1,326 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../command_manager"
-require_relative "../dependency_installer"
-require_relative "../install_update_options"
-require_relative "../local_remote_options"
-require_relative "../spec_fetcher"
-require_relative "../version_option"
-require_relative "../install_message" # must come before rdoc for messaging
-require_relative "../rdoc"
-
-class Gem::Commands::UpdateCommand < Gem::Command
-  include Gem::InstallUpdateOptions
-  include Gem::LocalRemoteOptions
-  include Gem::VersionOption
-
-  attr_reader :installer # :nodoc:
-
-  attr_reader :updated # :nodoc:
-
-  def initialize
-    options = {
-      force: false,
-    }
-
-    options.merge!(install_update_options)
-
-    super "update", "Update installed gems to the latest version", options
-
-    add_install_update_options
-
-    Gem::OptionParser.accept Gem::Version do |value|
-      Gem::Version.new value
-
-      value
-    end
-
-    add_option("--system [VERSION]", Gem::Version,
-               "Update the RubyGems system software") do |value, opts|
-      value ||= true
-
-      opts[:system] = value
-    end
-
-    add_local_remote_options
-    add_platform_option
-    add_prerelease_option "as update targets"
-
-    @updated   = []
-    @installer = nil
-  end
-
-  def arguments # :nodoc:
-    "GEMNAME       name of gem to update"
-  end
-
-  def defaults_str # :nodoc:
-    "--no-force --install-dir #{Gem.dir}\n" +
-      install_update_defaults_str
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The update command will update your gems to the latest version.
-
-The update command does not remove the previous version. Use the cleanup
-command to remove old versions.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} GEMNAME [GEMNAME ...]"
-  end
-
-  def check_latest_rubygems(version) # :nodoc:
-    if Gem.rubygems_version == version
-      say "Latest version already installed. Done."
-      terminate_interaction
-    end
-  end
-
-  def check_oldest_rubygems(version) # :nodoc:
-    if oldest_supported_version > version
-      alert_error "rubygems #{version} is not supported on #{RUBY_VERSION}. The oldest version supported by this ruby is #{oldest_supported_version}"
-      terminate_interaction 1
-    end
-  end
-
-  def check_update_arguments # :nodoc:
-    unless options[:args].empty?
-      alert_error "Gem names are not allowed with the --system option"
-      terminate_interaction 1
-    end
-  end
-
-  def execute
-    if options[:system]
-      update_rubygems
-      return
-    end
-
-    gems_to_update = which_to_update(
-      highest_installed_gems,
-      options[:args].uniq
-    )
-
-    if options[:explain]
-      say "Gems to update:"
-
-      gems_to_update.each do |name_tuple|
-        say "  #{name_tuple.full_name}"
-      end
-
-      return
-    end
-
-    say "Updating installed gems"
-
-    updated = update_gems gems_to_update
-
-    installed_names = highest_installed_gems.keys
-    updated_names = updated.map(&:name)
-    not_updated_names = options[:args].uniq - updated_names
-    not_installed_names = not_updated_names - installed_names
-    up_to_date_names = not_updated_names - not_installed_names
-
-    if updated.empty?
-      say "Nothing to update"
-    else
-      say "Gems updated: #{updated_names.join(" ")}"
-    end
-    say "Gems already up-to-date: #{up_to_date_names.join(" ")}" unless up_to_date_names.empty?
-    say "Gems not currently installed: #{not_installed_names.join(" ")}" unless not_installed_names.empty?
-  end
-
-  def fetch_remote_gems(spec) # :nodoc:
-    dependency = Gem::Dependency.new spec.name, "> #{spec.version}"
-    dependency.prerelease = options[:prerelease]
-
-    fetcher = Gem::SpecFetcher.fetcher
-
-    spec_tuples, errors = fetcher.search_for_dependency dependency
-
-    error = errors.find {|e| e.respond_to? :exception }
-
-    raise error if error
-
-    spec_tuples
-  end
-
-  def highest_installed_gems # :nodoc:
-    hig = {} # highest installed gems
-
-    # Get only gem specifications installed as --user-install
-    Gem::Specification.dirs = Gem.user_dir if options[:user_install]
-
-    Gem::Specification.each do |spec|
-      if hig[spec.name].nil? || hig[spec.name].version < spec.version
-        hig[spec.name] = spec
-      end
-    end
-
-    hig
-  end
-
-  def highest_remote_name_tuple(spec) # :nodoc:
-    spec_tuples = fetch_remote_gems spec
-
-    highest_remote_gem = spec_tuples.max
-    return unless highest_remote_gem
-
-    highest_remote_gem.first
-  end
-
-  def install_rubygems(spec) # :nodoc:
-    args = update_rubygems_arguments
-    version = spec.version
-
-    update_dir = File.join spec.base_dir, "gems", "rubygems-update-#{version}"
-
-    Dir.chdir update_dir do
-      say "Installing RubyGems #{version}" unless options[:silent]
-
-      installed = preparing_gem_layout_for(version) do
-        system Gem.ruby, "--disable-gems", "setup.rb", *args
-      end
-
-      unless options[:silent]
-        say "RubyGems system software updated" if installed
-      end
-    end
-  end
-
-  def preparing_gem_layout_for(version)
-    if Gem::Version.new(version) >= Gem::Version.new("3.2.a")
-      yield
-    else
-      require "tmpdir"
-      Dir.mktmpdir("gem_update") do |tmpdir|
-        FileUtils.mv Gem.plugindir, tmpdir
-
-        status = yield
-
-        unless status
-          FileUtils.mv File.join(tmpdir, "plugins"), Gem.plugindir
-        end
-
-        status
-      end
-    end
-  end
-
-  def rubygems_target_version
-    version = options[:system]
-    update_latest = version == true
-
-    unless update_latest
-      version     = Gem::Version.new     version
-      requirement = Gem::Requirement.new version
-
-      return version, requirement
-    end
-
-    version     = Gem::Version.new     Gem::VERSION
-    requirement = Gem::Requirement.new ">= #{Gem::VERSION}"
-
-    rubygems_update         = Gem::Specification.new
-    rubygems_update.name    = "rubygems-update"
-    rubygems_update.version = version
-
-    highest_remote_tup = highest_remote_name_tuple(rubygems_update)
-    target = highest_remote_tup ? highest_remote_tup.version : version
-
-    [target, requirement]
-  end
-
-  def update_gem(name, version = Gem::Requirement.default)
-    return if @updated.any? {|spec| spec.name == name }
-
-    update_options = options.dup
-    update_options[:prerelease] = version.prerelease?
-
-    @installer = Gem::DependencyInstaller.new update_options
-
-    say "Updating #{name}" unless options[:system]
-    begin
-      @installer.install name, Gem::Requirement.new(version)
-    rescue Gem::InstallError, Gem::DependencyError => e
-      alert_error "Error installing #{name}:\n\t#{e.message}"
-    end
-
-    @installer.installed_gems.each do |spec|
-      @updated << spec
-    end
-  end
-
-  def update_gems(gems_to_update)
-    gems_to_update.uniq.sort.each do |name_tuple|
-      update_gem name_tuple.name, name_tuple.version
-    end
-
-    @updated
-  end
-
-  ##
-  # Update RubyGems software to the latest version.
-
-  def update_rubygems
-    if Gem.disable_system_update_message
-      alert_error Gem.disable_system_update_message
-      terminate_interaction 1
-    end
-
-    check_update_arguments
-
-    version, requirement = rubygems_target_version
-
-    check_latest_rubygems version
-
-    check_oldest_rubygems version
-
-    installed_gems = Gem::Specification.find_all_by_name "rubygems-update", requirement
-    installed_gems = update_gem("rubygems-update", requirement) if installed_gems.empty? || installed_gems.first.version != version
-    return if installed_gems.empty?
-
-    install_rubygems installed_gems.first
-  end
-
-  def update_rubygems_arguments # :nodoc:
-    args = []
-    args << "--silent" if options[:silent]
-    args << "--prefix" << Gem.prefix if Gem.prefix
-    args << "--no-document" unless options[:document].include?("rdoc") || options[:document].include?("ri")
-    args << "--no-format-executable" if options[:no_format_executable]
-    args << "--previous-version" << Gem::VERSION
-    args
-  end
-
-  def which_to_update(highest_installed_gems, gem_names)
-    result = []
-
-    highest_installed_gems.each do |_l_name, l_spec|
-      next if !gem_names.empty? &&
-              gem_names.none? {|name| name == l_spec.name }
-
-      highest_remote_tup = highest_remote_name_tuple l_spec
-      next unless highest_remote_tup
-
-      result << highest_remote_tup
-    end
-
-    result
-  end
-
-  private
-
-  #
-  # Oldest version we support downgrading to. This is the version that
-  # originally ships with the oldest supported patch version of ruby.
-  #
-  def oldest_supported_version
-    @oldest_supported_version ||=
-      Gem::Version.new("3.3.3")
-  end
-end

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

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-
-class Gem::Commands::WhichCommand < Gem::Command
-  def initialize
-    super "which", "Find the location of a library file you can require",
-          search_gems_first: false, show_all: false
-
-    add_option "-a", "--[no-]all", "show all matching files" do |show_all, options|
-      options[:show_all] = show_all
-    end
-
-    add_option "-g", "--[no-]gems-first",
-               "search gems before non-gems" do |gems_first, options|
-      options[:search_gems_first] = gems_first
-    end
-  end
-
-  def arguments # :nodoc:
-    "FILE          name of file to find"
-  end
-
-  def defaults_str # :nodoc:
-    "--no-gems-first --no-all"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The which command is like the shell which command and shows you where
-the file you wish to require lives.
-
-You can use the which command to help determine why you are requiring a
-version you did not expect or to look at the content of a file you are
-requiring to see why it does not behave as you expect.
-    EOF
-  end
-
-  def execute
-    found = true
-
-    options[:args].each do |arg|
-      arg = arg.sub(/#{Regexp.union(*Gem.suffixes)}$/, "")
-      dirs = $LOAD_PATH
-
-      spec = Gem::Specification.find_by_path arg
-
-      if spec
-        if options[:search_gems_first]
-          dirs = spec.full_require_paths + $LOAD_PATH
-        else
-          dirs = $LOAD_PATH + spec.full_require_paths
-        end
-      end
-
-      paths = find_paths arg, dirs
-
-      if paths.empty?
-        alert_error "Can't find Ruby library file or shared library #{arg}"
-        found = false
-      else
-        say paths
-      end
-    end
-
-    terminate_interaction 1 unless found
-  end
-
-  def find_paths(package_name, dirs)
-    result = []
-
-    dirs.each do |dir|
-      Gem.suffixes.each do |ext|
-        full_path = File.join dir, "#{package_name}#{ext}"
-        if File.exist?(full_path) && !File.directory?(full_path)
-          result << full_path
-          return result unless options[:show_all]
-        end
-      end
-    end
-
-    result
-  end
-
-  def usage # :nodoc:
-    "#{program_name} FILE [FILE ...]"
-  end
-end

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../local_remote_options"
-require_relative "../version_option"
-require_relative "../gemcutter_utilities"
-
-class Gem::Commands::YankCommand < Gem::Command
-  include Gem::LocalRemoteOptions
-  include Gem::VersionOption
-  include Gem::GemcutterUtilities
-
-  def description # :nodoc:
-    <<-EOF
-The yank command permanently removes a gem you pushed to a server.
-
-Once you have pushed a gem several downloads will happen automatically
-via the webhooks. If you accidentally pushed passwords or other sensitive
-data you will need to change them immediately and yank your gem.
-    EOF
-  end
-
-  def arguments # :nodoc:
-    "GEM       name of gem"
-  end
-
-  def usage # :nodoc:
-    "#{program_name} -v VERSION [-p PLATFORM] [--key KEY_NAME] [--host HOST] GEM"
-  end
-
-  def initialize
-    super "yank", "Remove a pushed gem from the index"
-
-    add_version_option("remove")
-    add_platform_option("remove")
-    add_otp_option
-
-    add_option("--host HOST",
-               "Yank from another gemcutter-compatible host",
-               "  (e.g. https://rubygems.org)") do |value, options|
-      options[:host] = value
-    end
-
-    add_key_option
-    @host = nil
-  end
-
-  def execute
-    @host = options[:host]
-
-    sign_in @host, scope: get_yank_scope
-
-    version   = get_version_from_requirements(options[:version])
-    platform  = get_platform_from_requirements(options)
-
-    if version
-      yank_gem(version, platform)
-    else
-      say "A version argument is required: #{usage}"
-      terminate_interaction
-    end
-  end
-
-  def yank_gem(version, platform)
-    say "Yanking gem from #{host}..."
-    args = [:delete, version, platform, "api/v1/gems/yank"]
-    response = yank_api_request(*args)
-
-    say response.body
-  end
-
-  private
-
-  def yank_api_request(method, version, platform, api)
-    name = get_one_gem_name
-    response = rubygems_api_request(method, api, host, scope: get_yank_scope) do |request|
-      request.add_field("Authorization", api_key)
-
-      data = {
-        "gem_name" => name,
-        "version" => version,
-      }
-      data["platform"] = platform if platform
-
-      request.set_form_data data
-    end
-    response
-  end
-
-  def get_version_from_requirements(requirements)
-    requirements.requirements.first[1].version
-  rescue StandardError
-    nil
-  end
-
-  def get_yank_scope
-    :yank_rubygem
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-#--
-# This file contains all sorts of little compatibility hacks that we've
-# had to introduce over the years. Quarantining them into one file helps
-# us know when we can get rid of them.
-#
-# Ruby 1.9.x has introduced some things that are awkward, and we need to
-# support them, so we define some constants to use later.
-#
-# TODO remove at RubyGems 4
-#++
-
-module Gem
-  # :stopdoc:
-
-  RubyGemsVersion = VERSION
-  deprecate_constant(:RubyGemsVersion)
-
-  RbConfigPriorities = %w[
-    MAJOR
-    MINOR
-    TEENY
-    EXEEXT RUBY_SO_NAME arch bindir datadir libdir ruby_install_name
-    ruby_version rubylibprefix sitedir sitelibdir vendordir vendorlibdir
-    rubylibdir
-  ].freeze
-
-  if defined?(ConfigMap)
-    RbConfigPriorities.each do |key|
-      ConfigMap[key.to_sym] = RbConfig::CONFIG[key]
-    end
-  else
-    ##
-    # Configuration settings from ::RbConfig
-    ConfigMap = Hash.new do |cm, key|
-      cm[key] = RbConfig::CONFIG[key.to_s]
-    end
-    deprecate_constant(:ConfigMap)
-  end
-end