# See LICENSE.txt for permissions.

#++

module Gem

VERSION = "3.4.0.dev".freeze

end

# Must be first since it unloads the prelude from 1.9.2

##

# RubyGems is the Ruby standard for publishing and managing third party

# Taint support is deprecated in Ruby 2.7.

# This allows switching ".untaint" to ".tap(&Gem::UNTAINT)",

# to avoid deprecation warnings in Ruby 2.7.

# When https://bugs.ruby-lang.org/issues/17259 is available, there is no need to override Kernel#warn

KERNEL_WARN_IGNORES_INTERNAL_ENTRIES = RUBY_ENGINE == "truffleruby" ||

##

# An Array of Regexps that match windows Ruby platforms.

# The mode needed to read a file as straight binary.

def self.binary_mode

end

##

# The path where gem executables are to be installed.

def self.bindir(install_dir=Gem.dir)

install_dir.to_s == Gem.default_dir.to_s

Gem.default_bindir

end

# The path were rubygems plugins are to be installed.

def self.plugindir(install_dir=Gem.dir)

end

##

# A Zlib::Deflate.deflate wrapper

def self.deflate(data)

Zlib::Deflate.deflate data

end

target = {}

env.each_pair do |k,v|

case k

case v

when nil, String

target[k] = v

subdir = File.join dir, name

next if File.exist? subdir

begin

FileUtils.mkdir_p subdir, **options

# distinction as extensions cannot be shared between the two.

def self.extension_api_version # :nodoc:

"#{ruby_api_version}-static"

else

ruby_api_version

return i if path.instance_variable_defined?(:@gem_prelude_index)

end

index || 0

end

def self.load_yaml

return if @yaml_loaded

@yaml_loaded = true

end

def self.prefix

prefix = File.dirname RUBYGEMS_DIR

prefix

end

end

# Safely read a file in binary mode on all platforms.

def self.read_binary(path)

io.read

end

rescue Errno::EACCES, Errno::EROFS

io.read

end

end

##

# Safely write a file in binary mode on all platforms.

def self.write_binary(path, data)

io.write data

end

end

# Returns a String containing the API compatibility version of Ruby

def self.ruby_api_version

end

def self.env_requirement(gem_name)

@env_requirements_by_name ||= {}

@env_requirements_by_name[gem_name] ||= begin

Gem::Requirement.create(req)

end

end

# Returns the latest release version of RubyGems.

def self.latest_rubygems_version

raise "Can't find 'rubygems-update' in any repo. Check `gem source list`."

end

# Suffixes for require-able paths.

def self.suffixes

*%w[DLEXT DLEXT2].map do |key|

val = RbConfig::CONFIG[key]

next unless val and not val.empty?

# Lazily loads DefaultUserInteraction and returns the default UI.

def self.ui

Gem::DefaultUserInteraction.ui

end

def self.win_platform?

if @@win_platform.nil?

@@win_platform = !!WIN_PATTERNS.find {|r| ruby_platform =~ r }

end

def self.use_gemdeps(path = nil)

raise_exception = path

return unless path

path = path.dup

end

ENV["BUNDLE_GEMFILE"] ||= File.expand_path(path)

require "bundler"

begin

Gem::DefaultUserInteraction.use_ui(ui) do

MARSHAL_SPEC_DIR = "quick/Marshal.#{Gem.marshal_version}/".freeze

end

# REFACTOR: This should be pulled out into some kind of hacks file.

begin

##

# Defaults the operating system (or packager) wants to provide for RubyGems.

rescue LoadError

# Ignored

rescue StandardError => e

# Loads the default specs.

Gem::Specification.load_defaults

# directory.

def gem_build_complete_path # :nodoc:

end

##

def extensions_dir

Gem.default_ext_dir_for(base_dir) ||

Gem.extension_api_version)

end

# See LICENSE.txt for permissions.

#++

##

# Base class for all Gem commands. When creating a new gem command, define

when Array

@extra_args = value

when String

end

end

def configure_options(header, option_list)

return if option_list.nil? or option_list.empty?

@parser.separator " #{header}Options:"

option_list.each do |args, handler|

end

end

end

##

# ----------------------------------------------------------------

# Add the options common to all commands.

options[:help] = true

end

# Set us to "really verbose" so the progress meter works

if Gem.configuration.verbose and value

Gem.configuration.verbose = 1

end

end

Gem.configuration.verbose = false

end

# commands. Both options are actually handled before the other

# options get parsed.

end

end

end

end

# :stopdoc:

# See LICENSE.txt for permissions.

#++

##

# The command manager registers and installs all the individual sub-commands

].freeze

ALIAS_COMMANDS = {

}.freeze

##

# Register all the subcommands supported by the gem command.

def initialize

@commands = {}

BUILTIN_COMMANDS.each do |name|

end

case args.first

say Gem::Command::HELP

terminate_interaction 0

say Gem::VERSION

terminate_interaction 0

when /^-/ then

# frozen_string_literal: true

class Gem::Commands::BuildCommand < Gem::Command

include Gem::VersionOption

def initialize

add_platform_option

options[:force] = true

end

options[:strict] = true

end

options[:output] = value

end

options[:build_path] = value

end

end

# frozen_string_literal: true

class Gem::Commands::CertCommand < Gem::Command

def initialize

:add => [], :remove => [], :list => [], :build => [], :sign => []

options[:add] << open_cert(cert_file)

end

options[:list] << filter

end

options[:remove] << filter

end

options[:build] << email_address

end

options[:issuer_cert] = open_cert(cert_file)

options[:issuer_cert_file] = cert_file

end

options[:key] = open_private_key(key_file)

end

options[:key_algorithm] = algorithm

end

raise Gem::OptionParser::InvalidArgument, "#{cert_file}: does not exist" unless

File.file? cert_file

options[:sign] << cert_file

end

options[:expiration_length_days] = days.to_i

end

options[:resign] = resign

end

end

def open_private_key(key_file)

check_openssl

key = OpenSSL::PKey.read File.read(key_file), passphrase

raise Gem::OptionParser::InvalidArgument,

"#{key_file}: private key not found" unless key.private?

def build_key # :nodoc:

return options[:key] if options[:key]

say "\n"

say "\n"

raise Gem::CommandLineError,

def load_default_key

key_file = File.join Gem.default_key_path

key = File.read key_file

options[:key] = OpenSSL::PKey.read key, passphrase

rescue Errno::ENOENT

# frozen_string_literal: true

class Gem::Commands::CheckCommand < Gem::Command

include Gem::VersionOption

def initialize

:alien => true, :doctor => false, :dry_run => false, :gems => true

'Report "unmanaged" or rogue files in the',

options[:alien] = value

end

options[:doctor] = value

end

options[:dry_run] = value

end

options[:gems] = value

end

end

def check_gems

say

gems = get_all_gem_names rescue []

end

def doctor

say

Gem.path.each do |gem_repo|

end

def arguments # :nodoc:

end

def defaults_str # :nodoc:

end

def description # :nodoc:

# frozen_string_literal: true

class Gem::Commands::CleanupCommand < Gem::Command

def initialize

:force => false, :install_dir => Gem.dir,

:check_dev => true

options[:dryrun] = true

end

options[:dryrun] = true

end

options[:check_dev] = value

end

options[:user_install] = value

end

# frozen_string_literal: true

class Gem::Commands::ContentsCommand < Gem::Command

include Gem::VersionOption

def initialize

:specdirs => [], :lib_only => false, :prefix => true,

:show_install_dir => false

add_version_option

"Contents for all gems") do |all, options|

options[:all] = all

end

"Search for gems under specific paths") do |spec_dirs, options|

options[:specdirs] = spec_dirs

end

"Only return files in the Gem's lib_dirs") do |lib_only, options|

options[:lib_only] = lib_only

end

"Don't include installed path prefix") do |prefix, options|

options[:prefix] = prefix

end

options[:show_install_dir] = show

end

case file

when /\A#{spec.bindir}\//

# $' is POSTMATCH

when /\.so\z/

else

end

end

end

# frozen_string_literal: true

class Gem::Commands::DependencyCommand < Gem::Command

include Gem::LocalRemoteOptions

include Gem::VersionOption

def initialize

:version => Gem::Requirement.default, :domain => :local

add_version_option

add_platform_option

add_prerelease_option

|value, options|

options[:reverse_dependencies] = value

end

"Pipe Format (name --version ver)") do |value, options|

options[:pipe_format] = value

end

def ensure_local_only_reverse_dependencies # :nodoc:

if options[:reverse_dependencies] and remote? and not local?

terminate_interaction 1

end

end

def ensure_specs(specs) # :nodoc:

return unless specs.empty?

say "No gems found matching #{patterns} (#{options[:version]})" if

Gem.configuration.verbose

def print_dependencies(spec, level = 0) # :nodoc:

response = String.new

unless spec.dependencies.empty?

spec.dependencies.sort_by {|dep| dep.name }.each do |dep|

end

end

response

# frozen_string_literal: true

class Gem::Commands::EnvironmentCommand < Gem::Command

def initialize

end

def arguments # :nodoc:

platform display the supported gem platforms

<omitted> display everything

EOF

end

def description # :nodoc:

out << " - GEM CONFIGURATION:\n"

Gem.configuration.each do |name, value|

out << " - #{name.inspect} => #{value.inspect}\n"

end

out << " - SHELL PATH:\n"

add_path out, shell_path

out

# frozen_string_literal: true

class Gem::Commands::FetchCommand < Gem::Command

include Gem::LocalRemoteOptions

:version => Gem::Requirement.default,

}

add_bulk_threshold_option

add_proxy_option

add_platform_option

add_prerelease_option

options[:suggest_alternate] = value

end

end

def arguments # :nodoc:

end

def defaults_str # :nodoc:

# frozen_string_literal: true

##

