dependabot-bundler 0.142.1 → 0.143.0

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: c700c6e61d20f58cad008046e123af95e896186351c635fd932b49670b4ddc93
4
- data.tar.gz: 9429cb74a8e944f700327a6587ce56bcb64e65d09fb151c982871c5a086a1b5f
3
+ metadata.gz: 8a0f7290514dce87a5f26d307f8a37a72b726f6d1effb6f0589d91e984fad373
4
+ data.tar.gz: cdd97036823b29855e2db3a12e9fee8bd2fc7bfbe73dcdcb6592318ee8713aa8
5
5
  SHA512:
6
- metadata.gz: a53a4299d18333e66a571a8d9576c497f88b01c8e2c89d3424e7fa27cedc0474c1025ed619b4edd73e1a52627ab28b861c6d04b59c26ce3c8f1d8f1c662f019f
7
- data.tar.gz: 0014b7f705b26846083c2452cf4007c4300aee36b0d2bd2d3fa670e74e752d47b9c1bb25b9ef4f112e51fa43b508b750d31cad5bcab5f2ec8cf00317c6af85f8
6
+ metadata.gz: e2b50e420390fa3dd8cc0dbfb5535d6a2c374efe013af3dcafad6bef65d7790378832f774944e537fe165e75a7e0aae36db65ad70099fa946932e60d9eb9774b
7
+ data.tar.gz: 5fce5f1281efe61160daf5751b1417237df929de90f795a879175a504f8c0909358b20f941398e416c18e14d87583da8c94b35b1af7f99fbfb9701c1f882f6b9
@@ -6,118 +6,97 @@ require "functions/version_resolver"
6
6
  require "functions/conflicting_dependency_resolver"
7
7
 
8
8
  module Functions
9
- def self.parsed_gemfile(lockfile_name:, gemfile_name:, dir:)
10
- set_bundler_flags_and_credentials(dir: dir, credentials: [],
11
- using_bundler2: false)
12
- FileParser.new(lockfile_name: lockfile_name).
13
- parsed_gemfile(gemfile_name: gemfile_name)
9
+ def self.parsed_gemfile(**args)
10
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: [])
11
+ FileParser.new(lockfile_name: args.fetch(:lockfile_name)).
12
+ parsed_gemfile(gemfile_name: args.fetch(:gemfile_name))
14
13
  end
15
14
 
16
- def self.parsed_gemspec(lockfile_name:, gemspec_name:, dir:)
17
- set_bundler_flags_and_credentials(dir: dir, credentials: [],
18
- using_bundler2: false)
19
- FileParser.new(lockfile_name: lockfile_name).
20
- parsed_gemspec(gemspec_name: gemspec_name)
15
+ def self.parsed_gemspec(**args)
16
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: [])
17
+ FileParser.new(lockfile_name: args.fetch(:lockfile_name)).
18
+ parsed_gemspec(gemspec_name: args.fetch(:gemspec_name))
21
19
  end
22
20
 
23
- def self.vendor_cache_dir(dir:)
24
- set_bundler_flags_and_credentials(dir: dir, credentials: [],
25
- using_bundler2: false)
21
+ def self.vendor_cache_dir(**args)
22
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: [])
26
23
  Bundler.app_cache
27
24
  end
28
25
 
29
- def self.update_lockfile(dir:, gemfile_name:, lockfile_name:, using_bundler2:,
30
- credentials:, dependencies:)
31
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
32
- using_bundler2: using_bundler2)
26
+ def self.update_lockfile(**args)
27
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
33
28
  LockfileUpdater.new(
34
- gemfile_name: gemfile_name,
35
- lockfile_name: lockfile_name,
36
- dependencies: dependencies
29
+ gemfile_name: args.fetch(:gemfile_name),
30
+ lockfile_name: args.fetch(:lockfile_name),
31
+ dependencies: args.fetch(:dependencies)
37
32
  ).run
38
33
  end
39
34
 
40
- def self.force_update(dir:, dependency_name:, target_version:, gemfile_name:,
41
- lockfile_name:, using_bundler2:, credentials:,
42
- update_multiple_dependencies:)
43
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
44
- using_bundler2: using_bundler2)
35
+ def self.force_update(**args)
36
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
45
37
  ForceUpdater.new(
46
- dependency_name: dependency_name,
47
- target_version: target_version,
48
- gemfile_name: gemfile_name,
49
- lockfile_name: lockfile_name,
50
- update_multiple_dependencies: update_multiple_dependencies
38
+ dependency_name: args.fetch(:dependency_name),
39
+ target_version: args.fetch(:target_version),
40
+ gemfile_name: args.fetch(:gemfile_name),
41
+ lockfile_name: args.fetch(:lockfile_name),
42
+ update_multiple_dependencies: args.fetch(:update_multiple_dependencies)
51
43
  ).run
