"Install to the system location ($BUNDLE_PATH or $GEM_HOME) even if the bundle was previously installed somewhere else for this application"

method_option "trust-policy", :alias => "P", :type => :string, :banner =>

"Gem trust policy (like gem install -P). Must be one of " +

method_option "without", :type => :array, :banner =>

"Exclude gems that are part of the specified named group."

method_option "with", :type => :array, :banner =>

def remove_ruby_from_platforms_if_necessary!(dependencies)

return if Bundler.frozen_bundle? ||

remove_platform(Gem::Platform::RUBY)

add_current_platform

def connection

@connection ||= begin

needs_ssl = remote_uri.scheme == "https" ||

raise SSLError if needs_ssl && !defined?(OpenSSL::SSL)

con = PersistentHTTP.new :name => "bundler", :proxy => :ENV

end

ssl_client_cert = Bundler.settings[:ssl_client_cert] ||

if ssl_client_cert

pem = File.read(ssl_client_cert)

con.cert = OpenSSL::X509::Certificate.new(pem)

def bundler_cert_store

store = OpenSSL::X509::Store.new

ssl_ca_cert = Bundler.settings[:ssl_ca_cert] ||

if ssl_ca_cert

if File.directory? ssl_ca_cert

store.add_path ssl_ca_cert

raise GemfileError, "Please define :engine" if options[:engine_version] && options[:engine].nil?

if options[:engine] == "ruby" && options[:engine_version] &&

raise GemfileEvalError, "ruby_version must match the :engine_version for MRI"

end

@ruby_version = RubyVersion.new(ruby_version, options[:level], options[:engine], options[:engine_version])

# 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.

def self.prefix

prefix = File.dirname RUBYGEMS_DIR

"lib" == File.basename(RUBYGEMS_DIR)

prefix

end

# Returns the latest release version of RubyGems.

def self.latest_rubygems_version

end

##

def self.latest_version_for(name)

spec = latest_spec_for name

end

##

".rb",

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

val = RbConfig::CONFIG[key]

".#{val}"

end,

].compact.uniq

s = o.set

when Array

s = o.map do |sp,so|

raise TypeError, "Array must be in [[spec, source], ...] form"

end

@set.reject! do |t|

# already locally installed

Gem::Specification.any? do |installed_spec|

end

end

if Gem::Platform::RUBY == platform || Gem::Platform.local === platform

warn "Ignoring #{full_name} because its extensions are not built. " +

end

return false

# default Ruby platform.

def full_name

"#{name}-#{version}".dup.tap(&Gem::UNTAINT)

else

"#{name}-#{version}-#{platform}".dup.tap(&Gem::UNTAINT)

gem = "'#{gem_name}' (#{version})"

msg = String.new "Could not find a valid gem #{gem}"

msg << ", here is why:\n"

errors.each {|x| msg << " #{x.wordy}\n" }

else

msg << " (required by #{required_by}) in any repository"

else

msg << " in any repository"

def get_all_gem_names

args = options[:args]

raise Gem::CommandLineError,

"Please specify at least one gem name (e.g. gem build GEMNAME)"

end

def get_one_gem_name

args = options[:args]

raise Gem::CommandLineError,

"Please specify a gem name on the command line (e.g. gem build GEMNAME)"

end

end

def configure_options(header, option_list)

header = header.to_s.empty? ? "" : "#{header} "

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

add_common_option("-V", "--[no-]verbose",

"Set the verbose level of output") do |value, options|

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

Gem.configuration.verbose = 1

else

Gem.configuration.verbose = value

def build_cert(email, key) # :nodoc:

expiration_length_days = options[:expiration_length_days] ||

cert = Gem::Security.create_cert_email(

email,

@primary_gems = {}

Gem::Specification.each do |spec|

@primary_gems[spec.name].version < spec.version

@primary_gems[spec.name] = spec

end

gem_contents name

end

end

end

name_matches = name_pattern ? name_pattern =~ spec.name : true

version_matches = requirement.satisfied_by?(spec.version)

}.map(&:to_spec)

