# methods, and then we switch over to `class << self` here. Pick one or the

# other.

class << self

##

# RubyGems distributors (like operating system package managers) can

# disable RubyGems update by setting this to error message printed to

def default_gem_load_paths

@default_gem_load_paths ||= $LOAD_PATH[load_path_insert_index..-1]

end

end

##

# frozen_string_literal: true

class Gem::AvailableSet

include Enumerable

Tuple = Struct.new(:spec, :source)

def inject_into_list(dep_list)

@set.each {|t| dep_list.add t.spec }

end

end

# used by both Specification and StubSpecification.

class Gem::BasicSpecification

##

# Allows installation of extensions for git: gems.

end

class << self

extend Gem::Deprecate

rubygems_deprecate :default_specifications_dir, "Gem.default_specifications_dir"

end

##

false

end

end

end

# A very good example to look at is Gem::Commands::ContentsCommand

class Gem::Command

include Gem::UserInteraction

OptionParser.accept Symbol do |value|

HELP

# :startdoc:

end

##

# See Gem::Command for instructions on writing gem commands.

class Gem::CommandManager

include Gem::Text

include Gem::UserInteraction

ui.backtrace e

end

end

end

require 'rubygems/package'

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

def initialize

super 'build', 'Build a gem from a gemspec'

terminate_interaction 1

end

end

end

require 'rubygems/security'

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

def initialize

super 'cert', 'Manage RubyGems certificates and signing settings',

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

# It's simple, but is all we need

email =~ /\A.+@.+\z/

end

end if defined?(OpenSSL::SSL)

require 'rubygems/doctor'

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

include Gem::VersionOption

def initialize

def usage # :nodoc:

"#{program_name} [OPTIONS] [GEMNAME ...]"

end

end

require 'rubygems/uninstaller'

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

def initialize

super 'cleanup',

'Clean up old versions of installed gems',

# Restore path Gem::Uninstaller may have changed

Gem.use_paths @original_home, *@original_path

end

end

require 'rubygems/version_option'

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

include Gem::VersionOption

def initialize

[i, File.join(i, "specifications")]

end.flatten

end

end

require 'rubygems/version_option'

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

include Gem::LocalRemoteOptions

include Gem::VersionOption

/\A#{Regexp.union(*args)}/

end

end

end

require 'rubygems/command'

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

def initialize

super 'environment', 'Display information about the RubyGems environment'

end

return nil

end

end

require 'rubygems/version_option'

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

include Gem::LocalRemoteOptions

include Gem::VersionOption

say "Downloaded #{spec.full_name}"

end

end

end

# See `gem help generate_index`

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

def initialize

super 'generate_index',

'Generates the index files for a gem server directory',

end

end

end

end

require 'rubygems/command'

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

# :stopdoc:

EXAMPLES = <<-EOF.freeze

Some examples of 'gem' usage.

alert_warning "Unknown command #{command_name}. Try: gem help commands"

end

end

end

require 'rubygems/query_utils'

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

include Gem::QueryUtils

def initialize

def defaults_str

"--local"

end

end

# See `gem help install`

class Gem::Commands::InstallCommand < Gem::Command

attr_reader :installed_specs # :nodoc:

include Gem::VersionOption

gems = @installed_specs.length == 1 ? 'gem' : 'gems'

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

end

end

# Searches for gems starting with the supplied argument.

class Gem::Commands::ListCommand < Gem::Command

include Gem::QueryUtils

def initialize

def usage # :nodoc:

"#{program_name} [REGEXP ...]"

end

end

require 'rubygems/command'

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

def initialize

super 'lock', 'Generate a lockdown list of gems',

:strict => false

gemspecs.find {|path| File.exist? path }

end

end

unless defined? Gem::Commands::MirrorCommand

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

def initialize

super('mirror', 'Mirror all gem files (requires rubygems-mirror)')

begin

def execute

alert_error "Install the rubygems-mirror gem for the mirror command"

end

end

end

require 'rubygems/version_option'

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

include Gem::VersionOption

def initialize

say "Unable to find gem '#{name}'"

end

end

require 'rubygems/version_option'

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

include Gem::LocalRemoteOptions

include Gem::VersionOption

say "#{spec.name} (#{spec.version} < #{remote_version})"

end

end

end

require 'rubygems/text'

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

include Gem::Text

include Gem::LocalRemoteOptions

include Gem::GemcutterUtilities

request.add_field "OTP", options[:otp] if options[:otp]

end

end

end

require 'rubygems/version_option'

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

include Gem::VersionOption

def initialize

say "Restored #{spec.full_name}"

end

end

end

require 'rubygems/package'

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

include Gem::LocalRemoteOptions

include Gem::GemcutterUtilities

gem_metadata["allowed_push_host"]

]

end

end

require 'rubygems/deprecate'

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

extend Gem::Deprecate

rubygems_deprecate_command

add_query_options

end

end

require 'fileutils'

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

include Gem::VersionOption

def initialize

end

end

end

end

require 'rubygems/query_utils'

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

include Gem::QueryUtils

def initialize

def usage # :nodoc:

"#{program_name} [REGEXP]"

end

end

require 'rubygems/server'

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

def initialize

super 'server', 'Documentation and gem repository HTTP server',

:port => 8808, :gemdir => [], :daemon => false

options[:gemdir] = Gem.path if options[:gemdir].empty?

Gem::Server.run options

end

end

# RubyGems checkout or tarball.

class Gem::Commands::SetupCommand < Gem::Command

HISTORY_HEADER = /^===\s*[\d.a-zA-Z]+\s*\/\s*\d{4}-\d{2}-\d{2}\s*$/.freeze

VERSION_MATCHER = /^===\s*([\d.a-zA-Z]+)\s*\/\s*\d{4}-\d{2}-\d{2}\s*$/.freeze

def bin_file_names

@bin_file_names ||= []

end

end

require 'rubygems/gemcutter_utilities'

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

include Gem::GemcutterUtilities

def initialize

def execute

sign_in options[:host]

end

end

require 'rubygems/command'

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

def initialize

super 'signout', 'Sign out from all the current sessions.'

end

say 'You have successfully signed out from all sessions.'

end

end

end

require 'rubygems/local_remote_options'

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

include Gem::LocalRemoteOptions

def initialize

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

end

end

end

require 'rubygems/package'

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

include Gem::LocalRemoteOptions

include Gem::VersionOption

say "\n"

end

end

end

require 'rubygems/command'

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

def initialize

super('stale', 'List gems along with access times')

end

say "#{name} at #{atime.strftime '%c'}"

end

end

end

# See `gem help uninstall`

class Gem::Commands::UninstallCommand < Gem::Command

include Gem::VersionOption

def initialize

def uninstall(gem_name)

Gem::Uninstaller.new(gem_name, options).uninstall

end

end

end

class Gem::Commands::UnpackCommand < Gem::Command

include Gem::VersionOption

include Gem::SecurityOption

path

end

end

require 'rubygems/rdoc'

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

include Gem::InstallUpdateOptions

include Gem::LocalRemoteOptions

include Gem::VersionOption

result

end

end

require 'rubygems/command'

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

def initialize

super 'which', 'Find the location of a library file you can require',

:search_gems_first => false, :show_all => false

def usage # :nodoc:

"#{program_name} FILE [FILE ...]"

end

end

require 'rubygems/gemcutter_utilities'

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

include Gem::LocalRemoteOptions

include Gem::VersionOption

include Gem::GemcutterUtilities

def get_platform_from_requirements(requirements)

Gem.platforms[1].to_s if requirements.key? :added_platform

end

end

# - per environment (gemrc files listed in the GEMRC environment variable)

class Gem::ConfigFile

include Gem::UserInteraction

DEFAULT_BACKTRACE = false

end

end

end

end

remove_method :warn

class << self

remove_method :warn

end

