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

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

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-
-class Gem::Commands::EnvironmentCommand < Gem::Command
-  def initialize
-    super "environment", "Display information about the RubyGems environment"
-  end
-
-  def arguments # :nodoc:
-    args = <<-EOF
-          home            display the path where gems are installed. Aliases: gemhome, gemdir, GEM_HOME
-          path            display path used to search for gems. Aliases: gempath, GEM_PATH
-          user_gemhome    display the path where gems are installed when `--user-install` is given. Aliases: user_gemdir
-          version         display the gem format version
-          remotesources   display the remote gem servers
-          platform        display the supported gem platforms
-          credentials     display the path where credentials are stored
-          <omitted>       display everything
-    EOF
-    args.gsub(/^\s+/, "")
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The environment command lets you query rubygems for its configuration for
-use in shell scripts or as a debugging aid.
-
-The RubyGems environment can be controlled through command line arguments,
-gemrc files, environment variables and built-in defaults.
-
-Command line argument defaults and some RubyGems defaults can be set in a
-~/.gemrc file for individual users and a gemrc in the SYSTEM CONFIGURATION
-DIRECTORY for all users. These files are YAML files with the following YAML
-keys:
-
-  :sources: A YAML array of remote gem repositories to install gems from
-  :verbose: Verbosity of the gem command. false, true, and :really are the
-            levels
-  :update_sources: Enable/disable automatic updating of repository metadata
-  :backtrace: Print backtrace when RubyGems encounters an error
-  :gempath: The paths in which to look for gems
-  :disable_default_gem_server: Force specification of gem server host on push
-  <gem_command>: A string containing arguments for the specified gem command
-
-Example:
-
-  :verbose: false
-  install: --no-wrappers
-  update: --no-wrappers
-  :disable_default_gem_server: true
-
-RubyGems' default local repository can be overridden with the GEM_PATH and
-GEM_HOME environment variables. GEM_HOME sets the default repository to
-install into. GEM_PATH allows multiple local repositories to be searched for
-gems.
-
-If you are behind a proxy server, RubyGems uses the HTTP_PROXY,
-HTTP_PROXY_USER and HTTP_PROXY_PASS environment variables to discover the
-proxy server.
-
-If you would like to push gems to a private gem server the RUBYGEMS_HOST
-environment variable can be set to the URI for that server.
-
-If you are packaging RubyGems all of RubyGems' defaults are in
-lib/rubygems/defaults.rb.  You may override these in
-lib/rubygems/defaults/operating_system.rb
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} [arg]"
-  end
-
-  def execute
-    out = String.new
-    arg = options[:args][0]
-    out <<
-      case arg
-      when /^version/ then
-        Gem::VERSION
-      when /^gemdir/, /^gemhome/, /^home/, /^GEM_HOME/ then
-        Gem.dir
-      when /^gempath/, /^path/, /^GEM_PATH/ then
-        Gem.path.join(File::PATH_SEPARATOR)
-      when /^user_gemdir/, /^user_gemhome/ then
-        Gem.user_dir
-      when /^remotesources/ then
-        Gem.sources.to_a.join("\n")
-      when /^platform/ then
-        Gem.platforms.join(File::PATH_SEPARATOR)
-      when /^credentials/, /^creds/ then
-        Gem.configuration.credentials_path
-      when nil then
-        show_environment
-      else
-        raise Gem::CommandLineError, "Unknown environment option [#{arg}]"
-      end
-    say out
-    true
-  end
-
-  def add_path(out, path)
-    path.each do |component|
-      out << "     - #{component}\n"
-    end
-  end
-
-  def show_environment # :nodoc:
-    out = "RubyGems Environment:\n".dup
-
-    out << "  - RUBYGEMS VERSION: #{Gem::VERSION}\n"
-
-    out << "  - RUBY VERSION: #{RUBY_VERSION} (#{RUBY_RELEASE_DATE} patchlevel #{RUBY_PATCHLEVEL}) [#{RUBY_PLATFORM}]\n"
-
-    out << "  - INSTALLATION DIRECTORY: #{Gem.dir}\n"
-
-    out << "  - USER INSTALLATION DIRECTORY: #{Gem.user_dir}\n"
-
-    out << "  - CREDENTIALS FILE: #{Gem.configuration.credentials_path}\n"
-
-    out << "  - RUBYGEMS PREFIX: #{Gem.prefix}\n" unless Gem.prefix.nil?
-
-    out << "  - RUBY EXECUTABLE: #{Gem.ruby}\n"
-
-    out << "  - GIT EXECUTABLE: #{git_path}\n"
-
-    out << "  - EXECUTABLE DIRECTORY: #{Gem.bindir}\n"
-
-    out << "  - SPEC CACHE DIRECTORY: #{Gem.spec_cache_dir}\n"
-
-    out << "  - SYSTEM CONFIGURATION DIRECTORY: #{Gem::ConfigFile::SYSTEM_CONFIG_PATH}\n"
-
-    out << "  - RUBYGEMS PLATFORMS:\n"
-    Gem.platforms.each do |platform|
-      out << "     - #{platform}\n"
-    end
-
-    out << "  - GEM PATHS:\n"
-    out << "     - #{Gem.dir}\n"
-
-    gem_path = Gem.path.dup
-    gem_path.delete Gem.dir
-    add_path out, gem_path
-
-    out << "  - GEM CONFIGURATION:\n"
-    Gem.configuration.each do |name, value|
-      value = value.gsub(/./, "*") if name == "gemcutter_key"
-      out << "     - #{name.inspect} => #{value.inspect}\n"
-    end
-
-    out << "  - REMOTE SOURCES:\n"
-    Gem.sources.each do |s|
-      out << "     - #{s}\n"
-    end
-
-    out << "  - SHELL PATH:\n"
-
-    shell_path = ENV["PATH"].split(File::PATH_SEPARATOR)
-    add_path out, shell_path
-
-    out
-  end
-
-  private
-
-  ##
-  # Git binary path
-
-  def git_path
-    exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
-    ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
-      exts.each do |ext|
-        exe = File.join(path, "git#{ext}")
-        return exe if File.executable?(exe) && !File.directory?(exe)
-      end
-    end
-
-    nil
-  end
-end

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