end

end

def ensure_local_only_reverse_dependencies # :nodoc:

alert_error "Only reverse dependencies for local gems are supported."

terminate_interaction 1

end

sp.dependencies.each do |dep|

dep = Gem::Dependency.new(*dep) unless Gem::Dependency === dep

dep.requirement.satisfied_by?(spec.version)

result << [sp.full_name, dep]

end

def name_pattern(args)

return if args.empty?

flags = $2 ? Regexp::IGNORECASE : nil

Regexp.new $1, flags

else

end

def check_version # :nodoc:

alert_error "Can't use --version with multiple gems. You can specify multiple gems with" \

" version requirements using `gem fetch 'my_gem:1.0.0' 'my_other_gem:~>2.0.0'`"

terminate_interaction 1

# This is always true because it's the only way now.

options[:build_modern] = true

alert_error "unknown directory name #{options[:directory]}."

terminate_interaction 1

else

def defaults_str # :nodoc:

"--both --version '#{Gem::Requirement.default}' --no-force\n" +

end

def description # :nodoc:

end

def check_install_dir # :nodoc:

alert_error "Use --install-dir or --user-install but not both"

terminate_interaction 1

end

end

def check_version # :nodoc:

alert_error "Can't use --version with multiple gems. You can specify multiple gems with" \

" version requirements using `gem install 'my_gem:1.0.0' 'my_other_gem:~>2.0.0'`"

terminate_interaction 1

end

def install_gem(name, version) # :nodoc:

req = Gem::Requirement.create(version)

# `--extensions` must be explicitly given to pristine only gems

# with extensions.

Gem::Specification.select do |spec|

end

else

get_all_gem_names.sort.map do |gem_name|

end

end

say "Skipped #{spec.full_name}, it needs to compile an extension"

next

end

gem = spec.cache_file

require_relative "../remote_fetcher"

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

# ignore

end

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

Dir[File.join(Gem.dir, "doc", "rubygems-[0-9]*")].each do |dir|

rm_rf dir

history_string = ""

versions.shift <= options[:previous_version] do

history_string += version_lines.shift + text.shift

end

def check_rubygems_https(source_uri) # :nodoc:

uri = URI source_uri

uri.host.downcase == "rubygems.org"

question = <<-QUESTION.chomp

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

def remove_cache_file(desc, path) # :nodoc:

FileUtils.rm_rf path

say "*** Removed #{desc} source cache ***"

say "*** Unable to remove #{desc} source cache (write protected) ***"

else

say "*** Unable to remove #{desc} source cache ***"

raise Gem::CommandLineError, "Unsupported version type: '#{v}'"

end

alert_error "Specify --all or -v, not both"

terminate_interaction 1

end

field = get_one_optional_argument

raise Gem::CommandLineError, "--ruby and FIELD are mutually exclusive" if

if local?

if File.exist? gem

def defaults_str # :nodoc:

"--version '#{Gem::Requirement.default}' --no-force " +

end

def description # :nodoc:

end

def check_version # :nodoc:

alert_error "Can't use --version with multiple gems. You can specify multiple gems with" \

" version requirements using `gem uninstall 'my_gem:1.0.0' 'my_other_gem:~>2.0.0'`"

terminate_interaction 1

def execute

check_version

uninstall_specific

elsif options[:all]

uninstall_all

def defaults_str # :nodoc:

"--no-force --install-dir #{Gem.dir}\n" +

end

def description # :nodoc:

Gem::Specification.dirs = Gem.user_dir if options[:user_install]

Gem::Specification.each do |spec|

hig[spec.name] = spec

end

end

args << "--no-document" unless options[:document].include?("rdoc") || options[:document].include?("ri")

args << "--no-format-executable" if options[:no_format_executable]

args << "--previous-version" << Gem::VERSION if

args

end

result = []

highest_installed_gems.each do |l_name, l_spec|

gem_names.none? {|name| name == l_spec.name }

highest_remote_tup = highest_remote_name_tuple l_spec

dirs.each do |dir|

Gem.suffixes.each do |ext|

