end

def all_specs

end

def match_platform!

@sorted = nil

self

end

end

def source_for(spec)

f.source

end

end

def inject_into_list(dep_list)

end

end

def matches_for_glob(glob) # TODO: rename?

glob = File.join(self.lib_dirs_glob, glob)

end

##

def have_file?(file, suffixes)

return true if raw_require_paths.any? do |path|

base = File.join(gems_dir, full_name, path.tap(&Gem::UNTAINT), file).tap(&Gem::UNTAINT)

end

if have_extensions?

base = File.join extension_dir, file

else

false

end

def self.filter!(specs)

return unless bundler_version = self.bundler_version

return unless exact_match_index

specs.unshift(specs.delete_at(exact_match_index))

unless gemfile

begin

Gem::Util.traverse_parents(Dir.pwd) do |directory|

gemfile = File.join directory, gemfile

break

@program_name = "gem #{command}"

@defaults = defaults

@options = defaults.dup

@deprecated_options = { command => {} }

@parser = nil

@when_invoked = nil

if errors and !errors.empty?

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

else

if required_by and gem != required_by

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

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

end

end

##

def remove_option(name)

@option_groups.each do |_, option_list|

end

end

def merge_options(new_options)

@options = @defaults.clone

end

##

configure_options "", regular_options

@parser.separator nil

configure_options group_name, option_list

end

# Return a sorted list of all command names as strings.

def command_names

end

##

def find_command_possibilities(cmd_name)

len = cmd_name.length

exact ? [exact] : found

end

subject = certificate.subject.to_s

subject.downcase.index filter

end.sort_by do |certificate, _|

end.each do |certificate, path|

yield certificate, path

end

until done do

clean_gems

done = this_set.empty? || last_set == this_set

say "Clean up complete"

verbose do

"Skipped default gems: #{skipped.join ', '}"

end

@full = Gem::DependencyList.from_specs

deplist = Gem::DependencyList.new

deps = deplist.strongly_connected_components.flatten

if Gem.configuration.verbose

say "\nDirectories searched:"

end

return nil

ss, = fetcher.spec_for_dependency dependency

end

def fetch_specs(name_pattern, dependency) # :nodoc:

specs = []

if local?

name_pattern =~ spec.name and

dependency.requirement.satisfied_by? spec.version

}.map(&:to_spec)

def display_pipe(specs) # :nodoc:

specs.each do |spec|

unless spec.dependencies.empty?

say "#{dep.name} --version '#{dep.requirement}'"

end

end

response = String.new

response << ' ' * level + "Gem #{spec.full_name}\n"

unless spec.dependencies.empty?

response << ' ' * level + " #{dep}\n"

end

end

ss, _ = fetcher.spec_for_dependency dependency

end

def reverse_dependencies(specs) # :nodoc:

return reverse unless options[:reverse_dependencies]

Gem::SpecFetcher.fetcher.spec_for_dependency dep

if platform

specs_and_sources = filtered unless filtered.empty?

end

if spec.nil?

show_lookup_failure gem_name, version, errors, options[:domain]

margin_width = 4

summary_width = 80 - margin_width - desc_width

wrap_indent = ' ' * (margin_width + desc_width)

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

end

end

end

say

say "RubyGems installed the following executables:"

say

