Class: Gem::Resolver

# File 'lib/rubygems/resolver.rb', line 87

def self.for_current_gems(needed)
  new needed, Gem::Resolver::CurrentSet.new
end

# File 'lib/rubygems/resolver.rb', line 26

attr_accessor :development

# File 'lib/rubygems/resolver.rb', line 31

attr_accessor :development_shallow

# File 'lib/rubygems/resolver.rb', line 36

attr_accessor :ignore_dependencies

# File 'lib/rubygems/resolver.rb', line 47

attr_accessor :skip_gems

# File 'lib/rubygems/resolver.rb', line 52

attr_accessor :soft_missing

# File 'lib/rubygems/resolver.rb', line 41

attr_reader :stats

# File 'lib/rubygems/resolver.rb', line 271

def allow_missing?(dependency)
  @soft_missing
end

# File 'lib/rubygems/resolver.rb', line 297

def amount_constrained(dependency)
  @amount_constrained ||= {}
  @amount_constrained[dependency.name] ||= begin
    name_dependency = Gem::Dependency.new(dependency.name)
    dependency_request_for_name = Gem::Resolver::DependencyRequest.new(name_dependency, dependency.requester)
    all = @set.find_all(dependency_request_for_name).size

    if all <= 1
      all - SINGLE_POSSIBILITY_CONSTRAINT_PENALTY
    else
      search = search_for(dependency).size
      search - all
    end
  end
end

# File 'lib/rubygems/resolver.rb', line 252

def dependencies_for(specification)
  return [] if @ignore_dependencies
  spec = specification.spec
  requests(spec, specification)
end

# File 'lib/rubygems/resolver.rb', line 111

def explain(stage, *data) # :nodoc:
  return unless DEBUG_RESOLVER

  d = data.map(&:pretty_inspect).join(", ")
  $stderr.printf "%10s %s\n", stage.to_s.upcase, d
end

# File 'lib/rubygems/resolver.rb', line 118

def explain_list(stage) # :nodoc:
  return unless DEBUG_RESOLVER

  data = yield
  $stderr.printf "%10s (%d entries)\n", stage.to_s.upcase, data.size
  unless data.empty?
    require "pp"
    PP.pp data, $stderr
  end
end

# File 'lib/rubygems/resolver.rb', line 198

def find_possible(dependency) # :nodoc:
  all = @set.find_all dependency

  if (skip_dep_gems = skip_gems[dependency.name]) && !skip_dep_gems.empty?
    matching = all.select do |api_spec|
      skip_dep_gems.any? {|s| api_spec.version == s.version }
    end

    all = matching unless matching.empty?
  end

  matching_platform = select_local_platforms all

  [matching_platform, all]
end

# File 'lib/rubygems/resolver.rb', line 267

def name_for(dependency)
  dependency.name
end

# File 'lib/rubygems/resolver.rb', line 172

def output
  @output ||= debug? ? $stdout : File.open(IO::NULL, "w")
end

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

def requests(s, act, reqs=[]) # :nodoc:
  return reqs if @ignore_dependencies

  s.fetch_development_dependencies if @development

  s.dependencies.reverse_each do |d|
    next if d.type == :development && !@development
    next if d.type == :development && @development_shallow &&
            act.development?
    next if d.type == :development && @development_shallow &&
            act.parent

    reqs << Gem::Resolver::DependencyRequest.new(d, act)
    @stats.requirement!
  end

  @set.prefetch reqs

  @stats.record_requirements reqs

  reqs
end

# File 'lib/rubygems/resolver.rb', line 258

def requirement_satisfied_by?(requirement, activated, spec)
  matches_spec = requirement.matches_spec? spec
  return matches_spec if @soft_missing

  matches_spec &&
    spec.spec.required_ruby_version.satisfied_by?(Gem.ruby_version) &&
    spec.spec.required_rubygems_version.satisfied_by?(Gem.rubygems_version)
end

# File 'lib/rubygems/resolver.rb', line 185

def resolve
  Gem::Molinillo::Resolver.new(self, self).resolve(@needed.map {|d| DependencyRequest.new d, nil }).tsort.filter_map(&:payload)
rescue Gem::Molinillo::VersionConflict => e
  conflict = e.conflicts.values.first
  raise Gem::DependencyResolutionError, Conflict.new(conflict.requirement_trees.first.first, conflict.existing, conflict.requirement)
ensure
  @output.close if defined?(@output) && !debug?
end

# File 'lib/rubygems/resolver.rb', line 223

def search_for(dependency)
  possibles, all = find_possible(dependency)
  if !@soft_missing && possibles.empty?
    exc = Gem::UnsatisfiableDependencyError.new dependency, all
    exc.errors = @set.errors
    raise exc
  end

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

  # create groups & sources in the same loop
  sources = possibles.map do |spec|
    source = spec.source
    groups[source] << spec
    source
  end.uniq.reverse

  activation_requests = []

  sources.each do |source|
    groups[source].
      sort_by {|spec| [spec.version, spec.platform =~ Gem::Platform.local ? 1 : 0] }. # rubocop:disable Performance/RegexpMatch
      map {|spec| ActivationRequest.new spec, dependency }.
      each {|activation_request| activation_requests << activation_request }
  end

  activation_requests
end

# File 'lib/rubygems/resolver.rb', line 217

def select_local_platforms(specs) # :nodoc:
  specs.select do |spec|
    Gem::Platform.installable? spec
  end
end

# File 'lib/rubygems/resolver.rb', line 275

def sort_dependencies(dependencies, activated, conflicts)
  dependencies.sort_by.with_index do |dependency, i|
    name = name_for(dependency)
    [
      activated.vertex_named(name).payload ? 0 : 1,
      amount_constrained(dependency),
      conflicts[name] ? 0 : 1,
      activated.vertex_named(name).payload ? 0 : search_for(dependency).count,
      i, # for stable sort
    ]
  end
end