52
44
  end
53
45
 
54
- def self.dependency_source_type(gemfile_name:, dependency_name:, dir:,
55
- credentials:)
56
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
57
- using_bundler2: false)
46
+ def self.dependency_source_type(**args)
47
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
58
48
 
59
49
  DependencySource.new(
60
- gemfile_name: gemfile_name,
61
- dependency_name: dependency_name
50
+ gemfile_name: args.fetch(:gemfile_name),
51
+ dependency_name: args.fetch(:dependency_name)
62
52
  ).type
63
53
  end
64
54
 
65
- def self.depencency_source_latest_git_version(gemfile_name:, dependency_name:,
66
- dir:, credentials:,
67
- dependency_source_url:,
68
- dependency_source_branch:)
69
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
70
- using_bundler2: false)
55
+ def self.depencency_source_latest_git_version(**args)
56
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
71
57
  DependencySource.new(
72
- gemfile_name: gemfile_name,
73
- dependency_name: dependency_name
58
+ gemfile_name: args.fetch(:gemfile_name),
59
+ dependency_name: args.fetch(:dependency_name)
74
60
  ).latest_git_version(
75
- dependency_source_url: dependency_source_url,
76
- dependency_source_branch: dependency_source_branch
61
+ dependency_source_url: args.fetch(:dependency_source_url),
62
+ dependency_source_branch: args.fetch(:dependency_source_branch)
77
63
  )
78
64
  end
79
65
 
80
- def self.private_registry_versions(gemfile_name:, dependency_name:, dir:,
81
- credentials:)
82
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
83
- using_bundler2: false)
66
+ def self.private_registry_versions(**args)
67
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
84
68
 
85
69
  DependencySource.new(
86
- gemfile_name: gemfile_name,
87
- dependency_name: dependency_name
70
+ gemfile_name: args.fetch(:gemfile_name),
71
+ dependency_name: args.fetch(:dependency_name)
88
72
  ).private_registry_versions
89
73
  end
90
74
 
91
- def self.resolve_version(dependency_name:, dependency_requirements:,
92
- gemfile_name:, lockfile_name:, using_bundler2:,
93
- dir:, credentials:)
94
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
95
- using_bundler2: using_bundler2)
75
+ def self.resolve_version(**args)
76
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
96
77
  VersionResolver.new(
97
- dependency_name: dependency_name,
98
- dependency_requirements: dependency_requirements,
99
- gemfile_name: gemfile_name,
100
- lockfile_name: lockfile_name
78
+ dependency_name: args.fetch(:dependency_name),
79
+ dependency_requirements: args.fetch(:dependency_requirements),
80
+ gemfile_name: args.fetch(:gemfile_name),
81
+ lockfile_name: args.fetch(:lockfile_name)
101
82
  ).version_details
102
83
  end
103
84
 
104
- def self.jfrog_source(dir:, gemfile_name:, credentials:, using_bundler2:)
85
+ def self.jfrog_source(**args)
105
86
  # Set flags and credentials
106
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
107
- using_bundler2: using_bundler2)
87
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
108
88
 
109
- Bundler::Definition.build(gemfile_name, nil, {}).
89
+ Bundler::Definition.build(args.fetch(:gemfile_name), nil, {}).
110
90
  send(:sources).
111
91
  rubygems_remotes.
112
92
  find { |uri| uri.host.include?("jfrog") }&.
113
93
  host
114
94
  end
115
95
 
116
- def self.git_specs(dir:, gemfile_name:, credentials:, using_bundler2:)
117
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
118
- using_bundler2: using_bundler2)
96
+ def self.git_specs(**args)
97
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
119
98
 
120
- git_specs = Bundler::Definition.build(gemfile_name, nil, {}).dependencies.
99
+ git_specs = Bundler::Definition.build(args.fetch(:gemfile_name), nil, {}).dependencies.
121
100
  select do |spec|
122
101
  spec.source.is_a?(Bundler::Source::Git)
123
102
  end
