Module: Gem

# File 'lib/rubygems.rb', line 332

def self.configuration=(config)
  @configuration = config
end

# File 'lib/rubygems.rb', line 1177

attr_accessor :disable_system_update_message

# File 'lib/rubygems.rb', line 1184

attr_accessor :discover_gems_on_require

# File 'lib/rubygems.rb', line 1269

attr_reader :done_installing_hooks

# File 'lib/rubygems.rb', line 1026

def self.freebsd_platform?
  RbConfig::CONFIG["host_os"].to_s.include?("bsd")
end

# File 'lib/rubygems.rb', line 1195

attr_reader :gemdeps

# File 'lib/rubygems.rb', line 544

def self.host
  @host ||= Gem::DEFAULT_HOST
end

# File 'lib/rubygems.rb', line 550

def self.host=(host)
  @host = host
end

# File 'lib/rubygems.rb', line 1012

def self.java_platform?
  RUBY_PLATFORM == "java"
end

# File 'lib/rubygems.rb', line 1189

attr_reader :loaded_specs

# File 'lib/rubygems.rb', line 347

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

# File 'lib/rubygems.rb', line 357

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

# File 'lib/rubygems.rb', line 651

def self.platforms
  @platforms ||= []
  if @platforms.empty?
    @platforms = [Gem::Platform::RUBY, Gem::Platform.local]
  end
  @platforms
end

# File 'lib/rubygems.rb', line 644

def self.platforms=(platforms)
  @platforms = platforms
end

# File 'lib/rubygems.rb', line 1257

attr_reader :post_build_hooks

# File 'lib/rubygems.rb', line 1263

attr_reader :post_install_hooks

# File 'lib/rubygems.rb', line 1274

attr_reader :post_reset_hooks

# File 'lib/rubygems.rb', line 1280

attr_reader :post_uninstall_hooks

# File 'lib/rubygems.rb', line 1285

attr_reader :pre_install_hooks

# File 'lib/rubygems.rb', line 1290

attr_reader :pre_reset_hooks

# File 'lib/rubygems.rb', line 1296

attr_reader :pre_uninstall_hooks

# File 'lib/rubygems.rb', line 1019

def self.solaris_platform?
  RUBY_PLATFORM.include?("solaris")
end

# File 'lib/rubygems.rb', line 892

def self.sources
  source_list = configuration.sources || default_sources
  @sources ||= Gem::SourceList.from(source_list)
end

# File 'lib/rubygems.rb', line 904

def self.sources=(new_sources)
  if !new_sources
    @sources = nil
  else
    @sources = Gem::SourceList.from(new_sources)
  end
end

# File 'lib/rubygems.rb', line 1000

def self.win_platform?
  if @@win_platform.nil?
    ruby_platform = RbConfig::CONFIG["host_os"]
    @@win_platform = !WIN_PATTERNS.find {|r| ruby_platform =~ r }.nil?
  end

  @@win_platform
end

# File 'lib/rubygems.rb', line 572

def self.activated_gem_paths
  @activated_gem_paths ||= 0
end

# File 'lib/rubygems.rb', line 579

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

# File 'lib/rubygems.rb', line 1300

def already_loaded?(file)
  $LOADED_FEATURES.any? do |feature_path|
    feature_path.end_with?(file) && default_gem_load_paths.any? {|load_path_entry| feature_path == "#{load_path_entry}/#{file}" }
  end
end

# File 'lib/rubygems.rb', line 235

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

# File 'lib/rubygems.rb', line 289

def self.binary_mode
  "rb"
end

# File 'lib/rubygems.rb', line 296

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

# File 'lib/rubygems/defaults.rb', line 147

def self.cache_home
  @cache_home ||= ENV["XDG_CACHE_HOME"] || File.join(Gem.user_home, ".cache")
end

# File 'lib/rubygems.rb', line 1249

def clear_default_specs
  @path_to_default_spec_map.clear
end

# File 'lib/rubygems.rb', line 314

def self.clear_paths
  @paths         = nil
  @user_home     = nil
  Gem::Specification.reset
  Gem::Security.reset if defined?(Gem::Security)
end

# File 'lib/rubygems/defaults.rb', line 133

def self.config_file
  @config_file ||= find_config_file
end

# File 'lib/rubygems/defaults.rb', line 114

