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

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

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../query_utils"
-
-##
-# Searches for gems starting with the supplied argument.
-
-class Gem::Commands::ListCommand < Gem::Command
-  include Gem::QueryUtils
-
-  def initialize
-    super "list", "Display local gems whose name matches REGEXP",
-         domain: :local, details: false, versions: true,
-         installed: nil, version: Gem::Requirement.default
-
-    add_query_options
-  end
-
-  def arguments # :nodoc:
-    "REGEXP        regexp to look for in gem name"
-  end
-
-  def defaults_str # :nodoc:
-    "--local --no-details"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The list command is used to view the gems you have installed locally.
-
-The --details option displays additional details including the summary, the
-homepage, the author, the locations of different versions of the gem.
-
-To search for remote gems use the search command.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} [REGEXP ...]"
-  end
-end

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

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-
-class Gem::Commands::LockCommand < Gem::Command
-  def initialize
-    super "lock", "Generate a lockdown list of gems",
-          strict: false
-
-    add_option "-s", "--[no-]strict",
-               "fail if unable to satisfy a dependency" do |strict, options|
-      options[:strict] = strict
-    end
-  end
-
-  def arguments # :nodoc:
-    "GEMNAME       name of gem to lock\nVERSION       version of gem to lock"
-  end
-
-  def defaults_str # :nodoc:
-    "--no-strict"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The lock command will generate a list of +gem+ statements that will lock down
-the versions for the gem given in the command line.  It will specify exact
-versions in the requirements list to ensure that the gems loaded will always
-be consistent.  A full recursive search of all effected gems will be
-generated.
-
-Example:
-
-  gem lock rails-1.0.0 > lockdown.rb
-
-will produce in lockdown.rb:
-
-  require "rubygems"
-  gem 'rails', '= 1.0.0'
-  gem 'rake', '= 0.7.0.1'
-  gem 'activesupport', '= 1.2.5'
-  gem 'activerecord', '= 1.13.2'
-  gem 'actionpack', '= 1.11.2'
-  gem 'actionmailer', '= 1.1.5'
-  gem 'actionwebservice', '= 1.0.0'
-
-Just load lockdown.rb from your application to ensure that the current
-versions are loaded.  Make sure that lockdown.rb is loaded *before* any
-other require statements.
-
-Notice that rails 1.0.0 only requires that rake 0.6.2 or better be used.
-Rake-0.7.0.1 is the most recent version installed that satisfies that, so we
-lock it down to the exact version.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} GEMNAME-VERSION [GEMNAME-VERSION ...]"
-  end
-
-  def complain(message)
-    if options[:strict]
-      raise Gem::Exception, message
-    else
-      say "# #{message}"
-    end
-  end
-
-  def execute
-    say "require 'rubygems'"
-
-    locked = {}
-
-    pending = options[:args]
-
-    until pending.empty? do
-      full_name = pending.shift
-
-      spec = Gem::Specification.load spec_path(full_name)
-
-      if spec.nil?
-        complain "Could not find gem #{full_name}, try using the full name"
-        next
-      end
-
-      say "gem '#{spec.name}', '= #{spec.version}'" unless locked[spec.name]
-      locked[spec.name] = true
-
-      spec.runtime_dependencies.each do |dep|
-        next if locked[dep.name]
-        candidates = dep.matching_specs
-
-        if candidates.empty?
-          complain "Unable to satisfy '#{dep}' from currently installed gems"
-        else
-          pending << candidates.last.full_name
-        end
-      end
-    end
-  end
-
-  def spec_path(gem_full_name)
-    gemspecs = Gem.path.map do |path|
-      File.join path, "specifications", "#{gem_full_name}.gemspec"
-    end
-
-    gemspecs.find {|path| File.exist? path }
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-
-unless defined? Gem::Commands::MirrorCommand
-  class Gem::Commands::MirrorCommand < Gem::Command
-    def initialize
-      super("mirror", "Mirror all gem files (requires rubygems-mirror)")
-      begin
-        Gem::Specification.find_by_name("rubygems-mirror").activate
-      rescue Gem::LoadError
-        # no-op
-      end
-    end
-
-    def description # :nodoc:
-      <<-EOF
-The mirror command has been moved to the rubygems-mirror gem.
-      EOF
-    end
-
-    def execute
-      alert_error "Install the rubygems-mirror gem for the mirror command"
-    end
-  end
-end

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

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../version_option"
-
-class Gem::Commands::OpenCommand < Gem::Command
-  include Gem::VersionOption
-
-  def initialize
-    super "open", "Open gem sources in editor"
-
-    add_option("-e", "--editor COMMAND", String,
-               "Prepends COMMAND to gem path. Could be used to specify editor.") do |command, options|
-      options[:editor] = command || get_env_editor
-    end
-    add_option("-v", "--version VERSION", String,
-               "Opens specific gem version") do |version|
-      options[:version] = version
-    end
-  end
-
-  def arguments # :nodoc:
-    "GEMNAME     name of gem to open in editor"
-  end
-
-  def defaults_str # :nodoc:
-    "-e #{get_env_editor}"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-        The open command opens gem in editor and changes current path
-        to gem's source directory.
-        Editor command can be specified with -e option, otherwise rubygems
-        will look for editor in $EDITOR, $VISUAL and $GEM_EDITOR variables.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} [-e COMMAND] GEMNAME"
-  end
-
-  def get_env_editor
-    ENV["GEM_EDITOR"] ||
-      ENV["VISUAL"] ||
-      ENV["EDITOR"] ||
-      "vi"
-  end
-
-  def execute
-    @version = options[:version] || Gem::Requirement.default
-    @editor  = options[:editor] || get_env_editor
-
-    found = open_gem(get_one_gem_name)
-
-    terminate_interaction 1 unless found
-  end
-
-  def open_gem(name)
-    spec = spec_for name
-
-    return false unless spec
-
-    if spec.default_gem?
-      say "'#{name}' is a default gem and can't be opened."
-      return false
-    end
-
-    open_editor(spec.full_gem_path)
-  end
-
-  def open_editor(path)
-    system(*@editor.split(/\s+/) + [path], { chdir: path })
-  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}'"
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../local_remote_options"
-require_relative "../spec_fetcher"
-require_relative "../version_option"
-
-class Gem::Commands::OutdatedCommand < Gem::Command
-  include Gem::LocalRemoteOptions
-  include Gem::VersionOption
-
-  def initialize
-    super "outdated", "Display all gems that need updates"
-
-    add_local_remote_options
-    add_platform_option
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The outdated command lists gems you may wish to upgrade to a newer version.
-
-You can check for dependency mismatches using the dependency command and
-update the gems with the update or install commands.
-    EOF
-  end
-
-  def execute
-    Gem::Specification.outdated_and_latest_version.each do |spec, remote_version|
-      say "#{spec.name} (#{spec.version} < #{remote_version})"
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../local_remote_options"
-require_relative "../gemcutter_utilities"
-require_relative "../text"
-
-class Gem::Commands::OwnerCommand < Gem::Command
-  include Gem::Text
-  include Gem::LocalRemoteOptions
-  include Gem::GemcutterUtilities
-
-  def description # :nodoc:
-    <<-EOF
-The owner command lets you add and remove owners of a gem on a push
-server (the default is https://rubygems.org). Multiple owners can be
-added or removed at the same time, if the flag is given multiple times.
-
-The supported user identifiers are dependent on the push server.
-For rubygems.org, both e-mail and handle are supported, even though the
-user identifier field is called "email".
-
-The owner of a gem has the permission to push new versions, yank existing
-versions or edit the HTML page of the gem.  Be careful of who you give push
-permission to.
-    EOF
-  end
-
-  def arguments # :nodoc:
-    "GEM       gem to manage owners for"
-  end
-
-  def usage # :nodoc:
-    "#{program_name} GEM"
-  end
-
-  def initialize
-    super "owner", "Manage gem owners of a gem on the push server"
-    add_proxy_option
-    add_key_option
-    add_otp_option
-    defaults.merge! add: [], remove: []
-
-    add_option "-a", "--add NEW_OWNER", "Add an owner by user identifier" do |value, options|
-      options[:add] << value
-    end
-
-    add_option "-r", "--remove OLD_OWNER", "Remove an owner by user identifier" do |value, options|
-      options[:remove] << value
-    end
-
-    add_option "-h", "--host HOST",
-               "Use another gemcutter-compatible host",
-               "  (e.g. https://rubygems.org)" do |value, options|
-      options[:host] = value
-    end
-  end
-
-  def execute
-    @host = options[:host]
-
-    sign_in(scope: get_owner_scope)
-    name = get_one_gem_name
-
-    add_owners    name, options[:add]
-    remove_owners name, options[:remove]
-    show_owners   name
-  end
-
-  def show_owners(name)
-    Gem.load_yaml
-
-    response = rubygems_api_request :get, "api/v1/gems/#{name}/owners.yaml" do |request|
-      request.add_field "Authorization", api_key
-    end
-
-    with_response response do |resp|
-      owners = Gem::SafeYAML.load clean_text(resp.body)
-
-      say "Owners for gem: #{name}"
-      owners.each do |owner|
-        say "- #{owner["email"] || owner["handle"] || owner["id"]}"
-      end
-    end
-  end
-
-  def add_owners(name, owners)
-    manage_owners :post, name, owners
-  end
-
-  def remove_owners(name, owners)
-    manage_owners :delete, name, owners
-  end
-
-  def manage_owners(method, name, owners)
-    owners.each do |owner|
-      response = send_owner_request(method, name, owner)
-      action = method == :delete ? "Removing" : "Adding"
-
-      with_response response, "#{action} #{owner}"
-    rescue Gem::WebauthnVerificationError => e
-      raise e
-    rescue StandardError
-      # ignore early exits to allow for completing the iteration of all owners
-    end
-  end
-
-  private
-
-  def send_owner_request(method, name, owner)
-    rubygems_api_request method, "api/v1/gems/#{name}/owners", scope: get_owner_scope(method: method) do |request|
-      request.set_form_data "email" => owner
-      request.add_field "Authorization", api_key
-    end
-  end
-
-  def get_owner_scope(method: nil)
-    if method == :post || options.any? && options[:add].any?
-      :add_owner
-    elsif method == :delete || options.any? && options[:remove].any?
-      :remove_owner
-    end
-  end
-end

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

@@ -1,217 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../command"
-require_relative "../package"
-require_relative "../installer"
-require_relative "../version_option"
-
-class Gem::Commands::PristineCommand < Gem::Command
-  include Gem::VersionOption
-
-  def initialize
-    super "pristine",
-          "Restores installed gems to pristine condition from files located in the gem cache",
-          version: Gem::Requirement.default,
-          extensions: true,
-          extensions_set: false,
-          all: false
-
-    add_option("--all",
-               "Restore all installed gems to pristine",
-               "condition") do |value, options|
-      options[:all] = value
-    end
-
-    add_option("--skip=gem_name",
-               "used on --all, skip if name == gem_name") do |value, options|
-      options[:skip] ||= []
-      options[:skip] << value
-    end
-
-    add_option("--[no-]extensions",
-               "Restore gems with extensions",
-               "in addition to regular gems") do |value, options|
-      options[:extensions_set] = true
-      options[:extensions]     = value
-    end
-
-    add_option("--only-missing-extensions",
-               "Only restore gems with missing extensions") do |value, options|
-      options[:only_missing_extensions] = value
-    end
-
-    add_option("--only-executables",
-               "Only restore executables") do |value, options|
-      options[:only_executables] = value
-    end
-
-    add_option("--only-plugins",
-               "Only restore plugins") do |value, options|
-      options[:only_plugins] = value
-    end
-
-    add_option("-E", "--[no-]env-shebang",
-               "Rewrite executables with a shebang",
-               "of /usr/bin/env") do |value, options|
-      options[:env_shebang] = value
-    end
-
-    add_option("-i", "--install-dir DIR",
-               "Gem repository to get gems restored") do |value, options|
-      options[:install_dir] = File.expand_path(value)
-    end
-
-    add_option("-n", "--bindir DIR",
-               "Directory where executables are",
-               "located") do |value, options|
-      options[:bin_dir] = File.expand_path(value)
-    end
-
-    add_version_option("restore to", "pristine condition")
-  end
-
-  def arguments # :nodoc:
-    "GEMNAME       gem to restore to pristine condition (unless --all)"
-  end
-
-  def defaults_str # :nodoc:
-    "--extensions"
-  end
-
-  def description # :nodoc:
-    <<-EOF
-The pristine command compares an installed gem with the contents of its
-cached .gem file and restores any files that don't match the cached .gem's
-copy.
-
-If you have made modifications to an installed gem, the pristine command
-will revert them.  All extensions are rebuilt and all bin stubs for the gem
-are regenerated after checking for modifications.
-
-If the cached gem cannot be found it will be downloaded.
-
-If --no-extensions is provided pristine will not attempt to restore a gem
-with an extension.
-
-If --extensions is given (but not --all or gem names) only gems with
-extensions will be restored.
-    EOF
-  end
-
-  def usage # :nodoc:
-    "#{program_name} [GEMNAME ...]"
-  end
-
-  def execute
-    install_dir = options[:install_dir]
-
-    specification_record = install_dir ? Gem::SpecificationRecord.from_path(install_dir) : Gem::Specification.specification_record
-
-    specs = if options[:all]
-      specification_record.map
-
-    # `--extensions` must be explicitly given to pristine only gems
-    # with extensions.
-    elsif options[:extensions_set] &&
-          options[:extensions] && options[:args].empty?
-      specification_record.select do |spec|
-        spec.extensions && !spec.extensions.empty?
-      end
-    elsif options[:only_missing_extensions]
-      specification_record.select(&:missing_extensions?)
-    else
-      get_all_gem_names.sort.flat_map do |gem_name|
-        specification_record.find_all_by_name(gem_name, options[:version]).reverse
-      end
-    end
-
-    specs = specs.select {|spec| spec.platform == RUBY_ENGINE || Gem::Platform.local === spec.platform || spec.platform == Gem::Platform::RUBY }
-
-    if specs.to_a.empty?
-      raise Gem::Exception,
-            "Failed to find gems #{options[:args]} #{options[:version]}"
-    end
-
-    say "Restoring gems to pristine condition..."
-
-    specs.group_by(&:full_name_with_location).values.each do |grouped_specs|
-      spec = grouped_specs.find {|s| !s.default_gem? } || grouped_specs.first
-
-      unless only_executables_or_plugins?
-        # Default gemspecs include changes provided by ruby-core installer that
-        # can't currently be pristined (inclusion of compiled extension targets in
-        # the file list). So stick to resetting executables if it's a default gem.
-        options[:only_executables] = true if spec.default_gem?
-      end
-
-      if options.key? :skip
-        if options[:skip].include? spec.name
-          say "Skipped #{spec.full_name}, it was given through options"
-          next
-        end
-      end
-
-      unless spec.extensions.empty? || options[:extensions] || only_executables_or_plugins?
-        say "Skipped #{spec.full_name_with_location}, it needs to compile an extension"
-        next
-      end
-
-      gem = spec.cache_file
-
-      unless File.exist?(gem) || only_executables_or_plugins?
-        require_relative "../remote_fetcher"
-
-        say "Cached gem for #{spec.full_name_with_location} not found, attempting to fetch..."
-
-        dep = Gem::Dependency.new spec.name, spec.version
-        found, _ = Gem::SpecFetcher.fetcher.spec_for_dependency dep
-
-        if found.empty?
-          say "Skipped #{spec.full_name}, it was not found from cache and remote sources"
-          next
-        end
-
-        spec_candidate, source = found.first
-        Gem::RemoteFetcher.fetcher.download spec_candidate, source.uri.to_s, spec.base_dir
-      end
-
-      env_shebang =
-        if options.include? :env_shebang
-          options[:env_shebang]
-        else
-          install_defaults = Gem::ConfigFile::PLATFORM_DEFAULTS["install"]
-          install_defaults.to_s["--env-shebang"]
-        end
-
-      bin_dir = options[:bin_dir] if options[:bin_dir]
-
-      installer_options = {
-        wrappers: true,
-        force: true,
-        install_dir: install_dir || spec.base_dir,
-        env_shebang: env_shebang,
-        build_args: spec.build_args,
-        bin_dir: bin_dir,
-      }
-
-      if options[:only_executables]
-        installer = Gem::Installer.for_spec(spec, installer_options)
-        installer.generate_bin
-      elsif options[:only_plugins]
-        installer = Gem::Installer.for_spec(spec, installer_options)
-        installer.generate_plugins
-      else
-        installer = Gem::Installer.at(gem, installer_options)
-        installer.install
-      end
-
-      say "Restored #{spec.full_name_with_location}"
-    end
-  end
-
-  private
-
-  def only_executables_or_plugins?
-    options[:only_executables] || options[:only_plugins]
-  end
-end