@@ -136,8 +115,18 @@ module Functions
136
115
  end
137
116
  end
138
117
 
139
- def self.set_bundler_flags_and_credentials(dir:, credentials:,
140
- using_bundler2:)
118
+ def self.conflicting_dependencies(**args)
119
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
120
+ ConflictingDependencyResolver.new(
121
+ dependency_name: args.fetch(:dependency_name),
122
+ target_version: args.fetch(:target_version),
123
+ lockfile_name: args.fetch(:lockfile_name)
124
+ ).conflicting_dependencies
125
+ end
126
+
127
+ private
128
+
129
+ def self.set_bundler_flags_and_credentials(dir:, credentials:)
141
130
  dir = dir ? Pathname.new(dir) : dir
142
131
  Bundler.instance_variable_set(:@root, dir)
143
132
 
@@ -155,12 +144,6 @@ module Functions
155
144
  token.gsub("@", "%40F").gsub("?", "%3F")
156
145
  )
157
146
  end
158
-
159
- # Use HTTPS for GitHub if lockfile was generated by Bundler 2
160
- if using_bundler2
161
- Bundler.settings.set_command_option("forget_cli_options", "true")
162
- Bundler.settings.set_command_option("github.https", "true")
163
- end
164
147
  end
165
148
 
166
149
  def self.relevant_credentials(credentials)
@@ -179,15 +162,4 @@ module Functions
179
162
  credentials.
180
163
  select { |cred| cred["type"] == "git_source" }
181
164
  end
182
-
183
- def self.conflicting_dependencies(dir:, dependency_name:, target_version:,
184
- lockfile_name:, using_bundler2:, credentials:)
185
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
186
- using_bundler2: using_bundler2)
187
- ConflictingDependencyResolver.new(
188
- dependency_name: dependency_name,
189
- target_version: target_version,
190
- lockfile_name: lockfile_name
191
- ).conflicting_dependencies
192
- end
193
165
  end
@@ -10,115 +10,97 @@ require "functions/version_resolver"
10
10
  module Functions
11
11
  class NotImplementedError < StandardError; end
12
12
 
13
- def self.parsed_gemfile(lockfile_name:, gemfile_name:, dir:)
14
- set_bundler_flags_and_credentials(dir: dir, credentials: [],
15
- using_bundler2: false)
16
- FileParser.new(lockfile_name: lockfile_name).
17
- parsed_gemfile(gemfile_name: gemfile_name)
13
+ def self.parsed_gemfile(**args)
14
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: [])
15
+ FileParser.new(lockfile_name: args.fetch(:lockfile_name)).
16
+ parsed_gemfile(gemfile_name: args.fetch(:gemfile_name))
18
17
  end
19
18
 
20
- def self.parsed_gemspec(lockfile_name:, gemspec_name:, dir:)
21
- set_bundler_flags_and_credentials(dir: dir, credentials: [],
22
- using_bundler2: false)
23
- FileParser.new(lockfile_name: lockfile_name).
24
- parsed_gemspec(gemspec_name: gemspec_name)
19
+ def self.parsed_gemspec(**args)
20
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: [])
21
+ FileParser.new(lockfile_name: args.fetch(:lockfile_name)).
22
+ parsed_gemspec(gemspec_name: args.fetch(:gemspec_name))
25
23
  end
26
24
 
27
- def self.vendor_cache_dir(dir:)
28
- set_bundler_flags_and_credentials(dir: dir, credentials: [],
29
- using_bundler2: false)
25
+ def self.vendor_cache_dir(**args)
26
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: [])
30
27
  Bundler.app_cache
31
28
  end
32
29
 
33
- def self.update_lockfile(dir:, gemfile_name:, lockfile_name:, using_bundler2:,
34
- credentials:, dependencies:)
35
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
36
- using_bundler2: using_bundler2)
30
+ def self.update_lockfile(**args)
31
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
37
32
  LockfileUpdater.new(
38
- gemfile_name: gemfile_name,
39
- lockfile_name: lockfile_name,
40
- dependencies: dependencies
33
+ gemfile_name: args.fetch(:gemfile_name),
34
+ lockfile_name: args.fetch(:lockfile_name),
35
+ dependencies: args.fetch(:dependencies)
41
36
  ).run
42
37
  end
43
38
 
