specs = dep.matching_specs(true)

spec.executables.include? exec_name

unless spec = specs.first

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

def self.find_files_from_load_path(glob) # :nodoc:

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

Gem::Util.glob_files_in_dir(glob_with_suffixes, load_path)

end

##

end

class << self

extend Gem::Deprecate

deprecate :gunzip, "Gem::Util.gunzip", 2018, 12

end

##

end

class << self

extend Gem::Deprecate

deprecate :gzip, "Gem::Util.gzip", 2018, 12

end

##

end

class << self

extend Gem::Deprecate

deprecate :inflate, "Gem::Util.inflate", 2018, 12

end

##

def self.suffixes

@suffixes ||= ['',

'.rb',

val = RbConfig::CONFIG[key]

next unless val and not val.empty?

".#{val}"

].compact.uniq

end

end

class << self

##

# TODO remove with RubyGems 4.0

extend Gem::Deprecate

deprecate :detect_gemdeps, "Gem.use_gemdeps", 2018, 12

end

# FIX: Almost everywhere else we use the `def self.` way of defining class

# work

attr_reader :pre_uninstall_hooks

end

##

def inject_into_list(dep_list)

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

end

end

false

end

end

end

@defaults = defaults

@options = defaults.dup

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

@parser = nil

@when_invoked = nil

end

end

end

##

# Merge a set of command options with the set of default options (without

# modifying the default option hash).

def merge_options(new_options)

@options = @defaults.clone

end

##

def handle_options(args)

args = add_extra_args(args)

@options = Marshal.load Marshal.dump @defaults # deep copy

parser.parse!(args)

@options[:args] = args

private

def add_parser_description # :nodoc:

return unless description

terminate_interaction 1

end

end

end

@full = Gem::DependencyList.from_specs

deplist = Gem::DependencyList.new

deps = deplist.strongly_connected_components.flatten

end

def get_gems_to_cleanup

@primary_gems[spec.name].version != spec.version

spec.default_gem?

uninstall_from = options[:user_install] ? Gem.user_dir : @original_home

spec.base_dir == uninstall_from

@default_gems += default_gems

@default_gems.uniq!

add_version_option

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

options[:all] = all

end

options[:lib_only] = lib_only

end

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

options[:prefix] = prefix

end

'Show only the gem install dir') do |show, options|

options[:show_install_dir] = show

end

end

def gem_dependency(pattern, version, prerelease) # :nodoc:

Gem::Dependency.new pattern, version

dependency.prerelease = prerelease

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

end

end

end

require 'rubygems/commands/query_command'

class Gem::Commands::InfoCommand < Gem::Commands::QueryCommand

def initialize

super "info", "Show information for the given gem"

def defaults_str

"--local"

end

end

request_set = inst.resolve_dependencies name, req

if options[:explain]

request_set.sorted_requests.each do |s|

end

return

end

def spec_path(gem_full_name)

File.join path, "specifications", "#{gem_full_name}.gemspec"

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

end

unless defined? Gem::Commands::MirrorCommand

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

def initialize

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

begin

end

add_option('-v', '--version VERSION', String,

"Opens specific gem version") do |version|

end

end

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

end

end

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

end

end

end

require 'rubygems/gemcutter_utilities'

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

include Gem::LocalRemoteOptions

include Gem::GemcutterUtilities

end

def show_owners(name)

response = rubygems_api_request :get, "api/v1/gems/#{name}/owners.yaml" do |request|

request.add_field "Authorization", api_key

end

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

options[:details] = value

end

'Display only gem names') do |value, options|

options[:versions] = value

options[:details] = false unless value

options[:exact] = value

end

'Display prerelease versions') do |value, options|

options[:prerelease] = value

end

display_header 'LOCAL'

s.name =~ name and req =~ s.version

spec_tuples = specs.map do |spec|

[spec.name_tuple, spec]

require 'fileutils'

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

include Gem::VersionOption

def initialize

# 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

require 'rubygems/gemcutter_utilities'

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

include Gem::GemcutterUtilities

def initialize

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

def uninstall(gem_name)

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

end

end

}

gems_to_update = which_to_update hig, options[:args], :system

target = if update_latest

up_ver

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

require 'rubygems/gemcutter_utilities'

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

include Gem::LocalRemoteOptions

include Gem::VersionOption

include Gem::GemcutterUtilities

attr_reader :hash

protected :hash

end

spec = dep.to_spec

spec.activate

end

private :gem

module Gem

DEFAULT_HOST = "https://rubygems.org".freeze

@post_uninstall_hooks ||= []

@pre_uninstall_hooks ||= []