module_function define_method(:warn) {|*messages, **kw|

# The Dependency class holds a Gem name and a Gem::Requirement.

class Gem::Dependency

##

# Valid dependency types.

#--

:released

end

end

end

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

class Gem::DependencyInstaller

include Gem::UserInteraction

extend Gem::Deprecate

request_set

end

end

# this class necessary anymore? Especially #ok?, #why_not_ok?

class Gem::DependencyList

attr_reader :specs

include Enumerable

def active_count(specs, ignored)

specs.count {|spec| ignored[spec.full_name].nil? }

end

end

# removing the bogus specification.

class Gem::Doctor

include Gem::UserInteraction

##

rescue Errno::ENOENT

# ignore

end

end

# already activated gems or that RubyGems is otherwise unable to activate.

class LoadError < ::LoadError

# Name of gem

attr_accessor :name

# Version requirement of gem

attr_accessor :requirement

end

##

# system. Instead of rescuing from this class, make sure to rescue from the

# superclass Gem::LoadError to catch all types of load errors.

class MissingSpecError < Gem::LoadError

def initialize(name, requirement, extra_message=nil)

@name = name

@requirement = requirement

total = Gem::Specification.stubs.size

"Could not find '#{name}' (#{requirement}) among #{total} total gem(s)\n"

end

end

##

# not the requested version. Instead of rescuing from this class, make sure to

# rescue from the superclass Gem::LoadError to catch all types of load errors.

class MissingSpecVersionError < MissingSpecError

attr_reader :specs

def initialize(name, requirement, specs)

names = specs.map(&:full_name)

"Could not find '#{name}' (#{requirement}) - did find: [#{names.join ','}]\n"

end

end

# Raised when there are conflicting gem specs loaded

class ConflictError < LoadError

##

# A Hash mapping conflicting specifications to the dependencies that

# caused the conflict

super("Unable to activate #{target.full_name}, because #{reason}")

end

end

class ErrorReason; end

# in figuring out why a gem couldn't be installed.

#

class PlatformMismatch < ErrorReason

##

# the name of the gem

attr_reader :name

@platforms.size == 1 ? '' : 's',

@platforms.join(' ,')]

end

end

##

# data from a source

class SourceFetchProblem < ErrorReason

##

# Creates a new SourceFetchProblem for the given +source+ and +error+.

# The "exception" alias allows you to call raise on a SourceFetchProblem.

alias exception error

end

end

# and #conflicting_dependencies

class Gem::DependencyResolutionError < Gem::DependencyError

attr_reader :conflict

def initialize(conflict)

def conflicting_dependencies

@conflict.conflicting_dependencies

end

end

##

# Raised when attempting to uninstall a gem that isn't in GEM_HOME.

class Gem::GemNotInHomeException < Gem::Exception

attr_accessor :spec

end

###

# Raised when removing a gem with the uninstall command fails

class Gem::UninstallError < Gem::Exception

attr_accessor :spec

end

class Gem::DocumentError < Gem::Exception; end

# operating on the given directory.

class Gem::FilePermissionError < Gem::Exception

attr_reader :directory

def initialize(directory)

super "You don't have write permissions for the #{directory} directory."

end

end

##

# Used to raise parsing and loading errors

class Gem::FormatException < Gem::Exception

attr_accessor :file_path

end

class Gem::GemNotFoundException < Gem::Exception; end

# Raised by the DependencyInstaller when a specific gem cannot be found

class Gem::SpecificGemNotFoundException < Gem::GemNotFoundException

##

# Creates a new SpecificGemNotFoundException for a gem with the given +name+

# and +version+. Any +errors+ encountered when attempting to find the gem

# Errors encountered attempting to find the gem.

attr_reader :errors

end

##

# inability to find a valid possible spec for a request.

class Gem::ImpossibleDependenciesError < Gem::Exception

attr_reader :conflicts

attr_reader :request

def dependency

@request.dependency

end

end

class Gem::InstallError < Gem::Exception; end

class Gem::RuntimeRequirementNotMetError < Gem::InstallError

attr_accessor :suggestion

def message

[suggestion, super].compact.join("\n\t")

end

end

##

# exit_code

class Gem::SystemExitException < SystemExit

##

# The exit code for the process

super "Exiting RubyGems with exit_code #{exit_code}"

end

end

##

# there is no spec.

class Gem::UnsatisfiableDependencyError < Gem::DependencyError

##

# The unsatisfiable dependency. This is a

# Gem::Resolver::DependencyRequest, not a Gem::Dependency

def version

@dependency.requirement

end

end

##

require_relative '../user_interaction'

class Gem::Ext::Builder

include Gem::UserInteraction

##

destination

end

end

require_relative '../command'

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

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

unless File.exist?('Makefile')

cmd = "cmake . -DCMAKE_INSTALL_PREFIX=#{dest_path}"

results

end

end

#++

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

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

unless File.exist?('Makefile')

cmd = "sh ./configure --prefix=#{dest_path}"

results

end

end

require 'shellwords'

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

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

require 'fileutils'

require 'tempfile'

path[0..Dir.pwd.length - 1] = '.' if path.start_with?(Dir.pwd)

path

end

end

require "shellwords"

class Gem::Ext::RakeBuilder < Gem::Ext::Builder

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

if File.basename(extension) =~ /mkrf_conf/i

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

results

end

end

# classes they call directly.

class Gem::GemRunner

def initialize

@command_manager_class = Gem::CommandManager

@config_file_class = Gem::ConfigFile

Gem.use_paths Gem.configuration[:gemhome], Gem.configuration[:gempath]

Gem::Command.extra_args = Gem.configuration[:gem]

end

end

Gem.load_plugins

# Top level class for building the gem repository index.

class Gem::Indexer

include Gem::UserInteraction

##

Marshal.dump specs_index, io

end

end

end

# file. See Gem.pre_install and Gem.post_install for details.

class Gem::Installer

extend Gem::Deprecate

##

@install_lock = Mutex.new

class << self

##

# True if we've warned about PATH not including Gem.bindir

def exec_format

@exec_format ||= Gem.default_exec_format

end

end

##

end

class FakePackage

attr_accessor :spec

attr_accessor :dir_mode

def copy_to(path)

end

end

##

raise Gem::FilePermissionError.new(dir) unless File.writable? dir

end

end

require 'rubygems/installer'

class Gem::Installer

##

# Available through requiring rubygems/installer_test_case

# Available through requiring rubygems/installer_test_case

attr_writer :wrappers

end

##

# A test case for Gem::Installer.

class Gem::InstallerTestCase < Gem::TestCase

def setup

super

end

@@symlink_supported

end

end

# retrieval during tests.

class Gem::MockGemUi < Gem::StreamUI

##

# Raised when you haven't provided enough input to your MockGemUi

class InputEOFError < RuntimeError

def initialize(question)

super "Out of input for MockGemUi on #{question.inspect}"

end

end

class TermError < RuntimeError

attr_reader :exit_code

def initialize(exit_code)

super

@exit_code = exit_code

end

end

class SystemExitException < RuntimeError; end

raise TermError, status if status != 0

raise SystemExitException

end

end

# wrap the data returned from the indexes.

class Gem::NameTuple

def initialize(name, version, platform="ruby")

@name = name

@version = version

def hash

to_a.hash

end

end

require 'zlib'

class Gem::Package

include Gem::UserInteraction

class Error < Gem::Exception; end

class FormatError < Error

attr_reader :path

def initialize(message, source = nil)

super message

end

end

class PathError < Error

def initialize(destination, destination_dir)

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

[destination, destination_dir]

end

end

class NonSeekableIO < Error; end

rescue Zlib::GzipFile::Error => e

raise Gem::Package::FormatError.new(e.message, entry.full_name)

end

end

require 'rubygems/package/digest_io'

# IO wrapper that creates digests of contents written to the IO it wraps.

class Gem::Package::DigestIO

##

# Collected digests for wrapped writes.

#

result

end

end

# object to `Gem::Package.new`.

class Gem::Package::FileSource < Gem::Package::Source # :nodoc: all

attr_reader :path

def initialize(path)

def with_read_io(&block)

File.open path, 'rb', &block

end

end

# object to `Gem::Package.new`.

class Gem::Package::IOSource < Gem::Package::Source # :nodoc: all

attr_reader :io

def initialize(io)

def path

end

end

# Please pretend this doesn't exist.

class Gem::Package::Old < Gem::Package

undef_method :spec=

##

true

end

end

# A header for a tar file

class Gem::Package::TarHeader

##

# Fields in the tar header

def oct(num, len)

"%0#{len}o" % num

end

end

# TarReader reads tar files and allows iteration over their items

class Gem::Package::TarReader

include Enumerable

##

ensure

rewind

end

end

require 'rubygems/package/tar_reader/entry'

# Class for reading entries out of a tar file

class Gem::Package::TarReader::Entry