unless bin_file_names.grep(/#{File::SEPARATOR}gem$/)

def bundler_template_files

Dir.chdir "bundler/lib" do

Dir.glob(File.join('bundler', 'templates', '**', '*'), File::FNM_DOTMATCH).

end

end

def template_files_in(dir)

Dir.chdir dir do

Dir.glob(File.join('templates', '**', '*'), File::FNM_DOTMATCH).

end

end

dep.prerelease = options[:prerelease]

found, _ = Gem::SpecFetcher.fetcher.spec_for_dependency dep

end

if specs.empty?

end

unless options[:all]

end

specs.each do |s|

end

end

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

end

end

end

def uninstall_all

specs.each do |spec|

options[:version] = spec.version

specs = dependency.matching_specs

return Gem::RemoteFetcher.fetcher.download_to_cache(dependency) unless

selected

updated = update_gems gems_to_update

not_updated_names = options[:args].uniq - updated_names

if updated.empty?

spec_tuples, errors = fetcher.search_for_dependency dependency

raise error if error

end

def update_gem(name, version = Gem::Requirement.default)

update_options = options.dup

update_options[:prerelease] = version.prerelease?

highest_installed_gems.each do |l_name, l_spec|

next if not gem_names.empty? and

highest_remote_tup = highest_remote_name_tuple l_spec

highest_remote_ver = highest_remote_tup.version

yaml_hash[:ssl_client_cert] =

@hash[:ssl_client_cert] if @hash.key? :ssl_client_cert

keys << 'debug'

re = Regexp.union(*keys)

# Ok, now find a gem that has no conflicts, starting

# at the highest version.

unless valid

le = Gem::LoadError.new "unable to find a version of '#{names.first}' to activate"

def to_spec

matches = self.to_specs.compact

return active if active

return matches.first if prerelease?

# Move prereleases to the end of the list for >= 0 requirements

matches += pre if requirement == Gem::Requirement.default

matches.first

end

def find_name(full_name)

end

def inspect # :nodoc:

end

##

end

def why_not_ok?(quick = false)

each do |spec|

spec.runtime_dependencies.each do |dep|

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

dep.requirement.satisfied_by? installed_spec.version

end

unsatisfied[spec.name] << dep

return unsatisfied if quick

end

# Removes the gemspec matching +full_name+ from the dependency list

def remove_by_name(full_name)

end

##

# gemspecs that have a dependency satisfied by the named gemspec.

def spec_predecessors

specs = @specs.sort.reverse

# +ignored+.

def active_count(specs, ignored)

end

end

missing =

Gem::REPOSITORY_SUBDIRECTORIES.sort -

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

missing.empty?

# Specs installed in this gem repository

def installed_specs # :nodoc:

end

##

def initialize(dep, platform_mismatch=nil)

if platform_mismatch and !platform_mismatch.empty?

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

else

if dep.explicit?

if Gem.install_extension_in_lib and lib_dir

FileUtils.mkdir_p lib_dir

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

FileUtils.cp_r entries, lib_dir, :remove_destination => true

end

end

specs = map_gems_to_specs updated_gems

files = build_marshal_gemspecs specs

'Omit the named groups (comma separated)',

'when installing from a gem dependencies',

'file') do |v,o|

end

add_option(:"Install/Update", '--default',

def installation_satisfies_dependency?(dependency)

return true if @options[:development] and dependency.type == :development

return false if @only_install_dir

not dependency.matching_specs.empty?

end

def shebang(bin_file_name)

ruby_name = RbConfig::CONFIG['ruby_install_name'] if @env_shebang

path = File.join gem_dir, spec.bindir, bin_file_name

if first_line.start_with?("#!")

# Preserve extra words on shebang line, like "-w". Thanks RPA.

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

unless valid_uri_schemes.include?(uri.scheme)

raise ArgumentError, msg

end

# NameTuple objects.

def self.from_list(list)

end

##

# [name, version, platform] tuples.

def self.to_basic(list)

end

##

@build_time = Gem.source_date_epoch

@checksums = {}

@contents = nil

@files = nil

@security_policy = security_policy

@signatures = {}

def add_checksums(tar)

Gem.load_yaml

@checksums.each do |name, digests|

digests.each do |algorithm, digest|

)

@spec.signing_key = nil

else

@signer = Gem::Security::Signer.new nil, nil, passphrase

@signer.cert_chain

end

end

read_until_dashes io # spec

header = file_list io

end

end

private

def calculate_checksum(header)

end

def header(checksum = @checksum)

end

def calc_checksum(header)

SP(Z(to_oct(sum, 6)))

end

gem_path = default_path

end

end

# Return the default Gem path

terminate_interaction(check_installed_gems(gem_names)) if check_installed_gems?

end

private

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

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

end

def output_query_results(spec_tuples)

output = []

spec_tuples.each do |spec_tuple, source|

versions[spec_tuple.name] << [spec_tuple, source]

def output_versions(output, versions)

versions.each do |gem_name, matching_tuples|

matching_tuples.each do |n, _|

platforms[n.version] << n.platform if n.platform

list =

if platforms.empty? or options[:details]

else

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

out = version.to_s

def spec_platforms(entry, platforms)

non_ruby = platforms.any? do |_, pls|

end

return unless non_ruby

else

entry << " Platforms:\n"

sorted_platforms.each do |version, pls|

label = " #{version}: "

return if found.empty?

download spec, source.uri

end

