RUBYGEMS_DIR = __dir__

##

# An Array of Regexps that match windows Ruby platforms.

WIN_PATTERNS = [

/bccwin/i,

/cygwin/i,

/djgpp/i,

/mingw/i,

/mswin/i,

/wince/i,

].freeze

GEM_DEP_FILES = %w[

gem.deps.rb

gems.rb

Gemfile

Isolate

].freeze

##

# Subdirectories in a gem repository

REPOSITORY_SUBDIRECTORIES = %w[

build_info

cache

doc

extensions

gems

plugins

specifications

].freeze

##

# Subdirectories in a gem repository for default gems

REPOSITORY_DEFAULT_GEM_SUBDIRECTORIES = %w[

gems

specifications/default

].freeze

##

# The default value for SOURCE_DATE_EPOCH if not specified.

# We want a date after 1980-01-01, to prevent issues with Zip files.

# This particular timestamp is for 1980-01-02 00:00:00 GMT.

DEFAULT_SOURCE_DATE_EPOCH = 315_619_200

@@win_platform = nil

@configuration = nil

@gemdeps = nil

@loaded_specs = {}

LOADED_SPECS_MUTEX = Thread::Mutex.new

@path_to_default_spec_map = {}

@platforms = []

@ruby = nil

@ruby_api_version = nil

@sources = nil

@post_build_hooks ||= []

@post_install_hooks ||= []

@post_uninstall_hooks ||= []

@pre_uninstall_hooks ||= []

@pre_install_hooks ||= []

@pre_reset_hooks ||= []

@post_reset_hooks ||= []

@default_source_date_epoch = nil

@discover_gems_on_require = true

@target_rbconfig = nil

##

# Try to activate a gem containing +path+. Returns true if

# activation succeeded or wasn't needed because it was already

# activated. Returns false if it can't find the path in a gem.

def self.try_activate(path)

# finds the _latest_ version... regardless of loaded specs and their deps

# if another gem had a requirement that would mean we shouldn't

# activate the latest version, then either it would already be activated

# or if it was ambiguous (and thus unresolved) the code in our custom

# require will try to activate the more specific version.

spec = Gem::Specification.find_by_path path

return false unless spec

return true if spec.activated?

begin

spec.activate

rescue Gem::LoadError => e # this could fail due to gem dep collisions, go lax

spec_by_name = Gem::Specification.find_by_name(spec.name)

if spec_by_name.nil?

raise e

else

spec_by_name.activate

end

end

true

end

def self.needs

rs = Gem::RequestSet.new

yield rs

finish_resolve rs

end

def self.finish_resolve(request_set=Gem::RequestSet.new)

request_set.import Gem::Specification.unresolved_deps.values

request_set.import Gem.loaded_specs.values.map {|s| Gem::Dependency.new(s.name, s.version) }

request_set.resolve_current.each do |s|

s.full_spec.activate

end

end

##

# Find the full path to the executable for gem +name+. If the +exec_name+

# is not given, an exception will be raised, otherwise the

# specified executable's path is returned. +requirements+ allows

# you to specify specific gem versions.

def self.bin_path(name, exec_name = nil, *requirements)

requirements = Gem::Requirement.default if

requirements.empty?

find_spec_for_exe(name, exec_name, requirements).bin_file exec_name

end

def self.find_spec_for_exe(name, exec_name, requirements)

raise ArgumentError, "you must supply exec_name" unless exec_name

dep = Gem::Dependency.new name, requirements

loaded = Gem.loaded_specs[name]

return loaded if loaded && dep.matches_spec?(loaded)

specs = dep.matching_specs(true)

specs = specs.find_all do |spec|

spec.executables.include? exec_name

end if exec_name

unless spec = specs.first

msg = "can't find gem #{dep} with executable #{exec_name}"

raise Gem::GemNotFoundException, msg

end

spec

end

private_class_method :find_spec_for_exe

##

# Find the full path to the executable for gem +name+. If the +exec_name+

# is not given, an exception will be raised, otherwise the

# specified executable's path is returned. +requirements+ allows

# you to specify specific gem versions.

#

# A side effect of this method is that it will activate the gem that

# contains the executable.

#

# This method should *only* be used in bin stub files.

def self.activate_bin_path(name, exec_name = nil, *requirements) # :nodoc:

spec = find_spec_for_exe name, exec_name, requirements