@pre_install_hooks ||= []

def matching_specs(platform_only = false)

env_req = Gem.env_requirement(name)

requirement.satisfied_by?(spec.version) && env_req.satisfied_by?(spec.version)

Gem::BundlerVersionFinder.filter!(matches) if name == "bundler".freeze

if platform_only

spec.nil? || !Gem::Platform.match(spec.platform)

end

matches

matches.first

end

end

:wrappers => true,

:build_args => nil,

:build_docs_in_background => false,

}.freeze

##

# REFACTOR maybe abstract away using Gem::Specification.include? so

# that this isn't dependent only on the currently installed gems

not keep_names.include?(spec.full_name) and

Gem::Specification.include?(spec)

unless dependency_list.ok? or @ignore_dependencies or @force

"#{k} requires #{v.join(", ")}"

raise Gem::DependencyError, "Unable to resolve dependencies: #{reason}"

end

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

class Gem::DependencyList

attr_reader :specs

include Enumerable

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

each do |spec|

spec.runtime_dependencies.each do |dep|

dep.name == installed_spec.name and

dep.requirement.satisfied_by? installed_spec.version

unless inst or @specs.find { |s| s.satisfies_requirement? dep }

unsatisfied[spec.name] << dep

# If the state is inconsistent, at least don't crash

return true unless gem_to_remove

s.name == gem_to_remove.name &&

s.full_name != gem_to_remove.full_name

deps = []

end

end

s.satisfies_requirement? dep

end

##

# dependencies).

def remove_specs_unsatisfied_by(dependencies)

dep = dependencies[spec.name]

dep and not dep.requirement.satisfied_by? spec.version

end

##

# year/month that it is planned to go away.

def deprecate(name, repl, year, month)

old = "_deprecated_#{name}"

alias_method old, name

define_method name do |*args, &block|

warn "#{msg.join}." unless Gem::Deprecate.skip

send old, *args, &block

end

end

module_function :deprecate, :skip_during

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

@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

@conflicts = conflicts

@name = target.name

"#{act.full_name} conflicts with #{dependencies.join(", ")}"

# TODO: improve message by saying who activated `con`

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

end

end

class ErrorReason; end

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

@platforms.join(' ,')]

end

end

##

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

alias exception error

end

end

extend Gem::Deprecate

deprecate :source_exception, :none, 2018, 12

end

class Gem::CommandLineError < Gem::Exception; 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

##

# Used to raise parsing and loading errors

class Gem::FormatException < Gem::Exception

attr_accessor :file_path

end

class Gem::GemNotFoundException < Gem::Exception; 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

##

FileUtils.mkdir_p @spec.extension_dir

destination

end

require 'rubygems/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

require 'shellwords'

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

FileEntry = FileUtils::Entry_ # :nodoc:

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

private

def self.get_relative_path(path)

path

end

env_rubygems_host = nil if

env_rubygems_host and env_rubygems_host.empty?

end

end

say "Don't have an account yet? " +

"Create one at #{sign_in_host}/sign_up"

password = ask_for_password "Password: "

say "\n"

marshal_name = File.join @quick_marshal_dir, spec_file_name

marshal_zipped = Gem.deflate Marshal.dump(spec)

files << marshal_name

# Builds indices for RubyGems 1.2 and newer. Handles full, latest, prerelease

def build_modern_indices(specs)

s.version.prerelease?

latest_specs =

Gem::Specification._latest_specs specs

end

def map_gems_to_specs(gems)

if File.size(gemfile) == 0

alert_warning "Skipping zero-length gem: #{gemfile}"

next

"\t#{e.backtrace.join "\n\t"}"].join("\n")

alert_error msg

end

end

##

Marshal.dump specs_index, io

end

end

end

end

class FakePackage

attr_accessor :spec

attr_accessor :dir_mode

file = File.join destination_dir, file

next if File.exist? file

FileUtils.mkdir_p File.dirname(file)

end

end

def copy_to(path)

end

end

##

def generate_windows_script(filename, bindir)

if Gem.win_platform?

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

File.open script_path, 'w' do |file|

file.puts windows_stub_script(bindir, filename)

# Available through requiring rubygems/installer_test_case

attr_writer :wrappers

end

##

FileUtils.mkdir_p 'bin'

FileUtils.mkdir_p 'lib'

FileUtils.mkdir_p File.join('ext', 'a')

File.open File.join('bin', 'executable'), 'w' do |f|

f.puts "raise 'ran executable'"

end

File.open File.join('ext', 'a', 'mkrf_conf.rb'), 'w' do |f|

f << <<-EOF