def fetch_http(uri, last_modified = nil, head = false, depth = 0)

fetch_type = head ? Net::HTTP::Head : Net::HTTP::Get

response = request uri, fetch_type, last_modified do |req|

end

case response

end

def close_all

end

private

end

def close_all

end

private

if req.installed?

req.spec.spec.build_extensions

yield req, nil if block_given?

next

end

gem_home, ENV['GEM_HOME'] = ENV['GEM_HOME'], dir

existing = force ? [] : specs_in(dir)

dir = File.expand_path dir

sorted_requests.each do |request|

spec = request.spec

yield request, nil if block_given?

next

end

q.text 'sets:'

q.breakable

end

end

end

def specs

end

def specs_in(dir)

@git_set = @set.git_set

@git_sources = {}

@installing = false

@vendor_set = @set.vendor_set

@source_set = @set.source_set

@gem_sources = {}

def add_DEPENDENCIES(out) # :nodoc:

out << "DEPENDENCIES"

" #{name}#{requirement.for_lockfile}"

}

request.spec.source.uri

end

out << "GEM"

out << " remote: #{group}"

out << " specs:"

next if request.spec.name == 'bundler'

platform = "-#{request.spec.platform}" unless

Gem::Platform::RUBY == request.spec.platform

out << " revision: #{revision}"

out << " specs:"

out << " #{request.name} (#{request.version})"

dependencies.each do |dep|

out << " #{dep.name}#{dep.requirement.for_lockfile}"

end

def add_PLATFORMS(out) # :nodoc:

out << "PLATFORMS"

platforms.each do |platform|

out << " #{platform}"

end

def spec_groups

end

##

end

def to_a

end

def skip(type)

class Gem::Requirement

OPS = { #:nodoc:

}.freeze

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

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

##

if requirements.empty?

@requirements = [DefaultRequirement]

else

end

end

new = new.flatten

new.compact!

new.uniq!

@requirements.concat new

end

end

def as_list # :nodoc:

end

def hash # :nodoc:

# are prereleases

def prerelease?

end

def pretty_print(q) # :nodoc:

raise ArgumentError, "Need a Gem::Version: #{version.inspect}" unless

Gem::Version === version

# #28965: syck has a bug with unquoted '=' YAML.loading as YAML::DefaultKey

end

alias :=== :satisfied_by?

protected

def _tilde_requirements

end

private

def explain(stage, *data) # :nodoc:

return unless DEBUG_RESOLVER

$stderr.printf "%10s %s\n", stage.to_s.upcase, d

end

def resolve

locking_dg = Molinillo::DependencyGraph.new

rescue Molinillo::VersionConflict => e

conflict = e.conflicts.values.first

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

if (skip_dep_gems = skip_gems[dependency.name]) && !skip_dep_gems.empty?

matching = all.select do |api_spec|

end

all = matching unless matching.empty?

raise exc

end

# create groups & sources in the same loop

sources = possibles.map do |spec|

sources.each do |source|

groups[source].

end

activation_requests

@dep_uri = dep_uri

@uri = dep_uri + '../..'

@source = Gem::Source.new @uri

@to_fetch = []

def prefetch(reqs)

return unless @remote

needed = names - @data.keys - @to_fetch

@to_fetch += needed

def remote=(remote)

super

end

def errors

end

##

# Prefetches +reqs+ in all sets.

def prefetch(reqs)

end

end

activated = @activated.spec.full_name

dependency = @failed_dep.dependency

requirement = dependency.requirement

unless alternates.empty?

matching = <<-MATCHING.chomp

Gem::SpecFetcher.fetcher

end

list, errors = @f.available_specs :complete

dep = req.dependency

return res if @ignore_dependencies and

name = dep.name

dep.matching_specs.each do |gemspec|

res << Gem::Resolver::InstalledSpecification.new(self, gemspec)

end unless @ignore_installed

end

def inspect # :nodoc:

'#<%s domain: %s specs: %p always install: %p>' % [

self.class, @domain, @specs.keys, always_install,

q.text 'specs:'

q.breakable

end

end

dcs = dcs.split '.'

OpenSSL::X509::Name.parse name

end

# this value is preferred, otherwise the subject is used.

def extract_name(cert) # :nodoc:

if subject_alt_name

/\Aemail:/ =~ subject_alt_name.value # rubocop:disable Performance/StartWith

logger = WEBrick::Log.new nil, WEBrick::BasicLog::FATAL

@server = WEBrick::HTTPServer.new :DoNotListen => true, :Logger => logger

reset_gems

def uri_encode(str)

str.gsub(URI::UNSAFE) do |match|

end

end

}

