1
- # typed: strict
1
+ # typed: strong
2
2
# frozen_string_literal: true
3
3
4
4
require "dependabot/update_checkers/version_filters"
@@ -52,36 +52,68 @@ def package_details_fetcher
52
52
)
53
53
end
54
54
55
- sig { returns ( T :: Array [ T :: Hash [ Symbol , T . untyped ] ] ) }
56
- def versions
57
- package_details_fetcher . versions
55
+ sig { returns ( Dependabot :: Package :: PackageDetails ) }
56
+ def package_details
57
+ package_details_fetcher . package_details
58
58
end
59
59
60
60
sig { returns ( T . nilable ( T ::Hash [ T . untyped , T . untyped ] ) ) }
61
61
def latest_version_details
62
- possible_versions = versions
63
-
62
+ possible_versions = package_details . releases
64
63
possible_versions = filter_prereleases ( possible_versions )
65
64
possible_versions = filter_date_based_versions ( possible_versions )
66
65
possible_versions = filter_version_types ( possible_versions )
67
66
possible_versions = filter_ignored_versions ( possible_versions )
68
67
69
- possible_versions . reverse . find { |v | package_details_fetcher . released? ( v . fetch ( :version ) ) }
68
+ release = possible_versions . reverse . find do |r |
69
+ package_details_fetcher . released? ( r . version . version )
70
+ end
71
+
72
+ return unless release
73
+
74
+ { version : release . version , source_url : release . url }
75
+ end
76
+
77
+ sig do
78
+ params (
79
+ possible_versions : T ::Array [ Dependabot ::Package ::PackageRelease ]
80
+ ) . returns ( T ::Array [ Dependabot ::Package ::PackageRelease ] )
81
+ end
82
+ def filter_vulnerable_versions ( possible_versions )
83
+ return possible_versions if @security_advisories . empty?
84
+
85
+ filtered = possible_versions . reject do |release |
86
+ security_advisories . any? do |advisory |
87
+ advisory . vulnerable? ( release . version )
88
+ end
89
+ end
90
+
91
+ if possible_versions . count > filtered . count
92
+ diff = possible_versions . count - filtered . count
93
+ Dependabot . logger . info ( "Filtered out #{ diff } vulnerable versions" )
94
+ end
95
+
96
+ filtered
70
97
end
71
98
72
99
sig { returns ( T . nilable ( T ::Hash [ T . untyped , T . untyped ] ) ) }
73
100
def lowest_security_fix_version_details
74
- possible_versions = versions
101
+ possible_versions = package_details . releases
75
102
76
103
possible_versions = filter_prereleases ( possible_versions )
77
104
possible_versions = filter_date_based_versions ( possible_versions )
78
105
possible_versions = filter_version_types ( possible_versions )
79
- possible_versions = Dependabot ::UpdateCheckers ::VersionFilters . filter_vulnerable_versions ( possible_versions ,
80
- security_advisories )
106
+ possible_versions = filter_vulnerable_versions ( possible_versions )
81
107
possible_versions = filter_ignored_versions ( possible_versions )
82
108
possible_versions = filter_lower_versions ( possible_versions )
83
109
84
- possible_versions . find { |v | package_details_fetcher . released? ( v . fetch ( :version ) ) }
110
+ release = possible_versions . find do |r |
111
+ package_details_fetcher . released? ( r . version . version )
112
+ end
113
+
114
+ return unless release
115
+
116
+ { version : release . version , source_url : release . url }
85
117
end
86
118
87
119
private
@@ -99,31 +131,42 @@ def lowest_security_fix_version_details
99
131
sig { returns ( T ::Array [ Dependabot ::SecurityAdvisory ] ) }
100
132
attr_reader :security_advisories
101
133
102
- sig { params ( possible_versions : T ::Array [ T . untyped ] ) . returns ( T ::Array [ T . untyped ] ) }
134
+ sig do
135
+ params ( possible_versions : T ::Array [ Dependabot ::Package ::PackageRelease ] )
136
+ . returns ( T ::Array [ Dependabot ::Package ::PackageRelease ] )
137
+ end
103
138
def filter_prereleases ( possible_versions )
104
139
return possible_versions if wants_prerelease?
105
140
106
- filtered = possible_versions . reject { |v | v . fetch ( : version) . prerelease? }
141
+ filtered = possible_versions . reject { |release | release . version . prerelease? }
107
142
if possible_versions . count > filtered . count
108
143
Dependabot . logger . info ( "Filtered out #{ possible_versions . count - filtered . count } pre-release versions" )
109
144
end
110
145
filtered
111
146
end
112
147
113
- sig { params ( possible_versions : T ::Array [ T . untyped ] ) . returns ( T ::Array [ T . untyped ] ) }
148
+ sig do
149
+ params ( possible_versions : T ::Array [ Dependabot ::Package ::PackageRelease ] )
150
+ . returns ( T ::Array [ Dependabot ::Package ::PackageRelease ] )
151
+ end
114
152
def filter_date_based_versions ( possible_versions )
115
153
return possible_versions if wants_date_based_version?
116
154
117
- filtered = possible_versions . reject { |v | v . fetch ( : version) > version_class . new ( 1900 ) }
155
+ filtered = possible_versions . reject { |release | release . version > version_class . new ( 1900 ) }
118
156
if possible_versions . count > filtered . count
119
157
Dependabot . logger . info ( "Filtered out #{ possible_versions . count - filtered . count } date-based versions" )
120
158
end
121
159
filtered
122
160
end
123
161
124
- sig { params ( possible_versions : T ::Array [ T . untyped ] ) . returns ( T ::Array [ T . untyped ] ) }
162
+ sig do
163
+ params ( possible_versions : T ::Array [ Dependabot ::Package ::PackageRelease ] )
164
+ . returns ( T ::Array [ Dependabot ::Package ::PackageRelease ] )
165
+ end
125
166
def filter_version_types ( possible_versions )
126
- filtered = possible_versions . select { |v | matches_dependency_version_type? ( v . fetch ( :version ) ) }
167
+ filtered = possible_versions . select do |release |
168
+ matches_dependency_version_type? ( release . version )
169
+ end
127
170
if possible_versions . count > filtered . count
128
171
diff = possible_versions . count - filtered . count
129
172
classifier = dependency . version &.split ( /[.\- ]/ ) &.last
@@ -132,15 +175,18 @@ def filter_version_types(possible_versions)
132
175
filtered
133
176
end
134
177
135
- sig { params ( possible_versions : T ::Array [ T . untyped ] ) . returns ( T ::Array [ T . untyped ] ) }
178
+ sig do
179
+ params ( possible_versions : T ::Array [ Dependabot ::Package ::PackageRelease ] )
180
+ . returns ( T ::Array [ Dependabot ::Package ::PackageRelease ] )
181
+ end
136
182
def filter_ignored_versions ( possible_versions )
137
183
filtered = possible_versions
138
184
139
185
ignored_versions . each do |req |
140
186
ignore_requirements = Maven ::Requirement . requirements_array ( req )
141
187
filtered =
142
188
filtered
143
- . reject { |v | ignore_requirements . any? { |r | r . satisfied_by? ( v . fetch ( : version) ) } }
189
+ . reject { |release | ignore_requirements . any? { |r | r . satisfied_by? ( release . version ) } }
144
190
end
145
191
146
192
if @raise_on_ignored && filter_lower_versions ( filtered ) . empty? &&
@@ -156,12 +202,15 @@ def filter_ignored_versions(possible_versions)
156
202
filtered
157
203
end
158
204
159
- sig { params ( possible_versions : T ::Array [ T . untyped ] ) . returns ( T ::Array [ T . untyped ] ) }
205
+ sig do
206
+ params ( possible_versions : T ::Array [ Dependabot ::Package ::PackageRelease ] )
207
+ . returns ( T ::Array [ Dependabot ::Package ::PackageRelease ] )
208
+ end
160
209
def filter_lower_versions ( possible_versions )
161
210
return possible_versions unless dependency . numeric_version
162
211
163
- possible_versions . select do |v |
164
- v . fetch ( : version) > dependency . numeric_version
212
+ possible_versions . select do |release |
213
+ release . version > dependency . numeric_version
165
214
end
166
215
end
167
216
@@ -179,7 +228,7 @@ def wants_date_based_version?
179
228
T . must ( dependency . numeric_version ) >= version_class . new ( 100 )
180
229
end
181
230
182
- sig { params ( comparison_version : Version ) . returns ( T ::Boolean ) }
231
+ sig { params ( comparison_version : Dependabot :: Version ) . returns ( T ::Boolean ) }
183
232
def matches_dependency_version_type? ( comparison_version )
184
233
return true unless dependency . version
185
234
0 commit comments