File.open 'Rakefile', 'w' do |rf| rf.puts "task :default" end

valid_uri_schemes = ["http", "https", "file", "s3"]

unless valid_uri_schemes.include?(uri.scheme)

raise ArgumentError, msg

end

# retrieval during tests.

class Gem::MockGemUi < Gem::StreamUI

##

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

end

class TermError < RuntimeError

attr_reader :exit_code

def initialize(exit_code)

super

@exit_code = exit_code

end

end

class SystemExitException < RuntimeError; end

require 'rubygems/platform'

class Gem::NameTuple

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

@name = name

@version = version

class Error < Gem::Exception; end

class FormatError < Error

attr_reader :path

def initialize(message, source = nil)

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

# to the rest of RubyGems.

#

class Gem::PathSupport

##

# The default system path for managing Gems.

attr_reader :home

path

end

end

end

# 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

[id, secret]

end

end

def self.create_with_proxy(uri, request_class, last_modified, proxy) # :nodoc:

cert_files = get_cert_files

proxy ||= get_proxy_from_env(uri.scheme)

new(uri, request_class, last_modified, pool.pool_for(uri))

end

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

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

@client = Net::HTTP

class << self

attr_accessor :client

end

def initialize(proxy_uri, cert_files)

def get_no_proxy_from_env

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

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

end

# use it.

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

attr_reader :cert_files, :proxy_uri

def initialize(http_args, cert_files, proxy_uri)

# 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

node.spec.dependencies.each do |dep|

next if dep.type == :development and not @development

dep.match? r.spec.name, r.spec.version, @prerelease

unless match

next if dep.type == :development and @development_shallow

:mri_20 => %w[ruby],

:mri_21 => %w[ruby],

:rbx => %w[rbx],

}.freeze

mswin = Gem::Platform.new 'x86-mswin32'

:ruby_19 => Gem::Platform::RUBY,

:ruby_20 => Gem::Platform::RUBY,

:ruby_21 => Gem::Platform::RUBY,

:x64_mingw => x64_mingw,

:x64_mingw_20 => x64_mingw,

:x64_mingw_21 => x64_mingw

:ruby_19 => tilde_gt_1_9_0,

:ruby_20 => tilde_gt_2_0_0,

:ruby_21 => tilde_gt_2_1_0,

:x64_mingw => gt_eq_0,

:x64_mingw_20 => tilde_gt_2_0_0,

:x64_mingw_21 => tilde_gt_2_1_0,

Gem dependencies file #{@path} includes git reference for both ref and branch but only ref is used.

WARNING

end

warn <<-WARNING

Gem dependencies file #{@path} includes git reference for both ref/branch and tag but only ref/branch is used.

WARNING

def gem_group(name, options) # :nodoc:

g = options.delete :group

groups = options.delete :groups

all_groups |= groups if groups

# constructed.

class Gem::RequestSet::Lockfile

##

# Raised when a lockfile cannot be parsed

@path = path

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

end

end

##

@gem_deps_file.untaint unless gem_deps_file.tainted?

end

def add_DEPENDENCIES(out) # :nodoc:

base = File.expand_path(base)

if dest.index(base) == 0

return '.' unless offset

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 pinned_requirement(name) # :nodoc:

requirement = Gem::Dependency.new name

set.find_all(requirement)

specification && specification.version

end

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

require "rubygems/version"

require "rubygems/deprecate"

##

# A Requirement is a set of one or more version restrictions. It supports a

# few (<tt>=, !=, >, <, >=, <=, ~></tt>) different restriction operators.

# together in RubyGems.

class Gem::Requirement