@@ -1,256 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../dependency_installer"
-require_relative "../gem_runner"
-require_relative "../package"
-require_relative "../version_option"
-
-class Gem::Commands::ExecCommand < Gem::Command
-  include Gem::VersionOption
-
-  def initialize
-    super "exec", "Run a command from a gem", {
-      version: Gem::Requirement.default,
-    }
-
-    add_version_option
-    add_prerelease_option "to be installed"
-
-    add_option "-g", "--gem GEM", "run the executable from the given gem" do |value, options|
-      options[:gem_name] = value
-    end
-
-    add_option(:"Install/Update", "--conservative",
-      "Prefer the most recent installed version, ",
-      "rather than the latest version overall") do |_value, options|
-      options[:conservative] = true
-    end
-  end
-
-  def arguments # :nodoc:
-    "COMMAND  the executable command to run"
-  end
-
-  def defaults_str # :nodoc:
-    "--version '#{Gem::Requirement.default}'"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The exec command handles installing (if necessary) and running an executable
-from a gem, regardless of whether that gem is currently installed.
-
-The exec command can be thought of as a shortcut to running `gem install` and
-then the executable from the installed gem.
-
-For example, `gem exec rails new .` will run `rails new .` in the current
-directory, without having to manually run `gem install rails`.
-Additionally, the exec command ensures the most recent version of the gem
-is used (unless run with `--conservative`), and that the gem is not installed
-to the same gem path as user-installed gems.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} [options --] COMMAND [args]"
-  end
-
-  def execute
-    check_executable
-
-    print_command
-    if options[:gem_name] == "gem" && options[:executable] == "gem"
-      set_gem_exec_install_paths
-      Gem::GemRunner.new.run options[:args]
-      return
-    elsif options[:conservative]
-      install_if_needed
-    else
-      install
-      activate!
-    end
-
-    load!
-  end
-
-  private
-
-  def handle_options(args)
-    args = add_extra_args(args)
-    check_deprecated_options(args)
-    @options = Marshal.load Marshal.dump @defaults # deep copy
-    parser.order!(args) do |v|
-      # put the non-option back at the front of the list of arguments
-      args.unshift(v)
-
-      # stop parsing once we hit the first non-option,
-      # so you can call `gem exec rails --version` and it prints the rails
-      # version rather than rubygem's
-      break
-    end
-    @options[:args] = args
-
-    options[:executable], gem_version = extract_gem_name_and_version(options[:args].shift)
-    options[:gem_name] ||= options[:executable]
-
-    if gem_version
-      if options[:version].none?
-        options[:version] = Gem::Requirement.new(gem_version)
-      else
-        options[:version].concat [gem_version]
-      end
-    end
-
-    if options[:prerelease] && !options[:version].prerelease?
-      if options[:version].none?
-        options[:version] = Gem::Requirement.default_prerelease
-      else
-        options[:version].concat [Gem::Requirement.default_prerelease]
-      end
-    end
-  end
-
-  def check_executable
-    if options[:executable].nil?
-      raise Gem::CommandLineError,
-        "Please specify an executable to run (e.g. #{program_name} COMMAND)"
-    end
-  end
-
-  def print_command
-    verbose "running #{program_name} with:\n"
-    opts = options.reject {|_, v| v.nil? || Array(v).empty? }
-    max_length = opts.map {|k, _| k.size }.max
-    opts.each do |k, v|
-      next if v.nil?
-      verbose "\t#{k.to_s.rjust(max_length)}: #{v}"
-    end
-    verbose ""
-  end
-
-  def install_if_needed
-    activate!
-  rescue Gem::MissingSpecError
-    verbose "#{Gem::Dependency.new(options[:gem_name], options[:version])} not available locally, installing from remote"
-    install
-    activate!
-  end
-
-  def set_gem_exec_install_paths
-    home = Gem.dir
-
-    ENV["GEM_PATH"] = ([home] + Gem.path).join(File::PATH_SEPARATOR)
-    ENV["GEM_HOME"] = home
-    Gem.clear_paths
-  end
-
-  def install
-    set_gem_exec_install_paths
-
-    gem_name = options[:gem_name]
-    gem_version = options[:version]
-
-    install_options = options.merge(
-      minimal_deps: false,
-      wrappers: true
-    )
-
-    suppress_always_install do
-      dep_installer = Gem::DependencyInstaller.new install_options
-
-      request_set = dep_installer.resolve_dependencies gem_name, gem_version
-
-      verbose "Gems to install:"
-      request_set.sorted_requests.each do |activation_request|
-        verbose "\t#{activation_request.full_name}"
-      end
-
-      request_set.install install_options
-    end
-
-    Gem::Specification.reset
-  rescue Gem::InstallError => e
-    alert_error "Error installing #{gem_name}:\n\t#{e.message}"
-    terminate_interaction 1
-  rescue Gem::GemNotFoundException => e
-    show_lookup_failure e.name, e.version, e.errors, false
-
-    terminate_interaction 2
-  rescue Gem::UnsatisfiableDependencyError => e
-    show_lookup_failure e.name, e.version, e.errors, false,
-                        "'#{gem_name}' (#{gem_version})"
-
-    terminate_interaction 2
-  end
-
-  def activate!
-    gem(options[:gem_name], options[:version])
-    Gem.finish_resolve
-
-    verbose "activated #{options[:gem_name]} (#{Gem.loaded_specs[options[:gem_name]].version})"
-  end
-
-  def load!
-    argv = ARGV.clone
-    ARGV.replace options[:args]
-
-    executable = options[:executable]
-
-    contains_executable = Gem.loaded_specs.values.select do |spec|
-      spec.executables.include?(executable)
-    end
-
-    if contains_executable.any? {|s| s.name == executable }
-      contains_executable.select! {|s| s.name == executable }
-    end
-
-    if contains_executable.empty?
-      spec = Gem.loaded_specs[executable]
-
-      if spec.nil? || spec.executables.empty?
-        alert_error "Failed to load executable `#{executable}`," \
-              " are you sure the gem `#{options[:gem_name]}` contains it?"
-        terminate_interaction 1
-      end
-
-      if spec.executables.size > 1
-        alert_error "Ambiguous which executable from gem `#{executable}` should be run: " \
-              "the options are #{spec.executables.sort}, specify one via COMMAND, and use `-g` and `-v` to specify gem and version"
-        terminate_interaction 1
-      end
-
-      contains_executable << spec
-      executable = spec.executable
-    end
-
-    if contains_executable.size > 1
-      alert_error "Ambiguous which gem `#{executable}` should come from: " \
-            "the options are #{contains_executable.map(&:name)}, " \
-            "specify one via `-g`"
-      terminate_interaction 1
-    end
-
-    old_exe = $0
-    $0 = executable
-    load Gem.activate_bin_path(contains_executable.first.name, executable, ">= 0.a")
-  ensure
-    $0 = old_exe if old_exe
-    ARGV.replace argv
-  end
-
-  def suppress_always_install
-    name = :always_install
-    cls = ::Gem::Resolver::InstallerSet
-    method = cls.instance_method(name)
-    cls.remove_method(name)
-    cls.define_method(name) { [] }
-
-    begin
-      yield
-    ensure
-      cls.remove_method(name)
-      cls.define_method(name, method)
-    end
-  end
-end

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

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../local_remote_options"
-require_relative "../version_option"
-
-class Gem::Commands::FetchCommand < Gem::Command
-  include Gem::LocalRemoteOptions
-  include Gem::VersionOption
-
-  def initialize
-    defaults = {
-      suggest_alternate: true,
-      version: Gem::Requirement.default,
-    }
-
-    super "fetch", "Download a gem and place it in the current directory", defaults
-
-    add_bulk_threshold_option
-    add_proxy_option
-    add_source_option
-    add_clear_sources_option
-
-    add_version_option
-    add_platform_option
-    add_prerelease_option
-
-    add_option "--[no-]suggestions", "Suggest alternates when gems are not found" do |value, options|
-      options[:suggest_alternate] = value
-    end
-  end
-
-  def arguments # :nodoc:
-    "GEMNAME       name of gem to download"
-  end
-
-  def defaults_str # :nodoc:
-    "--version '#{Gem::Requirement.default}'"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The fetch command fetches gem files that can be stored for later use or
-unpacked to examine their contents.
-
-See the build command help for an example of unpacking a gem, modifying it,
-then repackaging it.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} GEMNAME [GEMNAME ...]"
-  end
-
-  def check_version # :nodoc:
-    if options[:version] != Gem::Requirement.default &&
-       get_all_gem_names.size > 1
-      alert_error "Can't use --version with multiple gems. You can specify multiple gems with" \
-                  " version requirements using `gem fetch 'my_gem:1.0.0' 'my_other_gem:~>2.0.0'`"
-      terminate_interaction 1
-    end
-  end
-
-  def execute
-    check_version
-
-    exit_code = fetch_gems
-
-    terminate_interaction exit_code
-  end
-
-  private
-
-  def fetch_gems
-    exit_code = 0
-
-    version = options[:version]
-
-    platform  = Gem.platforms.last
-    gem_names = get_all_gem_names_and_versions
-
-    gem_names.each do |gem_name, gem_version|
-      gem_version ||= version
-      dep = Gem::Dependency.new gem_name, gem_version
-      dep.prerelease = options[:prerelease]
-      suppress_suggestions = !options[:suggest_alternate]
-
-      specs_and_sources, errors =
-        Gem::SpecFetcher.fetcher.spec_for_dependency dep
-
-      if platform
-        filtered = specs_and_sources.select {|s,| s.platform == platform }
-        specs_and_sources = filtered unless filtered.empty?
-      end
-
-      spec, source = specs_and_sources.max_by {|s,| s }
-
-      if spec.nil?
-        show_lookup_failure gem_name, gem_version, errors, suppress_suggestions, options[:domain]
-        exit_code |= 2
-        next
-      end
-      source.download spec
-      say "Downloaded #{spec.full_name}"
-    end
-
-    exit_code
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-
-unless defined? Gem::Commands::GenerateIndexCommand
-  class Gem::Commands::GenerateIndexCommand < Gem::Command
-    module RubygemsTrampoline
-      def description # :nodoc:
-        <<~EOF
-          The generate_index command has been moved to the rubygems-generate_index gem.
-        EOF
-      end
-
-      def execute
-        alert_error "Install the rubygems-generate_index gem for the generate_index command"
-      end
-
-      def invoke_with_build_args(args, build_args)
-        name = "rubygems-generate_index"
-        spec = begin
-          Gem::Specification.find_by_name(name)
-        rescue Gem::LoadError
-          require "rubygems/dependency_installer"
-          Gem.install(name, Gem::Requirement.default, Gem::DependencyInstaller::DEFAULT_OPTIONS).find {|s| s.name == name }
-        end
-
-        # remove the methods defined in this file so that the methods defined in the gem are used instead,
-        # and without a method redefinition warning
-        %w[description execute invoke_with_build_args].each do |method|
-          RubygemsTrampoline.remove_method(method)
-        end
-        self.class.singleton_class.remove_method(:new)
-
-        spec.activate
-        Gem.load_plugin_files spec.matches_for_glob("rubygems_plugin#{Gem.suffix_pattern}")
-
-        self.class.new.invoke_with_build_args(args, build_args)
-      end
-    end
-    private_constant :RubygemsTrampoline
-
-    # remove_method(:initialize) warns, but removing new does not warn
-    def self.new
-      command = allocate
-      command.send(:initialize, "generate_index", "Generates the index files for a gem server directory (requires rubygems-generate_index)")
-      command
-    end
-
-    prepend(RubygemsTrampoline)
-  end
-end