def self.config_home
  @config_home ||= ENV["XDG_CONFIG_HOME"] || File.join(Gem.user_home, ".config")
end

# File 'lib/rubygems/defaults.rb', line 154

def self.data_home
  @data_home ||= ENV["XDG_DATA_HOME"] || File.join(Gem.user_home, ".local", "share")
end

# File 'lib/rubygems/defaults.rb', line 204

def self.default_bindir
  RbConfig::CONFIG["bindir"]
end

# File 'lib/rubygems/defaults.rb', line 228

def self.default_cert_path
  default_cert_path = File.join Gem.user_home, ".gem", "gem-public_cert.pem"

  unless File.exist?(default_cert_path)
    default_cert_path = File.join Gem.data_home, "gem", "gem-public_cert.pem"
  end

  default_cert_path
end

# File 'lib/rubygems/defaults.rb', line 37

def self.default_dir
  @default_dir ||= File.join(RbConfig::CONFIG["rubylibprefix"], "gems", RbConfig::CONFIG["ruby_version"])
end

# File 'lib/rubygems/defaults.rb', line 186

def self.default_exec_format
  exec_format = begin
                  RbConfig::CONFIG["ruby_install_name"].sub("ruby", "%s")
                rescue StandardError
                  "%s"
                end

  unless exec_format.include?("%s")
    raise Gem::Exception,
      "[BUG] invalid exec_format #{exec_format.inspect}, no %s"
  end

  exec_format
end

# File 'lib/rubygems/defaults.rb', line 48

def self.default_ext_dir_for(base_dir)
  nil
end

# File 'lib/rubygems.rb', line 1306

def default_gem_load_paths
  @default_gem_load_paths ||= $LOAD_PATH[load_path_insert_index..-1].map do |lp|
    expanded = File.expand_path(lp)
    next expanded unless File.exist?(expanded)

    File.realpath(expanded)
  end
end

# File 'lib/rubygems/defaults.rb', line 215

def self.default_key_path
  default_key_path = File.join Gem.user_home, ".gem", "gem-private_key.pem"

  unless File.exist?(default_key_path)
    default_key_path = File.join Gem.data_home, "gem", "gem-private_key.pem"
  end

  default_key_path
end

# File 'lib/rubygems/defaults.rb', line 175

def self.default_path
  path = []
  path << user_dir if user_home && File.exist?(user_home)
  path << default_dir
  path << vendor_dir if vendor_dir && File.directory?(vendor_dir)
  path
end

# File 'lib/rubygems/defaults.rb', line 55

def self.default_rubygems_dirs
  nil # default to standard layout
end

# File 'lib/rubygems/defaults.rb', line 15