OPS = { #:nodoc:

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

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

SOURCE_SET_REQUIREMENT = Struct.new(:for_lockfile).new "!" # :nodoc:

PATTERN_RAW = "\\s*(#{quoted})?\\s*(#{Gem::Version::VERSION_PATTERN})\\s*".freeze # :nodoc:

##

def for_lockfile # :nodoc:

return if [DefaultRequirement] == @requirements

version

"#{op} #{version}"

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

end

l.first <=> r.first # then, sort by the operator (for stability)

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'

##

groups = Hash.new { |hash, key| hash[key] = [] }

# create groups & sources in the same loop

source = spec.source

groups[source] << spec

source

activation_requests = []

if @spec.respond_to? :sources

exception = nil

begin

source.download full_spec, path

rescue exception

end

return path if path

raise exception if exception

uri = URI uri unless URI === uri

uri.query = nil

Gem::Resolver::APISet === set and set.dep_uri == uri

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

found = find_all request

s.version.prerelease? and not s.local?

found = found.select do |s|

Gem::Source::SpecificFile === s.source or

def find_all(req)

res = []

return res if @ignore_dependencies and

@always_install.none? { |spec| dep.match? spec }

Gem::Source::Lock.new source

end

end

##

# A specification constructed from the lockfile is returned

def spec

spec.name == @name and spec.version == @version

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

s.name = @name

x = @exact[0,5]

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

end

end

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

@options = DEFAULT_OPTIONS.merge(options)

unless @key

@key = default_key if File.exist? default_key

end

Gem::Specification.each do |spec|

total_file_count += spec.files.size

{

"name" => dep.name,

"type" => dep.type,

"version" => dep.requirement.to_s,

}

deps = deps.sort_by { |dep| [dep["name"].downcase, dep["version"]] }

deps.last["is_last"] = true unless deps.empty?

# documentation - just put it underneath the main doc folder.

def show_rdoc_for_pattern(pattern, res)

File.exist? File.join(path, 'rdoc/index.html')

case found_gems.length

when 0

return false

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

end

end

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

end

end

end

max = gem_name.size / 2

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

next unless n.match_platform?

distance = levenshtein_distance gem_name, n.name.downcase.tr('_-', '')

return [n.name] if distance == 0

[n.name, distance]

matches = if matches.empty? && type != :prerelease

suggest_gems_from_name gem_name, :prerelease

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

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

],

'Added "required_rubygems_version"',

'Now forward-compatible with future versions',

],

'Added Fixnum validation to the specification_version'

],

'Added sandboxed freeform metadata to the specification version.'

]

}.freeze

@@attributes = @@default_value.keys.sort_by { |s| s.to_s }

@@array_attributes = @@default_value.reject { |k,v| v != [] }.keys

@@default_value[k].nil?

@@stubs_by_name = {}

private_class_method :installed_stubs

def self.map_stubs(dirs, pattern) # :nodoc:

base_dir = File.dirname dir

gems_dir = File.join base_dir, "gems"

gemspec_stubs_in(dir, pattern) { |path| yield path, base_dir, gems_dir }

end

private_class_method :map_stubs

end

def self._resort!(specs) # :nodoc:

names = a.name <=> b.name

next names if names.nonzero?

b.version <=> a.version

end

##

# Return the directories that Specification uses to find specs.

def self.dirs

File.join dir.dup.untaint, "specifications"

end

##

def self.find_by_path(path)

path = path.dup.freeze

next unless Gem::BundlerVersionFinder.compatible?(s)

s.contains_requirable_file? path

spec.to_spec

end

# amongst the specs that are not activated.

def self.find_inactive_by_path(path)

next if s.activated?

next unless Gem::BundlerVersionFinder.compatible?(s)

s.contains_requirable_file? path

stub && stub.to_spec

end

def self.find_active_stub_by_path(path)

s.activated? and s.contains_requirable_file? path

stub.this

end

result[spec.name][spec.platform] = spec

end

minimum = native[spec.name]

minimum && spec.version < minimum

end

##

# Load custom marshal format, re-initializing defaults as needed

def self._load(str)

array = Marshal.load str

spec = Gem::Specification.new

def conflicts

conflicts = {}

spec = Gem.loaded_specs[dep.name]

if spec and not spec.satisfies_requirement? dep

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

end

env_req = Gem.env_requirement(name)

(conflicts[self] ||= []) << env_req unless env_req.satisfied_by? version

conflicts

# return true if there will be conflict when spec if loaded together with the list of specs.

def conficts_when_loaded_with?(list_of_specs) # :nodoc:

spec.dependencies.any? { |dep| dep.runtime? && (dep.name == name) && !satisfies_requirement?(dep) }

result

end

def has_conflicts?

return true unless Gem.env_requirement(name).satisfied_by?(version)

if dep.runtime?

spec = Gem.loaded_specs[dep.name]

spec and not spec.satisfies_requirement? dep

else

false

end

end

# The date this gem was created.

end

def to_yaml(opts = {}) # :nodoc:

# Because the user can switch the YAML engine behind our

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

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

require 'uri'

class Gem::SpecificationPolicy < SimpleDelegator

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