full_path = File.join dir, "#{package_name}#{ext}"

result << full_path

return result unless options[:show_all]

end

# True if the backtrace option has been specified, or debug is on.

def backtrace

end

# The name of the configuration file.

end

def ==(other) # :nodoc:

@hash == other.hash

end

start += 1

if path = loc.path

# Non-rubygems frames

uplevel -= 1

end

path = []

path << user_dir if user_home && File.exist?(user_home)

path << default_dir

path

end

# What does this dependency require?

def requirement

# @version_requirements and @version_requirement are legacy ivar

# names, and supported here because older gems need to keep

version = Gem::Version.new version

requirement.satisfied_by? version

end

# gems should be considered.

def consider_local?

end

##

# gems should be considered.

def consider_remote?

end

##

def in_background(what) # :nodoc:

fork_happened = false

begin

Process.fork do

yield

end

def install_development_deps # :nodoc:

:shallow

elsif @development

:all

installer_set.force = @force

if consider_local?

src = Gem::Source::SpecificFile.new dep_or_name

installer_set.add_local dep_or_name, src.spec, src

version = src.spec.version if version == Gem::Requirement.default

each do |spec|

spec.runtime_dependencies.each do |dep|

inst = Gem::Specification.any? do |installed_spec|

end

unsatisfied[spec.name] << dep

return unsatisfied if quick

end

def remove_specs_unsatisfied_by(dependencies)

specs.reject! do |spec|

dep = dependencies[spec.name]

end

end

missing =

Gem::REPOSITORY_SUBDIRECTORIES.sort -

raise "Update REPOSITORY_EXTENSION_MAP, missing: #{missing.join ', '}" unless

missing.empty?

# Are we doctoring a gem repository?

def gem_repository?

end

##

basename = File.basename(child, extension)

next if installed_specs.include? basename

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

type = File.directory?(child) ? "directory" : "file"

# Gem::Resolver::DependencyRequest +dep+

def initialize(dep, platform_mismatch=nil)

plats = platform_mismatch.map {|x| x.platform.to_s }.sort.uniq

super "Unable to resolve dependency: No match for '#{dep}' on this platform. Found: #{plats.join(', ')}"

else

full_tmp_dest = File.join(extension_dir, tmp_dest_relative)

# TODO remove in RubyGems 4

FileUtils.mkdir_p lib_dir

entries = Dir.entries(full_tmp_dest) - %w[. ..]

entries = entries.map {|entry| File.join full_tmp_dest, entry }

FileUtils::Entry_.new(full_tmp_dest).traverse do |ent|

destent = ent.class.new(dest_path, ent.rel)

end

ensure

ENV["DESTDIR"] = destdir

begin

env_rubygems_host = ENV["RUBYGEMS_HOST"]

env_rubygems_host = nil if

env_rubygems_host || configured_host

end

next

end

[spec.name, spec.version, platform]

end

files = @files

files.delete @quick_marshal_dir if files.include? @quick_dir

files.delete @quick_marshal_dir

dst_name = File.join(@dest_directory, @quick_marshal_dir_base)

index.each do |spec|

platform = spec.original_platform

specs_index << [spec.name, spec.version, platform]

end

return if spec.name == existing

# somebody has written to RubyGems' directory, overwrite, too bad

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

# True if the gems in the system satisfy +dependency+.

def installation_satisfies_dependency?(dependency)

return true if installed_specs.detect {|s| dependency.matches_spec? s }

return false if @only_install_dir

end

##

end

def generate_bin # :nodoc:

ensure_writable_dir @bin_dir

@version = version

unless platform.kind_of? Gem::Platform

end

@platform = platform

def ==(other)

case other

when self.class

@platform == other.platform

when Array

to_a == other

class PathError < Error

def initialize(destination, destination_dir)

super "installing into parent path %s of %s is not allowed" %

end

end

class SymlinkError < Error

def initialize(name, destination, destination_dir)

super "installing symlink '%s' pointing to parent path %s of %s is not allowed" %

end

end

"package content (data.tar.gz) is missing", @gem