Gem::LOADED_SPECS_MUTEX.synchronize do

spec.activate

finish_resolve

end

spec.bin_file exec_name

end

##

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

def self.binary_mode

"rb"

end

##

# The path where gem executables are to be installed.

def self.bindir(install_dir=Gem.dir)

return File.join install_dir, "bin" unless

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)

File.join install_dir, "plugins"

end

##

# Reset the +dir+ and +path+ values. The next time +dir+ or +path+

# is requested, the values will be calculated from scratch. This is

# mainly used by the unit tests to provide test isolation.

def self.clear_paths

@paths = nil

@user_home = nil

Gem::Specification.reset

Gem::Security.reset if defined?(Gem::Security)

end

##

# The standard configuration object for gems.

def self.configuration

@configuration ||= Gem::ConfigFile.new []

end

##

# Use the given configuration object (which implements the ConfigFile

# protocol) as the standard configuration object.

def self.configuration=(config)

@configuration = config

end

##

# A Zlib::Deflate.deflate wrapper

def self.deflate(data)

require "zlib"

Zlib::Deflate.deflate data

end

# Retrieve the PathSupport object that RubyGems uses to

# lookup files.

def self.paths

@paths ||= Gem::PathSupport.new(ENV)

end

# Initialize the filesystem paths to use from +env+.

# +env+ is a hash-like object (typically ENV) that

# is queried for 'GEM_HOME', 'GEM_PATH', and 'GEM_SPEC_CACHE'

# Keys for the +env+ hash should be Strings, and values of the hash should

# be Strings or +nil+.

def self.paths=(env)

clear_paths

target = {}

env.each_pair do |k,v|

case k

when "GEM_HOME", "GEM_PATH", "GEM_SPEC_CACHE"

case v

when nil, String

target[k] = v

when Array

unless Gem::Deprecate.skip

warn <<-EOWARN

Array values in the parameter to `Gem.paths=` are deprecated.

Please use a String or nil.