end

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

# executables

executables = nil if executables.empty?

executables.last["is_last"] = true if executables

"version" => Gem::VERSION,

}

specs.last["is_last"] = true

# tag all specs with first_name_entry

listeners = @server.listeners.map{|l| l.addr[2] }

# TODO: 0.0.0.0 == any, not localhost.

say "Launching browser to http://#{host}:#{@port}"

when :latest

tup = pkg.spec.name_tuple

if !cur

names << tup

elsif cur.version < tup.version

end

end

end

def fetch_spec(name) # :nodoc:

# Yields each source URI in the list.

def each

end

##

# Returns an Array of source URI Strings.

def to_a

end

alias_method :to_ary, :to_a

if other.kind_of? Gem::Source

@sources.include? other

else

end

end

if source.kind_of? Gem::Source

@sources.delete source

else

end

end

list.each do |source, specs|

if dependency.name.is_a?(String) && specs.respond_to?(:bsearch)

specs = specs[start_index ... end_index] if start_index && end_index

end

end

end

return [tuples, errors]

end

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

suggest_gems_from_name gem_name, :prerelease

else

end

end

##

def tuples_for(source, type, gracefully_ignore=false) # :nodoc:

@caches[type][source.uri] ||=

rescue Gem::RemoteFetcher::FetchError

raise unless gracefully_ignore

[]

end

end

@@nil_attributes, @@non_nil_attributes = @@default_value.keys.partition do |k|

@@default_value[k].nil?

end

# After a reset, make sure already loaded specs

# are still marked as activated.

specs = {}

end

@@all

end

end

def self.gemspec_stubs_in(dir, pattern)

end

private_class_method :gemspec_stubs_in

dirs.flat_map do |dir|

base_dir = File.dirname dir

gems_dir = File.join base_dir, "gems"

end

end

private_class_method :map_stubs

@@stubs ||= begin

pattern = "*.gemspec"

stubs = installed_stubs(dirs, pattern) + default_stubs(pattern)

_resort!(stubs)

stubs

end

end

@@stubs_by_name[name]

else

pattern = "#{name}-*.gemspec"

@@stubs_by_name.merge! stubs

@@stubs_by_name[name] ||= EMPTY

def self.dirs=(dirs)

self.reset

end

extend Enumerable

def self.find_in_unresolved(path)

# TODO: do we need these?? Kill it

end

##

# specs that contain the file matching +path+.

def self.find_in_unresolved_tree(path)

specs.each do |spec|

spec.traverse do |from_spec, dep, to_spec, trail|

# Return the latest installed spec for gem +name+.

def self.latest_spec_for(name)

end

def self._latest_specs(specs, prerelease = false) # :nodoc:

native = {}

specs.reverse_each do |spec|

result.map(&:last).map(&:values).flatten.reject do |spec|

minimum = native[spec.name]

minimum && spec.version < minimum

end

##

# version as well.

def self.outdated

end

##

Gem::Dependency.new local_spec.name, ">= #{local_spec.version}"

remotes, = fetcher.search_for_dependency dependency

latest_remote = remotes.sort.last

def self.reset

@@dirs = nil

@@all = nil

@@stubs = nil

@@stubs_by_name = {}

versions = find_all_by_name(dep.name)

unless versions.empty?

warn " Available/installed versions of this gem:"

end

end

warn "#{w}: Clearing out unresolved specs. Try 'gem cleanup <gem>'"

warn "Please report a bug if this causes problems."

unresolved.clear

end

end

# DOC: This method needs documented or nodoc'd

def self.unresolved_deps

end

##

# Cleanup any YAML::PrivateType. They only show up for an old bug

# where nil => null, so just convert them to nil based on the type.

spec.instance_variable_set :@rubygems_version, array[0]

# spec version

self.summary = sanitize_string(summary)

self.description = sanitize_string(description)

self.post_install_message = sanitize_string(post_install_message)

end

##

return nil if executables.nil?

if @bindir

else

executables

end

def build_args

if File.exist? build_info_file

build_info = File.readlines build_info_file

build_info.delete ""