end

raise Gem::Security::Exception, "duplicate files in the package: (#{duplicates.map(&:inspect).join(', ')})"

end

end

end

def ==(other) # :nodoc:

end

def to_s # :nodoc:

prefix = parts.join("/")

end

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

end

def self.match_platforms?(platform, platforms)

platforms.any? do |local_platform|

end

end

private_class_method :match_platforms?

when String then

arch = arch.split "-"

extra = arch.pop

arch.last << "-#{extra}"

end

else cpu

end

@os, @version = arch

return

end

when /mingw-?(\w+)?/ then [ "mingw", $1 ]

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

os, version = $1, $3

[os, version]

when /netbsdelf/ then [ "netbsdelf", nil ]

when /openbsd(\d+\.\d+)?/ then [ "openbsd", $1 ]

# the same CPU, OS and version.

def ==(other)

end

alias :eql? :==

return nil unless Gem::Platform === other

# universal-mingw32 matches x64-mingw-ucrt

# cpu

end

##

end

def display_header(type)

say

say "*** #{type} GEMS ***"

say

name_matches = name ? s.name =~ name : true

version_matches = show_prereleases? || !s.version.prerelease?

end

spec_tuples = specs.map do |spec|

# Check if gem +name+ version +version+ is installed.

def installed?(name, req = Gem::Requirement.default)

end

def output_query_results(spec_tuples)

return unless options[:versions]

list =

name_tuples.map {|n| n.version }.uniq

else

platforms.sort.reverse.map do |version, pls|

end

def spec_homepage(entry, spec)

entry << "\n" << format_text("Homepage: #{spec.homepage}", 68, 4)

end

def spec_license(entry, spec)

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

licenses << spec.licenses.join(", ")

cache_dir =

if Dir.pwd == install_dir # see fetch_command

install_dir

install_cache_dir

else

File.join Gem.user_dir, "cache"

data = send "fetch_#{uri.scheme}", uri, mtime, head

begin

data = Gem::Util.gunzip data

rescue Zlib::GzipFile::Error

return Gem.read_binary(path)

end

Gem.write_binary(path, data)

end

require "uri"

uri = URI(Gem::UriFormatter.new(env_proxy).normalize)

user = ENV["#{_scheme}_proxy_user"] || ENV["#{_SCHEME}_PROXY_USER"]

password = ENV["#{_scheme}_proxy_pass"] || ENV["#{_SCHEME}_PROXY_PASS"]

def get_no_proxy_from_env

env_no_proxy = ENV["no_proxy"] || ENV["NO_PROXY"]

env_no_proxy.split(/\s*,\s*/)

end

no_proxy = get_no_proxy_from_env

proxy_hostname = proxy_uri.respond_to?(:hostname) ? proxy_uri.hostname : proxy_uri.host

