Given a set of Gem::Dependency objects as needed and a way to query the set of available specs via set, calculates a set of ActivationRequest objects which indicate all the specs that should be activated to meet the all the requirements.

Namespace
Methods
C
F
N
R
Constants
DEBUG_RESOLVER = !ENV['DEBUG_RESOLVER'].nil?
 

If the DEBUG_RESOLVER environment variable is set then debugging mode is enabled for the resolver. This will display information about the state of the resolver while a set of dependencies is being resolved.

State = Struct.new(:needed, :specs, :dep, :spec, :possibles, :conflicts) do def summary # :nodoc: nd = needed.map { |s| s.to_s }.sort if nd if specs then ss = specs.map { |s| s.full_name }.sort ss.unshift ss.length end d = dep.to_s d << " from #{dep.requester.full_name}" if dep.requester ps = possibles.map { |p| p.full_name }.sort ps.unshift ps.length cs = conflicts.map do |(s, c)| [s.full_name, c.conflicting_dependencies.map { |cd| cd.to_s }] end { :needed => nd, :specs => ss, :dep => d, :spec => spec.full_name, :possibles => ps, :conflicts => cs } end end
 

Contains the state for attempting activation of a set of possible specs. needed is a Gem::List of DependencyRequest objects that, well, need to be satisfied. specs is the List of ActivationRequest that are being tested. dep is the DependencyRequest that was used to generate this state. spec is the Specification for this state. possible is List of DependencyRequest objects that can be tried to find a complete set. conflicts is a [DependencyRequest, Conflict] hit tried to activate the state.

DependencyConflict = Gem::Resolver::Conflict # :nodoc:
 

TODO: Remove in RubyGems 3

Attributes
[R] conflicts

Contains all the conflicts encountered while doing resolution

[RW] development

Set to true if development dependencies should be considered.

[RW] ignore_dependencies

When true, no dependencies are looked up for requested gems.

[R] missing

List of dependencies that could not be found in the configured sources.

[RW] soft_missing

When a missing dependency, don't stop. Just go on and record what was missing.

[R] stats
Class Public methods
compose_sets(*sets)

Combines sets into a ComposedSet that allows specification lookup in a uniform manner. If one of the sets is itself a ComposedSet its sets are flattened into the result ComposedSet.

# File lib/rubygems/resolver.rb, line 57
def self.compose_sets *sets
  sets.compact!

  sets = sets.map do |set|
    case set
    when Gem::Resolver::BestSet then
      set
    when Gem::Resolver::ComposedSet then
      set.sets
    else
      set
    end
  end.flatten

  case sets.length
  when 0 then
    raise ArgumentError, 'one set in the composition must be non-nil'
  when 1 then
    sets.first
  else
    Gem::Resolver::ComposedSet.new(*sets)
  end
end
for_current_gems(needed)

Creates a Resolver that queries only against the already installed gems for the needed dependencies.

# File lib/rubygems/resolver.rb, line 85
def self.for_current_gems needed
  new needed, Gem::Resolver::CurrentSet.new
end
new(needed, set = nil)

Create Resolver object which will resolve the tree starting with needed Dependency objects.

set is an object that provides where to look for specifications to satisfy the Dependencies. This defaults to IndexSet, which will query rubygems.org.

# File lib/rubygems/resolver.rb, line 97
def initialize needed, set = nil
  @set = set || Gem::Resolver::IndexSet.new
  @needed = needed

  @conflicts           = []
  @development         = false
  @ignore_dependencies = false
  @missing             = []
  @soft_missing        = false
  @stats               = Gem::Resolver::Stats.new
end
Instance Public methods
resolve()

Proceed with resolution! Returns an array of ActivationRequest objects.

# File lib/rubygems/resolver.rb, line 161
def resolve
  @conflicts = []

  needed = Gem::Resolver::RequirementList.new

  @needed.reverse_each do |n|
    request = Gem::Resolver::DependencyRequest.new n, nil

    needed.add request
    @stats.requirement!
  end

  @stats.record_requirements needed

  res = resolve_for needed, nil

  raise Gem::DependencyResolutionError, res if
    res.kind_of? Gem::Resolver::Conflict

  res.to_a
end