##

# Header for this tar entry

@io.pos = @orig_pos

@read = 0

end

end

# A test case for Gem::Package::Tar* classes

class Gem::Package::TarTestCase < Gem::TestCase

def ASCIIZ(str, length)

str + "\0" * (length - str.length)

end

def util_symlink_entry

util_entry tar_symlink_header("foo", "bar", 0, Time.now, "link")

end

end

# Allows writing of tar files

class Gem::Package::TarWriter

class FileOverflow < StandardError; end

##

# IO wrapper that allows writing a limited amount of data

class BoundedStream

##

# Maximum number of bytes that can be written

@written += data.bytesize

data.bytesize

end

end

##

# IO wrapper that provides only #write

class RestrictedStream

##

# Creates a new RestrictedStream wrapping +io+

def write(data)

@io.write data

end

end

##

return name, prefix

end

end

# end

class Gem::PackageTask < Rake::PackageTask

##

# Ruby Gem::Specification containing the metadata for this package. The

# name, version and package_files are automatically determined from the

end

end

end

end

# to the rest of RubyGems.

#

class Gem::PathSupport

##

# The default system path for managing Gems.

attr_reader :home

path

end

end

end

# See `gem help platform` for information on platform matching.

class Gem::Platform

@local = nil

attr_accessor :cpu

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

CURRENT = 'current'.freeze

end

module Gem

if defined? ::Psych::Visitors

class NoAliasYAMLTree < Psych::Visitors::YAMLTree

def self.create

new({})

end unless respond_to? :create

end

private :format_time

end

end

end

# a remote source.

class Gem::RemoteFetcher

include Gem::UserInteraction

include Gem::UriParsing

# that could happen while downloading from the internet.

class FetchError < Gem::Exception

include Gem::UriParsing

##

def to_s # :nodoc:

"#{super} (#{uri})"

end

end

##

@pools[proxy] ||= Gem::Request::ConnectionPools.new proxy, @cert_files

end

end

end

require 'rubygems/user_interaction'

class Gem::Request

extend Gem::UserInteraction

include Gem::UserInteraction

ua

end

end

require 'rubygems/request/http_pool'

# frozen_string_literal: true

class Gem::Request::ConnectionPools # :nodoc:

@client = Net::HTTP

class << self

attr_accessor :client

end

def initialize(proxy_uri, cert_files)

net_http_args

end

end

end

# use it.

class Gem::Request::HTTPPool # :nodoc:

attr_reader :cert_files, :proxy_uri

def initialize(http_args, cert_files, proxy_uri)

connection.start

connection

end

end

# frozen_string_literal: true

class Gem::Request::HTTPSPool < Gem::Request::HTTPPool # :nodoc:

private

def setup_connection(connection)

Gem::Request.configure_connection_for_https(connection, @cert_files)

super

end

end

# #=> ["nokogiri-1.6.0", "mini_portile-0.5.1", "pg-0.17.0"]

class Gem::RequestSet

include TSort

##

yield match

end

end

end

require 'rubygems/request_set/gem_dependency_api'

# See `gem help install` and `gem help gem_dependencies` for further details.

class Gem::RequestSet::GemDependencyAPI