# Generates a index files for use as a gem server.

class Gem::Commands::GenerateIndexCommand < Gem::Command

def initialize

options[:directory] = File.expand_path dir

end

options[:build_modern] = value

end

options[:update] = value

end

end

# frozen_string_literal: true

class Gem::Commands::HelpCommand < Gem::Command

# :stopdoc:

# :startdoc:

def initialize

@command_manager = Gem::CommandManager.instance

end

desc_width = @command_manager.command_names.map {|n| n.size }.max + 4

summary_width = 80 - margin_width - desc_width

format = "#{' ' * margin_width}%-#{desc_width}s%s"

@command_manager.command_names.each do |cmd_name|

# frozen_string_literal: true

class Gem::Commands::InfoCommand < Gem::Command

include Gem::QueryUtils

add_query_options

defaults[:details] = true

defaults[:exact] = true

# frozen_string_literal: true

##

# Gem installer command line tool

defaults.merge!(install_update_options)

add_install_update_options

add_local_remote_options

@installed_specs = []

check_install_dir

check_version

end

def install_from_gemdeps # :nodoc:

rs = Gem::RequestSet.new

specs = rs.install_from_gemdeps options do |req, inst|

def load_hooks # :nodoc:

if options[:install_as_default]

else

end

end

def show_install_errors(errors) # :nodoc:

def show_installed # :nodoc:

return if @installed_specs.empty?

say "#{@installed_specs.length} #{gems} installed"

end

end

# frozen_string_literal: true

##

# Searches for gems starting with the supplied argument.

include Gem::QueryUtils

def initialize

:domain => :local, :details => false, :versions => true,

:installed => nil, :version => Gem::Requirement.default

# frozen_string_literal: true

class Gem::Commands::LockCommand < Gem::Command

def initialize

:strict => false

options[:strict] = strict

end

end

# frozen_string_literal: true

unless defined? Gem::Commands::MirrorCommand

class Gem::Commands::MirrorCommand < Gem::Command

def initialize

begin

rescue Gem::LoadError

# no-op

end

# frozen_string_literal: true

class Gem::Commands::OpenCommand < Gem::Command

include Gem::VersionOption

def initialize

"Prepends COMMAND to gem path. Could be used to specify editor.") do |command, options|

options[:editor] = command || get_env_editor

end

"Opens specific gem version") do |version|

options[:version] = version

end

end

def get_env_editor

end

def execute

# frozen_string_literal: true

class Gem::Commands::OutdatedCommand < Gem::Command

include Gem::LocalRemoteOptions

include Gem::VersionOption

def initialize

add_local_remote_options

add_platform_option

# frozen_string_literal: true

class Gem::Commands::OwnerCommand < Gem::Command

include Gem::Text

end

def initialize

add_proxy_option

add_key_option

add_otp_option

defaults.merge! :add => [], :remove => []

options[:add] << value

end

options[:remove] << value

end

options[:host] = value

end

end

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.add_field "Authorization", api_key

end

end

# frozen_string_literal: true

class Gem::Commands::PristineCommand < Gem::Command

include Gem::VersionOption

def initialize

:version => Gem::Requirement.default,

:extensions => true,

:extensions_set => false,

:all => false

options[:all] = value

end

options[:skip] ||= []

options[:skip] << value

end

options[:extensions_set] = true

options[:extensions] = value

end

options[:only_executables] = value

end

options[:only_plugins] = value

end

options[:env_shebang] = value

end

options[:install_dir] = File.expand_path(value)

end

options[:bin_dir] = File.expand_path(value)

end

end

def arguments # :nodoc:

end

def defaults_str # :nodoc:

end

def description # :nodoc:

gem = spec.cache_file

unless File.exist? gem or options[:only_executables] or options[:only_plugins]

say "Cached gem for #{spec.full_name} not found, attempting to fetch..."

if options.include? :env_shebang

options[:env_shebang]

else

end

bin_dir = options[:bin_dir] if options[:bin_dir]

# frozen_string_literal: true

class Gem::Commands::PushCommand < Gem::Command

include Gem::LocalRemoteOptions

end

def initialize

@user_defined_host = false

add_key_option

add_otp_option

options[:host] = value

@user_defined_host = true

end

# frozen_string_literal: true

class Gem::Commands::QueryCommand < Gem::Command

extend Gem::Deprecate

alert_warning message unless Gem::Deprecate.skip

end

super name, summary,

:domain => :local, :details => false, :versions => true,

:installed => nil, :version => Gem::Requirement.default

options[:name] = /#{value}/i

end

# frozen_string_literal: true

class Gem::Commands::RdocCommand < Gem::Command

include Gem::VersionOption

def initialize

:version => Gem::Requirement.default,

:include_rdoc => false, :include_ri => true, :overwrite => false

options[:all] = value

end

options[:include_rdoc] = value

end

options[:include_ri] = value

end

options[:overwrite] = value

end

end

if specs.empty?

terminate_interaction 1

end

doc.force = options[:overwrite]

if options[:overwrite]

end

begin

# frozen_string_literal: true

class Gem::Commands::SearchCommand < Gem::Command

include Gem::QueryUtils

def initialize

:domain => :remote, :details => false, :versions => true,

:installed => nil, :version => Gem::Requirement.default

# frozen_string_literal: true

unless defined? Gem::Commands::ServerCommand

class Gem::Commands::ServerCommand < Gem::Command

def initialize

begin

rescue Gem::LoadError

# no-op

end

# frozen_string_literal: true

##

# Installs RubyGems itself. This command is ordinarily only available from a

ENV_PATHS = %w[/usr/bin/env /bin/env].freeze

def initialize

:format_executable => false, :document => %w[ri],

:force => true,

:regenerate_binstubs => true,

:regenerate_plugins => true

options[:previous_version] = version

end

options[:prefix] = File.expand_path prefix

end

options[:destdir] = File.expand_path destdir

end

end

options[:format_executable] = value

end

options[:document] = case value

when nil then %w[rdoc ri]

when false then []

end

end

if value

else

end

options[:document].uniq!

end

if value

else

end

options[:document].uniq!

end

options[:regenerate_binstubs] = value

end

options[:regenerate_plugins] = value

end

options[:force] = value

end

options[:env_shebang] = value

end

end

def check_ruby_version

unless required_version.satisfied_by? Gem.ruby_version

alert_error "Expected Ruby version #{required_version}, is #{Gem.ruby_version}"

check_ruby_version

if Gem.configuration.really_verbose

extend FileUtils::Verbose

else

end

if options[:previous_version].empty?

end

options[:previous_version] = Gem::Version.new(options[:previous_version])

end

if documentation_success

say "Rdoc documentation was installed. You may now invoke:"

say " gem server"

say "and then peruse beautifully formatted documentation for your gems"

say

end

say "Ruby Interactive (ri) documentation was installed. ri is kind of like man "

say "pages for Ruby libraries. You may access it like this:"

say " ri Classname"

def install_executables(bin_dir)

prog_mode = options[:prog_mode] || 0755

executables.each do |tool, path|

say "Installing #{tool} executable" if @verbose

Dir.chdir path do

bin_file = "gem"

dest_file = target_bin_path(bin_dir, bin_file)

bin_tmp_file = File.join Dir.tmpdir, "#{bin_file}.#{$$}"

bin = File.readlines bin_file

bin[0] = shebang

fp.puts bin.join

end

begin

bin_cmd_file = File.join Dir.tmpdir, "#{bin_file}.bat"

file.puts <<-TEXT

@ECHO OFF

IF NOT "%~f0" == "~f0" GOTO :WinNT

def shebang

if options[:env_shebang]

@env_path ||= ENV_PATHS.find {|env_path| File.executable? env_path }

"#!#{@env_path} #{ruby_name}\n"

else

end

def install_lib(lib_dir)

libs.each do |tool, path|

say "Installing #{tool}" if @verbose

end

def install_rdoc

rubygems_name = "rubygems-#{Gem::VERSION}"

rubygems_doc_dir = File.join gem_doc_dir, rubygems_name

(not File.exist? rubygems_doc_dir or

File.writable? rubygems_doc_dir)

say "Removing old RubyGems RDoc and ri" if @verbose

rm_rf dir

end

def fake_spec.full_gem_path

end

rdoc = Gem::RDoc.new fake_spec, generate_rdoc, generate_ri

rdoc.generate

cp File.join("bundler", bundler_spec.bindir, e), File.join(bundler_bin_dir, e)

end

Dir.chdir("bundler") do

built_gem = Gem::Package.build(bundler_spec)

prefix = options[:prefix]

if prefix.empty?

return unless man_dir

else

end

prepend_destdir_if_present(man_dir)

if prefix.empty?

lib_dir = RbConfig::CONFIG[site_or_vendor]

else

end

[prepend_destdir_if_present(lib_dir), prepend_destdir_if_present(bin_dir)]

def files_in(dir)

Dir.chdir dir do

select {|f| !File.directory?(f) }

end

end

def remove_old_bin_files(bin_dir)

old_bin_files = {

}

old_bin_files.each do |old_bin_file, new_name|

deprecation_message = "`#{old_bin_file}` has been deprecated. Use `#{new_name}` instead."

fp.write <<-EOF

#!#{Gem.ruby}

next unless Gem.win_platform?