44
- def self.force_update(dir:, dependency_name:, target_version:, gemfile_name:,
45
- lockfile_name:, using_bundler2:, credentials:,
46
- update_multiple_dependencies:)
47
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
48
- using_bundler2: using_bundler2)
39
+ def self.force_update(**args)
40
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
49
41
  ForceUpdater.new(
50
- dependency_name: dependency_name,
51
- target_version: target_version,
52
- gemfile_name: gemfile_name,
53
- lockfile_name: lockfile_name,
54
- update_multiple_dependencies: update_multiple_dependencies
42
+ dependency_name: args.fetch(:dependency_name),
43
+ target_version: args.fetch(:target_version),
44
+ gemfile_name: args.fetch(:gemfile_name),
45
+ lockfile_name: args.fetch(:lockfile_name),
46
+ update_multiple_dependencies: args.fetch(:update_multiple_dependencies)
55
47
  ).run
56
48
  end
57
49
 
58
- def self.dependency_source_type(gemfile_name:, dependency_name:, dir:,
59
- credentials:)
60
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
61
- using_bundler2: false)
50
+ def self.dependency_source_type(**args)
51
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
62
52
 
63
53
  DependencySource.new(
64
- gemfile_name: gemfile_name,
65
- dependency_name: dependency_name
54
+ gemfile_name: args.fetch(:gemfile_name),
55
+ dependency_name: args.fetch(:dependency_name)
66
56
  ).type
67
57
  end
68
58
 
69
- def self.depencency_source_latest_git_version(gemfile_name:, dependency_name:,
70
- dir:, credentials:,
71
- dependency_source_url:,
72
- dependency_source_branch:)
73
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
74
- using_bundler2: false)
59
+ def self.depencency_source_latest_git_version(**args)
60
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
75
61
  DependencySource.new(
76
- gemfile_name: gemfile_name,
77
- dependency_name: dependency_name
62
+ gemfile_name: args.fetch(:gemfile_name),
63
+ dependency_name: args.fetch(:dependency_name)
78
64
  ).latest_git_version(
79
- dependency_source_url: dependency_source_url,
80
- dependency_source_branch: dependency_source_branch
65
+ dependency_source_url: args.fetch(:dependency_source_url),
66
+ dependency_source_branch: args.fetch(:dependency_source_branch)
81
67
  )
82
68
  end
83
69
 
84
- def self.private_registry_versions(gemfile_name:, dependency_name:, dir:,
85
- credentials:)
86
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
87
- using_bundler2: false)
70
+ def self.private_registry_versions(**args)
71
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
88
72
 
89
73
  DependencySource.new(
90
- gemfile_name: gemfile_name,
91
- dependency_name: dependency_name
74
+ gemfile_name: args.fetch(:gemfile_name),
75
+ dependency_name: args.fetch(:dependency_name)
92
76
  ).private_registry_versions
93
77
  end
94
78
 
95
- def self.resolve_version(dependency_name:, dependency_requirements:,
96
- gemfile_name:, lockfile_name:, using_bundler2:,
97
- dir:, credentials:)
98
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials, using_bundler2: using_bundler2)
79
+ def self.resolve_version(**args)
80
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
99
81
  VersionResolver.new(
100
- dependency_name: dependency_name,
101
- dependency_requirements: dependency_requirements,
102
- gemfile_name: gemfile_name,
103
- lockfile_name: lockfile_name
82
+ dependency_name: args.fetch(:dependency_name),
83
+ dependency_requirements: args.fetch(:dependency_requirements),
84
+ gemfile_name: args.fetch(:gemfile_name),
85
+ lockfile_name: args.fetch(:lockfile_name)
104
86
  ).version_details
105
87
  end
106
88
 
107
- def self.jfrog_source(dir:, gemfile_name:, credentials:, using_bundler2:)
108
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials, using_bundler2: using_bundler2)
89
+ def self.jfrog_source(**args)
90
+ # Set flags and credentials
91
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
109
92
 
110
- Bundler::Definition.build(gemfile_name, nil, {}).
93
+ Bundler::Definition.build(args.fetch(:gemfile_name), nil, {}).
111
94
  send(:sources).
112
95
  rubygems_remotes.
113
96
  find { |uri| uri.host.include?("jfrog") }&.
114
97
  host
115
98
  end
116
99
 
117
- def self.git_specs(dir:, gemfile_name:, credentials:, using_bundler2:)
118
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
119
- using_bundler2: using_bundler2)
100
+ def self.git_specs(**args)
101
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
120
102
 