ENGINE_MAP = { # :nodoc:

:jruby => %w[jruby],

:jruby_18 => %w[jruby],

Gem.sources << url

end

end

# constructed.

class Gem::RequestSet::Lockfile

##

# Raised when a lockfile cannot be parsed

class ParseError < Gem::Exception

##

# The column where the error was encountered

@path = path

super "#{message} (at line #{line} column #{column})"

end

end

##

def requests

@set.sorted_requests

end

end

require 'rubygems/request_set/lockfile/tokenizer'

# frozen_string_literal: true

class Gem::RequestSet::Lockfile::Parser

###

# Parses lockfiles

def unget(token) # :nodoc:

@tokens.unshift token

end

end

require 'rubygems/request_set/lockfile/parser'

class Gem::RequestSet::Lockfile::Tokenizer

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

EOF = Token.new :EOF

@tokens

end

end

# together in RubyGems.

class Gem::Requirement

OPS = { #:nodoc:

"=" => lambda {|v, r| v == r },

"!=" => lambda {|v, r| v != r },

end

end

end

end

class Gem::Version

# This is needed for compatibility with older yaml

# gemspecs.

Requirement = Gem::Requirement # :nodoc:

end

# all the requirements.

class Gem::Resolver

require 'rubygems/resolver/molinillo'

##

end

end

private :amount_constrained

end

require 'rubygems/resolver/activation_request'

# dependency that was used to introduce this activation.

class Gem::Resolver::ActivationRequest

##

# The parent request for this activation request.

def name_tuple

@name_tuple ||= Gem::NameTuple.new(name, version, platform)

end

end

# Returns instances of APISpecification.

class Gem::Resolver::APISet < Gem::Resolver::Set

##

# The URI for the dependency API this APISet uses.

@data[name]

end

end

# is the name, version, and dependencies.

class Gem::Resolver::APISpecification < Gem::Resolver::Specification

##

# Creates an APISpecification for the given +set+ from the rubygems.org

# +api_data+.

def source # :nodoc:

@set.source

end

end

# It combines IndexSet and APISet

class Gem::Resolver::BestSet < Gem::Resolver::ComposedSet

##

# Creates a BestSet for the given +sources+ or Gem::sources if none are

# specified. +sources+ must be a Gem::SourceList.

index_set

end

end

end

# This method will eliminate nesting of composed sets.

class Gem::Resolver::ComposedSet < Gem::Resolver::Set

attr_reader :sets # :nodoc:

##

def prefetch(reqs)

@sets.each {|s| s.prefetch(reqs) }

end

end

# with a spec that would be activated.

class Gem::Resolver::Conflict

##

# The specification that was activated prior to the conflict

def requester

@failed_dep.requester

end

end

# for installed gems.

class Gem::Resolver::CurrentSet < Gem::Resolver::Set

def find_all(req)

req.dependency.matching_specs

end

end

# contained the Dependency.

class Gem::Resolver::DependencyRequest

##

# The wrapped Gem::Dependency

def to_s # :nodoc:

@dependency.to_s

end

end

# set.add_git_gem 'rake', 'git://example/rake.git', tag: 'rake-10.1.0'

class Gem::Resolver::GitSet < Gem::Resolver::Set

##

# The root directory for git gems in this set. This is usually Gem.dir, the

# installation directory for regular gems.

end

end

end

end

# option.

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

def ==(other) # :nodoc:

self.class === other and

@set == other.set and

q.pp @source

end

end

end

# source index.

class Gem::Resolver::IndexSet < Gem::Resolver::Set

def initialize(source = nil) # :nodoc:

super()

end

end

end

end

# and +version+ are needed.

class Gem::Resolver::IndexSpecification < Gem::Resolver::Specification

##

# An IndexSpecification is created from the index format described in `gem

# help generate_index`.

@source.fetch_spec tuple

end

end

end

# locally.

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

def ==(other) # :nodoc:

self.class === other and

@set == other.set and

def source

@source ||= Gem::Source::Installed.new

end

end

# files

class Gem::Resolver::InstallerSet < Gem::Resolver::Set

##

# List of Gem::Specification objects that must always be installed.

@domain = :local unless remote

end

end

end

# A LocalSpecification comes from a .gem file on the local filesystem.

class Gem::Resolver::LocalSpecification < Gem::Resolver::SpecSpecification

##

# Returns +true+ if this gem is installable for the current platform.

q.text "source: #{@source.path}"

end

end

end

# A set of gems from a gem dependencies lockfile.

class Gem::Resolver::LockSet < Gem::Resolver::Set

attr_reader :specs # :nodoc:

##

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

end

end

end

# lockfile.

class Gem::Resolver::LockSpecification < Gem::Resolver::Specification

attr_reader :sources

def initialize(set, name, version, sources, platform)

s.dependencies.concat @dependencies

end

end

end

# first.

class Gem::Resolver::RequirementList

include Enumerable

##

x = @exact[0,5]

x + @list[0,5 - x.size]

end

end

# dependencies) used in resolution. This set is abstract.

class Gem::Resolver::Set

##

# Set to true to disable network access for this set

def remote? # :nodoc:

@remote

end

end

# Kind off like BestSet but filters the sources for gems

class Gem::Resolver::SourceSet < Gem::Resolver::Set

##

# Creates a SourceSet for the given +sources+ or Gem::sources if none are

# specified. +sources+ must be a Gem::SourceList.

link = @links[name]

@sets[link] ||= Gem::Source.new(link).dependency_resolver_set if link

end

end

# Resolver specifications that are backed by a Gem::Specification.

class Gem::Resolver::SpecSpecification < Gem::Resolver::Specification

##

# A SpecSpecification is created for a +set+ for a Gem::Specification in

# +spec+. The +source+ is either where the +spec+ came from, or should be

def version

spec.version

end

end

# dependency resolution in the resolver is included.

class Gem::Resolver::Specification

##

# The dependencies of the gem for this specification

def local? # :nodoc:

false

end

end

# frozen_string_literal: true

class Gem::Resolver::Stats

def initialize

@max_depth = 0

@max_requirements = 0

$stdout.printf PATTERN, "Backtracking #", @backtracking

$stdout.printf PATTERN, "Iteration #", @iterations

end

end

# rake.gemspec (watching the given name).

class Gem::Resolver::VendorSet < Gem::Resolver::Set

##

# The specifications for this set.

end

end

end

end

# option.

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

def ==(other) # :nodoc:

self.class === other and

@set == other.set and

def install(options = {})

yield nil

end

end

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

# More on AWS SigV4: https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html

class Gem::S3URISigner

class ConfigurationError < Gem::Exception

def initialize(message)

super message

end

def to_s # :nodoc:

"#{super}"

end

end

class InstanceProfileError < Gem::Exception

def initialize(message)

super message

end

def to_s # :nodoc:

"#{super}"

end

end

attr_accessor :uri

BASE64_URI_TRANSLATE = { "+" => "%2B", "/" => "%2F", "=" => "%3D", "\n" => "" }.freeze

EC2_IAM_INFO = "http://169.254.169.254/latest/meta-data/iam/info".freeze

EC2_IAM_SECURITY_CREDENTIALS = "http://169.254.169.254/latest/meta-data/iam/security-credentials/".freeze

end

# Gem::Security::Policies.

class Gem::Security::Policy

include Gem::UserInteraction

attr_reader :name

end

alias to_s name # :nodoc:

end

require "rubygems/user_interaction"

class Gem::Security::Signer

include Gem::UserInteraction

##

end

end

end

end

# verification.

class Gem::Security::TrustDir

##

# Default permissions for the trust directory and its contents

FileUtils.mkdir_p @dir, :mode => @permissions[:trust_dir]

end

end

end

# TODO Refactor into a real WEBrick servlet to remove code duplication.

class Gem::Server

attr_reader :spec_dirs

include ERB::Util

system("#{@launch} http://#{host}:#{@port}")

end

end

# bundler dependency API and so-forth.

class Gem::Source

include Comparable

include Gem::Text

return if @uri.host.nil?

levenshtein_distance(@uri.host, host) <= distance_threshold

end

end

require 'rubygems/source/git'

# source.specs

class Gem::Source::Git < Gem::Source

##

# The name of the gem created by this git gem.

Digest::SHA1.hexdigest normalized

end

end

# Represents an installed gem. This is used for dependency resolution.

class Gem::Source::Installed < Gem::Source

def initialize # :nodoc:

@uri = nil

end

def pretty_print(q) # :nodoc:

q.text '[Installed]'

end

end

# dependencies.

class Gem::Source::Local < Gem::Source

def initialize # :nodoc:

@specs = nil

@api_uri = nil

end

end

end

end

# dependency lock files.

class Gem::Source::Lock < Gem::Source

##

# The wrapped Gem::Source

def uri # :nodoc:

@wrapped.uri

end

end

# local gems.

class Gem::Source::SpecificFile < Gem::Source

##

# The path to the gem for this specific file.

super

end

end

end

# This represents a vendored source that is similar to an installed gem.

class Gem::Source::Vendor < Gem::Source::Installed

##

# Creates a new Vendor source for a gem that was unpacked at +path+.

nil

end

end

end

# The most common way to get a SourceList is Gem.sources.

class Gem::SourceList

include Enumerable

##

@sources.delete_if {|x| x.uri.to_s == source.to_s }

end

end

end

# SpecFetcher handles metadata updates from remote gem repositories.

class Gem::SpecFetcher

include Gem::UserInteraction

include Gem::Text

raise unless gracefully_ignore

[]

end

end

# items you may add to a specification.

class Gem::Specification < Gem::BasicSpecification

extend Gem::Deprecate

# REFACTOR: Consider breaking out this version stuff into a separate

def raw_require_paths # :nodoc:

@require_paths

end

end

require 'rubygems/user_interaction'

class Gem::SpecificationPolicy

include Gem::UserInteraction

VALID_NAME_PATTERN = /\A[a-zA-Z0-9\.\-\_]+\z/.freeze # :nodoc:

def help_text # :nodoc:

"See https://guides.rubygems.org/specification-reference/ for help"

end

end

# information.

class Gem::StubSpecification < Gem::BasicSpecification

# :nodoc:

PREFIX = "# stub: ".freeze

OPEN_MODE = 'r:UTF-8:-'.freeze

class StubLine # :nodoc: all

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

:full_name

REQUIRE_PATHS[x] || x

end

end

end

def self.default_gemspec_stub(filename, base_dir, gems_dir)

def stubbed?

data.is_a? StubLine

end

end

# should.

module Syck

class DefaultKey

remove_method :to_s rescue nil

def to_s

'='

end

end

end

require "rubygems/command"

class Gem::Command

##

# Allows resetting the hash of specific args per command. This method is

# available when requiring 'rubygems/test_case'

def self.specific_extra_args_hash=(value)

@specific_extra_args_hash = value

end

end

##

# your normal set of gems is not affected.

class Gem::TestCase < Minitest::Test

extend Gem::Deprecate

attr_accessor :fetcher # :nodoc:

end

class << self

# :nodoc:

##

# Return the join path, with escaping backticks, dollars, and

"\"#{path.gsub(/[`$"]/, '\\&')}\""

end

end

end

@@good_rake = "#{rubybin} #{escape_path(TEST_PATH, 'good_rake.rb')}"

# It is available by requiring Gem::TestCase.

class StaticSet < Gem::Resolver::Set

##

# A StaticSet ignores remote because it has a fixed set of gems.

def prefetch(reqs) # :nodoc:

end

end

##

PUBLIC_KEY = nil

PUBLIC_CERT = nil

end if defined?(OpenSSL::SSL)

end

require 'rubygems/test_utilities'

# See RubyGems' tests for more examples of FakeFetcher.

class Gem::FakeFetcher

attr_reader :data

attr_reader :last_request

attr_accessor :paths

download spec, source.uri.to_s

end

end

# :stopdoc:

class Gem::RemoteFetcher

def self.fetcher=(fetcher)

@fetcher = fetcher

end

end

# :startdoc:

# After the gems are created they are removed from Gem.dir.

class Gem::TestCase::SpecFetcherSetup

##

# Executes a SpecFetcher setup block. Yields an instance then creates the

# gems and specifications defined in the instance.

io.write spec.to_ruby_for_cache

end

end

end

##

# This class was added to flush out problems in Rubinius' IO implementation.

class TempIO < Tempfile

##

# Creates a new TempIO that will be initialized to contain +string+.

flush

Gem.read_binary path

end

end

# file. See Gem.pre_uninstall and Gem.post_uninstall for details.

class Gem::Uninstaller

include Gem::UserInteraction

include Gem::InstallerUninstallerUtils

raise e

end

end

# p uf.normalize #=> 'http://example.com'

class Gem::UriFormatter

##

# The URI to be formatted.

return unless @uri

CGI.unescape @uri

end

end

#

class Gem::UriParser

##

# Parses the #uri, raising if it's invalid

rescue URI::InvalidURIError

uri

end

end

# Gem::StreamUI implements a simple stream based user interface.

class Gem::StreamUI

extend Gem::Deprecate

##

# An absolutely silent progress reporter.

class SilentProgressReporter

##

# The count of items is never updated for the silent progress reporter.

def done

end

end

##

# A basic dotted progress reporter.

class SimpleProgressReporter

include Gem::DefaultUserInteraction

##

def done

@out.puts "\n#{@terminal_message}"

end

end

##

# A progress reporter that prints out messages about the current progress.