net_http_args + [

proxy_hostname,

def close_all

until @queue.empty?

connection.finish

end

end

def tsort_each_child(node) # :nodoc:

node.spec.dependencies.each do |dep|

match = @requests.find do |r|

end

unless match

next if @soft_missing

raise Gem::DependencyError,

"Unresolved dependency found during sorting - #{dep} (requested by #{node.spec.full_name})"

duplicate = @dependencies.include? name

@dependencies[name] =

Gem::Requirement.default

elsif source_set

Gem::Requirement.source_set

raise ArgumentError,

"You must specify engine_version along with the Ruby engine" if

return true if @installing

raise Gem::RubyVersionMismatch, message

end

message = "Your Ruby engine is #{Gem.ruby_engine}, " +

"but your #{gem_deps_file} requires #{engine}"

when "PLATFORMS" then

parse_PLATFORMS

else

end

else

raise "BUG: unhandled token #{token.type} (#{token.value.inspect}) at line #{token.line} column #{token.column}"

def get(expected_types = nil, expected_value = nil) # :nodoc:

token = @tokens.shift

unget token

message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " +

raise Gem::RequestSet::Lockfile::ParseError.new message, token.column, token.line, @filename

end

unget token

message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " +

end

def parse_DEPENDENCIES # :nodoc:

token = get :text

requirements = []

set = Gem::Resolver::LockSet.new sources

last_specs = nil

token = get :text

name = token.value

column = token.column

type = token.type

data = token.value

version, platform = data.split "-", 2

platform =

type = peek.type

value = peek.value

get

get :text

last_spec = nil

token = get :text

name = token.value

column = token.column

type = token.type

data = token.value

last_spec = set.add_git_spec name, data, repository, revision, true

else

dependency = parse_dependency name, data

set = Gem::Resolver::VendorSet.new

last_spec = nil

token = get :text

name = token.value

column = token.column

type = token.type

data = token.value

last_spec = set.add_vendor_gem name, directory

else

dependency = parse_dependency name, data

end

def parse_PLATFORMS # :nodoc:

name = get(:text).value

@platforms << name

require_relative "parser"

class Gem::RequestSet::Lockfile::Tokenizer

end

def skip(type)

end

##

def specific?

return true if @requirements.length > 1 # GIGO, > 1, > 2 is silly

end

def to_s # :nodoc:

s.fetch_development_dependencies if @development

s.dependencies.reverse_each do |d|

act.development?

act.parent

reqs << Gem::Resolver::DependencyRequest.new(d, act)

conflict = e.conflicts.values.first

raise Gem::DependencyResolutionError, Conflict.new(conflict.requirement_trees.first.first, conflict.existing, conflict.requirement)

ensure

end

##

end

def ==(other) # :nodoc:

@platform == other.platform

end

end

def find_all(req) # :nodoc:

super

rescue Gem::RemoteFetcher::FetchError => e

end

def prefetch(reqs) # :nodoc:

super

end

uri = uri + "."

raise error unless api_set = @sets.find do |set|

end

index_set = Gem::Resolver::IndexSet.new api_set.source

end

def ==(other) # :nodoc:

@failed_dep == other.failed_dep

end

class Gem::Resolver::GitSpecification < Gem::Resolver::SpecSpecification

def ==(other) # :nodoc:

@source == other.source

end

class Gem::Resolver::InstalledSpecification < Gem::Resolver::SpecSpecification

def ==(other) # :nodoc:

@spec == other.spec

end

found = find_all request

found.delete_if do |s|

end unless dependency.prerelease?

found = found.select do |s|

end

found = found.sort_by do |s|

# Should local gems should be considered?

def consider_local? # :nodoc:

end

##

# Should remote gems should be considered?

def consider_remote? # :nodoc:

end

##

dep = req.dependency

name = dep.name

end

end

res.concat @remote_set.find_all req if consider_remote?

res

dep = Gem::Dependency.new name, version

found = @specs.find do |spec|

end

tuple = Gem::NameTuple.new found.name, found.version, found.platform

def spec

@spec ||= Gem::Specification.find do |spec|

end

@spec ||= Gem::Specification.new do |s|

class Gem::Resolver::VendorSpecification < Gem::Resolver::SpecSpecification

def ==(other) # :nodoc:

@source == other.source

end

path = File.expand_path path

File.open path, "wb", permissions do |io|

io.write pemmable.to_pem cipher, passphrase

else

io.write pemmable.to_pem

message = "certificate #{signer.subject}"

raise Gem::Security::Exception,

"#{message} not valid before #{not_before}"

end

raise Gem::Security::Exception, "#{message} not valid after #{not_after}"

end

raise Gem::Security::Exception,

"#{message} was not issued by #{issuer.subject}"

end

# Ensures the public key of +key+ matches the public key in +signer+

def check_key(signer, key)

return true unless @only_signed

raise Gem::Security::Exception, "missing key or signature"

if @verify_data

raise Gem::Security::Exception, "no digests provided (probable bug)" if

else

signer_digests = {}

end

if @only_trusted

check_trust chain, digester, trust_dir

# trust is irrelevant if there's no signatures to verify

else

alert_warning "#{subject signer} is not trusted for #{full_name}"

raise Gem::Security::Exception, "no certs provided" if @cert_chain.empty?

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

re_sign_key(

end

def ==(other) # :nodoc:

end

alias_method :eql?, :== # :nodoc:

end

def ==(other) # :nodoc:

@need_submodules == other.need_submodules

end

found[source] = specs.select do |tup|

if dependency.match?(tup)

pm = (

rejected_specs[dependency] ||= \

Gem::PlatformMismatch.new(tup.name, tup.version))

# spec.platform = Gem::Platform.local

def platform=(platform)

@original_platform == Gem::Platform::RUBY

@original_platform = platform

end

def self.find_active_stub_by_path(path)

stub = @@active_stub_with_requirable_file[path] ||= (stubs.find do |s|

end || NOT_FOUND)

stub.this

end

latest_remote = remotes.sort.last

yield [local_spec, latest_remote] if

end

nil

# Singular reader for #authors. Returns the first author in the list

def author

end

##

conflicts = {}

self.runtime_dependencies.each do |dep|

spec = Gem.loaded_specs[dep.name]

(conflicts[spec] ||= []) << dep

end

end

self.dependencies.any? do |dep|

if dep.runtime?

spec = Gem.loaded_specs[dep.name]

else

false

end

DateLike = Object.new # :nodoc:

def DateLike.===(obj) # :nodoc:

end

DateTimeFormat = # :nodoc:

# executable now. See Gem.bin_path.

def default_executable # :nodoc:

result = @default_executable

result = Array(@executables).first

else

result = nil

# Singular accessor for #executables

def executable

end

##

# True if this gem has files in test_files

def has_unit_tests? # :nodoc:

end

# :stopdoc:

self.name = name if name

self.version = version if version

self.platform = platform

end

return

end

warn "ignoring #{sym} loading #{full_name}" if $DEBUG

else

super

# file list.

def normalize

@extra_rdoc_files.uniq!

@files ||= []

@files.concat(@extra_rdoc_files)

# platform. For use with legacy gems.

def original_name # :nodoc:

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

else

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

attributes.each do |attr_name|

current_value = self.send attr_name

current_value = current_value.sort if %i[files test_files].include? attr_name

q.text "s.#{attr_name} = "

# Singular accessor for #require_paths

def require_path

end

##

def satisfies_requirement?(dependency)

return @name == dependency.name &&

end

##

# Singular accessor for #test_files

def test_file # :nodoc:

end

##

@test_files = [@test_suite_file].flatten

@test_suite_file = nil

end

@test_files

else

@test_files = []

result << " s.name = #{ruby_code name}"

result << " s.version = #{ruby_code version}"

result << " s.platform = #{ruby_code original_platform}"

end

result << ""

result << " s.required_rubygems_version = #{ruby_code required_rubygems_version} if s.respond_to? :required_rubygems_version="

result << " s.metadata = #{ruby_code metadata} if s.respond_to? :metadata="

end

result << " s.require_paths = #{ruby_code raw_require_paths}"

prerelease_dep && [email protected]?

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

end

if open_ended

else

bugfix = if op == ">"

", '> #{dep_version}'"

", '>= #{dep_version}'"

end

String

end

error "#{field} must be an Array of #{klass}"

end

end

homepage = @specification.homepage

# Make sure a homepage is valid HTTP/HTTPS URI

require "uri"

begin

homepage_uri = URI.parse(homepage)

@default_specs_matching_uninstall_params = default_specs

list, other_repo_specs = list.partition do |spec|

end

list.sort!

# spec:: the spec of the gem to be uninstalled

def remove(spec)

e = Gem::GemNotInHomeException.new \

"Gem '#{spec.full_name}' is not installed in directory #{@gem_home}"

e.spec = spec

# Ask a question. Returns an answer if connected to a tty, nil otherwise.

def ask(question)

@outs.print(question + " ")

@outs.flush

# Ask for a password. Does not echo response to terminal.

def ask_for_password(question)

@outs.print(question, " ")

@outs.flush

# same precision. Version "1.0" is not the same as version "1".

def eql?(other)

end

def hash # :nodoc: