Skip to content
Find file
Fetching contributors…
Cannot retrieve contributors at this time
243 lines (215 sloc) 9.88 KB
# This is the latest iteration of the gem dependency resolving algorithm. As of now,
# it can resolve (as a success of failure) any set of gem dependencies we throw at it
# in a reasonable amount of time. The most iterations I've seen it take is about 150.
# The actual implementation of the algorithm is not as good as it could be yet, but that
# can come later.
# Extending Gem classes to add necessary tracking information
module Gem
class Dependency
def required_by
@required_by ||= []
class Specification
def required_by
@required_by ||= []
module Bundler
class GemNotFound < StandardError; end
class VersionConflict < StandardError; end
class Resolver
attr_reader :errors
# Figures out the best possible configuration of gems that satisfies
# the list of passed dependencies and any child dependencies without
# causing any gem activation errors.
# ==== Parameters
# *dependencies<Gem::Dependency>:: The list of dependencies to resolve
# ==== Returns
# <GemBundle>,nil:: If the list of dependencies can be resolved, a
# collection of gemspecs is returned. Otherwise, nil is returned.
def self.resolve(requirements, sources, source_requirements = {})
resolver = new(sources, source_requirements)
result = catch(:success) do
resolver.resolve(requirements, {})
output = resolver.errors.inject("") do |o, (conflict, (origin, requirement))|
o << " Conflict on: #{conflict.inspect}:\n"
o << " * #{conflict} (#{origin.version}) activated by #{origin.required_by.first}\n"
o << " * #{requirement} required by #{requirement.required_by.first}\n"
o << " All possible versions of origin requirements conflict."
raise VersionConflict, "No compatible versions could be found for required dependencies:\n #{output}"
if result
# Order gems in order of dependencies. Every gem's dependency is at
# a smaller index in the array.
ordered = []
result.values.each do |spec1|
index = nil
place = ordered.detect do |spec2|
spec1.dependencies.any? { |d| == }
place ?
ordered.insert(ordered.index(place), spec1) :
ordered << spec1
def initialize(sources, source_requirements)
@errors = {}
@stack = []
@specs = { |h,k| h[k] = [] }
@by_gem = source_requirements
@cache = {}
@index = {}
sources.each do |source|
source.gems.each do |name, specs|
# Hack to work with a regular Gem::SourceIndex
specs = [specs] unless specs.is_a?(Array)
specs.compact.each do |spec|
next if @specs[].any? { |s| s.version == spec.version && s.platform == spec.platform }
@specs[] << spec
def debug
puts yield if defined?($debug) && $debug
def resolve(reqs, activated)
# If the requirements are empty, then we are in a success state. Aka, all
# gem dependencies have been resolved.
throw :success, activated if reqs.empty?
debug { STDIN.gets ; print "\e[2J\e[f" ; "==== Iterating ====\n\n" }
# Sort dependencies so that the ones that are easiest to resolve are first.
# Easiest to resolve is defined by:
# 1) Is this gem already activated?
# 2) Do the version requirements include prereleased gems?
# 3) Sort by number of gems available in the source.
reqs = reqs.sort_by do |a|
[ activated[] ? 0 : 1,
a.version_requirements.prerelease? ? 0 : 1,
@errors[] ? 0 : 1,
activated[] ? 0 : search(a).size ]
debug { "Activated:\n" + { |a| " #{} (#{a.version})" }.join("\n") }
debug { "Requirements:\n" + { |r| " #{} (#{r.version_requirements})"}.join("\n") }
activated = activated.dup
# Pull off the first requirement so that we can resolve it
current = reqs.shift
debug { "Attempting:\n #{} (#{current.version_requirements})"}
# Check if the gem has already been activated, if it has, we will make sure
# that the currently activated gem satisfies the requirement.
if existing = activated[]
if current.version_requirements.satisfied_by?(existing.version)
debug { " * [SUCCESS] Already activated" }
# Since the current requirement is satisfied, we can continue resolving
# the remaining requirements.
resolve(reqs, activated)
debug { " * [FAIL] Already activated" }
@errors[] = [existing, current]
debug { {|d| " * #{} (#{d.version_requirements})" }.join("\n") }
# debug { " * All current conflicts:\n" + { |c| " - #{c}" }.join("\n") }
# Since the current requirement conflicts with an activated gem, we need
# to backtrack to the current requirement's parent and try another version
# of it (maybe the current requirement won't be present anymore). If the
# current requirement is a root level requirement, we need to jump back to
# where the conflicting gem was activated.
parent = current.required_by.last || existing.required_by.last
# We track the spot where the current gem was activated because we need
# to keep a list of every spot a failure happened.
debug { " -> Jumping to: #{}" }
# There are no activated gems for the current requirement, so we are going
# to find all gems that match the current requirement and try them in decending
# order. We also need to keep a set of all conflicts that happen while trying
# this gem. This is so that if no versions work, we can figure out the best
# place to backtrack to.
conflicts =
# Fetch all gem versions matching the requirement
# TODO: Warn / error when no matching versions are found.
matching_versions = search(current)
if matching_versions.empty?
if current.required_by.empty?
location = @by_gem[] ? @by_gem[] : "any of the sources"
raise GemNotFound, "Could not find gem '#{current}' in #{location}"
Bundler.logger.warn "Could not find gem '#{current}' (required by '#{current.required_by.last}') in any of the sources"
matching_versions.reverse_each do |spec|
conflict = resolve_requirement(spec, current, reqs.dup, activated.dup)
conflicts << conflict if conflict
# If the current requirement is a root level gem and we have conflicts, we
# can figure out the best spot to backtrack to.
if current.required_by.empty? && !conflicts.empty?
# Check the current "catch" stack for the first one that is included in the
# conflicts set. That is where the parent of the conflicting gem was required.
# By jumping back to this spot, we can try other version of the parent of
# the conflicting gem, hopefully finding a combination that activates correctly.
@stack.reverse_each do |savepoint|
if conflicts.include?(savepoint)
debug { " -> Jumping to: #{savepoint}" }
throw savepoint
def resolve_requirement(spec, requirement, reqs, activated)
# We are going to try activating the spec. We need to keep track of stack of
# requirements that got us to the point of activating this gem.
spec.required_by.replace requirement.required_by
spec.required_by << requirement
activated[] = spec
debug { " Activating: #{} (#{spec.version})" }
debug { { |d| " * #{} (#{d.version_requirements})" }.join("\n") }
# Now, we have to loop through all child dependencies and add them to our
# array of requirements.
debug { " Dependencies"}
spec.dependencies.each do |dep|
next if dep.type == :development
debug { " * #{} (#{dep.version_requirements})" }
dep.required_by << requirement
reqs << dep
# We create a savepoint and mark it by the name of the requirement that caused
# the gem to be activated. If the activated gem ever conflicts, we are able to
# jump back to this point and try another version of the gem.
length = @stack.length
@stack <<
retval = catch( do
resolve(reqs, activated)
# Since we're doing a lot of throw / catches. A push does not necessarily match
# up to a pop. So, we simply slice the stack back to what it was before the catch
# block.
def search(dependency)
@cache[dependency.hash] ||= begin
pinned = @by_gem[].gems if @by_gem[]
specs = (pinned || @specs)[]
wants_prerelease = dependency.version_requirements.prerelease?
only_prerelease = specs.all? {|spec| spec.version.prerelease? }
found = { |spec| dependency =~ spec }
unless wants_prerelease || (pinned && only_prerelease)
found.reject! { |spec| spec.version.prerelease? }
found.sort_by {|s| [s.version, s.platform == 'ruby' ? "\0" : s.platform] }
Jump to Line
Something went wrong with that request. Please try again.