Class: Gem::Resolver

Inherits:
Object
  • Object
show all
Includes:
Molinillo::SpecificationProvider, Molinillo::UI
Defined in:
lib/rubygems/resolver.rb

Overview

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.

Defined Under Namespace

Modules: Molinillo Classes: APISet, APISpecification, ActivationRequest, BestSet, ComposedSet, Conflict, CurrentSet, DependencyRequest, GitSet, GitSpecification, IndexSet, IndexSpecification, InstalledSpecification, InstallerSet, LocalSpecification, LockSet, LockSpecification, RequirementList, Set, SourceSet, SpecSpecification, Specification, Stats, VendorSet, VendorSpecification

Constant Summary collapse

DEBUG_RESOLVER =

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.

!ENV["DEBUG_RESOLVER"].nil?

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Molinillo::SpecificationProvider

#dependencies_equal?, #name_for_explicit_dependency_source, #name_for_locking_dependency_source

Methods included from Molinillo::UI

#after_resolution, #before_resolution, #debug, #indicate_progress, #progress_rate

Constructor Details

#initialize(needed, set = nil) ⇒ Resolver

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.



102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/rubygems/resolver.rb', line 102

def initialize(needed, set = nil)
  @set = set || Gem::Resolver::IndexSet.new
  @needed = needed

  @development         = false
  @development_shallow = false
  @ignore_dependencies = false
  @missing             = []
  @skip_gems           = {}
  @soft_missing        = false
  @stats               = Gem::Resolver::Stats.new
end

Instance Attribute Details

#development ⇒ Object

Set to true if all development dependencies should be considered.



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

def development
  @development
end

#development_shallow ⇒ Object

Set to true if immediate development dependencies should be considered.



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

def development_shallow
  @development_shallow
end

#ignore_dependencies ⇒ Object

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



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

def ignore_dependencies
  @ignore_dependencies
end

#missing ⇒ Object (readonly)

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



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

def missing
  @missing
end

#skip_gems ⇒ Object

Hash of gems to skip resolution. Keyed by gem name, with arrays of gem specifications as values.



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

def skip_gems
  @skip_gems
end

#soft_missing ⇒ Object

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



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

def soft_missing
  @soft_missing
end

#stats ⇒ Object (readonly)

Returns the value of attribute stats.



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

def stats
  @stats
end

Class Method Details

.compose_sets(*sets) ⇒ Object

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.



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/rubygems/resolver.rb', line 62

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) ⇒ Object

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



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

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

Instance Method Details

#activation_request(dep, possible) ⇒ Object

Creates an ActivationRequest for the given dep and the last possible specification.

Returns the Specification and the ActivationRequest



139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/rubygems/resolver.rb', line 139

def activation_request(dep, possible) # :nodoc:
  spec = possible.pop

  explain :activate, [spec.full_name, possible.size]
  explain :possible, possible

  activation_request =
    Gem::Resolver::ActivationRequest.new spec, dep, possible

  return spec, activation_request
end

#allow_missing?(dependency) ⇒ Boolean

Returns:

  • (Boolean) 


277
278
279
280
 
# File 'lib/rubygems/resolver.rb', line 277

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

#debug? ⇒ Boolean

Returns:

  • (Boolean) 


180
181
182
 
# File 'lib/rubygems/resolver.rb', line 180

def debug?
  DEBUG_RESOLVER
end

#dependencies_for(specification) ⇒ Object 



258
259
260
261
262
 
# File 'lib/rubygems/resolver.rb', line 258

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

#explain(stage, *data) ⇒ Object

:nodoc:



115
116
117
118
119
120
 
# 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

#explain_list(stage) ⇒ Object

:nodoc:



122
123
124
125
126
127
128
129
130
131
 
# 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
  unless data.empty?
    require "pp"
    PP.pp data, $stderr
  end
end

#find_possible(dependency) ⇒ Object

Extracts the specifications that may be able to fulfill dependency and returns those that match the local platform and all those that match.



203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
 
# File 'lib/rubygems/resolver.rb', line 203

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

#name_for(dependency) ⇒ Object 



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

def name_for(dependency)
  dependency.name
end

#output ⇒ Object 



176
177
178
 
# File 'lib/rubygems/resolver.rb', line 176

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

#requests(s, act, reqs = []) ⇒ Object

:nodoc:



151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/rubygems/resolver.rb', line 151

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

#requirement_satisfied_by?(requirement, activated, spec) ⇒ Boolean

Returns:

  • (Boolean) 


264
265
266
267
268
269
270
271
 
# File 'lib/rubygems/resolver.rb', line 264

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

#resolve ⇒ Object

Proceed with resolution! Returns an array of ActivationRequest objects.



189
190
191
192
193
194
195
196
197
 
# File 'lib/rubygems/resolver.rb', line 189

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) && !debug?
end

#search_for(dependency) ⇒ Object 



228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/rubygems/resolver.rb', line 228

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

  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] }.
      map {|spec| ActivationRequest.new spec, dependency }.
      each {|activation_request| activation_requests << activation_request }
  end

  activation_requests
end

#select_local_platforms(specs) ⇒ Object

Returns the gems in specs that match the local platform.



222
223
224
225
226
 
# File 'lib/rubygems/resolver.rb', line 222

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

#sort_dependencies(dependencies, activated, conflicts) ⇒ Object 



282
283
284
285
286
287
288
289
290
291
292
293
 
# File 'lib/rubygems/resolver.rb', line 282

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