An Array (#{env.inspect}) was passed in from #{caller[3]}

EOWARN

end

target[k] = v.join File::PATH_SEPARATOR

end

else

target[k] = v

end

end

@paths = Gem::PathSupport.new ENV.to_hash.merge(target)

Gem::Specification.dirs = @paths.path

end

##

# The path where gems are to be installed.

def self.dir

paths.home

end

def self.path

paths.path

end

def self.spec_cache_dir

paths.spec_cache_dir

end

##

# The RbConfig object for the deployment target platform.

#

# This is usually the same as the running platform, but may be

# different if you are cross-compiling.

def self.target_rbconfig

@target_rbconfig || Gem::TargetRbConfig.for_running_ruby

end

def self.set_target_rbconfig(rbconfig_path)

@target_rbconfig = Gem::TargetRbConfig.from_path(rbconfig_path)

Gem::Platform.local(refresh: true)

Gem.platforms << Gem::Platform.local unless Gem.platforms.include? Gem::Platform.local

@target_rbconfig

end

##

# Quietly ensure the Gem directory +dir+ contains all the proper

# subdirectories. If we can't create a directory due to a permission

# problem, then we will silently continue.

#

# If +mode+ is given, missing directories are created with this mode.

#

# World-writable directories will never be created.

def self.ensure_gem_subdirectories(dir = Gem.dir, mode = nil)

ensure_subdirectories(dir, mode, REPOSITORY_SUBDIRECTORIES)

end

##

# Quietly ensure the Gem directory +dir+ contains all the proper

# subdirectories for handling default gems. If we can't create a

# directory due to a permission problem, then we will silently continue.

#

# If +mode+ is given, missing directories are created with this mode.

#

# World-writable directories will never be created.

def self.ensure_default_gem_subdirectories(dir = Gem.dir, mode = nil)

ensure_subdirectories(dir, mode, REPOSITORY_DEFAULT_GEM_SUBDIRECTORIES)

end

def self.ensure_subdirectories(dir, mode, subdirs) # :nodoc:

old_umask = File.umask

File.umask old_umask | 0o002

options = {}

options[:mode] = mode if mode

subdirs.each do |name|

subdir = File.join dir, name

next if File.exist? subdir

require "fileutils"

begin

FileUtils.mkdir_p subdir, **options

rescue SystemCallError

end

end

ensure

File.umask old_umask

end

##

# The extension API version of ruby. This includes the static vs non-static

# distinction as extensions cannot be shared between the two.

def self.extension_api_version # :nodoc:

if target_rbconfig["ENABLE_SHARED"] == "no"

"#{ruby_api_version}-static"

else

ruby_api_version

end

end

##

# Returns a list of paths matching +glob+ that can be used by a gem to pick

# up features from other gems. For example:

#

# Gem.find_files('rdoc/discover').each do |path| load path end

#

# if +check_load_path+ is true (the default), then find_files also searches

# $LOAD_PATH for files as well as gems.

#

# Note that find_files will return all files even if they are from different

# versions of the same gem. See also find_latest_files

def self.find_files(glob, check_load_path=true)

files = []

files = find_files_from_load_path glob if check_load_path

gem_specifications = @gemdeps ? Gem.loaded_specs.values : Gem::Specification.stubs

files.concat gem_specifications.flat_map {|spec|

spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")

}

# $LOAD_PATH might contain duplicate entries or reference

# the spec dirs directly, so we prune.

files.uniq! if check_load_path

files

end

def self.find_files_from_load_path(glob) # :nodoc:

glob_with_suffixes = "#{glob}#{Gem.suffix_pattern}"

$LOAD_PATH.flat_map do |load_path|

Gem::Util.glob_files_in_dir(glob_with_suffixes, load_path)

end.select {|file| File.file? file }

end

##

# Returns a list of paths matching +glob+ from the latest gems that can be

# used by a gem to pick up features from other gems. For example:

#

# Gem.find_latest_files('rdoc/discover').each do |path| load path end

#

# if +check_load_path+ is true (the default), then find_latest_files also

# searches $LOAD_PATH for files as well as gems.

#

# Unlike find_files, find_latest_files will return only files from the

# latest version of a gem.

def self.find_latest_files(glob, check_load_path=true)

files = []

files = find_files_from_load_path glob if check_load_path

files.concat Gem::Specification.latest_specs(true).flat_map {|spec|

spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")

}

# $LOAD_PATH might contain duplicate entries or reference

# the spec dirs directly, so we prune.

files.uniq! if check_load_path

files

end

##

# Top level install helper method. Allows you to install gems interactively:

#

# % irb

# >> Gem.install "minitest"

# Fetching: minitest-5.14.0.gem (100%)

# => [#<Gem::Specification:0x1013b4528 @name="minitest", ...>]

def self.install(name, version = Gem::Requirement.default, *options)

require_relative "rubygems/dependency_installer"

inst = Gem::DependencyInstaller.new(*options)

inst.install name, version

inst.installed_gems

end

##

# Get the default RubyGems API host. This is normally

# <tt>https://rubygems.org</tt>.

def self.host

@host ||= Gem::DEFAULT_HOST

end

## Set the default RubyGems API host.

def self.host=(host)

@host = host

end

##

# The index to insert activated gem paths into the $LOAD_PATH. The activated

# gem's paths are inserted before site lib directory by default.

def self.load_path_insert_index

$LOAD_PATH.each_with_index do |path, i|

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

end

index = $LOAD_PATH.index RbConfig::CONFIG["sitelibdir"]

index || 0

end

##

# The number of paths in the +$LOAD_PATH+ from activated gems. Used to

# prioritize +-I+ and <code>ENV['RUBYLIB']</code> entries during +require+.

def self.activated_gem_paths

@activated_gem_paths ||= 0

end

##

# Add a list of paths to the $LOAD_PATH at the proper place.

def self.add_to_load_path(*paths)

@activated_gem_paths = activated_gem_paths + paths.size

# gem directories must come after -I and ENV['RUBYLIB']

$LOAD_PATH.insert(Gem.load_path_insert_index, *paths)

end

@yaml_loaded = false

##

# Loads YAML, preferring Psych

def self.load_yaml

return if @yaml_loaded

require "psych"

require_relative "rubygems/psych_tree"

require_relative "rubygems/safe_yaml"

@yaml_loaded = true

end

@safe_marshal_loaded = false

def self.load_safe_marshal

return if @safe_marshal_loaded

require_relative "rubygems/safe_marshal"

@safe_marshal_loaded = true

end

##

# The file name and line number of the caller of the caller of this method.

#

# +depth+ is how many layers up the call stack it should go.

#

# e.g.,

#

# def a; Gem.location_of_caller; end

# a #=> ["x.rb", 2] # (it'll vary depending on file name and line number)

#

# def b; c; end

# def c; Gem.location_of_caller(2); end

# b #=> ["x.rb", 6] # (it'll vary depending on file name and line number)

def self.location_of_caller(depth = 1)

caller[depth] =~ /(.*?):(\d+).*?$/i

file = $1

lineno = $2.to_i

[file, lineno]

end

##

# The version of the Marshal format for your Ruby.

def self.marshal_version

"#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"

end

##

# Set array of platforms this RubyGems supports (primarily for testing).

def self.platforms=(platforms)

@platforms = platforms

end

##

# Array of platforms this RubyGems supports.

def self.platforms

@platforms ||= []

if @platforms.empty?

@platforms = [Gem::Platform::RUBY, Gem::Platform.local]

end

@platforms

end

##

# Adds a post-build hook that will be passed an Gem::Installer instance

# when Gem::Installer#install is called. The hook is called after the gem

# has been extracted and extensions have been built but before the

# executables or gemspec has been written. If the hook returns +false+ then

# the gem's files will be removed and the install will be aborted.

def self.post_build(&hook)

@post_build_hooks << hook

end

##

# Adds a post-install hook that will be passed an Gem::Installer instance

# when Gem::Installer#install is called

def self.post_install(&hook)

@post_install_hooks << hook

end

##

# Adds a post-installs hook that will be passed a Gem::DependencyInstaller

# and a list of installed specifications when

# Gem::DependencyInstaller#install is complete

def self.done_installing(&hook)

@done_installing_hooks << hook

end

##

# Adds a hook that will get run after Gem::Specification.reset is

# run.

def self.post_reset(&hook)

@post_reset_hooks << hook

end

##

# Adds a post-uninstall hook that will be passed a Gem::Uninstaller instance

# and the spec that was uninstalled when Gem::Uninstaller#uninstall is

# called

def self.post_uninstall(&hook)

@post_uninstall_hooks << hook

end

##

# Adds a pre-install hook that will be passed an Gem::Installer instance

# when Gem::Installer#install is called. If the hook returns +false+ then

# the install will be aborted.

def self.pre_install(&hook)

@pre_install_hooks << hook

end

##

# Adds a hook that will get run before Gem::Specification.reset is

# run.

def self.pre_reset(&hook)

@pre_reset_hooks << hook

end

##

# Adds a pre-uninstall hook that will be passed an Gem::Uninstaller instance

# and the spec that will be uninstalled when Gem::Uninstaller#uninstall is

# called

def self.pre_uninstall(&hook)

@pre_uninstall_hooks << hook

end

##

# The directory prefix this RubyGems was installed at. If your

# prefix is in a standard location (ie, rubygems is installed where

# you'd expect it to be), then prefix returns nil.

def self.prefix

prefix = File.dirname RUBYGEMS_DIR

if prefix != File.expand_path(RbConfig::CONFIG["sitelibdir"]) &&

prefix != File.expand_path(RbConfig::CONFIG["libdir"]) &&

File.basename(RUBYGEMS_DIR) == "lib"

prefix

end

end

##

# Refresh available gems from disk.

def self.refresh

Gem::Specification.reset

end

##

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

def self.read_binary(path)

File.binread(path)

end

##

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

def self.write_binary(path, data)

File.binwrite(path, data)

rescue Errno::ENOSPC

# If we ran out of space but the file exists, it's *guaranteed* to be corrupted.

File.delete(path) if File.exist?(path)

raise

end

##

# Open a file with given flags

def self.open_file(path, flags, &block)

File.open(path, flags, &block)

end

##

# Open a file with given flags, and protect access with a file lock

def self.open_file_with_lock(path, &block)

file_lock = "#{path}.lock"

open_file_with_flock(file_lock, &block)

ensure

require "fileutils"

FileUtils.rm_f file_lock

end

##

# Open a file with given flags, and protect access with flock

def self.open_file_with_flock(path, &block)

# read-write mode is used rather than read-only in order to support NFS

mode = IO::RDWR | IO::APPEND | IO::CREAT | IO::BINARY

mode |= IO::SHARE_DELETE if IO.const_defined?(:SHARE_DELETE)

File.open(path, mode) do |io|

begin

# Try to get a lock without blocking.

# If we do, the file is locked.

# Otherwise, explain why we're waiting and get a lock, but block this time.

if io.flock(File::LOCK_EX | File::LOCK_NB) != 0

warn "Waiting for another process to let go of lock: #{path}"

io.flock(File::LOCK_EX)

end

io.puts(Process.pid)

rescue Errno::ENOSYS, Errno::ENOTSUP

end

yield io

end

end

##

# The path to the running Ruby interpreter.

def self.ruby

if @ruby.nil?

@ruby = RbConfig.ruby

@ruby = "\"#{@ruby}\"" if /\s/.match?(@ruby)

end

@ruby

end

##

# Returns a String containing the API compatibility version of Ruby

def self.ruby_api_version

@ruby_api_version ||= target_rbconfig["ruby_version"].dup

end

def self.env_requirement(gem_name)

@env_requirements_by_name ||= {}

@env_requirements_by_name[gem_name] ||= begin

req = ENV["GEM_REQUIREMENT_#{gem_name.upcase}"] || ">= 0"

Gem::Requirement.create(req)

end

end

post_reset { @env_requirements_by_name = {} }

##

# Returns the latest release-version specification for the gem +name+.

def self.latest_spec_for(name)

dependency = Gem::Dependency.new name

fetcher = Gem::SpecFetcher.fetcher

spec_tuples, = fetcher.spec_for_dependency dependency

spec, = spec_tuples.last

spec

end

##

# Returns the latest release version of RubyGems.

def self.latest_rubygems_version

latest_version_for("rubygems-update") ||

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

end

##

# Returns the version of the latest release-version of gem +name+

def self.latest_version_for(name)

latest_spec_for(name)&.version

end

##

# A Gem::Version for the currently running Ruby.

def self.ruby_version

return @ruby_version if defined? @ruby_version

version = RUBY_VERSION.dup

if RUBY_PATCHLEVEL == -1

if RUBY_ENGINE == "ruby"

desc = RUBY_DESCRIPTION[/\Aruby #{Regexp.quote(RUBY_VERSION)}([^ ]+) /, 1]

else

desc = RUBY_DESCRIPTION[/\A#{RUBY_ENGINE} #{Regexp.quote(RUBY_ENGINE_VERSION)} \(#{RUBY_VERSION}([^ ]+)\) /, 1]

end

version << ".#{desc}" if desc

end

@ruby_version = Gem::Version.new version

end

##

# A Gem::Version for the currently running RubyGems

def self.rubygems_version

return @rubygems_version if defined? @rubygems_version

@rubygems_version = Gem::Version.new Gem::VERSION

end

##

# Returns an Array of sources to fetch remote gems from. Uses

# default_sources if the sources list is empty.

def self.sources

source_list = configuration.sources || default_sources

@sources ||= Gem::SourceList.from(source_list)

end

##

# Need to be able to set the sources without calling

# Gem.sources.replace since that would cause an infinite loop.

#

# DOC: This comment is not documentation about the method itself, it's

# more of a code comment about the implementation.

def self.sources=(new_sources)

if !new_sources

@sources = nil

else

@sources = Gem::SourceList.from(new_sources)

end

end

##

# Glob pattern for require-able path suffixes.

def self.suffix_pattern

@suffix_pattern ||= "{#{suffixes.join(",")}}"

end

##

# Regexp for require-able path suffixes.

def self.suffix_regexp

@suffix_regexp ||= /#{Regexp.union(suffixes)}\z/

end

##

# Glob pattern for require-able plugin suffixes.

def self.plugin_suffix_pattern

@plugin_suffix_pattern ||= "_plugin#{suffix_pattern}"

end

##

# Regexp for require-able plugin suffixes.

def self.plugin_suffix_regexp

@plugin_suffix_regexp ||= /_plugin#{suffix_regexp}\z/

end

##

# Suffixes for require-able paths.

def self.suffixes

@suffixes ||= ["",

".rb",

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

val = RbConfig::CONFIG[key]

next unless val && !val.empty?

".#{val}"

end].compact.uniq

end

##

# Suffixes for dynamic library require-able paths.

def self.dynamic_library_suffixes

@dynamic_library_suffixes ||= suffixes - [".rb"]

end

##

# Prints the amount of time the supplied block takes to run using the debug

# UI output.

def self.time(msg, width = 0, display = Gem.configuration.verbose)

now = Time.now