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

def initialize

@set = []

@sorted = nil

end

attr_reader :set

attr_reader :ssl_verify_mode

##

##

# Path name of directory or file of openssl client certificate, used for remote https connection with client authentication

request_set = as.to_request_set install_development_deps

request_set.soft_missing = @force

installer_set = Gem::Resolver::InstallerSet.new @domain

installer_set.always_install.concat request_set.always_install

ENV["RUBYOPT"] = ["-r#{siteconf_path}", rubyopt].compact.join(' ')

cmd = [Gem.ruby, File.basename(extension), *args].join ' '

ENV["DESTDIR"] = nil

ENV["RUBYOPT"] = rubyopt

if ARGV.first

str = ARGV.first

str = str.dup.force_encoding("BINARY") if str.respond_to? :force_encoding

version = $1

ARGV.shift

end

vals[:gid] ||= 0

vals[:mtime] ||= 0

vals[:checksum] ||= ""

vals[:magic] ||= "ustar"

vals[:version] ||= "00"

vals[:uname] ||= "wheel"

FileUtils.mkdir_p cache_dir rescue nil unless File.exist? cache_dir

end

scheme = source_uri.scheme

def cache_update_path uri, path = nil, update = true

mtime = path && File.stat(path).mtime rescue nil

end

end

##

connection.key = OpenSSL::PKey::RSA.new pem

end

if Gem.configuration.ssl_ca_cert

if File.directory? Gem.configuration.ssl_ca_cert

store.add_path Gem.configuration.ssl_ca_cert

else

store.add_file Gem.configuration.ssl_ca_cert

end

end

connection.cert_store = store

rescue LoadError => e

request = @request_class.new @uri.request_uri

unless @uri.nil? || @uri.user.nil? || @uri.user.empty? then

end

request.add_field 'User-Agent', @user_agent

attr_accessor :ignore_dependencies

##

# Sets used for resolution

attr_reader :sets # :nodoc:

@git_set = nil

@ignore_dependencies = false

@install_dir = Gem.dir

@requests = []

@sets = []

@soft_missing = false

gemdeps = options[:gemdeps]

@install_dir = options[:install_dir] || Gem.dir

load_gemdeps gemdeps, options[:without_groups]

@sets << @vendor_set

set = Gem::Resolver.compose_sets(*@sets)

resolver = Gem::Resolver.new @dependencies, set

resolver.development = @development

sets = sets.map do |set|

case set

when Gem::Resolver::ComposedSet then

set.sets

else

# http://guides.rubygems.org/rubygems-org-api

def initialize dep_uri = 'https://rubygems.org/api/v1/dependencies'

dep_uri = URI dep_uri unless URI === dep_uri # for ruby 1.8

@dep_uri = dep_uri

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

@source = Gem::Source.new @uri

def find_all req

res = []

versions(req.name).each do |ver|

if req.dependency.match? req.name, ver[:number]

res << Gem::Resolver::APISpecification.new(self, ver)

# data for DependencyRequests +reqs+.

def prefetch reqs

names = reqs.map { |r| r.dependency.name }

needed = names - @data.keys

def initialize sources = Gem.sources

super()

@sets << source.dependency_resolver_set

end

end

def pretty_print q # :nodoc:

q.group 2, '[BestSet', ']' do

q.breakable

# Gem::Resolver::compose_sets instead.

def initialize *sets

@sets = sets

end

##

# Finds all specs matching +req+ in all sets.

def find_all req

attr_reader :specs # :nodoc:

def initialize # :nodoc:

@git = ENV['git'] || 'git'

@need_submodules = {}

@repositories = {}

@repositories.each do |name, (repository, reference)|

source = Gem::Source::Git.new name, repository, reference

source.root_dir = @root_dir

source.specs.each do |spec|

git_spec = Gem::Resolver::GitSpecification.new self, spec, source

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

def initialize source = nil # :nodoc:

@f =

if source then

sources = Gem::SourceList.from [source]

def find_all req

res = []

name = req.dependency.name

@all[name].each do |uri, n|

# Creates a new InstallerSet that will look for gems in +domain+.

def initialize domain

@domain = domain

@f = Gem::SpecFetcher.fetcher

@always_install = []

@ignore_dependencies = false

@ignore_installed = false

@specs = {}

end

end

end

end

# Creates a new LockSet from the given +source+

def initialize source

@source = Gem::Source::Lock.new source

@specs = []

end

class Gem::Resolver::Set

##

# The find_all method must be implemented. It returns all Resolver

# Specification objects matching the given DependencyRequest +req+.

def prefetch reqs

end

end

attr_reader :specs # :nodoc:

def initialize # :nodoc:

@directories = {}

@specs = {}

end

attr_reader :reference

##

# The git repository this gem is sourced from.

attr_reader :repository

@reference = reference

@need_submodules = submodules

@root_dir = Gem.dir

@git = ENV['git'] || 'git'

end

def checkout # :nodoc:

cache

unless File.exist? install_dir then

system @git, 'clone', '--quiet', '--no-checkout',

repo_cache_dir, install_dir

# Creates a local cache repository for the git gem.

def cache # :nodoc:

if File.exist? repo_cache_dir then

Dir.chdir repo_cache_dir do

system @git, 'fetch', '--quiet', '--force', '--tags',

# The directory where the git gem will be installed.

def install_dir # :nodoc:

File.join base_dir, 'gems', "#{@name}-#{dir_shortref}"

end

def specs

checkout

Dir.chdir install_dir do

Dir['{,*,*/*}.gemspec'].map do |spec_file|

directory = File.dirname spec_file

assert File.exist?(path), msg

end

# TODO: move to minitest

def refute_path_exists path, msg = nil

msg = message(msg) { "Expected path '#{path}' to not exist" }

class StaticSet

##

# Creates a new StaticSet for the given +specs+

def initialize(specs)

@specs = specs

end

##

# 3. 1.0.a.2

# 4. 0.9

#

# == How Software Changes

#

# Users expect to be able to specify a version constraint that gives them