1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
# frozen_string_literal: true
require_relative "vendored_tsort"
module Bundler
class SpecSet
include Enumerable
include TSort
attr_reader :incomplete_specs
def initialize(specs, incomplete_specs = [])
@specs = specs
@incomplete_specs = incomplete_specs
end
def for(dependencies, check = false, platforms = [nil])
handled = ["bundler"].product(platforms).map {|k| [k, true] }.to_h
deps = dependencies.product(platforms)
specs = []
loop do
break unless dep = deps.shift
name = dep[0].name
platform = dep[1]
key = [name, platform]
next if handled.key?(key)
handled[key] = true
specs_for_dep = specs_for_dependency(*dep)
if specs_for_dep.any?
specs.concat(specs_for_dep)
specs_for_dep.first.dependencies.each do |d|
next if d.type == :development
deps << [d, dep[1]]
end
elsif check
@incomplete_specs += lookup[name]
end
end
specs
end
def [](key)
key = key.name if key.respond_to?(:name)
lookup[key].reverse
end
def []=(key, value)
@specs << value
@lookup = nil
@sorted = nil
end
def delete(spec)
@specs.delete(spec)
@lookup = nil
@sorted = nil
end
def sort!
self
end
def to_a
sorted.dup
end
def to_hash
lookup.dup
end
def materialize(deps)
materialized = self.for(deps, true)
SpecSet.new(materialized, incomplete_specs)
end
# Materialize for all the specs in the spec set, regardless of what platform they're for
# This is in contrast to how for does platform filtering (and specifically different from how `materialize` calls `for` only for the current platform)
# @return [Array<Gem::Specification>]
def materialized_for_all_platforms
@specs.map do |s|
next s unless s.is_a?(LazySpecification)
s.source.remote!
spec = s.materialize_for_installation
raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec
spec
end
end
def incomplete_ruby_specs?(deps)
self.for(deps, true, [Gem::Platform::RUBY])
@incomplete_specs.any?
end
def missing_specs
@specs.select {|s| s.is_a?(LazySpecification) }
end
def merge(set)
arr = sorted.dup
set.each do |set_spec|
full_name = set_spec.full_name
next if arr.any? {|spec| spec.full_name == full_name }
arr << set_spec
end
SpecSet.new(arr)
end
def -(other)
SpecSet.new(to_a - other.to_a)
end
def find_by_name_and_platform(name, platform)
@specs.detect {|spec| spec.name == name && spec.match_platform(platform) }
end
def delete_by_name_and_version(name, version)
@specs.reject! {|spec| spec.name == name && spec.version == version }
@lookup = nil
@sorted = nil
end
def what_required(spec)
unless req = find {|s| s.dependencies.any? {|d| d.type == :runtime && d.name == spec.name } }
return [spec]
end
what_required(req) << spec
end
def <<(spec)
@specs << spec
end
def length
@specs.length
end
def size
@specs.size
end
def empty?
@specs.empty?
end
def each(&b)
sorted.each(&b)
end
private
def sorted
rake = @specs.find {|s| s.name == "rake" }
begin
@sorted ||= ([rake] + tsort).compact.uniq
rescue TSort::Cyclic => error
cgems = extract_circular_gems(error)
raise CyclicDependencyError, "Your bundle requires gems that depend" \
" on each other, creating an infinite loop. Please remove either" \
" gem '#{cgems[1]}' or gem '#{cgems[0]}' and try again."
end
end
def extract_circular_gems(error)
error.message.scan(/@name="(.*?)"/).flatten
end
def lookup
@lookup ||= begin
lookup = Hash.new {|h, k| h[k] = [] }
Index.sort_specs(@specs).reverse_each do |s|
lookup[s.name] << s
end
lookup
end
end
def tsort_each_node
# MUST sort by name for backwards compatibility
@specs.sort_by(&:name).each {|s| yield s }
end
def specs_for_dependency(dep, platform)
specs_for_name = lookup[dep.name]
if platform.nil?
matching_specs = specs_for_name.map {|s| s.materialize_for_installation if Gem::Platform.match_spec?(s) }.compact
GemHelpers.sort_best_platform_match(matching_specs, Bundler.local_platform)
else
GemHelpers.select_best_platform_match(specs_for_name, dep.force_ruby_platform ? Gem::Platform::RUBY : platform)
end
end
def tsort_each_child(s)
s.dependencies.sort_by(&:name).each do |d|
next if d.type == :development
lookup[d.name].each {|s2| yield s2 }
end
end
end
end
|