class VerboseProgressReporter

include Gem::DefaultUserInteraction

##

def done

@out.puts @terminal_message

end

end

##

# An absolutely silent download reporter.

class SilentDownloadReporter

##

# The silent download reporter ignores all arguments

def done

end

end

##

# A progress reporter that behaves nicely with threaded downloading.

class ThreadedDownloadReporter

MUTEX = Mutex.new

##

@out.puts message

end

end

end

end

##

# STDOUT, and STDERR.

class Gem::ConsoleUI < Gem::StreamUI

##

# The Console UI has no arguments as it defaults to reading input from

# stdin, output to stdout and warnings or errors to stderr.

def initialize

super STDIN, STDOUT, STDERR, true

end

end

##

# SilentUI is a UI choice that is absolutely silent.

class Gem::SilentUI < Gem::StreamUI

##

# The SilentUI has no arguments as it does not use any stream.

def progress_reporter(*args) # :nodoc:

SilentProgressReporter.new(@outs, *args)

end

end

end

class << self

extend Gem::Deprecate

rubygems_deprecate :silent_system

end

##

require 'rubygems/text'

class Gem::Licenses

extend Gem::Text

NONSTANDARD = 'Nonstandard'.freeze

return unless lowest < license.size

by_distance[lowest]

end

end

# frozen_string_literal: true

module Gem

class List

include Enumerable

attr_accessor :value, :tail

return List.new(value) unless list

List.new value, list

end

end

end

# Validator performs various gem file and gem database validation

class Gem::Validator

include Gem::UserInteraction

def initialize # :nodoc:

errors

end

end

# a zero to give a sensible result.

class Gem::Version

autoload :Requirement, File.expand_path('requirement', __dir__)

include Comparable

numeric_segments = string_segments.slice!(0, string_start || string_segments.size)

return numeric_segments, string_segments

end

end

# frozen_string_literal: true

class TestGem

TEST_PLUGIN_LOAD = :loaded

end

# frozen_string_literal: true

class Gem::Commands::CrashCommand < Gem::Command

raise "crash"

end

end

class Gem::Commands::InterruptCommand < Gem::Command

def initialize

super('interrupt', 'Raises an Interrupt Exception', {})

end

def execute

raise Interrupt, "Interrupt exception"

end

end

Gem::CommandManager.instance.register_command :interrupt

#

class TestBundledCA < Gem::TestCase

THIS_FILE = File.expand_path __FILE__

def bundled_certificate_store

def test_accessing_new_index

assert_https('fastly.rubygems.org')

end

end if defined?(OpenSSL::SSL)

require 'shellwords'

class TestConfig < Gem::TestCase

def test_datadir

util_make_gems

spec = Gem::Specification.find_by_name("a")

assert_equal(Gem.ruby, ruby)

assert_match(/\/bad_rake.rb\z/, rake)

end

end

require 'rubygems/deprecate'

class TestDeprecate < Gem::TestCase

def setup

super

end

class Thing

extend Gem::Deprecate

attr_accessor :message

def foo

@message = "bar"

end

rubygems_deprecate :foo, :bar

end

class OtherThing

extend Gem::Deprecate

attr_accessor :message

def foo

@message = "bar"

end

deprecate :foo, :bar, 2099, 3

end

def test_deprecated_method_calls_the_old_method