def self.default_sources
  %w[https://rubygems.org/]
end

# File 'lib/rubygems/defaults.rb', line 23

def self.default_spec_cache_dir
  default_spec_cache_dir = File.join Gem.user_home, ".gem", "specs"

  unless File.exist?(default_spec_cache_dir)
    default_spec_cache_dir = File.join Gem.cache_home, "gem", "specs"
  end

  default_spec_cache_dir
end

# File 'lib/rubygems/defaults.rb', line 62

def self.default_specifications_dir
  @default_specifications_dir ||= File.join(Gem.default_dir, "specifications", "default")
end

# File 'lib/rubygems/defaults.rb', line 241

def self.default_user_install # :nodoc:
  if !ENV.key?("GEM_HOME") && (File.exist?(Gem.dir) && !File.writable?(Gem.dir))
    Gem.ui.say "Defaulting to user installation because default installation directory (#{Gem.dir}) is not writable."
    return true
  end

  false
end

# File 'lib/rubygems.rb', line 339

def self.deflate(data)
  require "zlib"
  Zlib::Deflate.deflate data
end

# File 'lib/rubygems.rb', line 387

def self.dir
  paths.home
end

# File 'lib/rubygems.rb', line 683

def self.done_installing(&hook)
  @done_installing_hooks << hook
end

# File 'lib/rubygems.rb', line 956

def self.dynamic_library_suffixes
  @dynamic_library_suffixes ||= suffixes - [".rb"]
end

# File 'lib/rubygems.rb', line 421

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

# File 'lib/rubygems.rb', line 408

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

# File 'lib/rubygems.rb', line 425

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

# File 'lib/rubygems.rb', line 824

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

# File 'lib/rubygems.rb', line 452

def self.extension_api_version # :nodoc:
  if RbConfig::CONFIG["ENABLE_SHARED"] == "no"
    "#{ruby_api_version}-static"
  else
    ruby_api_version
  end
end

# File 'lib/rubygems/defaults.rb', line 121

def self.find_config_file
  gemrc = File.join Gem.user_home, ".gemrc"
  if File.exist? gemrc
    gemrc
  else
    File.join Gem.config_home, "gem", "gemrc"
  end
end

# File 'lib/rubygems.rb', line 1234

def find_default_spec(path)
  @path_to_default_spec_map[path]
end

# File 'lib/rubygems.rb', line 472

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.map {|spec|
    spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")
  }.flatten

  # $LOAD_PATH might contain duplicate entries or reference
  # the spec dirs directly, so we prune.
  files.uniq! if check_load_path

  files
end

# File 'lib/rubygems.rb', line 490

def self.find_files_from_load_path(glob) # :nodoc:
  glob_with_suffixes = "#{glob}#{Gem.suffix_pattern}"
  $LOAD_PATH.map do |load_path|
    Gem::Util.glob_files_in_dir(glob_with_suffixes, load_path)
  end.flatten.select {|file| File.file? file }
end

# File 'lib/rubygems/defaults.rb', line 81

def self.find_home
  Dir.home.dup
rescue StandardError
  if Gem.win_platform?
    File.expand_path File.join(ENV["HOMEDRIVE"] || ENV["SystemDrive"], "/")
  else
    File.expand_path "/"
  end
end

# File 'lib/rubygems.rb', line 509

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).map {|spec|
    spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")
  }.flatten

  # $LOAD_PATH might contain duplicate entries or reference
  # the spec dirs directly, so we prune.
  files.uniq! if check_load_path

  files
end

# File 'lib/rubygems.rb', line 242

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

# File 'lib/rubygems.rb', line 1241

def find_unresolved_default_spec(path)
  default_spec = @path_to_default_spec_map[path]
  default_spec if default_spec && loaded_specs[default_spec.name] != default_spec
end

# File 'lib/rubygems.rb', line 220

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

# File 'lib/rubygems.rb', line 533

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

# File 'lib/rubygems/defaults.rb', line 253

def self.install_extension_in_lib # :nodoc:
  true
end

# File 'lib/rubygems.rb', line 849

def self.latest_rubygems_version
  latest_version_for("rubygems-update") ||
    raise("Can't find 'rubygems-update' in any repo. Check `gem source list`.")
end

# File 'lib/rubygems.rb', line 836

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

# File 'lib/rubygems.rb', line 857

def self.latest_version_for(name)
  latest_spec_for(name)&.version
end

# File 'lib/rubygems.rb', line 1061

def self.load_env_plugins
  load_plugin_files find_files_from_load_path("rubygems_plugin")
end

# File 'lib/rubygems.rb', line 558

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

# File 'lib/rubygems.rb', line 1033

def self.load_plugin_files(plugins) # :nodoc:
  plugins.each do |plugin|
    # Skip older versions of the GemCutter plugin: Its commands are in
    # RubyGems proper now.

    next if /gemcutter-0\.[0-3]/.match?(plugin)

    begin
      load plugin
    rescue ScriptError, StandardError => e
      details = "#{plugin.inspect}: #{e.message} (#{e.class})"
      warn "Error loading RubyGems plugin #{details}"
    end
  end
end

# File 'lib/rubygems.rb', line 1052

def self.load_plugins
  Gem.path.each do |gem_path|
    load_plugin_files Gem::Util.glob_files_in_dir("*#{Gem.plugin_suffix_pattern}", plugindir(gem_path))
  end
end

# File 'lib/rubygems.rb', line 604

def self.load_safe_marshal
  return if @safe_marshal_loaded

  require_relative "rubygems/safe_marshal"

  @safe_marshal_loaded = true
end

# File 'lib/rubygems.rb', line 591

def self.load_yaml
  return if @yaml_loaded

  require "psych"
  require_relative "rubygems/psych_tree"

  require_relative "rubygems/safe_yaml"

  @yaml_loaded = true
end

# File 'lib/rubygems.rb', line 626

def self.location_of_caller(depth = 1)
  caller[depth] =~ /(.*?):(\d+).*?$/i
  file = $1
  lineno = $2.to_i

  [file, lineno]
