Class: Bundler::Definition
- Inherits:
-
Object
- Object
- Bundler::Definition
show all
- Includes:
- GemHelpers
- Defined in:
- lib/bundler/definition.rb
Constant Summary
Constants included
from GemHelpers
GemHelpers::GENERICS, GemHelpers::GENERIC_CACHE
Instance Attribute Summary collapse
Class Method Summary
collapse
Instance Method Summary
collapse
Methods included from GemHelpers
generic, generic_local_platform, platform_specificity_match, select_best_platform_match
Constructor Details
#initialize(lockfile, dependencies, sources, unlock, ruby_version = nil, optional_groups = [], gemfiles = []) ⇒ Definition
How does the new system work?
-
Load information from Gemfile and Lockfile
-
Invalidate stale locked specs
-
All specs from stale source are stale
-
All specs that are reachable only through a stale dependency are stale.
-
If all fresh dependencies are satisfied by the locked
specs, then we can try to resolve locally.
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
# File 'lib/bundler/definition.rb', line 56
def initialize(lockfile, dependencies, sources, unlock, ruby_version = nil, optional_groups = [], gemfiles = [])
if [true, false].include?(unlock)
@unlocking_bundler = false
@unlocking = unlock
else
unlock = unlock.dup
@unlocking_bundler = unlock.delete(:bundler)
unlock.delete_if {|_k, v| Array(v).empty? }
@unlocking = !unlock.empty?
end
@dependencies = dependencies
@sources = sources
@unlock = unlock
@optional_groups = optional_groups
@remote = false
@specs = nil
@ruby_version = ruby_version
@gemfiles = gemfiles
@lockfile = lockfile
@lockfile_contents = String.new
@locked_bundler_version = nil
@locked_ruby_version = nil
@locked_specs_incomplete_for_platform = false
if lockfile && File.exist?(lockfile)
@lockfile_contents = Bundler.read_file(lockfile)
@locked_gems = LockfileParser.new(@lockfile_contents)
@locked_platforms = @locked_gems.platforms
@platforms = @locked_platforms.dup
@locked_bundler_version = @locked_gems.bundler_version
@locked_ruby_version = @locked_gems.ruby_version
if unlock != true
@locked_deps = @locked_gems.dependencies
@locked_specs = SpecSet.new(@locked_gems.specs)
@locked_sources = @locked_gems.sources
else
@unlock = {}
@locked_deps = {}
@locked_specs = SpecSet.new([])
@locked_sources = []
end
else
@unlock = {}
@platforms = []
@locked_gems = nil
@locked_deps = {}
@locked_specs = SpecSet.new([])
@locked_sources = []
@locked_platforms = []
end
@unlock[:gems] ||= []
@unlock[:sources] ||= []
@unlock[:ruby] ||= if @ruby_version && locked_ruby_version_object
@ruby_version.diff(locked_ruby_version_object)
end
@unlocking ||= @unlock[:ruby] ||= (!@locked_ruby_version ^ !@ruby_version)
add_current_platform unless Bundler.frozen_bundle?
converge_path_sources_to_gemspec_sources
@path_changes = converge_paths
@source_changes = converge_sources
unless @unlock[:lock_shared_dependencies]
eager_unlock = expand_dependencies(@unlock[:gems], true)
@unlock[:gems] = @locked_specs.for(eager_unlock, [], false, false, false).map(&:name)
end
@gem_version_promoter = create_gem_version_promoter
@dependency_changes = converge_dependencies
@local_changes = converge_locals
@requires = compute_requires
end
|
Instance Attribute Details
#dependencies ⇒ Object
Returns the value of attribute dependencies.
10
11
12
|
# File 'lib/bundler/definition.rb', line 10
def dependencies
@dependencies
end
|
Returns the value of attribute gem_version_promoter.
10
11
12
|
# File 'lib/bundler/definition.rb', line 10
def gem_version_promoter
@gem_version_promoter
end
|
#gemfiles ⇒ Object
Returns the value of attribute gemfiles.
10
11
12
|
# File 'lib/bundler/definition.rb', line 10
def gemfiles
@gemfiles
end
|
#locked_deps ⇒ Object
Returns the value of attribute locked_deps.
10
11
12
|
# File 'lib/bundler/definition.rb', line 10
def locked_deps
@locked_deps
end
|
#locked_gems ⇒ Object
Returns the value of attribute locked_gems.
10
11
12
|
# File 'lib/bundler/definition.rb', line 10
def locked_gems
@locked_gems
end
|
#lockfile ⇒ Object
Returns the value of attribute lockfile.
10
11
12
|
# File 'lib/bundler/definition.rb', line 10
def lockfile
@lockfile
end
|
Returns the value of attribute platforms.
10
11
12
|
# File 'lib/bundler/definition.rb', line 10
def platforms
@platforms
end
|
#requires ⇒ Object
Returns the value of attribute requires.
10
11
12
|
# File 'lib/bundler/definition.rb', line 10
def requires
@requires
end
|
#ruby_version ⇒ Object
Returns the value of attribute ruby_version.
10
11
12
|
# File 'lib/bundler/definition.rb', line 10
def ruby_version
@ruby_version
end
|
Class Method Details
Given a gemfile and lockfile creates a Bundler definition
Instance Method Details
517
518
519
520
521
|
# File 'lib/bundler/definition.rb', line 517
def add_current_platform
current_platform = Bundler.local_platform
add_platform(current_platform) if Bundler.feature_flag.specific_platform?
add_platform(generic(current_platform))
end
|
507
508
509
510
|
# File 'lib/bundler/definition.rb', line 507
def add_platform(platform)
@new_platform ||= !@platforms.include?(platform)
@platforms |= [platform]
end
|
136
137
138
139
140
141
142
143
144
145
146
147
|
# File 'lib/bundler/definition.rb', line 136
def create_gem_version_promoter
locked_specs =
if unlocking? && @locked_specs.empty? && !@lockfile_contents.empty?
Bundler::SpecSet.new(@locked_gems.specs)
else
@locked_specs
end
GemVersionPromoter.new(locked_specs, @unlock[:gems])
end
|
#current_dependencies ⇒ Object
231
232
233
|
# File 'lib/bundler/definition.rb', line 231
def current_dependencies
dependencies.select(&:should_include?)
end
|
#ensure_equivalent_gemfile_and_lockfile(explicit_flag = false) ⇒ Object
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
|
# File 'lib/bundler/definition.rb', line 388
def ensure_equivalent_gemfile_and_lockfile(explicit_flag = false)
msg = String.new
msg << "You are trying to install in deployment mode after changing\n" \
"your Gemfile. Run `bundle install` elsewhere and add the\n" \
"updated #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)} to version control."
unless explicit_flag
suggested_command = if Bundler.settings.locations("frozen")[:global]
"bundle config --delete frozen"
elsif Bundler.settings.locations("deployment").keys.&([:global, :local]).any?
"bundle config --delete deployment"
else
"bundle install --no-deployment"
end
msg << "\n\nIf this is a development machine, remove the #{Bundler.default_gemfile} " \
"freeze \nby running `#{suggested_command}`."
end
added = []
deleted = []
changed = []
new_platforms = @platforms - @locked_platforms
deleted_platforms = @locked_platforms - @platforms
added.concat new_platforms.map {|p| "* platform: #{p}" }
deleted.concat deleted_platforms.map {|p| "* platform: #{p}" }
gemfile_sources = sources.lock_sources
new_sources = gemfile_sources - @locked_sources
deleted_sources = @locked_sources - gemfile_sources
new_deps = @dependencies - @locked_deps.values
deleted_deps = @locked_deps.values - @dependencies
if (new_deps.empty? && deleted_deps.empty?) && (!new_sources.empty? && !deleted_sources.empty?)
new_sources.reject! {|source| (source.path? && source.path.exist?) || equivalent_rubygems_remotes?(source) }
deleted_sources.reject! {|source| (source.path? && source.path.exist?) || equivalent_rubygems_remotes?(source) }
end
if @locked_sources != gemfile_sources
if new_sources.any?
added.concat new_sources.map {|source| "* source: #{source}" }
end
if deleted_sources.any?
deleted.concat deleted_sources.map {|source| "* source: #{source}" }
end
end
added.concat new_deps.map {|d| "* #{pretty_dep(d)}" } if new_deps.any?
if deleted_deps.any?
deleted.concat deleted_deps.map {|d| "* #{pretty_dep(d)}" }
end
both_sources = Hash.new {|h, k| h[k] = [] }
@dependencies.each {|d| both_sources[d.name][0] = d }
@locked_deps.each {|name, d| both_sources[name][1] = d.source }
both_sources.each do |name, (dep, lock_source)|
next unless (dep.nil? && !lock_source.nil?) || (!dep.nil? && !lock_source.nil? && !lock_source.can_lock?(dep))
gemfile_source_name = (dep && dep.source) || "no specified source"
lockfile_source_name = lock_source || "no specified source"
changed << "* #{name} from `#{gemfile_source_name}` to `#{lockfile_source_name}`"
end
reason = change_reason
msg << "\n\n#{reason.split(", ").map(&:capitalize).join("\n")}" unless reason.strip.empty?
msg << "\n\nYou have added to the Gemfile:\n" << added.join("\n") if added.any?
msg << "\n\nYou have deleted from the Gemfile:\n" << deleted.join("\n") if deleted.any?
msg << "\n\nYou have changed in the Gemfile:\n" << changed.join("\n") if changed.any?
msg << "\n"
raise ProductionError, msg if added.any? || deleted.any? || changed.any? || !nothing_changed?
end
|
#find_indexed_specs(current_spec) ⇒ Object
527
528
529
|
# File 'lib/bundler/definition.rb', line 527
def find_indexed_specs(current_spec)
index[current_spec.name].select {|spec| spec.match_platform(current_spec.platform) }.sort_by(&:version)
end
|
#find_resolved_spec(current_spec) ⇒ Object
523
524
525
|
# File 'lib/bundler/definition.rb', line 523
def find_resolved_spec(current_spec)
specs.find_by_name_and_platform(current_spec.name, current_spec.platform)
end
|
#groups ⇒ Object
319
320
321
|
# File 'lib/bundler/definition.rb', line 319
def groups
dependencies.map(&:groups).flatten.uniq
end
|
#has_local_dependencies? ⇒ Boolean
311
312
313
|
# File 'lib/bundler/definition.rb', line 311
def has_local_dependencies?
!sources.path_sources.empty? || !sources.git_sources.empty?
end
|
#has_rubygems_remotes? ⇒ Boolean
307
308
309
|
# File 'lib/bundler/definition.rb', line 307
def has_rubygems_remotes?
sources.rubygems_sources.any? {|s| s.remotes.any? }
end
|
#index ⇒ Object
263
264
265
266
267
268
269
270
271
272
273
274
275
|
# File 'lib/bundler/definition.rb', line 263
def index
@index ||= Index.build do |idx|
dependency_names = @dependencies.map(&:name)
sources.all_sources.each do |source|
source.dependency_names = dependency_names - pinned_spec_names(source)
idx.add_source source.specs
dependency_names.concat(source.unmet_deps).uniq!
end
double_check_for_index(idx, dependency_names)
end
end
|
#lock(file, preserve_unknown_sections = false) ⇒ Object
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
|
# File 'lib/bundler/definition.rb', line 323
def lock(file, preserve_unknown_sections = false)
contents = to_lock
contents.gsub!(/\n/, "\r\n") if @lockfile_contents.match("\r\n")
if @locked_bundler_version
locked_major = @locked_bundler_version.segments.first
current_major = Gem::Version.create(Bundler::VERSION).segments.first
if updating_major = locked_major < current_major
Bundler.ui.warn "Warning: the lockfile is being updated to Bundler #{current_major}, " \
"after which you will be unable to return to Bundler #{@locked_bundler_version.segments.first}."
end
end
preserve_unknown_sections ||= !updating_major && (Bundler.frozen_bundle? || !(unlocking? || @unlocking_bundler))
return if file && File.exist?(file) && lockfiles_equal?(@lockfile_contents, contents, preserve_unknown_sections)
if Bundler.frozen_bundle?
Bundler.ui.error "Cannot write a changed lockfile while frozen."
return
end
SharedHelpers.filesystem_access(file) do |p|
File.open(p, "wb") {|f| f.puts(contents) }
end
end
|
#locked_bundler_version ⇒ Object
354
355
356
357
358
359
360
|
# File 'lib/bundler/definition.rb', line 354
def locked_bundler_version
if @locked_bundler_version && @locked_bundler_version < Gem::Version.new(Bundler::VERSION)
new_version = Bundler::VERSION
end
new_version || @locked_bundler_version || Bundler::VERSION
end
|
#locked_ruby_version ⇒ Object
362
363
364
365
366
367
368
369
|
# File 'lib/bundler/definition.rb', line 362
def locked_ruby_version
return unless ruby_version
if @unlock[:ruby] || !@locked_ruby_version
Bundler::RubyVersion.system
else
@locked_ruby_version
end
end
|
#locked_ruby_version_object ⇒ Object
371
372
373
374
375
376
377
378
379
380
381
|
# File 'lib/bundler/definition.rb', line 371
def locked_ruby_version_object
return unless @locked_ruby_version
@locked_ruby_version_object ||= begin
unless version = RubyVersion.from_string(@locked_ruby_version)
raise LockfileError, "The Ruby version #{@locked_ruby_version} from " \
"#{@lockfile} could not be parsed. " \
"Try running bundle update --ruby to resolve this."
end
version
end
end
|
#missing_specs ⇒ Object
202
203
204
205
206
|
# File 'lib/bundler/definition.rb', line 202
def missing_specs
missing = []
resolve.materialize(requested_dependencies, missing)
missing
end
|
#missing_specs? ⇒ Boolean
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
# File 'lib/bundler/definition.rb', line 208
def missing_specs?
missing = missing_specs
return false if missing.empty?
Bundler.ui.debug "The definition is missing #{missing.map(&:full_name)}"
true
rescue BundlerError => e
@index = nil
@resolve = nil
@specs = nil
@gem_version_promoter = create_gem_version_promoter
Bundler.ui.debug "The definition is missing dependencies, failed to resolve & materialize locally (#{e})"
true
end
|
198
199
200
|
# File 'lib/bundler/definition.rb', line 198
def new_platform?
@new_platform
end
|
#new_specs ⇒ Object
190
191
192
|
# File 'lib/bundler/definition.rb', line 190
def new_specs
specs - @locked_specs
end
|
#nothing_changed? ⇒ Boolean
534
535
536
|
# File 'lib/bundler/definition.rb', line 534
def nothing_changed?
!@source_changes && !@dependency_changes && !@new_platform && !@path_changes && !@local_changes && !@locked_specs_incomplete_for_platform
end
|
512
513
514
515
|
# File 'lib/bundler/definition.rb', line 512
def remove_platform(platform)
return if @platforms.delete(Gem::Platform.new(platform))
raise InvalidOption, "Unable to remove the platform `#{platform}` since the only platforms are #{@platforms.join ", "}"
end
|
#removed_specs ⇒ Object
194
195
196
|
# File 'lib/bundler/definition.rb', line 194
def removed_specs
@locked_specs - specs
end
|
#requested_specs ⇒ Object
223
224
225
226
227
228
229
|
# File 'lib/bundler/definition.rb', line 223
def requested_specs
@requested_specs ||= begin
groups = requested_groups
groups.map!(&:to_sym)
specs_for(groups)
end
end
|
Resolve all the dependencies specified in Gemfile. It ensures that dependencies that have been already resolved via locked file and are fresh are reused when resolving dependencies
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
|
# File 'lib/bundler/definition.rb', line 246
def resolve
@resolve ||= begin
last_resolve = converge_locked_specs
if Bundler.frozen_bundle?
Bundler.ui.debug "Frozen, using resolution from the lockfile"
last_resolve
elsif !unlocking? && nothing_changed?
Bundler.ui.debug("Found no changes, using resolution from the lockfile")
last_resolve
else
Bundler.ui.debug("Found changes from the lockfile, re-resolving dependencies because #{change_reason}")
last_resolve.merge Resolver.resolve(expanded_dependencies, index, source_requirements, last_resolve, gem_version_promoter, additional_base_requirements_for_resolve, platforms)
end
end
end
|
#resolve_remotely! ⇒ Object
155
156
157
158
159
160
|
# File 'lib/bundler/definition.rb', line 155
def resolve_remotely!
raise "Specs already loaded" if @specs
@remote = true
sources.remote!
specs
end
|
#resolve_with_cache! ⇒ Object
149
150
151
152
153
|
# File 'lib/bundler/definition.rb', line 149
def resolve_with_cache!
raise "Specs already loaded" if @specs
sources.cached!
specs
end
|
#spec_git_paths ⇒ Object
315
316
317
|
# File 'lib/bundler/definition.rb', line 315
def spec_git_paths
sources.git_sources.map {|s| s.path.to_s }
end
|
For given dependency list returns a SpecSet with Gemspec of all the required dependencies.
1. The method first resolves the dependencies specified in Gemfile
2. After that it tries and fetches gemspec of resolved dependencies
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
# File 'lib/bundler/definition.rb', line 168
def specs
@specs ||= begin
begin
specs = resolve.materialize(Bundler.settings[:cache_all_platforms] ? dependencies : requested_dependencies)
rescue GemNotFound => e gem_name, gem_version = (e)
locked_gem = @locked_specs[gem_name].last
raise if locked_gem.nil? || locked_gem.version.to_s != gem_version || !@remote
raise GemNotFound, "Your bundle is locked to #{locked_gem}, but that version could not " \
"be found in any of the sources listed in your Gemfile. If you haven't changed sources, " \
"that means the author of #{locked_gem} has removed it. You'll need to update your bundle " \
"to a version other than #{locked_gem} that hasn't been removed in order to install."
end
unless specs["bundler"].any?
bundler = sources.metadata_source.specs.search(Gem::Dependency.new("bundler", VERSION)).last
specs["bundler"] = bundler
end
specs
end
end
|
#specs_for(groups) ⇒ Object
235
236
237
238
239
|
# File 'lib/bundler/definition.rb', line 235
def specs_for(groups)
deps = dependencies.select {|d| (d.groups & groups).any? }
deps.delete_if {|d| !d.should_include? }
specs.for(expand_dependencies(deps))
end
|
#to_lock ⇒ Object
383
384
385
386
|
# File 'lib/bundler/definition.rb', line 383
def to_lock
require "bundler/lockfile_generator"
LockfileGenerator.generate(self)
end
|
#unlocking? ⇒ Boolean
538
539
540
|
# File 'lib/bundler/definition.rb', line 538
def unlocking?
@unlocking
end
|
495
496
497
498
499
500
501
502
503
504
505
|
# File 'lib/bundler/definition.rb', line 495
def validate_platforms!
return if @platforms.any? do |bundle_platform|
Bundler.rubygems.platforms.any? do |local_platform|
MatchPlatform.platforms_match?(bundle_platform, local_platform)
end
end
raise ProductionError, "Your bundle only supports platforms #{@platforms.map(&:to_s)} " \
"but your local platforms are #{Bundler.rubygems.platforms.map(&:to_s)}, and " \
"there's no compatible match between those two lists."
end
|
#validate_ruby! ⇒ Object
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
|
# File 'lib/bundler/definition.rb', line 470
def validate_ruby!
return unless ruby_version
if diff = ruby_version.diff(Bundler::RubyVersion.system)
problem, expected, actual = diff
msg = case problem
when :engine
"Your Ruby engine is #{actual}, but your Gemfile specified #{expected}"
when :version
"Your Ruby version is #{actual}, but your Gemfile specified #{expected}"
when :engine_version
"Your #{Bundler::RubyVersion.system.engine} version is #{actual}, but your Gemfile specified #{ruby_version.engine} #{expected}"
when :patchlevel
if !expected.is_a?(String)
"The Ruby patchlevel in your Gemfile must be a string"
else
"Your Ruby patchlevel is #{actual}, but your Gemfile specified #{expected}"
end
end
raise RubyVersionMismatch, msg
end
end
|
#validate_runtime! ⇒ Object
465
466
467
468
|
# File 'lib/bundler/definition.rb', line 465
def validate_runtime!
validate_ruby!
validate_platforms!
end
|