Class: Gem::Resolver

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

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 41

attr_reader :missing

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

attr_accessor :skip_gems

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

attr_accessor :soft_missing

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

attr_reader :stats

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

def allow_missing?(dependency)
  @missing << dependency
  @soft_missing
end

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

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 257

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

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

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

  d = data.map { |x| x.pretty_inspect }.join(", ")
  $stderr.printf "%10s %s\n", stage.to_s.upcase, d
end

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

def explain_list stage # :nodoc:
  return unless DEBUG_RESOLVER

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

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

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

  return matching_platform, all
end

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

def name_for(dependency)
  dependency.name
end

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

def output
  @output ||= debug? ? $stdout : File.open(Gem::Util::NULL_DEVICE, 'w')
end

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

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 and not @development
    next if d.type == :development and @development_shallow and
            act.development?
    next if d.type == :development and @development_shallow and
            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 263

def requirement_satisfied_by?(requirement, activated, spec)
  requirement.matches_spec? spec
end

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

def resolve
  locking_dg = Molinillo::DependencyGraph.new
  Molinillo::Resolver.new(self, self).resolve(@needed.map { |d| DependencyRequest.new d, nil }, locking_dg).tsort.map(&:payload).compact
rescue 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) and !debug?
end

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

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

  sources = []

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

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

  activation_requests = []

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

  activation_requests
end

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

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

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

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