end

# File 'lib/rubygems.rb', line 637

def self.marshal_version
  "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
end

# File 'lib/rubygems.rb', line 212

def self.needs
  rs = Gem::RequestSet.new

  yield rs

  finish_resolve rs
end

# File 'lib/rubygems.rb', line 773

def self.open_file(path, flags, &block)
  File.open(path, flags, &block)
end

# File 'lib/rubygems.rb', line 790

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
      io.flock(File::LOCK_EX)
    rescue Errno::ENOSYS, Errno::ENOTSUP
    end
    yield io
  end
end

# File 'lib/rubygems.rb', line 780

def self.open_file_with_lock(path, &block)
  file_lock = "#{path}.lock"
  open_file_with_flock(file_lock, &block)
ensure
  FileUtils.rm_f file_lock
end

# File 'lib/rubygems/defaults.rb', line 286

def self.operating_system_defaults
  {}
end

# File 'lib/rubygems.rb', line 391

def self.path
  paths.path
end

# File 'lib/rubygems/defaults.rb', line 168

def self.path_separator
  File::PATH_SEPARATOR
end

# File 'lib/rubygems/defaults.rb', line 305

def self.platform_defaults
  {}
end

# File 'lib/rubygems.rb', line 929

def self.plugin_suffix_pattern
  @plugin_suffix_pattern ||= "_plugin#{suffix_pattern}"
end

# File 'lib/rubygems.rb', line 936

def self.plugin_suffix_regexp
  @plugin_suffix_regexp ||= /_plugin#{suffix_regexp}\z/
end

# File 'lib/rubygems.rb', line 305

def self.plugindir(install_dir=Gem.dir)
  File.join install_dir, "plugins"
end

# File 'lib/rubygems.rb', line 666

def self.post_build(&hook)
  @post_build_hooks << hook
end

# File 'lib/rubygems.rb', line 674

def self.post_install(&hook)
  @post_install_hooks << hook
end

# File 'lib/rubygems.rb', line 691

def self.post_reset(&hook)
  @post_reset_hooks << hook
end

# File 'lib/rubygems.rb', line 700

def self.post_uninstall(&hook)
  @post_uninstall_hooks << hook
end

# File 'lib/rubygems.rb', line 709

def self.pre_install(&hook)
  @pre_install_hooks << hook
end

# File 'lib/rubygems.rb', line 717

def self.pre_reset(&hook)
  @pre_reset_hooks << hook
end

# File 'lib/rubygems.rb', line 726

def self.pre_uninstall(&hook)
  @pre_uninstall_hooks << hook
end

# File 'lib/rubygems.rb', line 735

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

# File 'lib/rubygems.rb', line 755

def self.read_binary(path)
  File.binread(path)
end

# File 'lib/rubygems.rb', line 748

def self.refresh
  Gem::Specification.reset
end

# File 'lib/rubygems.rb', line 1209