assert_match(/Thing#foo is deprecated; use bar instead\./, err)

assert_match(/on or after 2099-03-01/, err)

end

end

require 'rbconfig'

class TestGem < Gem::TestCase

PLUGINS_LOADED = [] # rubocop:disable Style/MutableConstant

PROJECT_DIR = File.expand_path('../../..', __FILE__).tap(&Gem::UNTAINT)

def util_cache_dir

File.join Gem.dir, "cache"

end

end

require 'rubygems/security'

class TestGemAvailableSet < Gem::TestCase

def setup

super

assert_equal [a3a, a2, a2a, a1, a1a], g

end

end

require 'rubygems/test_case'

class TestGemBundlerVersionFinder < Gem::TestCase

def setup

super

bvf.filter!(specs)

specs

end

end

require 'rubygems/command'

class Gem::Command

public :parser

end

class TestGemCommand < Gem::TestCase

def setup

super

assert_equal expected, @ui.error

end

end

require 'rubygems/command_manager'

class TestGemCommandManager < Gem::TestCase

PROJECT_DIR = File.expand_path('../../..', __FILE__).tap(&Gem::UNTAINT)

def setup

ensure

Gem::Commands.send(:remove_const, :FooCommand)

end

end

require 'rubygems/package'

class TestGemCommandsBuildCommand < Gem::TestCase

CERT_FILE = cert_path 'public3072'

SIGNING_KEY = key_path 'private3072'

ensure

ENV["SOURCE_DATE_EPOCH"] = epoch

end

end

end

class TestGemCommandsCertCommand < Gem::TestCase

ALTERNATE_CERT = load_cert 'alternate'

EXPIRED_PUBLIC_CERT = load_cert 'expired'

assert_equal "invalid argument: --sign #{nonexistent}: does not exist",

e.message

end

end if defined?(OpenSSL::SSL) && !Gem.java_platform?

require 'rubygems/commands/check_command'

class TestGemCommandsCheckCommand < Gem::TestCase

def setup

super

refute_path_exists b.gem_dir

refute_path_exists b.spec_file

end

end

require 'rubygems/installer'

class TestGemCommandsCleanupCommand < Gem::TestCase

def setup

super

assert_path_exists d_1.gem_dir

assert_path_exists d_2.gem_dir

end

end

require 'rubygems/commands/contents_command'

class TestGemCommandsContentsCommand < Gem::TestCase

def setup

super

assert_equal Gem::Requirement.new('0.0.2'), @cmd.options[:version]

assert @cmd.options[:show_install_dir]

end

end

require 'rubygems/commands/dependency_command'

class TestGemCommandsDependencyCommand < Gem::TestCase

def setup

super

@stub_ui = Gem::MockGemUi.new

assert_equal "Gem a-2.a\n\n", @stub_ui.output

assert_equal '', @stub_ui.error

end

end

require 'rubygems/commands/environment_command'

class TestGemCommandsEnvironmentCommand < Gem::TestCase

def setup

super

assert_equal "#{Gem.platforms.join File::PATH_SEPARATOR}\n", @ui.output

assert_equal '', @ui.error

end

end

require 'rubygems/commands/fetch_command'

class TestGemCommandsFetchCommand < Gem::TestCase

def setup

super

assert_path_exists(File.join(@tempdir, a1.file_name),

"#{a1.full_name} not fetched")

end

end

require 'rubygems/commands/generate_index_command'

class TestGemCommandsGenerateIndexCommand < Gem::TestCase

def setup

super

"WARNING: The \"--no-modern\" option has been deprecated and will be removed in Rubygems 4.0. The `--no-modern` option is currently ignored. Modern indexes (specs, latest_specs, and prerelease_specs) are always generated.\n",

@ui.error

end

end

require "rubygems/command_manager"

class TestGemCommandsHelpCommand < Gem::TestCase

def setup

super

yield @ui.output, @ui.error

end

end

require 'rubygems/commands/info_command'

class TestGemCommandsInfoCommand < Gem::TestCase

def setup

super

assert_match %r{#{@gem.summary}\n}, @ui.output

assert_match "", @ui.error

end

end

require 'rubygems/rdoc'

class TestGemCommandsInstallCommand < Gem::TestCase

def setup

super

common_installer_setup

assert_equal " a-3", out.shift

assert_empty out

end

end

require 'rubygems/commands/list_command'

class TestGemCommandsListCommand < Gem::TestCase

def setup

super

assert_equal "true\n", @ui.output

assert_equal '', @ui.error

end

end

require 'rubygems/commands/lock_command'

class TestGemCommandsLockCommand < Gem::TestCase

def setup

super

assert_equal 'Could not find gem c-1, try using the full name', e.message

end

end

require 'rubygems/commands/mirror_command'

class TestGemCommandsMirrorCommand < Gem::TestCase

def setup

super

assert_match %r{Install the rubygems-mirror}i, @ui.error

end

end

require 'rubygems/commands/open_command'

class TestGemCommandsOpenCommand < Gem::TestCase

def setup

super

assert_match %r{'foo' is a default gem and can't be opened\.} , @ui.output

assert_equal "", @ui.error

end

end

require 'rubygems/commands/outdated_command'

class TestGemCommandsOutdatedCommand < Gem::TestCase

def setup

super

assert_equal "foo (0.2 < 2.0)\n", @ui.output

assert_equal "", @ui.error

end

end

require 'rubygems/commands/owner_command'

class TestGemCommandsOwnerCommand < Gem::TestCase

def setup

super

assert_match 'Code: ', @otp_ui.output

assert_equal '111111', @stub_fetcher.last_request['OTP']

end

end

require 'rubygems/commands/pristine_command'

class TestGemCommandsPristineCommand < Gem::TestCase

def setup

super

common_installer_setup

assert @cmd.options[:extensions]

assert @cmd.options[:extensions_set]

end

end

require 'rubygems/commands/push_command'

class TestGemCommandsPushCommand < Gem::TestCase

def setup

super

def singleton_gem_class

class << Gem; self; end

end

end

end

class TestGemCommandsQueryCommandWithInstalledGems < Gem::TestCase

include TestGemCommandsQueryCommandSetup

def test_execute

fetcher.spec 'a', '3.a'

end

end

end

class TestGemCommandsQueryCommandWithoutInstalledGems < Gem::TestCase

include TestGemCommandsQueryCommandSetup

def test_execute_platform

fetcher.download 'a', '3.a'

end

end

end

require 'rubygems/commands/search_command'

class TestGemCommandsSearchCommand < Gem::TestCase

def setup

super

def test_initialize

assert_equal :remote, @cmd.defaults[:domain]

end

end

require 'rubygems/commands/server_command'

class TestGemCommandsServerCommand < Gem::TestCase

def setup

super

assert_equal 'invalid argument: -p 65536: not a port number',

e.message

end

end

require 'rubygems/commands/setup_command'

class TestGemCommandsSetupCommand < Gem::TestCase

bundler_gemspec = File.expand_path("../../../bundler/lib/bundler/version.rb", __FILE__)

if File.exist?(bundler_gemspec)

BUNDLER_VERS = File.read(bundler_gemspec).match(/VERSION = "(#{Gem::Version::VERSION_PATTERN})"/)[1]

def default_bundle_bin_path

File.join @install_dir, 'bin', 'bundle'

end

end unless Gem.java_platform?

require 'rubygems/installer'

class TestGemCommandsSigninCommand < Gem::TestCase

def setup

super

sign_in_ui

end

end

require 'rubygems/installer'

class TestGemCommandsSignoutCommand < Gem::TestCase

def setup

super

@cmd = Gem::Commands::SignoutCommand.new

assert_match %r{You are not currently signed in}, @sign_out_ui.error

end

end

require 'rubygems/commands/sources_command'

class TestGemCommandsSourcesCommand < Gem::TestCase

def setup

super

assert_equal "source cache successfully updated\n", @ui.output

assert_equal '', @ui.error

end

end

require 'rubygems/commands/specification_command'

class TestGemCommandsSpecificationCommand < Gem::TestCase

def setup

super

assert_match %r{s.name = "foo"}, @ui.output

assert_equal '', @ui.error

end

end

require 'rubygems/commands/stale_command'

class TestGemCommandsStaleCommand < Gem::TestCase

def setup

super

@stub_ui = Gem::MockGemUi.new

assert_equal("#{foo_bar.name}-#{foo_bar.version}", lines[0].split.first)

assert_equal("#{bar_baz.name}-#{bar_baz.version}", lines[1].split.first)

end

end

require 'rubygems/commands/uninstall_command'

class TestGemCommandsUninstallCommand < Gem::InstallerTestCase

def setup

super

@cmd = Gem::Commands::UninstallCommand.new

end

end

end

end

require 'rubygems/commands/unpack_command'

class TestGemCommandsUnpackCommand < Gem::TestCase

def setup

super

assert @cmd.options[:spec]

end

end

require 'rubygems/commands/update_command'

class TestGemCommandsUpdateCommand < Gem::TestCase

def setup

super

common_installer_setup

assert_equal " a-2", out.shift

assert_empty out

end

end

require 'rubygems/commands/which_command'

class TestGemCommandsWhichCommand < Gem::TestCase

def setup

super

Gem::Specification.reset

FileUtils.touch filename

end

end

end

require 'rubygems/commands/yank_command'

class TestGemCommandsYankCommand < Gem::TestCase

def setup

super

assert_equal 'key', @fetcher.last_request['Authorization']

assert_equal [yank_uri], @fetcher.paths

end

end

require 'rubygems/config_file'

class TestGemConfigFile < Gem::TestCase

def setup

super

util_config_file

assert_equal(true, @cfg.disable_default_gem_server)

end

end

require 'rubygems/dependency'

class TestGemDependency < Gem::TestCase

def test_initialize

d = dep "pkg", "> 1.0"

assert_equal dep("a", " >= 1.a").identity, :abs_latest

assert_equal dep("a").identity, :latest

end

end

require 'rubygems/security'

class TestGemDependencyInstaller < Gem::TestCase

def setup

super

common_installer_setup

@d1, @d2, @x1_m, @x1_o, @w1, @y1,

@y1_1_p, @z1].compact)

end

end

require 'rubygems/dependency_list'

class TestGemDependencyList < Gem::TestCase

def setup

super

@deplist.add @a1, @a2, @b1, @c2, @d1

end

end

require 'rubygems/test_case'

class TestGemDependencyResolutionError < Gem::TestCase

def setup

super

assert_match %r{^conflicting dependencies a \(= 1\) and a \(= 2\)$},

@error.message

end

end

require 'rubygems/doctor'

class TestGemDoctor < Gem::TestCase

def gem(name)

spec = quick_gem name do |gem|

gem.files = %W[lib/#{name}.rb Rakefile]

assert doctor.gem_repository?, 'gems installed'

end

end

require 'rubygems/installer'

class TestGemExtBuilder < Gem::TestCase

def setup

super

def test_build_extensions_install_ext_only

class << Gem

alias orig_install_extension_in_lib install_extension_in_lib

remove_method :install_extension_in_lib

def Gem.install_extension_in_lib

false

end

end

@spec.extensions << 'ext/extconf.rb'

refute_path_exists File.join @spec.gem_dir, 'lib', 'a', 'b.rb'

ensure

class << Gem

remove_method :install_extension_in_lib

alias install_extension_in_lib orig_install_extension_in_lib

end

end

assert_equal %w[--with-foo-dir=/nonexistent], builder.build_args

end

end unless Gem.java_platform?

require 'rubygems/ext'

class TestGemExtCmakeBuilder < Gem::TestCase

def setup

super

assert_contains_make_command '', output

assert_contains_make_command 'install', output

end

end

require 'rubygems/ext'

class TestGemExtConfigureBuilder < Gem::TestCase

def setup

super

assert_contains_make_command '', output[4]

assert_contains_make_command 'install', output[7]

end

end

require 'rubygems/ext'

class TestGemExtExtConfBuilder < Gem::TestCase

def setup

super

RbConfig::CONFIG.delete 'configure_args'

end

end

end

require 'rubygems/ext'

class TestGemExtRakeBuilder < Gem::TestCase

def setup

super

EO_MKRF

end

end

end

require 'rubygems/test_case'

class TestGemGemRunner < Gem::TestCase

def setup

super

assert_empty @ui.error

end

end

require 'rubygems/gemcutter_utilities'

class TestGemGemcutterUtilities < Gem::TestCase

def setup

super

@cmd.verify_api_key :missing

end

end

end

require 'rubygems/test_case'

class TestGemImpossibleDependenciesError < Gem::TestCase

def test_message_conflict

request = dependency_request dep('net-ssh', '>= 2.0.13'), 'rye', '0.9.8'

assert_equal expected, error.message

end

end

require 'rubygems/indexer'

class TestGemIndexer < Gem::TestCase

def setup

super

file = File.join dir, name

refute File.exist?(file), "#{file} exists"

end

end

require 'rubygems/dependency_installer'

class TestGemInstallUpdateOptions < Gem::InstallerTestCase

def setup

super

assert_equal true, @cmd.options[:post_install_message]

end

end

require 'rubygems/installer_test_case'

class TestGemInstaller < Gem::InstallerTestCase

def setup

super

common_installer_setup

def mask

0100755

end

end

require 'rubygems/command'

class TestGemLocalRemoteOptions < Gem::TestCase

def setup

super

assert_equal [@gem_repo], Gem.sources

end

end

require 'rubygems/name_tuple'

class TestGemNameTuple < Gem::TestCase

def test_full_name

n = Gem::NameTuple.new "a", Gem::Version.new(0), "ruby"

assert_equal "a-0", n.full_name

assert_equal 1, a_p.<=>(a)

end

end

require 'digest'

class TestGemPackage < Gem::Package::TarTestCase

def setup

super

StringIO.new tgz_io.string

end

end

require 'rubygems/simple_gem'

class TestGemPackageOld < Gem::TestCase

def setup

super

'and cannot be verified',

e.message

end

end

end

require 'rubygems/package'

class TestGemPackageTarHeader < Gem::Package::TarTestCase

def setup

super

assert_equal 0, tar_header.uid

assert_equal 0, tar_header.gid

end

end

require 'rubygems/package'

class TestGemPackageTarReader < Gem::Package::TarTestCase

def test_each_entry

tar = tar_dir_header "foo", "bar", 0, Time.now

tar << tar_file_header("bar", "baz", 0, 0, Time.now)

ensure

io.close!

end

end

require 'rubygems/package'

class TestGemPackageTarReaderEntry < Gem::Package::TarTestCase

def setup

super

assert_equal char, @entry.getc

end

end

require 'minitest/mock'

class TestGemPackageTarWriter < Gem::Package::TarTestCase

def setup

super

end

assert_includes exception.message, name

end

end

end

class TestGemPackageTask < Gem::TestCase

def test_gem_package

original_rake_fileutils_verbosity = RakeFileUtils.verbose_flag

RakeFileUtils.verbose_flag = false

assert_equal 'pkg/nokogiri-1.5.0-java', pkg.package_dir_path

end

end if defined?(Rake::PackageTask)

require 'fileutils'

class TestGemPathSupport < Gem::TestCase

def setup

super

assert_equal dir, ps.home

assert_equal [dir, not_existing], ps.path

end

end

require 'rbconfig'

class TestGemPlatform < Gem::TestCase

def test_self_local

util_set_arch 'i686-darwin8.10.1'

def refute_local_match(name)

refute_match Gem::Platform.local, name

end

end

require 'rubygems/rdoc'

class TestGemRDoc < Gem::TestCase

Gem::RDoc.load_rdoc

def setup

FileUtils.rm_r @a.doc_dir

end

end

end

# proxy is configured.

class TestGemRemoteFetcher < Gem::TestCase

include Gem::DefaultUserInteraction

SERVER_DATA = <<-EOY.freeze

end

class NilLog < WEBrick::Log

def log(level, data) #Do nothing

end

end

private

def key(filename)

OpenSSL::PKey::RSA.new(File.read(File.join(__dir__, filename)))

end

end if defined?(OpenSSL::SSL)

end

class TestGemRequest < Gem::TestCase

CA_CERT_FILE = cert_path 'ca'

CHILD_CERT = load_cert 'child'

EXPIRED_CERT = load_cert 'expired'

end

class Conn

attr_accessor :payload

def new(*args); self; end

self.payload = req

@response

end

end

end if defined?(OpenSSL::SSL)

require 'timeout'

class TestGemRequestConnectionPool < Gem::TestCase

class FakeHttp

def initialize(*args)

end

def start

end

end

def setup

end

end.join

end

end

require 'rubygems/request_set'

class TestGemRequestSet < Gem::TestCase

def setup

super

assert_empty deps

end

end

require 'rubygems/request_set'

class TestGemRequestSetGemDependencyAPI < Gem::TestCase

def setup

super

assert_equal engine_version, RUBY_ENGINE_VERSION if engine

end

end unless Gem.java_platform?

require 'rubygems/request_set/lockfile'

class TestGemRequestSetLockfile < Gem::TestCase

def setup

super

assert_equal 'hello', File.read(gem_deps_lock_file)

end

end

require 'rubygems/request_set/lockfile/parser'

class TestGemRequestSetLockfileParser < Gem::TestCase

def setup

super

@gem_deps_file = 'gem.deps.rb'

parser = tokenizer.make_parser set, platforms

parser.parse

end

end

require 'rubygems/request_set/lockfile/parser'

class TestGemRequestSetLockfileTokenizer < Gem::TestCase

def setup

super

def tokenize_lockfile

Gem::RequestSet::Lockfile::Tokenizer.from_file(@lock_file).to_a

end

end

require "rubygems/requirement"

class TestGemRequirement < Gem::TestCase

def test_concat

r = req '>= 1'

refute req(requirement).satisfied_by?(v(version)),

"#{requirement} is not satisfied by #{version}"

end

end

require 'rubygems/test_case'

class TestGemResolver < Gem::TestCase

def setup

super

assert_match "No match for 'a (= 1)' on this platform. Found: c-p-1",

e.message

end

end

require 'rubygems/test_case'

class TestGemResolverActivationRequest < Gem::TestCase

def setup

super

assert @req.installed?

end

end

require 'rubygems/test_case'

class TestGemResolverAPISet < Gem::TestCase

def setup

super

assert_empty set.instance_variable_get :@data

end

end

require 'rubygems/test_case'

class TestGemResolverAPISpecification < Gem::TestCase

def test_initialize

set = Gem::Resolver::APISet.new

data = {

assert_kind_of Gem::Specification, spec

assert_equal 'j-1-java', spec.full_name

end

end

require 'rubygems/test_case'

class TestGemResolverBestSet < Gem::TestCase

def setup

super

assert_equal error, e

end

end

require 'rubygems/test_case'

class TestGemResolverComposedSet < Gem::TestCase

def test_errors

index_set = Gem::Resolver::IndexSet.new

current_set = Gem::Resolver::CurrentSet.new

refute best_set.remote?

refute current_set.remote?

end

end

require 'rubygems/test_case'

class TestGemResolverConflict < Gem::TestCase

def test_explanation

root =

dependency_request dep('net-ssh', '>= 2.0.13'), 'rye', '0.9.8'

assert_equal expected, conflict.request_path(child.requester)

end

end

require 'rubygems/test_case'

class TestGemResolverDependencyRequest < Gem::TestCase

def setup

super

assert_equal dependency, dr.dependency

end

end

require 'rubygems/test_case'

class TestGemResolverGitSet < Gem::TestCase

def setup

super

assert_equal "#{@gemhome}2", spec.source.root_dir

end

end

require 'rubygems/installer'

class TestGemResolverGitSpecification < Gem::TestCase

def setup

super

assert called

end

end

require 'rubygems/test_case'

class TestGemResolverIndexSet < Gem::TestCase

def setup

super

assert_equal %w[a-1.a], found.map {|s| s.full_name }

end

end

require 'rubygems/available_set'

class TestGemResolverIndexSpecification < Gem::TestCase

def test_initialize

set = Gem::Resolver::IndexSet.new

source = Gem::Source.new @gem_repo

assert_equal a_2_p.full_name, spec.full_name

end

end

require 'rubygems/test_case'

class TestGemResolverInstalledSpecification < Gem::TestCase

def setup

super

assert b_spec.installable_platform?

end

end

require 'rubygems/test_case'

class TestGemResolverInstallerSet < Gem::TestCase

def test_add_always_install

spec_fetcher do |fetcher|

fetcher.download 'a', 1

refute set.consider_local?

refute set.consider_remote?

end

end

require 'rubygems/available_set'

class TestGemResolverLocalSpecification < Gem::TestCase

def setup

super

assert b_spec.installable_platform?

end

end

require 'rubygems/test_case'

class TestGemResolverLockSet < Gem::TestCase

def setup

super

def test_prefetch

assert_respond_to @set, :prefetch

end

end

require 'rubygems/resolver'

class TestGemResolverLockSpecification < Gem::TestCase

def setup

super

assert_same real_spec, l_spec.spec

end

end

require 'rubygems/test_case'

class TestGemResolverRequirementList < Gem::TestCase

def setup

super

assert_equal [req], @list.each.to_a

end

end

require 'rubygems/test_case'

class TestGemResolverSpecification < Gem::TestCase

class TestSpec < Gem::Resolver::Specification

attr_writer :source

attr_reader :spec

@spec = spec

end

end

def test_install

assert_equal source, a_spec.source

end

end

require 'rubygems/test_case'

class TestGemResolverVendorSet < Gem::TestCase

def setup

super

@set.load_spec 'b', v(1), Gem::Platform::RUBY, nil

end

end

end

require 'rubygems/test_case'

class TestGemResolverVendorSpecification < Gem::TestCase

def setup

super

assert_equal v(1), v_spec.version

end

end

end

class TestGemSecurity < Gem::TestCase

CHILD_KEY = load_key 'child'

ALTERNATE_CERT = load_cert 'child'

assert_equal key.to_pem, key_from_file.to_pem

end

end if defined?(OpenSSL::SSL) && !Gem.java_platform?

end

class TestGemSecurityPolicy < Gem::TestCase

ALTERNATE_KEY = load_key 'alternate'

INVALID_KEY = load_key 'invalid'

CHILD_KEY = load_key 'child'

return digests, signatures

end

end if defined?(OpenSSL::SSL)

end

class TestGemSecuritySigner < Gem::TestCase

ALTERNATE_KEY = load_key 'alternate'

CHILD_KEY = load_key 'child'

GRANDCHILD_KEY = load_key 'grandchild'

signer.sign 'hello'

end

end

end if defined?(OpenSSL::SSL)

end

class TestGemSecurityTrustDir < Gem::TestCase

CHILD_CERT = load_cert 'child'

def setup

assert_equal mask, File.stat(@dest_dir).mode unless win_platform?

end

end if defined?(OpenSSL::SSL)

require 'stringio'

class Gem::Server

attr_reader :server

end

class TestGemServer < Gem::TestCase

def process_based_port

0

end

@server.instance_variable_set :@server, webrick

end

end

require 'timeout'

class TestGemSilentUI < Gem::TestCase

def setup

super

@sui = Gem::SilentUI.new

assert_empty out, 'No output'

assert_empty err, 'No output'

end

end

require 'rubygems/indexer'

class TestGemSource < Gem::TestCase

def tuple(*args)

Gem::NameTuple.new(*args)

end

distance_threshold = 5

assert rubygems_source.typo_squatting?("rubysertgems.org", distance_threshold)

end

end

require 'rubygems/test_case'

class TestGemSourceFetchProblem < Gem::TestCase

def test_exception

source = Gem::Source.new @gem_repo

error = RuntimeError.new 'test'

refute_match sf.wordy, 'secret'

end

end

require 'rubygems/source'

class TestGemSourceGit < Gem::TestCase

def setup

super

assert_equal '291c4caac7feba8bb64c297987028acb3dde6cfe',

source.uri_hash

end

end

require 'rubygems/source'

class TestGemSourceInstalled < Gem::TestCase

def test_spaceship

a1 = quick_gem 'a', '1'

util_build_gem a1

assert_equal(1, vendor.<=>(installed), 'vendor <=> installed')

assert_equal(-1, installed.<=>(vendor), 'installed <=> vendor')

end

end

require 'rubygems/test_case'

class TestGemSourceList < Gem::TestCase

def setup

super

@sl.delete Gem::Source.new(@uri)

assert_equal @sl.sources, []

end

end

require 'fileutils'

class TestGemSourceLocal < Gem::TestCase

def setup

super

assert_equal(-1, specific.<=>(local), 'specific <=> local')

assert_equal(1, local.<=>(specific), 'local <=> specific')

end

end

require 'rubygems/test_case'

class TestGemSourceLock < Gem::TestCase

def test_fetch_spec

spec_fetcher do |fetcher|

fetcher.spec 'a', 1

assert_equal URI(@gem_repo), lock.uri

end

end

require 'rubygems/source'

class TestGemSourceSpecificFile < Gem::TestCase

def setup

super

assert_equal(0, a1_source.<=>(a1_source), 'a1_source <=> a1_source')

assert_equal(1, a2_source.<=>(a1_source), 'a2_source <=> a1_source')

end

end

require 'rubygems/source'

class TestGemSourceVendor < Gem::TestCase

def test_initialize

source = Gem::Source::Vendor.new 'vendor/foo'

assert_equal(1, vendor.<=>(installed), 'vendor <=> installed')

assert_equal(-1, installed.<=>(vendor), 'installed <=> vendor')

end

end

require 'rubygems/spec_fetcher'

class TestGemSpecFetcher < Gem::TestCase

def tuple(*args)

Gem::NameTuple.new(*args)

end

assert_equal({}, specs)

assert_kind_of Gem::SourceFetchProblem, errors.first

end

end

require 'rubygems/platform'

class TestGemSpecification < Gem::TestCase

LEGACY_YAML_SPEC = <<-EOF.freeze

--- !ruby/object:Gem::Specification

rubygems_version: "1.0"

RbConfig::CONFIG['ENABLE_SHARED'], 'no'

class << Gem

alias orig_default_ext_dir_for default_ext_dir_for

remove_method :default_ext_dir_for

def Gem.default_ext_dir_for(base_dir)

'elsewhere'

end

end

ext_spec

RbConfig::CONFIG['ENABLE_SHARED'] = enable_shared

class << Gem

remove_method :default_ext_dir_for

alias default_ext_dir_for orig_default_ext_dir_for

end

end

def test_require_paths_default_ext_dir_for

class << Gem

send :alias_method, :orig_default_ext_dir_for, :default_ext_dir_for

remove_method :default_ext_dir_for

end

def Gem.default_ext_dir_for(base_dir)

end

ensure

class << Gem

send :remove_method, :default_ext_dir_for

send :alias_method, :default_ext_dir_for, :orig_default_ext_dir_for

send :remove_method, :orig_default_ext_dir_for

end

end

ensure

$VERBOSE = old_verbose

end

end

require 'timeout'

class TestGemStreamUI < Gem::TestCase

# increase timeout with MJIT for --jit-wait testing

mjit_enabled = defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled?

SHORT_TIMEOUT = (RUBY_ENGINE == "ruby" && !mjit_enabled) ? 0.1 : 1.0

reporter.fetch 'a.gem', 1024

assert_equal "", @out.string

end

end

require "rubygems/stub_specification"

class TestStubSpecification < Gem::TestCase

FOO = File.join SPECIFICATIONS, "foo-0.0.1-x86-mswin32.gemspec"

BAR = File.join SPECIFICATIONS, "bar-0.0.2.gemspec"

return stub

end

end

end

require "rubygems/text"

class TestGemText < Gem::TestCase

include Gem::Text

def test_format_text

def test_clean_text

assert_equal ".]2;nyan.", clean_text("\e]2;nyan\a")

end

end

require 'rubygems/uninstaller'

class TestGemUninstaller < Gem::InstallerTestCase

def setup

super

@installer = setup_base_installer

refute File.exist?(plugin_path), 'last version uninstalled, but plugin still present'

end

end

require 'rubygems/test_case'

class TestGemUnsatisfiableDependencyError < Gem::TestCase

def setup

super

def test_version

assert_equal @a_dep.requirement, @e.version

end

end

require 'rubygems/uri_formatter'

class TestGemUriFormatter < Gem::TestCase

def test_normalize_uri

assert_equal 'FILE://example/',

Gem::UriFormatter.new('FILE://example/').normalize

def test_unescape

assert_equal 'a@b\c', Gem::UriFormatter.new('a%40b%5Cc').unescape

end

end

require 'rubygems/util'

class TestGemUtil < Gem::TestCase

def test_class_popen

skip "popen with a block does not behave well on jruby" if Gem.java_platform?

assert_equal "0\n", Gem::Util.popen(*ruby_with_rubygems_in_load_path, '-e', 'p 0')

path = "/home/skillet"

assert_equal "/home/skillet", Gem::Util.correct_for_windows_path(path)

end

end

require "rubygems/validator"

class TestGemValidator < Gem::TestCase

def setup

super

assert_empty alien

end

end

require "minitest/benchmark"

class TestGemVersion < Gem::TestCase

class V < ::Gem::Version

end

def refute_version_equal(unexpected, actual)

refute_equal v(unexpected), v(actual)

end

end

require 'rubygems/version_option'

class TestGemVersionOption < Gem::TestCase

def setup

super

assert_equal expected, @cmd.options

end

end

require 'rubygems/test_case'

class TestKernel < Gem::TestCase

def setup

super

assert $:.any? {|p| %r{bundler-1/lib} =~ p }