fp.puts %(@ECHO.#{deprecation_message})

end

end

end

def remove_old_lib_files(lib_dir)

lib_dirs.each do |old_lib_dir, new_lib_dir|

lib_files = files_in(new_lib_dir)

to_remove = old_lib_files - lib_files

to_remove << gauntlet_rubygems if File.exist? gauntlet_rubygems

to_remove.delete_if do |file|

end

remove_file_list(to_remove, old_lib_dir)

end

def show_release_notes

release_notes =

if File.exist? release_notes

end

def uninstall_old_gemcutter

ui.uninstall

rescue Gem::InstallError

end

destdir = options[:destdir]

return path if destdir.empty?

end

def install_file_list(files, dest_dir)

# frozen_string_literal: true

class Gem::Commands::SigninCommand < Gem::Command

include Gem::GemcutterUtilities

def initialize

options[:host] = value

end

end

def description # :nodoc:

end

def usage # :nodoc:

# frozen_string_literal: true

class Gem::Commands::SignoutCommand < Gem::Command

def initialize

end

def description # :nodoc:

end

def usage # :nodoc:

credentials_path = Gem.configuration.credentials_path

if !File.exist?(credentials_path)

elsif !File.writable?(credentials_path)

alert_error "File '#{Gem.configuration.credentials_path}' is read-only."\

else

Gem.configuration.unset_api_key!

end

end

end

# frozen_string_literal: true

class Gem::Commands::SourcesCommand < Gem::Command

include Gem::LocalRemoteOptions

def initialize

options[:add] = value

end

options[:list] = value

end

options[:remove] = value

end

options[:clear_all] = value

end

options[:update] = value

end

options[:force] = value

end

def check_rubygems_https(source_uri) # :nodoc:

uri = URI source_uri

question = <<-QUESTION.chomp

https://rubygems.org is recommended for security over #{uri}

end

def defaults_str # :nodoc:

end

def description # :nodoc:

# frozen_string_literal: true

class Gem::Commands::SpecificationCommand < Gem::Command

include Gem::LocalRemoteOptions

def initialize

Gem.load_yaml

:domain => :local, :version => Gem::Requirement.default,

:format => :yaml

add_platform_option

add_prerelease_option

options[:all] = true

end

options[:format] = :ruby

end

options[:format] = :yaml

end

options[:format] = :marshal

end

# frozen_string_literal: true

class Gem::Commands::StaleCommand < Gem::Command

def initialize

end

def description # :nodoc:

# frozen_string_literal: true

##

# Gem uninstaller command line tool

include Gem::VersionOption

def initialize

:version => Gem::Requirement.default, :user_install => true,

:check_dev => false, :vendor => false

) do |value, options|

options[:all] = value

end

options[:ignore] = value

end

options[:check_dev] = value

end

options[:executables] = value

end

options[:install_dir] = File.expand_path(value)

end

options[:bin_dir] = File.expand_path(value)

end

options[:user_install] = value

end

options[:format_executable] = value

end

options[:force] = value

end

options[:abort_on_dependent] = value

end

add_version_option

add_platform_option

unless Gem.vendor_dir

end

options[:vendor] = true

options[:install_dir] = Gem.vendor_dir

end

# frozen_string_literal: true

# forward-declare

include Gem::SecurityOption

def initialize

:version => Gem::Requirement.default,

:target => Dir.pwd

options[:target] = value

end

options[:spec] = true

end

end

end

io.write metadata

end

else

target_dir = File.expand_path basename, options[:target]

package = Gem::Package.new path, security_policy

# frozen_string_literal: true

class Gem::Commands::UpdateCommand < Gem::Command

include Gem::InstallUpdateOptions

options.merge!(install_update_options)

add_install_update_options

value

end

value = true unless value

options[:system] = value

args = update_rubygems_arguments

version = spec.version

Dir.chdir update_dir do

say "Installing RubyGems #{version}" unless options[:silent]

installed = preparing_gem_layout_for(version) do

end

say "RubyGems system software updated" if installed unless options[:silent]

requirement = Gem::Requirement.new ">= #{Gem::VERSION}"

rubygems_update = Gem::Specification.new

rubygems_update.version = version

highest_remote_tup = highest_remote_name_tuple(rubygems_update)

check_oldest_rubygems version

return if installed_gems.empty?

install_rubygems installed_gems.first

def update_rubygems_arguments # :nodoc:

args = []

options[:system] == true or

Gem::Version.new(options[:system]) >= Gem::Version.new(2)

args

# frozen_string_literal: true

class Gem::Commands::WhichCommand < Gem::Command

def initialize

:search_gems_first => false, :show_all => false

options[:show_all] = show_all

end

options[:search_gems_first] = gems_first

end

end

found = true

options[:args].each do |arg|

dirs = $LOAD_PATH

spec = Gem::Specification.find_by_path arg

# frozen_string_literal: true

class Gem::Commands::YankCommand < Gem::Command

include Gem::LocalRemoteOptions

end

def initialize

add_version_option("remove")

add_platform_option("remove")

add_otp_option

options[:host] = value

end

request.add_field("Authorization", api_key)

data = {

}

request.set_form_data data

end

# See LICENSE.txt for permissions.

#++

##

# Gem::ConfigFile RubyGems options and gem command options from gemrc.

# :startdoc:

##

# List of arguments supplied to the config file object.

@update_sources = DEFAULT_UPDATE_SOURCES

@concurrent_downloads = DEFAULT_CONCURRENT_DOWNLOADS

@cert_expiration_length_days = DEFAULT_CERT_EXPIRATION_LENGTH_DAYS

operating_system_config = Marshal.load Marshal.dump(OPERATING_SYSTEM_DEFAULTS)

platform_config = Marshal.load Marshal.dump(PLATFORM_DEFAULTS)

system_config = load_file SYSTEM_WIDE_CONFIG_FILE

user_config = load_file config_file_name.dup.tap(&Gem::UNTAINT)

.split(File::PATH_SEPARATOR).inject({}) do |result, file|

result.merge load_file file

end

@hash = operating_system_config.merge platform_config

@hash = @hash.merge system_config

@hash = @hash.merge user_config

@hash = @hash.merge environment_config

# Location of RubyGems.org credentials

def credentials_path

if File.exist? credentials

credentials

else

config = load_file(credentials_path).merge(host => api_key)

dirname = File.dirname credentials_path

FileUtils.mkdir_p(dirname)

Gem.load_yaml

permissions = 0600 & (~File.umask)

f.write config.to_yaml

end

yield :backtrace, @backtrace

yield :bulk_threshold, @bulk_threshold

hash.each(&block)

end

when /^--debug$/ then

$DEBUG = true

else

@args << arg

end

@hash[:ssl_client_cert] if @hash.key? :ssl_client_cert

keys = yaml_hash.keys.map {|key| key.to_s }

re = Regexp.union(*keys)

@hash.each do |key, value|

# Writes out this config file, replacing its source.

def write

FileUtils.mkdir_p File.dirname(config_file_name)

io.write to_yaml

end

end

# GEM_SKIP=libA:libB ruby -I../libA -I../libB ./mycode.rb

def gem(gem_name, *requirements) # :doc:

raise Gem::LoadError, "skipping #{gem_name}" if skip_list.include? gem_name

if gem_name.kind_of? Gem::Dependency

# See LICENSE.txt for permissions.

#++

module Kernel

start += 1

if path = loc.path

# Non-rubygems frames

uplevel -= 1

end

module CoreExtensions

module TCPSocketExt

# specified in the environment

def self.default_spec_cache_dir

unless File.exist?(default_spec_cache_dir)

end

default_spec_cache_dir

# specified in the environment

def self.default_dir

end

##

Dir.home.dup

rescue

if Gem.win_platform?

else

File.expand_path "/"

end

gem_dir = File.join(Gem.user_home, ".gem")

gem_dir = File.join(Gem.data_home, "gem") unless File.exist?(gem_dir)

parts = [gem_dir, ruby_engine]

File.join parts

end

# The path to standard location of the user's configuration directory.

def self.config_home

end

##

# Finds the user's config file

def self.find_config_file

if File.exist? gemrc

gemrc

else

# The path to standard location of the user's cache directory.

def self.cache_home

end

##

# The path to standard location of the user's data directory.

def self.data_home

end

##

# Deduce Ruby's --program-prefix and --program-suffix from its install name

def self.default_exec_format

unless exec_format =~ /%s/

raise Gem::Exception,

# The default directory for binaries

def self.default_bindir

end

def self.ruby_engine

# Directory where vendor gems are installed.

def self.vendor_dir # :nodoc:

return vendor_dir.dup

end

end

##

end

def pretty_print(q) # :nodoc:

q.pp name

q.breakable

q.pp requirement

q.breakable

q.pp type

reqs = other.requirement.requirements

return false unless reqs.length == 1

version = reqs.first.last

# frozen_string_literal: true

##

# Installs a gem along with all its dependencies from local and remote gems.

# See LICENSE.txt for permissions.

#++

##

# Gem::DependencyList is used for installing and uninstalling gems in the

# frozen_string_literal: true

##

# Cleans up after a partially-failed uninstall or for an invalid

# subdirectory.

REPOSITORY_EXTENSION_MAP = [ # :nodoc:

].freeze

missing =

Gem.use_paths @gem_repository.to_s

unless gem_repository?

say

return

end

basename = File.basename(child, extension)

next if installed_specs.include? basename

next if /^rubygems-\d/ =~ basename

action = if @dry_run

else

FileUtils.rm_r(child)

end

say "#{action} #{type} #{sub_directory}/#{File.basename(child)}"

"Found %s (%s), but was for platform%s %s" %