SPECIAL_CHARACTERS = /\A[#{Regexp.escape('.-_')}]+/.freeze # :nodoc:

end

def validate_licenses

if license.length > 64

error "each license must be 64 characters or less"

end

message += "Did you mean #{suggestions.map { |s| "'#{s}'"}.join(', ')}?\n" unless suggestions.nil?

warning(message)

end

warning <<-warning if licenses.empty?

licenses is empty, but is recommended. Use a license identifier from

def help_text # :nodoc:

"See http://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

end

path_list = parts.last

REQUIRE_PATHS[x] || x

end

end

def self.default_gemspec_stub(filename, base_dir, gems_dir)

# should.

module Syck

class DefaultKey

remove_method :to_s rescue nil

def to_s

'='

end

end

end

# frozen_string_literal: true

# TODO: $SAFE = 1

if defined? Gem::QuickLoader

Gem::QuickLoader.load_full_rubygems_library

else

end

begin

rescue Gem::LoadError

end

attr_accessor :uri # :nodoc:

def assert_activate(expected, *specs)

specs.each do |spec|

case spec

def assert_contains_make_command(target, output, msg = nil)

if output.match(/\n/)

'Expected output containing make command "%s": %s' % [

('%s %s' % [make_command, target]).rstrip,

output.inspect

]

else

'Expected make command "%s": %s' % [

('%s %s' % [make_command, target]).rstrip,

output.inspect

]

end

assert scan_make_command_lines(output).any? { |line|

@fetcher = nil

if Gem::USE_BUNDLER_FOR_GEMDEPS

end

@back_ui = Gem::DefaultUserInteraction.ui

@ui = Gem::MockGemUi.new

Gem.ensure_gem_subdirectories @gemhome

@orig_LOAD_PATH = $LOAD_PATH.dup

expand_path = File.expand_path(s)

if expand_path != s

expand_path.untaint

s = expand_path

end

s

Dir.chdir @tempdir

def uninstall_gem(spec)

require 'rubygems/uninstaller'

def ask_if_ok(spec)

true

end

end

##

def create_tmpdir

tmpdir = nil

tmpdir = File.join tmpdir, "test_rubygems_#{$$}"

FileUtils.mkdir_p tmpdir

return tmpdir

spec.files.each do |file|

next if File.exist? file

FileUtils.mkdir_p File.dirname(file)

end

use_ui Gem::MockGemUi.new do

Gem::Specification.reset

end

##

# Install the provided specs

s.add_dependency 'x', '>= 1'

end

s.files = %w[lib/code.rb]

s.require_paths = %w[lib]

s.platform = Gem::Platform.new 'i386-linux'

end

class << self

# :nodoc:

##

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

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

end

end

end

@@ruby = rubybin

##

# Construct a new Gem::Dependency.

def prefetch(reqs) # :nodoc:

end

end

##

def self.cert_path(cert_name)

if 32 == (Time.at(2**32) rescue 32)

return cert_file if File.exist? cert_file

end

end

##

# Returns the path to the key named +key_name+ from <tt>test/rubygems</tt>

def self.key_path(key_name)

end

# :stopdoc:

# only available in RubyGems tests

begin

PRIVATE_KEY = load_key 'private'

flush

Gem.read_binary path

end

end

x = nil

str1.each_char.each_with_index do |char1,i|

str2.each_char.each_with_index do |char2,j|

cost = (char1 == char2) ? 0 : 1

x = min3(

e + 1, # deletion

d[j] + cost # substitution

)

# Indicate if development dependencies should be checked when

# uninstalling. (default: false)

#

if options[:force]

@force_all = true

elsif index >= 0 && index < list.size

uninstall_gem list[index]

else

end

else

uninstall_gem list.first

# Leave any executables created by other installed versions

# of this gem installed.

s.name == spec.name && s.version != spec.version

list.each do |s|

s.executables.each do |exe_name|

raise e

end

end

@outs.puts question

list.each_with_index do |item, index|

end

@outs.print "> "

def done

end

end

##

def done

@out.puts @terminal_message

end

end

##

def done

end

end

##

@out.puts message

end

end

end

end

##

def initialize

super STDIN, STDOUT, STDERR, true

end

end

##

def progress_reporter(*args) # :nodoc:

SilentProgressReporter.new(@outs, *args)

end

end

zipped = StringIO.new(String.new, 'w')

zipped.set_encoding Encoding::BINARY

zipped.string

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

installed_files = []

Find.find gem_directory do |file_name|

installed_files << fn unless

fn =~ /CVS/ || fn.empty? || File.directory?(file_name)

end

File.open gem_path, Gem.binary_mode do |file|

package = Gem::Package.new gem_path

File.exist? File.join(gem_directory, file_name)

gone.sort.each do |path|

errors[gem_name][path] = "Missing file"

end

File.readable? File.join(gem_directory, file_name)

unreadable.sort.each do |path|

errors[gem_name][path] = "Unreadable file"

errors

end

end

# a zero to give a sensible result.

class Gem::Version

autoload :Requirement, 'rubygems/requirement'

include Comparable

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

return numeric_segments, string_segments

end

end