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
|
# frozen_string_literal: true
class Gem::AvailableSet
include Enumerable
Tuple = Struct.new(:spec, :source)
attr_accessor :remote # :nodoc:
def initialize
@set = []
@sorted = nil
@remote = true
end
attr_reader :set
def add(spec, source)
@set << Tuple.new(spec, source)
@sorted = nil
self
end
def <<(o)
case o
when Gem::AvailableSet
s = o.set
when Array
s = o.map do |sp,so|
if !sp.kind_of?(Gem::Specification) or !so.kind_of?(Gem::Source)
raise TypeError, "Array must be in [[spec, source], ...] form"
end
Tuple.new(sp,so)
end
else
raise TypeError, "must be a Gem::AvailableSet"
end
@set += s
@sorted = nil
self
end
##
# Yields each Tuple in this AvailableSet
def each
return enum_for __method__ unless block_given?
@set.each do |tuple|
yield tuple
end
end
##
# Yields the Gem::Specification for each Tuple in this AvailableSet
def each_spec
return enum_for __method__ unless block_given?
each do |tuple|
yield tuple.spec
end
end
def empty?
@set.empty?
end
def all_specs
@set.map {|t| t.spec }
end
def match_platform!
@set.reject! {|t| !Gem::Platform.match(t.spec.platform) }
@sorted = nil
self
end
def sorted
@sorted ||= @set.sort do |a,b|
i = b.spec <=> a.spec
i != 0 ? i : (a.source <=> b.source)
end
end
def size
@set.size
end
def source_for(spec)
f = @set.find {|t| t.spec == spec }
f.source
end
##
# Converts this AvailableSet into a RequestSet that can be used to install
# gems.
#
# If +development+ is :none then no development dependencies are installed.
# Other options are :shallow for only direct development dependencies of the
# gems in this set or :all for all development dependencies.
def to_request_set(development = :none)
request_set = Gem::RequestSet.new
request_set.development = :all == development
each_spec do |spec|
request_set.always_install << spec
request_set.gem spec.name, spec.version
request_set.import spec.development_dependencies if
:shallow == development
end
request_set
end
##
#
# Used by the Resolver, the protocol to use a AvailableSet as a
# search Set.
def find_all(req)
dep = req.dependency
match = @set.find_all do |t|
dep.match? t.spec
end
match.map do |t|
Gem::Resolver::LocalSpecification.new(self, t.spec, t.source)
end
end
def prefetch(reqs)
end
def pick_best!
return self if empty?
@set = [sorted.first]
@sorted = nil
self
end
def remove_installed!(dep)
@set.reject! do |t|
# already locally installed
Gem::Specification.any? do |installed_spec|
dep.name == installed_spec.name and
dep.requirement.satisfied_by? installed_spec.version
end
end
@sorted = nil
self
end
def inject_into_list(dep_list)
@set.each {|t| dep_list.add t.spec }
end
end
|