121
- git_specs = Bundler::Definition.build(gemfile_name, nil, {}).dependencies.
103
+ git_specs = Bundler::Definition.build(args.fetch(:gemfile_name), nil, {}).dependencies.
122
104
  select do |spec|
123
105
  spec.source.is_a?(Bundler::Source::Git)
124
106
  end
@@ -137,8 +119,18 @@ module Functions
137
119
  end
138
120
  end
139
121
 
140
- def self.set_bundler_flags_and_credentials(dir:, credentials:,
141
- using_bundler2:)
122
+ def self.conflicting_dependencies(**args)
123
+ set_bundler_flags_and_credentials(dir: args.fetch(:dir), credentials: args.fetch(:credentials))
124
+ ConflictingDependencyResolver.new(
125
+ dependency_name: args.fetch(:dependency_name),
126
+ target_version: args.fetch(:target_version),
127
+ lockfile_name: args.fetch(:lockfile_name)
128
+ ).conflicting_dependencies
129
+ end
130
+
131
+ private
132
+
133
+ def self.set_bundler_flags_and_credentials(dir:, credentials:)
142
134
  dir = dir ? Pathname.new(dir) : dir
143
135
  Bundler.instance_variable_set(:@root, dir)
144
136
 
@@ -181,15 +173,4 @@ module Functions
181
173
  credentials.
182
174
  select { |cred| cred["type"] == "git_source" }
183
175
  end
184
-
185
- def self.conflicting_dependencies(dir:, dependency_name:, target_version:,
186
- lockfile_name:, using_bundler2:, credentials:)
187
- set_bundler_flags_and_credentials(dir: dir, credentials: credentials,
188
- using_bundler2: using_bundler2)
189
- ConflictingDependencyResolver.new(
190
- dependency_name: dependency_name,
191
- target_version: target_version,
192
- lockfile_name: lockfile_name
193
- ).conflicting_dependencies
194
- end
195
176
  end
@@ -15,7 +15,6 @@ RSpec.describe Functions do
15
15
  dir: tmp_path,
16
16
  gemfile_name: "Gemfile",
17
17
  credentials: {},
18
- using_bundler2: true
19
18
  )
20
19
 
21
20
  expect(jfrog_source).to eq("test.jfrog.io")
@@ -72,7 +72,6 @@ module Dependabot
72
72
  args: {
73
73
  gemfile_name: gemfile.name,
74
74
  lockfile_name: lockfile.name,
75
- using_bundler2: using_bundler2?,
76
75
  dir: tmp_dir,
77
76
  credentials: credentials,
78
77
  dependencies: dependencies.map(&:to_h)
@@ -298,12 +297,6 @@ module Dependabot
298
297
  dependency_files.select { |f| f.name.end_with?(".specification") }
299
298
  end
300
299
 
301
- def using_bundler2?
302
- return unless lockfile
303
-
304
- lockfile.content.match?(/BUNDLED WITH\s+2/m)
305
- end
306
-
307
300
  def bundler_version
308
301
  @bundler_version ||= Helpers.bundler_version(lockfile)
309
302
  end
@@ -16,7 +16,7 @@ module Dependabot
16
16
  # "~> 4.2.5, >= 4.2.5.1" without first needing to split them.
17
17
  def initialize(*requirements)
18
18
  requirements = requirements.flatten.flat_map do |req_string|
19
- req_string.split(",")
19
+ req_string.split(",").map(&:strip)
20
20
  end
21
21
 
22
22
  super(requirements)
@@ -41,7 +41,6 @@ module Dependabot
41
41
  target_version: target_version,
42
42
  credentials: credentials,
43
43
  lockfile_name: lockfile.name,
44
- using_bundler2: using_bundler2?
45
44
  }
46
45
  )
47
46
  end
@@ -57,7 +57,6 @@ module Dependabot
57
57
  credentials: credentials,
58
58
  gemfile_name: gemfile.name,
59
59
  lockfile_name: lockfile.name,
60
- using_bundler2: using_bundler2?,
61
60
  update_multiple_dependencies: update_multiple_dependencies?
62
61
  }
63
62
  )
@@ -145,12 +144,6 @@ module Dependabot
145
144
  File.write(lockfile.name, sanitized_lockfile_body) if lockfile
146
145
  end
147
146
 
148
- def using_bundler2?
149
- return unless lockfile
150
-
151
- lockfile.content.match?(/BUNDLED WITH\s+2/m)
152
- end
153
-
154
147
  def bundler_version