[@name,

@version,

end

end

# frozen_string_literal: true

##

# Base exception class for RubyGems. All exception raised by RubyGems are a

if DidYouMean.respond_to?(:correct_error)

DidYouMean.correct_error(Gem::UnknownCommandError, Gem::UnknownCommandSpellChecker)

else

Gem::UnknownCommandSpellChecker

prepend DidYouMean::Correctable

def build_message # :nodoc:

requester = @request.requester

dependency = @request.dependency

message = "#{requester} requires #{dependency} but it conflicted:\n".dup

module Gem::Ext; end

##

# Raised when there is an error while building extensions.

class Gem::Ext::BuildError < Gem::InstallError

end

# See LICENSE.txt for permissions.

#++

class Gem::Ext::Builder

include Gem::UserInteraction

end

def self.make(dest_path, results, make_dir = Dir.pwd, sitedir = nil)

end

# try to find make program from Ruby configure arguments first

unless make_program_name

end

make_program = Shellwords.split(make_program_name)

# The installation of the bundled gems is failed when DESTDIR is empty in mswin platform.

env = [destdir]

if sitedir

end

# Pass DESTDIR via command line to override what's in MAKEFLAGS

cmd = [

*make_program,

begin

run(cmd, results, "make #{target}".rstrip, make_dir)

rescue Gem::InstallError

end

end

end

verbose = Gem.configuration.really_verbose

begin

if verbose

puts("current directory: #{dir}")

p(command)

require "open3"

# Set $SOURCE_DATE_EPOCH for the subprocess.

output, status = begin

Open3.capture2e(build_env, *command, :chdir => dir)

rescue => error

results << output

end

ensure

end

unless status.success?

# Writes +output+ to gem_make.out in the extension install directory.

def write_gem_make_out(output) # :nodoc:

FileUtils.mkdir_p @spec.extension_dir

io.puts output

end

def build_crate(dest_path, results, args, cargo_dir)

env = build_env

cmd = cargo_command(cargo_dir, dest_path, args)

results

end

def build_env

build_env = rb_config_env

build_env

end

cmd = []

cmd += [cargo, "rustc"]

cmd += ["--target-dir", dest_path]

cmd += ["--manifest-path", manifest]

cmd += ["--lib"]

def cargo_dylib_path(dest_path)

prefix = so_ext == "dll" ? "" : "lib"

path_parts = [dest_path]

path_parts += [profile_target_directory, "#{prefix}#{cargo_crate_name}.#{so_ext}"]

File.join(*path_parts)

end

def cargo_crate_name

end

def rustc_dynamic_linker_flags(dest_dir)

def profile_target_directory

case profile

else raise "unknown target directory for profile: #{profile}"

end

end

class Gem::Ext::CmakeBuilder < Gem::Ext::Builder

def self.build(extension, dest_path, results, args=[], lib_dir=nil, cmake_dir=Dir.pwd)

cmd = ["cmake", ".", "-DCMAKE_INSTALL_PREFIX=#{dest_path}", *Gem::Command.build_args]

run cmd, results, class_name, cmake_dir

class Gem::Ext::ConfigureBuilder < Gem::Ext::Builder

def self.build(extension, dest_path, results, args=[], lib_dir=nil, configure_dir=Dir.pwd)

cmd = ["sh", "./configure", "--prefix=#{dest_path}", *args]

run cmd, results, class_name, configure_dir

class Gem::Ext::ExtConfBuilder < Gem::Ext::Builder

def self.build(extension, dest_path, results, args=[], lib_dir=nil, extension_dir=Dir.pwd)

tmp_dest = Dir.mktmpdir(".gem.", extension_dir)

begin

require "shellwords"

cmd.push(*args)

run(cmd, results, class_name, extension_dir) do |s, r|

if File.exist? mkmf_log

unless s.success?

r << "To see why this extension failed to compile, please check" \

" the mkmf.log which can be found here:\n"

end

FileUtils.mv mkmf_log, dest_path

end

private

def self.get_relative_path(path, base)

path

end

end

run([Gem.ruby, File.basename(extension), *args], results, class_name, extension_dir)

end

if rake

require "shellwords"

rake = rake.shellsplit

else

begin

rescue Gem::Exception

end

end

# See LICENSE.txt for permissions.

#++

##

# Run an instance of the gem program.

config_args = Gem.configuration[command_name]

config_args = case config_args

when String

else

Array(config_args)

end

# other arguments in the list.

def extract_build_args(args) # :nodoc:

build_args = args.slice!(offset...args.length)

# frozen_string_literal: true

##

# Utility methods for using the RubyGems API.

# Add the --key option

def add_key_option

"from #{Gem.configuration.credentials_path}") do |value,options|

options[:key] = value

end

# Add the --otp option

def add_otp_option

options[:otp] = value

end

end

@host ||=

begin

env_rubygems_host = nil if

env_rubygems_host and env_rubygems_host.empty?

# If +allowed_push_host+ metadata is present, then it will only allow that host.

def rubygems_api_request(method, path, host = nil, allowed_push_host = nil, scope: nil, &block)

self.host = host if host

unless self.host

end

def mfa_unauthorized?(response)

end

def update_scope(scope)

end

def ask_otp

end

def pretty_host(host)

if default_host?

else

host

end

# frozen_string_literal: true

##

# Top level class for building the gem repository index.

# Create an indexer that will index the gems in +directory+.

def initialize(directory, options = {})

options = { :build_modern => true }.merge options

@build_modern = options[:build_modern]

@dest_directory = directory

marshal_name = "Marshal.#{Gem.marshal_version}"

@marshal_index = File.join @directory, marshal_name

@quick_marshal_dir = File.join @quick_dir, marshal_name

@quick_marshal_dir_base = File.join "quick", marshal_name # FIX: UGH

@specs_index = File.join @directory, "specs.#{Gem.marshal_version}"

@latest_specs_index =

files = []

specs.each do |spec|

next if spec.default_gem?

spec_file_name = "#{spec.original_name}.gemspec.rz"

marshal_zipped = Gem.deflate Marshal.dump(spec)

io.write marshal_zipped

end

say "Generating #{name} index"

Gem.time "Generated #{name} index" do

specs = index.map do |*spec|

# We have to splat here because latest_specs is an array, while the

# others are hashes.

latest_specs =

Gem::Specification._latest_specs specs

build_modern_index(prerelease.sort, @prerelease_specs_index,

@files += [@specs_index,

"#{@specs_index}.gz",

def compress_indices

say "Compressing indices"

if @build_modern

gzip @specs_index

gzip @latest_specs_index

zipped = Gem.deflate data

io.write zipped

end

end

end

files = files.map do |path|

end

files.each do |file|

end

if updated_gems.empty?

terminate_interaction 0

end

files = build_marshal_gemspecs specs

update_specs_index released, @dest_specs_index, @specs_index

update_specs_index released, @dest_latest_specs_index, @latest_specs_index

update_specs_index(prerelease,

files << "#{@prerelease_specs_index}.gz"

files = files.map do |path|

end

files.each do |file|

specs_index = compact_specs specs_index.uniq.sort

Marshal.dump specs_index, io

end

end

# frozen_string_literal: true

##

# A post-install hook that displays "Successfully installed

# frozen_string_literal: true

##

# A default post-install hook that displays "Successfully installed

# See LICENSE.txt for permissions.

#++

##

# Mixin methods for install and update options for Gem::Commands

# Add the install/update options to the option parser.

def add_install_update_options

options[:install_dir] = File.expand_path(value)

end

options[:bin_dir] = File.expand_path(value)

end

options[:document] = case value

when nil then %w[ri]

when false then []

end

end

options[:build_root] = File.expand_path(value)

end

unless Gem.vendor_dir

end

options[:vendor] = true

options[:install_dir] = Gem.vendor_dir

end

options[:document] = []

end

"Rewrite the shebang line on installed",

"scripts to use /usr/bin/env") do |value, options|

options[:env_shebang] = value

end

options[:force] = value

end

options[:wrappers] = value

end

add_security_option

options[:ignore_dependencies] = value

end

options[:format_executable] = value

end

options[:user_install] = value

end

options[:post_install_message] = value

end

v = Gem::GEM_DEP_FILES.find do |file|

File.exist? file

end unless v

options[:gemdeps] = v

end

options[:without_groups].concat v.map {|without| without.intern }

end

options[:install_as_default] = v

end

options[:explain] = v

end

options[:lock] = v

end

options[:suggest_alternate] = v

end

end

# Default description for the gem install and update commands.

def install_update_defaults_str

end

end

# See LICENSE.txt for permissions.

#++

##

# The installer installs the files contained in the .gem into the Gem.home.

@spec = spec

end

FileUtils.mkdir_p destination_dir

spec.files.each do |file|

file = File.join destination_dir, file

next if File.exist? file

FileUtils.mkdir_p File.dirname(file)

fp.puts "# #{file}"

end

end

# :post_install_message:: Print gem post install message if true

def initialize(package, options={})

@options = options

@package = package

ruby_executable = false

existing = nil

line = io.gets

shebang = /^#!.*ruby/

question = "#{spec.name}'s executable \"#{filename}\" conflicts with ".dup

if ruby_executable

return if ask_yes_no "#{question}\nOverwrite the executable?", false

if Gem.win_platform?

script_name = formatted_program_filename(filename) + ".bat"

script_path = File.join bindir, File.basename(script_name)

file.puts windows_stub_script(bindir, filename)

end

dir_mode = options[:prog_mode] || (mode | 0111)

unless dir_mode == mode

FileUtils.chmod dir_mode, bin_path

end

def generate_bin_script(filename, bindir)

bin_script_path = File.join bindir, formatted_program_filename(filename)

FileUtils.rm_f bin_script_path # prior install may have been --no-wrappers

file.print app_script_text(filename)

file.chmod(options[:prog_mode] || 0755)

end

if File.exist? dst

if File.symlink? dst

link = File.readlink(dst).split File::SEPARATOR

return if spec.version < cur_version

end

File.unlink dst

@build_args = options[:build_args]

unless @build_root.nil?

alert_warning "You build with buildroot.\n Build root: #{@build_root}\n Bin dir: #{@bin_dir}\n Gem home: #{@gem_home}\n Plugins dir: #{@plugins_dir}"

end

end

user_bin_dir = @bin_dir || Gem.bindir(gem_home)

user_bin_dir = user_bin_dir.tr(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR

path = path.tr(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR

if Gem.win_platform?

path = path.split(File::PATH_SEPARATOR)

unless path.include? user_bin_dir

alert_warning "You don't have #{user_bin_dir} in your PATH,\n\t gem executables will not run."

self.class.path_warning = true

end

end

def gemdeps_load(name)

<<-TEXT

TEXT

elsif bindir.downcase.start_with? rb_topdir.downcase

# stub within ruby folder, but not standard bin. Portable

from = Pathname.new bindir

to = Pathname.new "#{rb_topdir}/bin"

rel = to.relative_path_from from

def write_build_info_file

return if build_args.empty?

dir_mode = options[:dir_mode]

FileUtils.mkdir_p build_info_dir, :mode => dir_mode && 0755

build_info_file = File.join build_info_dir, "#{spec.full_name}.info"

build_args.each do |arg|

io.puts arg

end

# Writes the .gem file to the cache directory

def write_cache_file

@package.copy_to cache_file

end

end

def load_relative_enabled?

end

def bash_prolog_script

plugins = spec.plugins

return if plugins.empty?

spec.plugins.each do |plugin|

plugin_script_path = File.join plugins_dir, "#{spec.name}_plugin#{File.extname(plugin)}"

file.puts "require_relative '#{Pathname.new(plugin).relative_path_from(Pathname.new(plugins_dir))}'"

end

# See LICENSE.txt for permissions.

#++

##

# Mixin methods for local and remote Gem::Command options.

# Add local/remote options to the command line parser.

def add_local_remote_options

options[:domain] = :local

end

options[:domain] = :remote

end

options[:domain] = :both

end

# Add the --bulk-threshold option

def add_bulk_threshold_option

"Threshold for switching to bulk",

"synchronization (default #{Gem.configuration.bulk_threshold})") do

|value, options|

# Add the --clear-sources option

def add_clear_sources_option

Gem.sources = nil

options[:sources_cleared] = true

end

def add_proxy_option

accept_uri_http

options[:http_proxy] = (value == false) ? :no_proxy : value

Gem.configuration[:http_proxy] = options[:http_proxy]

end

def add_source_option

accept_uri_http

if options.delete :sources_cleared

Gem.sources = [source]

# Add the --update-sources option

def add_update_sources_option

Gem.configuration.update_sources = value

end

end

# frozen_string_literal: true

##

# This Gem::StreamUI subclass records input and output to StringIO for

end

def initialize(input = "")

ins = StringIO.new input

outs = StringIO.new

errs = StringIO.new

def full_name

case @platform

"#{@name}-#{@version}"

else

"#{@name}-#{@version}-#{@platform}"

# frozen_string_literal: true

#++

require_relative "../rubygems"

##

# Example using a Gem::Package

return super unless gem.present?

return super unless gem.start

Gem::Package::Old.new gem

end

tar = Gem::Package::TarReader.new io

tar.each_entry do |entry|

case entry.full_name

metadata = entry.read

metadata = Gem::Util.gunzip entry.read

end

end

# Creates a new package that will read or write to the file +gem+.

def initialize(gem, security_policy) # :notnew:

@gem = gem

end

end

gzip_to io do |gz_io|

Psych.dump checksums_by_algorithm, gz_io

end

# and adds this file to the +tar+.

def add_contents(tar) # :nodoc:

gzip_to io do |gz_io|

Gem::Package::TarWriter.new gz_io do |data_tar|

add_files data_tar

end

end

end

##

next unless stat.file?

tar.add_file_simple file, stat.mode, stat.size do |dst_io|

dst_io.write src_io.read 16384 until src_io.eof?

end

end

# Adds the package's Gem::Specification to the +tar+ file

def add_metadata(tar) # :nodoc:

gzip_to io do |gz_io|

gz_io.write @spec.to_yaml

end

end

end

##

gem_tar = Gem::Package::TarReader.new io

gem_tar.each do |entry|

open_tar_gz entry do |pkg_tar|

pkg_tar.each do |contents_entry|

reader = Gem::Package::TarReader.new io

reader.each do |entry|

extract_tar_gz entry, destination_dir, pattern

real_destination = link_target.start_with?("/") ? link_target : File.expand_path(link_target, File.dirname(destination))

raise Gem::Package::SymlinkError.new(entry.full_name, real_destination, destination_dir) unless

end

FileUtils.rm_rf destination

directories << mkdir

end

out.write entry.read

FileUtils.chmod file_mode(entry.header.mode), destination

end if entry.file?

def install_location(filename, destination_dir) # :nodoc:

raise Gem::Package::PathError.new(filename, destination_dir) if

destination_dir = File.realpath(destination_dir)

destination = File.expand_path(filename, destination_dir)

raise Gem::Package::PathError.new(destination, destination_dir) unless

destination.tap(&Gem::UNTAINT)

destination

def load_spec(entry) # :nodoc:

case entry.full_name

@spec = Gem::Specification.from_yaml entry.read

Zlib::GzipReader.wrap(entry, external_encoding: Encoding::UTF_8) do |gzio|

@spec = Gem::Specification.from_yaml gzio.read

end

def read_checksums(gem)

Gem.load_yaml

Zlib::GzipReader.wrap entry do |gz_io|

Gem::SafeYAML.safe_load gz_io.read

end

# certificate and key are not present only checksum generation is set up.

def setup_signer(signer_options: {})

if @spec.signing_key

@signer =

Gem::Security::Signer.new(

case file_name

when "metadata", "metadata.gz" then

load_spec entry

verify_gz entry

end

rescue

end

unless @spec

end

raise Gem::Package::FormatError.new \

end

if duplicates = @files.group_by {|f| f }.select {|k,v| v.size > 1 }.map(&:first) and duplicates.any?

end

end

end

def with_write_io(&block)

end

def with_read_io(&block)

end

end

# cannot be written.

def initialize(gem, security_policy)

Gem.load_yaml

@contents = nil

read_until_dashes io # spec

header = file_list io

end

end

raise Gem::Exception, errstr unless header

header.each do |entry|

destination = install_location full_name, destination_dir

file_data = Zlib::Inflate.inflate file_data

raise Gem::Package::FormatError, "#{full_name} in #{@gem} is corrupt" if

FileUtils.rm_rf destination

FileUtils.mkdir_p File.dirname(destination), :mode => dir_mode && 0755

out.write file_data

end

loop do

line = io.gets

break unless line

end

return true unless @security_policy

raise Gem::Security::Exception,

@security_policy.verify_data

true

##

# Pack format for a tar header

##

# Unpack format for a tar header

attr_reader(*FIELDS)

# \ff flags a negative 256-based number

# In case we have a match, parse it as a signed binary value

# in big-endian order, except that the high-order bit is ignored.

strict_oct(str)

end

end

end

@header.name

end

rescue ArgumentError => e

raise Gem::Package::TarInvalidError,

end

##

def add_file_signed(name, mode, signer)

digest_algorithms = [

signer.digest_algorithm,

].compact.uniq

digests = add_file_digest name, mode, digest_algorithms do |io|

raise Gem::Package::TooLongFileName.new("File \"#{name}\" has a too long path (should be 256 or less)")

end

if name.bytesize > 100

name = parts.pop # initially empty for names with a trailing slash ("foo/.../bar/")

while !parts.empty? && (prefix.bytesize > 155 || name.empty?)

end

if name.bytesize > 100 or prefix.empty?

# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

##

# Create a package based upon a Gem::Specification. Gem packages, as well as

Gem::Package.build gem_spec

verbose trace do

end

end

end

attr_accessor :cpu, :os, :version

def self.local

arch = "#{arch}_60" if arch =~ /mswin(?:32|64)$/

@local ||= new(arch)

end

case arch

when Gem::Platform::CURRENT then

Gem::Platform.local

Gem::Platform::RUBY

else

super

when Array then

@cpu, @os, @version = arch

when String then

if arch.length > 2 and arch.last !~ /\d/ # reassemble x86-linux-gnu

extra = arch.pop

cpu = arch.shift

@cpu = case cpu

else cpu

end

@cpu, os = nil, cpu if os.nil? # legacy jruby

@os, @version = case os

when /(mswin\d+)(\_(\d+))?/ then

os, version = $1, $3

[os, version]

# test

when /^(\w+_platform)(\d+)?/ then [ $1, $2 ]

end

when Gem::Platform then

@cpu = arch.cpu

end

def to_s

end

##

return nil unless Gem::Platform === other

# universal-mingw32 matches x64-mingw-ucrt

# cpu

# os

@os == other.os and

when String then

# This data is from http://gems.rubyforge.org/gems/yaml on 19 Aug 2007

other = case other

else other

end

# A pure-Ruby gem that may use Gem::Specification#extensions to build

# binary files.

##

# A platform-specific gem that is built for the packaging Ruby's platform.

# This will be replaced with Gem::Platform::local.

end

end unless respond_to? :create

def visit_String(str)

quote = Psych::Nodes::Scalar::SINGLE_QUOTED

@emitter.scalar str, nil, nil, false, true, quote

# frozen_string_literal: true

module Gem::QueryUtils

include Gem::VersionOption

def add_query_options

options[:installed] = value

end

options[:installed] = false

end

add_version_option command, "for use with --installed"

options[:details] = value

end

options[:versions] = value

options[:details] = false unless value

end

options[:all] = value

end

options[:exact] = value

end

options[:prerelease] = value

end

if pls != [Gem::Platform::RUBY]

platform_list = [pls.delete(Gem::Platform::RUBY), *pls.sort].compact

end

out

def spec_authors(entry, spec)

authors = "Author#{spec.authors.length > 1 ? 's' : ''}: ".dup

entry << format_text(authors, 68, 4)

end

return if spec.license.nil? or spec.license.empty?

licenses = "License#{spec.licenses.length > 1 ? 's' : ''}: ".dup

entry << "\n" << format_text(licenses, 68, 4)

end

return unless spec.loaded_from

if specs.length == 1

entry << "\n" << " Installed at#{default}: #{spec.base_dir}"

else

specs.each do |s|

version = s.version.to_s

entry << "\n" << " #{label} (#{version}): #{s.base_dir}"

end

end

end

return unless non_ruby

if platforms.length == 1

entry << " #{title}: #{platforms.values.sort.join(', ')}\n"

else

entry << " Platforms:\n"

sorted_platforms.each do |version, pls|

label = " #{version}: "

data[0, label.length] = label

entry << data << "\n"

end

# frozen_string_literal: true

begin

module Gem

RDoc = ::RDoc::RubygemsHook

end

# frozen_string_literal: true

##

# RemoteFetcher handles the details of fetching gems and gem information from

# fetching the gem.

def initialize(proxy=nil, dns=nil, headers={})

Socket.do_not_reverse_lookup = true

# REFACTOR: split this up and dis on scheme (eg download_http)

# REFACTOR: be sure to clean up fake fetcher when you do this... cleaner

case scheme

unless File.exist? local_gem_path

begin

verbose "Downloading gem #{gem_file_name}"

self.cache_update_path remote_gem_path, local_gem_path

end

end

begin

path = source_uri.path

FileUtils.cp(remote_gem_path, local_gem_path)

rescue Errno::EACCES

verbose "Using local gem #{local_gem_path}"

when nil then # TODO test for local overriding cache

source_path = if Gem.win_platform? && source_uri.scheme &&

"#{source_uri.scheme}:#{source_uri.path}"

else

source_uri.path

head ? response : response.body

when Net::HTTPMovedPermanently, Net::HTTPFound, Net::HTTPSeeOther,

Net::HTTPTemporaryRedirect then

raise FetchError.new("redirecting but no redirect location was given", uri)

end

location = Gem::Uri.new location

end

def https?(uri)

end

def close_all

# frozen_string_literal: true

class Gem::Request

extend Gem::UserInteraction

end

def self.configure_connection_for_https(connection, cert_files)

connection.use_ssl = true

connection.verify_mode =

return unless cert

case error_number

when OpenSSL::X509::V_ERR_CERT_HAS_EXPIRED then

"Certificate #{cert.subject} expired at #{cert.not_after.iso8601}"

when OpenSSL::X509::V_ERR_CERT_NOT_YET_VALID then

"Certificate #{cert.subject} not valid until #{cert.not_before.iso8601}"

when OpenSSL::X509::V_ERR_CERT_REJECTED then

"Certificate #{cert.subject} is rejected"

Gem::UriFormatter.new(@uri.password).unescape

end

if @last_modified

end

yield request if block_given?

# Returns a proxy URI for the given +scheme+ if one is set in the

# environment variables.

_scheme = scheme.downcase

_SCHEME = scheme.upcase

env_proxy = ENV["#{_scheme}_proxy"] || ENV["#{_SCHEME}_PROXY"]

no_env_proxy = env_proxy.nil? || env_proxy.empty?

if no_env_proxy

end

require "uri"

reset connection

bad_response = true

retry

rescue Net::HTTPFatalError

verbose "fatal error"

# HACK work around EOFError bug in Net::HTTP

# NOTE Errno::ECONNABORTED raised a lot on Windows, and make impossible

# to install gems.

requests = @requests[connection.object_id]

verbose "connection reset after #{requests} requests, retrying"

reset connection

ua = "RubyGems/#{Gem::VERSION} #{Gem::Platform.local}".dup

ruby_version = RUBY_VERSION

ua << " Ruby/#{ruby_version} (#{RUBY_RELEASE_DATE}"

if RUBY_LEVEL >= 0

end

ua << ")"

ua

end

end

# Returns list of no_proxy entries (if any) from the environment

def get_no_proxy_from_env

return [] if env_no_proxy.nil? or env_no_proxy.empty?

end

def https?(uri)

end

def no_proxy?(host, env_no_proxy)

# frozen_string_literal: true

##

# A RequestSet groups a request to activate a set of dependencies.

end

def install_into(dir, force = true, options = {})

existing = force ? [] : specs_in(dir)

existing.delete_if {|s| @always_install.include? s }

installed

ensure

end

##

end

def pretty_print(q) # :nodoc:

q.breakable

if @remote

q.breakable

end

if @prerelease

q.breakable

end

if @development_shallow

q.breakable

elsif @development

q.breakable

end

if @soft_missing

end

q.breakable

@dependencies.map do |dep|

q.text dep.to_s

end

q.breakable

q.breakable

q.pp @sets.map {|set| set.class }

end

end

:ruby_21 => %w[ruby rbx maglev truffleruby],

}.freeze

PLATFORM_MAP = { # :nodoc:

:jruby => Gem::Platform::RUBY,

:x64_mingw_21 => x64_mingw,

}.freeze

VERSION_MAP = { # :nodoc:

:jruby => gt_eq_0,

reference ||= ref

reference ||= branch

reference ||= tag

if ref && branch

warn <<-WARNING

# :development. Only one group may be specified.

def gemspec(options = {})

development_group = options.delete(:development_group) || :development

spec = find_gemspec name, path

def pin_gem_source(name, type = :default, source = nil)

source_description =

case type

when :path then "path: #{source}"

when :git then "git: #{source}"

when :source then "source: #{source}"

end

raise ArgumentError,

engine_version = options[:engine_version]

raise ArgumentError,

engine and not engine_version

return true if @installing

@gem_deps_file = File.expand_path(gem_deps_file)

@gem_deps_dir = File.dirname(@gem_deps_file)

@gem_deps_file.untaint unless gem_deps_file.tainted?

end

out << " specs:"

requests.sort_by {|request| request.name }.each do |request|

platform = "-#{request.spec.platform}" unless

Gem::Platform::RUBY == request.spec.platform

if dest.index(base) == 0

offset = dest[base.size + 1..-1]

offset

else

def write

content = to_s

io.write content

end

end

end

end

@tokens.skip :newline

case token.value

parse_DEPENDENCIES

parse_GIT

parse_GEM

parse_PATH

parse_PLATFORMS

else

token = get until @tokens.empty? or peek.first == :section

def parse_GEM # :nodoc:

sources = []

data = get(:text).value

skip :newline

sources << Gem::Source.new(Gem::DEFAULT_HOST) if sources.empty?

skip :newline

data = token.value

if type == :text and column == 4

platform =

platform ? Gem::Platform.new(platform) : Gem::Platform::RUBY

end

def parse_GIT # :nodoc:

repository = get(:text).value

skip :newline

revision = get(:text).value

skip :newline

skip :newline

end

skip :newline

end

def parse_PATH # :nodoc:

directory = get(:text).value

skip :newline

skip :newline

# frozen_string_literal: true

class Gem::RequestSet::Lockfile::Tokenizer

Token = Struct.new :type, :value, :column, :line

private

def tokenize(input)

s = StringScanner.new input

until s.eos? do

input

when Gem::Version, Array then

new input

source_set

else

if input.respond_to? :to_str

end

def self.default

end

def self.default_prerelease

end

###

end

def encode_with(coder) # :nodoc:

end

##

end

def pretty_print(q) # :nodoc:

q.pp as_list

end

end

# frozen_string_literal: true

##

# Given a set of Gem::Dependency objects as +needed+ and a way to query the

# all the requirements.

class Gem::Resolver

##

# If the DEBUG_RESOLVER environment variable is set then debugging mode is

# enabled for the resolver. This will display information about the state

# of the resolver while a set of dependencies is being resolved.

##

# Set to true if all development dependencies should be considered.

case sets.length

when 0 then

when 1 then

sets.first

else

data = yield

$stderr.printf "%10s (%d entries)\n", stage.to_s.upcase, data.size

unless data.empty?

PP.pp data, $stderr

end

end

include Molinillo::UI

def output

end

def debug?

private :amount_constrained

end

end

def inspect # :nodoc:

self.class, @spec, @request

]

end

end

def pretty_print(q) # :nodoc:

q.breakable

q.pp @spec

q.breakable

q.pp @request

end

end

# API URL +dep_uri+ which is described at

# https://guides.rubygems.org/rubygems-org-api

super()

dep_uri = URI dep_uri unless URI === dep_uri

@dep_uri = dep_uri

@data = Hash.new {|h,k| h[k] = [] }

@source = Gem::Source.new @uri

end

def pretty_print(q) # :nodoc:

q.breakable

q.text "URI: #{@dep_uri}"

q.breakable

q.pp @data.keys

end

end

end

def pretty_print(q) # :nodoc:

q.breakable

q.text "name: #{name}"

q.text "platform: #{platform}"

q.breakable

q.breakable

q.pp @dependencies

end

def pretty_print(q) # :nodoc:

q.breakable

q.breakable

q.pp @sets

matching = matching % [

dependency,

]

end

end

def pretty_print(q) # :nodoc:

q.breakable

q.pp @activated

q.breakable

q.pp @dependency

q.breakable

if @dependency == @failed_dep

else

q.pp @failed_dep

end

end

end

end

path

end

end

def pretty_print(q) # :nodoc:

q.breakable

q.text @dependency.to_s

q.breakable

q.pp @requester

end

end

def initialize # :nodoc:

super()

@need_submodules = {}

@repositories = {}

@root_dir = Gem.dir

end

def pretty_print(q) # :nodoc:

next if @repositories.empty?

q.breakable

# the executables.

def install(options = {})

installer = Gem::Installer.for_spec spec, options

end

def pretty_print(q) # :nodoc:

q.breakable

q.text "name: #{name}"

q.text "version: #{version}"

q.breakable

q.breakable

q.pp dependencies

end

def pretty_print(q) # :nodoc:

q.breakable

q.breakable

q.pp @f.sources

q.breakable

q.breakable

end

def inspect # :nodoc:

end

def pretty_print(q) # :nodoc:

q.breakable

q.text full_name

end

q.breakable

q.pp @source

end

end

end

def pretty_print(q) # :nodoc:

q.breakable

q.text "name: #{name}"

q.text "platform: #{platform}"

q.breakable

q.breakable

q.pp spec.dependencies

end

def inspect # :nodoc:

always_install = @always_install.map {|s| s.full_name }

self.class, @domain, @specs.keys, always_install

]

end

end

def pretty_print(q) # :nodoc:

q.breakable

q.text "domain: #{@domain}"

q.breakable

q.pp @specs.keys

q.breakable

q.pp @always_install

end

end

end

def pretty_print(q) # :nodoc:

q.breakable

q.text "name: #{name}"

q.text "platform: #{platform}"

q.breakable

q.breakable

q.pp dependencies

end

def pretty_print(q) # :nodoc:

q.breakable

q.breakable

q.pp @source

q.breakable

q.breakable

q.pp @specs.map {|spec| spec.full_name }

def install(options = {})

destination = options[:install_dir] || Gem.dir

yield nil

return

end

end

def pretty_print(q) # :nodoc:

q.breakable

q.text "name: #{@name}"

unless @dependencies.empty?

q.breakable

q.breakable

q.pp @dependencies

end

# frozen_string_literal: true

# specification.

def install(options = {})

gem = download options

end

def pretty_print(q) # :nodoc:

next if @directories.empty?

q.breakable

##

# S3URISigner implements AWS SigV4 for S3 Source to avoid a dependency on the aws-sdk-* gems

end

def ec2_metadata_credentials_json

iam_info = ec2_metadata_request(EC2_IAM_INFO)

# Expected format: arn:aws:iam::<id>:instance-profile/<role_name>

ec2_metadata_request(EC2_IAM_SECURITY_CREDENTIALS + role_name)

end

if ::Psych.respond_to? :safe_load

def self.safe_load(input)

::Psych.safe_load(input, permitted_classes: PERMITTED_CLASSES, permitted_symbols: PERMITTED_SYMBOLS, aliases: true)

else

::Psych.safe_load(input, PERMITTED_CLASSES, PERMITTED_SYMBOLS, true)

end

def self.load(input)

::Psych.safe_load(input, permitted_classes: [::Symbol])

else

::Psych.safe_load(input, [::Symbol])

# See LICENSE.txt for permissions.

#++

##

# = Signing gems

##

# Used internally to select the signing digest from all computed digests

##

# Length of keys created by RSA and DSA keys

##

# Default algorithm to use when building a key pair

##

# Named curve used for Elliptic Curve

##

# Cipher used to encrypt the key pair used to sign gems.

# Must be in the list returned by OpenSSL::Cipher.ciphers

##

# One day in seconds

# * The certificate contains a subject key identifier

EXTENSIONS = {

}.freeze

def self.alt_name_or_x509_entry(certificate, x509_entry)

OpenSSL::Digest.new(algorithm)

end

else

def self.create_digest(algorithm = DIGEST_NAME)

Digest.const_get(algorithm).new

def self.create_key(algorithm)

if defined?(OpenSSL::PKey)

case algorithm.downcase

OpenSSL::PKey::DSA.new(RSA_DSA_KEY_LENGTH)

OpenSSL::PKey::RSA.new(RSA_DSA_KEY_LENGTH)

if RUBY_VERSION >= "2.4.0"

OpenSSL::PKey::EC.generate(EC_NAME)

else

# Turns +email_address+ into an OpenSSL::X509::Name

def self.email_to_name(email_address)

OpenSSL::X509::Name.new([

["CN", cn],

signee_key = certificate.public_key

alt_name = certificate.extensions.find do |extension|

end

alt_name

issuer_alt_name = signing_cert.extensions.find do |extension|

end

issuer_alt_name

signed = create_cert signee_subject, signee_key, age, extensions, serial

def self.trust_dir

return @trust_dir if @trust_dir

@trust_dir ||= Gem::Security::TrustDir.new dir

end

def self.write(pemmable, path, permissions = 0600, passphrase = nil, cipher = KEY_CIPHER)

path = File.expand_path path

if passphrase and cipher

io.write pemmable.to_pem cipher, passphrase

else

end

if Gem::HAVE_OPENSSL

end

# No security policy: all package signature checks are disabled.

NoSecurity = Policy.new(

:verify_data => false,

:verify_signer => false,

:verify_chain => false,

# easily spoofed, and is not recommended.

AlmostNoSecurity = Policy.new(

:verify_data => true,

:verify_signer => false,

:verify_chain => false,

# is not recommended.

LowSecurity = Policy.new(

:verify_data => true,

:verify_signer => true,

:verify_chain => false,

# gem off as unsigned.

MediumSecurity = Policy.new(

:verify_data => true,

:verify_signer => true,

:verify_chain => true,

# a reasonable guarantee that the contents of the gem have not been altered.

HighSecurity = Policy.new(

:verify_data => true,

:verify_signer => true,

:verify_chain => true,

# Policy used to verify a certificate and key when signing a gem

SigningPolicy = Policy.new(

:verify_data => false,

:verify_signer => true,

:verify_chain => true,

# Hash of configured security policies

Policies = {

# SigningPolicy is not intended for use by `gem -P` so do not list it

}.freeze

# frozen_string_literal: true

##

# A Gem::Security::Policy object encapsulates the settings for verifying

# and is valid for the given +time+.

def check_chain(chain, time)

begin

chain.each_cons 2 do |issuer, cert|

# If the +issuer+ is +nil+ no verification is performed.

def check_cert(signer, issuer, time)

signer

message = "certificate #{signer.subject}"

unless signer and key

return true unless @only_signed

end

raise Gem::Security::Exception,

# +time+.

def check_root(chain, time)

root = chain.first

raise Gem::Security::Exception,

"root certificate #{root.subject} is not self-signed " +

# the digests of the two certificates match according to +digester+

def check_trust(chain, digester, trust_dir)

root = chain.first

path = Gem::Security.trust_dir.cert_path root

def subject(certificate) # :nodoc:

certificate.extensions.each do |extension|

return extension.value

end

# If +key+ is given it is used to validate the signing certificate.

def verify(chain, key = nil, digests = {}, signatures = {},

if signatures.empty?

if @only_signed

raise Gem::Security::Exception,

end

if @verify_data

signer_digests.nil? or signer_digests.empty?

else

signer_digests = {}

def self.re_sign_cert(expired_cert, expired_cert_path, private_key)

return unless expired_cert.not_after < Time.now

expired_cert_file = "#{File.basename(expired_cert_path)}.expired.#{expiry}"

new_expired_cert_path = File.join(Gem.user_home, ".gem", expired_cert_file)

# this value is preferred, otherwise the subject is used.

def extract_name(cert) # :nodoc:

if subject_alt_name

/\Aemail:/ =~ subject_alt_name.value # rubocop:disable Performance/StartWith

def sign(data)

return unless @key

if @cert_chain.length == 1 and @cert_chain.last.not_after < Time.now

alert("Your certificate has expired, trying to re-sign it...")

return unless disk_key

if disk_key.to_pem == @key.to_pem && disk_cert == old_cert.to_pem

old_cert_file = "gem-public_cert.pem.expired.#{expiry}"

old_cert_path = File.join(Gem.user_home, ".gem", old_cert_file)

def each_certificate

return enum_for __method__ unless block_given?

Dir[glob].each do |certificate_file|

begin

destination = cert_path certificate

io.write certificate.to_pem

io.chmod(@permissions[:trusted_cert])

end

# permissions.

def verify

if File.exist? @dir

raise Gem::Security::Exception,

"trust directory #{@dir} is not a directory" unless

# See LICENSE.txt for permissions.

#++

# forward-declare

module Gem::SecurityOption

def add_security_option

Gem::OptionParser.accept Gem::Security::Policy do |value|

defined?(Gem::Security::HighSecurity)

policy = Gem::Security::Policies[value]

policy

end

Gem::Security::Policy,

options[:security_policy] = value

end

end

include Gem::Text

FILES = { # :nodoc:

}.freeze

##

# Returns a Set that can fetch specifications from this source.

def dependency_resolver_set # :nodoc:

fetch_uri = if uri.host == "rubygems.org"

index_uri = uri.dup

return spec if spec

end

spec = fetcher.fetch_path source_uri

spec = Gem::Util.inflate spec

require "fileutils"

FileUtils.mkdir_p cache_dir

io.write spec

end

end

end

def pretty_print(q) # :nodoc:

q.breakable

q.text @uri.to_s

if api = uri

q.breakable

q.text api.to_s

end

end

private

def enforce_trailing_slash(uri)

end

end

@remote = true

@root_dir = Gem.dir

end

def <=>(other)

return false unless File.exist? repo_cache_dir

unless File.exist? install_dir

repo_cache_dir, install_dir

end

Dir.chdir install_dir do

if @need_submodules

require "open3"

success &&= status.success?

end

if File.exist? repo_cache_dir

Dir.chdir repo_cache_dir do

end

else

@repository, repo_cache_dir

end

end

# Directory where git gems get unpacked and so-forth.

def base_dir # :nodoc:

end

##

def install_dir # :nodoc:

return unless File.exist? repo_cache_dir

end

def pretty_print(q) # :nodoc:

q.breakable

q.text @repository

# The directory where the git gem's repository will be cached.

def repo_cache_dir # :nodoc:

end

##

hash = nil

Dir.chdir repo_cache_dir do

end

raise Gem::Exception,

return [] unless install_dir

Dir.chdir install_dir do

directory = File.dirname spec_file

file = File.basename spec_file

spec.base_dir = base_dir

spec.extension_dir =

Gem.extension_api_version, "#{name}-#{dir_shortref}"

spec.full_gem_path = File.dirname spec.loaded_from if spec

# A hash for the git gem based on the git repository URI.

def uri_hash # :nodoc:

normalized =

if @repository =~ %r{^\w+://(\w+@)?}

uri.sub(/\A(\w+)/) { $1.downcase }

else

@repository

end

def pretty_print(q) # :nodoc:

end

end

end

def inspect # :nodoc:

"#<%s specs: %p>" % [self.class, keys]

end

end

def pretty_print(q) # :nodoc:

q.breakable

q.seplist @specs.keys do |v|

q.text v.full_name

end

def pretty_print(q) # :nodoc:

q.breakable

q.text @path

end

# frozen_string_literal: true

##

# SpecFetcher handles metadata updates from remote gem repositories.

# alternative gem names.

def suggest_gems_from_name(gem_name, type = :latest, num_results = 5)

max = gem_name.size / 2

names = available_specs(type).first.values.flatten(1)

matches = names.map do |n|

next unless n.match_platform?

end.compact

if matches.length < num_results

matches += names.map do |n|

next unless n.match_platform?

next if distance >= max

return [n.name] if distance == 0

[n.name, distance]

# See LICENSE.txt for permissions.

#++

##

# The Specification class contains the information for a gem. Typically

# key should be equal to the CURRENT_SPECIFICATION_VERSION.

SPECIFICATION_VERSION_HISTORY = { # :nodoc:

1 => [

'Deprecated "test_suite_file" in favor of the new, but equivalent, "test_files"',

'"test_file=x" is a shortcut for "test_files=[x]"',

],

2 => [

'Added "required_rubygems_version"',

],

3 => [

],

4 => [

],

}.freeze

@@default_value = {

:authors => [],

:autorequire => nil,

:cert_chain => [],

:date => nil,

:dependencies => [],

:platform => Gem::Platform::RUBY,

:post_install_message => nil,

:rdoc_options => [],

:required_ruby_version => Gem::Requirement.default,

:required_rubygems_version => Gem::Requirement.default,

:requirements => [],

# legacy constants

when nil, Gem::Platform::RUBY then

@new_platform = Gem::Platform::RUBY

else

@new_platform = Gem::Platform.new platform

end

file = file.dup.tap(&Gem::UNTAINT)

return unless File.file?(file)

code.tap(&Gem::UNTAINT)

@required_rubygems_version,

@original_platform,

@dependencies,

@email,

@authors,

@description,

return if default_gem?

return if File.exist? gem_build_complete_path

return if !File.writable?(base_dir)

begin

# We need to require things in $LOAD_PATH without looking for the

unresolved_deps = Gem::Specification.unresolved_deps.dup

Gem::Specification.unresolved_deps.clear

ui = Gem::SilentUI.new

Gem::DefaultUserInteraction.use_ui ui do

# spec.doc_dir 'ri' # => "/path/to/gem_repo/doc/a-1/ri"

def doc_dir(type = nil)

if type

File.join @doc_dir, type

def encode_with(coder) # :nodoc:

mark_version

platform = case @original_platform

when String then

@original_platform

else

@original_platform.to_s

end

attributes = @@attributes.map(&:to_s) - %w[name version platform]

attributes.each do |name|

end

def pretty_print(q) # :nodoc:

q.breakable

attributes = @@attributes - [:name, :version]

# Returns the full path to this spec's ri directory.

def ri_dir

end

##

def ruby_code(obj)

case obj

when String then obj.dump + ".freeze"

when Hash then

seg = obj.keys.sort.map {|k| "#{k.to_s.dump} => #{obj[k].to_s.dump}" }

"{ #{seg.join(', ')} }"

when Gem::Version then obj.to_s.dump

when Numeric then obj.inspect

when true, false, nil then obj.inspect

when Gem::Platform then "Gem::Platform.new(#{obj.to_a.inspect})"

# back, we have to check again here to make sure that our

# psych code was properly loaded, and load it if not.

unless Gem.const_defined?(:NoAliasYAMLTree)

end

builder = Gem::NoAliasYAMLTree.create

builder << self

ast = builder.tree

io = StringIO.new

io.set_encoding Encoding::UTF_8

# skip to set required_ruby_version when d rubygems.

# It caused to raise CircularDependencyError

if @version.prerelease? && (@name.nil? || @name.strip != "rubygems")

end

invalidate_memoized_attributes

class Gem::SpecificationPolicy

include Gem::UserInteraction

metadata = @specification.metadata

unless Hash === metadata

end

metadata.each do |key, value|

prerelease_dep && [email protected]?

open_ended = dep.requirement.requirements.all? do |op, version|

end

if open_ended

base = segments.first 2

" use a bounded requirement, such as '~> x.y'"

else

", '> #{dep_version}'"

", '>= #{dep_version}'"

end

def validate_require_paths

return unless @specification.raw_require_paths.empty?

end

def validate_non_files

def validate_specification_version

return if @specification.specification_version.is_a?(Integer)

end

def validate_platform

WARNING

end

LAZY_PATTERN = /\AFI XME|\ATO DO/x.freeze

HOMEPAGE_URI_PATTERN = /\A[a-z][a-z\d+.-]*:/i.freeze

# Make sure a homepage is valid HTTP/HTTPS URI

if homepage and not homepage.empty?

begin

homepage_uri = URI.parse(homepage)

unless [URI::HTTP, URI::HTTPS].member? homepage_uri.class

def validate_shebang_line_in(executable)

executable_path = File.join(@specification.bindir, executable)

warning "#{executable_path} is missing #! line"

end

end

def validate_extensions # :nodoc:

builder = Gem::Ext::Builder.new(@specification)

rake_extension = @specification.extensions.any? {|s| builder.builder_for(s) == Gem::Ext::RakeBuilder }

warning <<-WARNING if rake_extension && !rake_dependency

You have specified rake based extension, but rake is not added as dependency. It is recommended to add rake as a dependency in gemspec since there's no guarantee rake will be already installed.

PREFIX = "# stub: ".freeze

# :nodoc:

class StubLine # :nodoc: all

attr_reader :name, :version, :platform, :require_paths, :extensions,

# These are common require paths.

REQUIRE_PATHS = { # :nodoc:

}.freeze

# These are common require path lists. This hash is used to optimize

# in their require paths, so lets take advantage of that by pre-allocating

# a require path list for that case.

REQUIRE_PATH_LIST = { # :nodoc:

}.freeze

def initialize(data, extensions)

# frozen_string_literal: true

# See LICENSE.txt for permissions.

#++

##

# An Uninstaller.

# Is +spec+ in +gem_dir+?

def path_ok?(gem_dir, spec)

full_path == spec.full_gem_path || original_path == spec.full_gem_path

end

# Asks if it is OK to remove +spec+. Returns true if it is OK.

def ask_if_ok(spec) # :nodoc:

msg << "\t#{spec.full_name}"

siblings = Gem::Specification.select do |s|

s.name == spec.name && s.full_name != spec.full_name

end

end

return ask_yes_no(msg.join("\n"), false)

end

# of what it did for us to find rather than trying to recreate

# it again.

if @format_executable

Gem::Installer.exec_format % File.basename(filename)

else

filename

def redact_credentials_from(text)

return text unless valid_uri? && password? && text.include?(to_s)

end

def method_missing(method_name, *args, &blk)

end

def with_redacted_user

end

def with_redacted_password

end

def valid_uri?

end

def oauth_basic?

end

def token?

# Creates a new URI formatter for +uri+.

def initialize(uri)

@uri = uri

end

# See LICENSE.txt for permissions.

#++

##

# Module that defines the default UserInteraction. Any class including this

##

# Displays the given +statement+ on the standard output (or equivalent).

ui.say statement

end

default_answer = case default

when nil

when true

else

end

result = nil

def require_io_console

@require_io_console ||= begin

begin

rescue LoadError

end

true

# and the +terminal_message+ when it is complete.

def initialize(out_stream, size, initial_message,

@out = out_stream

@total = size

@count = 0

# frozen_string_literal: true

##

# This module contains various utility methods as module methods.

# Zlib::GzipReader wrapper that unzips +data+.

def self.gunzip(data)

gzip_reader = begin

Zlib::GzipReader.new(data)

# Zlib::GzipWriter wrapper that zips +data+.

def self.gzip(data)

zipped.set_encoding Encoding::BINARY

Zlib::GzipWriter.wrap zipped do |io|

# A Zlib::Inflate#inflate wrapper

def self.inflate(data)

Zlib::Inflate.inflate data

end

loop do

Dir.chdir here, &block rescue Errno::EACCES

return if new_here == here # toplevel

here = new_here

end

# comes with a leading slash.

def self.correct_for_windows_path(path)

path[1..-1]

else

path

# frozen_string_literal: true

class Gem::Licenses

extend Gem::Text

# Software Package Data Exchange (SPDX) standard open-source software

# license identifiers

# See LICENSE.txt for permissions.

#++

##

# Validator performs various gem file and gem database validation

include Gem::UserInteraction

def initialize # :nodoc:

end

private

begin

next unless data # HACK `gem check -a mkrf`

File.open source, Gem.binary_mode do |f|

unless f.read == data

end

end

end

end

def yaml_initialize(tag, map) # :nodoc:

@segments = nil

@hash = nil

end

end

def encode_with(coder) # :nodoc:

end

##

@@release[self] ||= if prerelease?

segments = self.segments

segments.pop while segments.any? {|s| String === s }

else

self

end

# See LICENSE.txt for permissions.

#++

##

# Mixin methods for --version and --platform Gem::Command options.

end

end

"Specify the platform of gem to #{task}", *wrap) do

|value, options|

unless options[:added_platform]

Gem::Requirement.new(*value.split(/\s*,\s*/))

end

"Specify version of gem to #{task}", *wrap) do

|value, options|

# Allow handling for multiple --version operators