build_info

else

def conficts_when_loaded_with?(list_of_specs) # :nodoc:

result = list_of_specs.any? do |spec|

end

result

end

# Returns all specs that matches this spec's runtime dependencies.

def dependent_specs

end

##

# List of dependencies that are used for development

def development_dependencies

end

##

def ruby_code(obj)

case obj

when String then obj.dump + ".freeze"

when Hash then

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

when Gem::Version then obj.to_s.dump

when DateLike then obj.strftime('%Y-%m-%d').dump

# True if this gem has the same attributes as +other+.

def same_attributes?(spec)

end

private :same_attributes?

unless result == :next

spec_name = dep_spec.name

dep_spec.traverse(trail, visited, &block) unless

end

end

end

end

def keep_only_files_and_directories

end

def validate_metadata

def validate_duplicate_dependencies # :nodoc:

# NOTE: see REFACTOR note in Gem::Dependency about types - this might be brittle

error_messages = []

@specification.dependencies.each do |dep|

end

end

if warning_messages.any?

end

end

def validate_non_files

return unless packaging

unless non_files.empty?

error "[\"#{non_files.join "\", \""}\"] are not files"

String

end

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

end

end

license value '#{license}' is invalid. Use a license identifier from

http://spdx.org/licenses or '#{Gem::Licenses::NONSTANDARD}' for a nonstandard license.

WARNING

warning(message)

end

end

validate_shebang_line_in(executable)

end

warning "#{file} is a symlink, which is not supported on all platforms"

end

end

builder = Gem::Ext::Builder.new(@specification)

rake_extension = @specification.extensions.any? {|s| builder.builder_for(s) == Gem::Ext::RakeBuilder }

warning <<-WARNING if rake_extension && !rake_dependency

You have specified rake based extension, but rake is not added as dependency. It is recommended to add rake as a dependency in gemspec since there's no guarantee rake will be already installed.

end

end

make = parse_make_command_line(line)

if make[:targets].include?(target)

$LOAD_PATH.replace @orig_LOAD_PATH if @orig_LOAD_PATH

if @orig_LOADED_FEATURES

if @orig_LOAD_PATH

($LOADED_FEATURES - @orig_LOADED_FEATURES).each do |feat|

$LOADED_FEATURES.delete(feat)

end

end

ensure

prefix = File.dirname(__FILE__) + "/"

new_features = ($LOADED_FEATURES - old_loaded_features)

$LOADED_FEATURES.replace old_loaded_features

end

spec_fetcher = Gem::SpecFetcher.fetcher

latest = Gem::Specification._latest_specs all_specs

spec_fetcher.specs[@uri] = []

unless Gem::RemoteFetcher === @fetcher

v = Gem.marshal_version

s_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic specs

latest_specs = latest.map do |spec|

l_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic latest_specs

p_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic prerelease_specs

@fetcher.data["#{@gem_repo}specs.#{v}.gz"] = s_zip

# Finds all gems matching +dep+ in this set.

def find_all(dep)

end

##

def cache_update_path(uri, path = nil, update = true)

if data = fetch_path(uri)

data

else

Gem.read_binary(path) if path

if list.empty?

return unless other_repo_specs.any?

message = ["#{@gem} is not installed in GEM_HOME, try:"]

"\tgem uninstall -i #{repo} #{@gem}"

}

remove_all list

elsif list.size > 1

gem_names << "All versions"

say

return if executables.empty?

remove = if @force_executables.nil?

ask_yes_no("Remove executables:\n" +

# NOTE: removes uninstalled gems from +list+.

def remove_all(list)

end

##

end

spec.dependent_gems(@check_dev).each do |dep_spec, dep, satlist|

msg << "#{dep_spec.name}-#{dep_spec.version} depends on #{dep}"

end

end

def _gets_noecho

require_io_console

end

##

# TODO needs further cleanup

def alien(gems=[])

Gem::Specification.each do |spec|

next unless gems.include? spec.name unless gems.empty?

def bump

@@bump[self] ||= begin

segments = self.segments

segments.pop if segments.size > 1

segments[-1] = segments[-1].succ

def release

@@release[self] ||= if prerelease?

segments = self.segments

self.class.new segments.join('.')

else

self

def approximate_recommendation

segments = self.segments

segments.pop while segments.size > 2

segments.push 0 while segments.size < 2