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
|
require 'tsort'
module Bundler
class SpecSet
include TSort, Enumerable
def initialize(specs)
@specs = specs.sort_by { |s| s.name }
end
def each
sorted.each { |s| yield s }
end
def length
@specs.length
end
def for(dependencies, skip = [], check = false, match_current_platform = false)
handled, deps, specs = {}, dependencies.dup, []
skip << 'bundler'
until deps.empty?
dep = deps.shift
next if handled[dep] || skip.include?(dep.name)
spec = lookup[dep.name].find do |s|
match_current_platform ?
Gem::Platform.match(s.platform) :
s.match_platform(dep.__platform)
end
handled[dep] = true
if spec
specs << spec
spec.dependencies.each do |d|
next if d.type == :development
d = DepProxy.new(d, dep.__platform) unless match_current_platform
deps << d
end
elsif check
return false
end
end
if spec = lookup['bundler'].first
specs << spec
end
check ? true : SpecSet.new(specs)
end
def valid_for?(deps)
self.for(deps, [], true)
end
def [](key)
key = key.name if key.respond_to?(:name)
lookup[key].reverse
end
def []=(key, value)
@specs << value
@lookup = nil
@sorted = nil
value
end
def to_a
sorted.dup
end
def to_hash
lookup.dup
end
def materialize(deps, missing_specs = nil)
materialized = self.for(deps, [], false, true).to_a
materialized.map! do |s|
next s unless s.is_a?(LazySpecification)
spec = s.__materialize__
if missing_specs
missing_specs << s unless spec
else
raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec
end
spec if spec
end
SpecSet.new(materialized.compact)
end
def merge(set)
arr = sorted.dup
set.each do |s|
next if arr.any? { |s2| s2.name == s.name && s2.version == s.version && s2.platform == s.platform }
arr << s
end
SpecSet.new(arr)
end
private
def sorted
rake = @specs.find { |s| s.name == 'rake' }
@sorted ||= ([rake] + tsort).compact.uniq
end
def lookup
@lookup ||= begin
lookup = Hash.new { |h,k| h[k] = [] }
specs = @specs.sort_by do |s|
s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s
end
specs.reverse_each do |s|
lookup[s.name] << s
end
lookup
end
end
def tsort_each_node
@specs.each { |s| yield s }
end
def tsort_each_child(s)
s.dependencies.sort_by { |d| d.name }.each do |d|
next if d.type == :development
lookup[d.name].each { |s2| yield s2 }
end
end
end
end
|