def register_default_spec(spec)
  extended_require_paths = spec.require_paths.map {|f| f + "/" }
  new_format = extended_require_paths.any? {|path| spec.files.any? {|f| f.start_with? path } }

  if new_format
    prefix_group = extended_require_paths.join("|")
    prefix_pattern = /^(#{prefix_group})/
  end

  spec.files.each do |file|
    if new_format
      file = file.sub(prefix_pattern, "")
      next unless $~
    end

    spec.activate if already_loaded?(file)

    @path_to_default_spec_map[file] = spec
    @path_to_default_spec_map[file.sub(suffix_regexp, "")] = spec
  end
end

# File 'lib/rubygems.rb', line 807

def self.ruby
  if @ruby.nil?
    @ruby = RbConfig.ruby

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

  @ruby
end

# File 'lib/rubygems.rb', line 820

def self.ruby_api_version
  @ruby_api_version ||= RbConfig::CONFIG["ruby_version"].dup
end

# File 'lib/rubygems/defaults.rb', line 208

def self.ruby_engine
  RUBY_ENGINE
end

# File 'lib/rubygems.rb', line 864

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

# File 'lib/rubygems.rb', line 883

def self.rubygems_version
  return @rubygems_version if defined? @rubygems_version
  @rubygems_version = Gem::Version.new Gem::VERSION
end

# File 'lib/rubygems.rb', line 1164

def self.source_date_epoch
  Time.at(source_date_epoch_string.to_i).utc.freeze
end

# File 'lib/rubygems.rb', line 1145

def self.source_date_epoch_string
  # The value used if $SOURCE_DATE_EPOCH is not set.
  @default_source_date_epoch ||= Time.now.to_i.to_s

  specified_epoch = ENV["SOURCE_DATE_EPOCH"]

  # If it's empty or just whitespace, treat it like it wasn't set at all.
  specified_epoch = nil if !specified_epoch.nil? && specified_epoch.strip.empty?

  epoch = specified_epoch || @default_source_date_epoch

  epoch.strip
end

# File 'lib/rubygems.rb', line 395

def self.spec_cache_dir
  paths.spec_cache_dir
end

# File 'lib/rubygems/defaults.rb', line 140

def self.state_file
  @state_file ||= File.join(Gem.state_home, "gem", "last_update_check")
end

# File 'lib/rubygems/defaults.rb', line 161

def self.state_home
  @state_home ||= ENV["XDG_STATE_HOME"] || File.join(Gem.user_home, ".local", "state")
end

# File 'lib/rubygems.rb', line 915

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

# File 'lib/rubygems.rb', line 922

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

# File 'lib/rubygems.rb', line 943

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

# File 'lib/rubygems.rb', line 964

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

  value = yield

  elapsed = Time.now - now

  ui.say format("%2$*1$s: %3$3.3fs", -width, msg, elapsed) if display

  value
end

# File 'lib/rubygems.rb', line 187

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

# File 'lib/rubygems.rb', line 979

def self.ui
  require_relative "rubygems/user_interaction"

  Gem::DefaultUserInteraction.ui
end

# File 'lib/rubygems/vendor/uri/lib/uri/common.rb', line 844

def URI(uri)
  if uri.is_a?(Gem::URI::Generic)
    uri
  elsif uri = String.try_convert(uri)
    Gem::URI.parse(uri)
  else
    raise ArgumentError,
      "bad argument (expected Gem::URI object or Gem::URI string)"
  end
end

# File 'lib/rubygems.rb', line 1085

def self.use_gemdeps(path = nil)
  raise_exception = path

  path ||= ENV["RUBYGEMS_GEMDEPS"]
  return unless path

  path = path.dup

  if path == "-"
    Gem::Util.traverse_parents Dir.pwd do |directory|
      dep_file = GEM_DEP_FILES.find {|f| File.file?(f) }

      next unless dep_file

      path = File.join directory, dep_file
      break
    end
  end

  unless File.file? path
    return unless raise_exception

    raise ArgumentError, "Unable to find gem dependencies file at #{path}"
  end

  ENV["BUNDLE_GEMFILE"] ||= File.expand_path(path)
  require_relative "rubygems/user_interaction"
  require "bundler"
  begin
    Gem::DefaultUserInteraction.use_ui(ui) do
      Bundler.ui.silence do
        @gemdeps = Bundler.setup
      end
    ensure
      Gem::DefaultUserInteraction.ui.close
    end
  rescue Bundler::BundlerError => e
    warn e.message
    warn "You may need to `bundle install` to install missing gems"
    warn ""
  end
end

# File 'lib/rubygems.rb', line 989

def self.use_paths(home, *paths)
  paths.flatten!
  paths.compact!
  hash = { "GEM_HOME" => home, "GEM_PATH" => paths.empty? ? home : paths.join(File::PATH_SEPARATOR) }
  hash.delete_if {|_, v| v.nil? }
  self.paths = hash
end

# File 'lib/rubygems/defaults.rb', line 103

def self.user_dir
  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]
  parts << RbConfig::CONFIG["ruby_version"] unless RbConfig::CONFIG["ruby_version"].empty?
  File.join parts
end

# File 'lib/rubygems/defaults.rb', line 96

def self.user_home
  @user_home ||= find_home
end

# File 'lib/rubygems/defaults.rb', line 260

def self.vendor_dir # :nodoc:
  if vendor_dir = ENV["GEM_VENDOR"]
    return vendor_dir.dup
  end

  return nil unless RbConfig::CONFIG.key? "vendordir"

  File.join RbConfig::CONFIG["vendordir"], "gems",
            RbConfig::CONFIG["ruby_version"]
end

# File 'lib/rubygems.rb', line 762

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