155
148
  @bundler_version ||= Helpers.bundler_version(lockfile)
156
149
  end
@@ -70,7 +70,7 @@ module Dependabot
70
70
 
71
71
  def filter_ignored_versions(versions_array)
72
72
  filtered = versions_array.
73
- reject { |v| ignore_reqs.any? { |r| r.satisfied_by?(v) } }
73
+ reject { |v| ignore_requirements.any? { |r| r.satisfied_by?(v) } }
74
74
  raise AllVersionsIgnored if @raise_on_ignored && filtered.empty? && versions_array.any?
75
75
 
76
76
  filtered
@@ -110,8 +110,8 @@ module Dependabot
110
110
  )
111
111
  end
112
112
 
113
- def ignore_reqs
114
- ignored_versions.map { |req| Gem::Requirement.new(req.split(",")) }
113
+ def ignore_requirements
114
+ ignored_versions.flat_map { |req| requirement_class.requirements_array(req) }
115
115
  end
116
116
 
117
117
  def gemfile
@@ -171,7 +171,6 @@ module Dependabot
171
171
  dir: tmp_dir,
172
172
  gemfile_name: gemfile.name,
173
173
  credentials: credentials,
174
- using_bundler2: using_bundler2?
175
174
  }
176
175
  )
177
176
  git_specs.reject do |spec|
@@ -197,7 +196,6 @@ module Dependabot
197
196
  dir: dir,
198
197
  gemfile_name: gemfile.name,
199
198
  credentials: credentials,
200
- using_bundler2: using_bundler2?
201
199
  }
202
200
  )
203
201
  end
@@ -233,12 +231,6 @@ module Dependabot
233
231
  re = FileUpdater::LockfileUpdater::LOCKFILE_ENDING
234
232
  lockfile.content.gsub(re, "")
235
233
  end
236
-
237
- def using_bundler2?
238
- return unless lockfile
239
-
240
- lockfile.content.match?(/BUNDLED WITH\s+2/m)
241
- end
242
234
  end
243
235
  end
244
236
  end
@@ -87,7 +87,6 @@ module Dependabot
87
87
  dependency_requirements: dependency.requirements,
88
88
  gemfile_name: gemfile.name,
89
89
  lockfile_name: lockfile&.name,
90
- using_bundler2: using_bundler2?,
91
90
  dir: tmp_dir,
92
91
  credentials: credentials
93
92
  }
@@ -218,12 +217,6 @@ module Dependabot
218
217
  dependency_files.find { |f| f.name == "gems.locked" }
219
218
  end
220
219
 
221
- def using_bundler2?
222
- return unless lockfile
223
-
224
- lockfile.content.match?(/BUNDLED WITH\s+2/m)
225
- end
226
-
227
220
  def bundler_version
228
221
  @bundler_version ||= Helpers.bundler_version(lockfile)
229
222
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: dependabot-bundler
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.142.1
4
+ version: 0.143.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Dependabot
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2021-04-16 00:00:00.000000000 Z
11
+ date: 2021-04-21 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: dependabot-common
@@ -16,14 +16,14 @@ dependencies:
16
16
  requirements:
17
17
  - - '='
18
18
  - !ruby/object:Gem::Version
19
- version: 0.142.1
19
+ version: 0.143.0
20
20
  type: :runtime
21
21
  prerelease: false
22
22
  version_requirements: !ruby/object:Gem::Requirement
23
23
  requirements:
24
24
  - - '='
25
25
  - !ruby/object:Gem::Version
26
- version: 0.142.1
26
+ version: 0.143.0
27
27
  - !ruby/object:Gem::Dependency
28
28
  name: byebug
29
29
  requirement: !ruby/object:Gem::Requirement
@@ -100,14 +100,14 @@ dependencies:
100
100
  requirements:
101
101
  - - "~>"
102
102
  - !ruby/object:Gem::Version
103
- version: 1.12.0
103
+ version: 1.13.0
104
104
  type: :development
105
105
  prerelease: false
106
106
  version_requirements: !ruby/object:Gem::Requirement
107
107
  requirements:
108
108
  - - "~>"
109
109
  - !ruby/object:Gem::Version
110
- version: 1.12.0
110
+ version: 1.13.0
111
111
  - !ruby/object:Gem::Dependency
112
112
  name: simplecov
113
113
  requirement: !ruby/object:Gem::Requirement