dependabot-gradle 0.404.0 → 0.405.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: a935f6b3fea9a72c31647c687d6c10f424092df8b33e70c0ddd4b839ba8d238c
4
- data.tar.gz: 993fbbfef6de18414f8b7e0bf6d9796fb5284d370d76e0275aa38f5e469ed611
3
+ metadata.gz: 23b2f64e7bfd7fbe66f210d89e04723c85787439352a918256b4f5bec91d7397
4
+ data.tar.gz: b7dbc1f70f0c1cd6b1a446b06feb71171cb73d627b279595db5afb99e7b2c7b2
5
5
  SHA512:
6
- metadata.gz: a245d1f9a234b9163d300bc3398f561d50a7bcf29ce1a7e8b08a259bf9d00f59f1b06e35f1454e735e83536cc0379a2095b2ffe15c66c2515c1f3735ce7248dd
7
- data.tar.gz: 2b5be0715e6134ffa0bfa01189fe71c8e41fae18b5b54047bdf85b3fff00ccf58efcc907573efd435d66063d7bc65201a9f5db6158e8b6a76efcd341e05c5cf2
6
+ metadata.gz: d0cf5a5f95ac854986d974d1a1e7f874094be1259d41e47e07579b8e44a8b0130d56bd5014ca44df388b1970ea82ef612d4012b2188e06cc1c118b103e03bd28
7
+ data.tar.gz: 84d8cdc10c8b84da2fdaa700a166c01fbb6c6b5a2748a8ac745467e7771b2067be50bfc9ef3bdc9d96aed2699c5e3e0e73d9cfd7d95cf51fb31dcb932a9c08a8
@@ -26,6 +26,27 @@ module Dependabot
26
26
  paths.uniq
27
27
  end
28
28
 
29
+ sig { returns(T::Array[String]) }
30
+ def version_catalog_paths
31
+ content = settings_file.content
32
+ return [] unless content
33
+
34
+ masked = FileParser.mask_literals_and_comments(content, kotlin: settings_file.name.end_with?(".kts"))
35
+ catalog_blocks = masked.to_enum(:scan, version_catalogs_block_regex).map do
36
+ match = T.must(Regexp.last_match)
37
+ match.begin(0)..(match.end(0) + closing_bracket_index(T.must(masked[match.end(0)..])))
38
+ end
39
+
40
+ paths = content.to_enum(:scan, catalog_file_path_regex).filter_map do
41
+ match = T.must(Regexp.last_match)
42
+ start = match.begin(0)
43
+ next unless masked[start, 4] == "from" && catalog_blocks.any? { |block| block.cover?(start) }
44
+
45
+ resolve_catalog_path(T.must(match[:path]))
46
+ end
47
+ paths.uniq
48
+ end
49
+
29
50
  sig { returns(T::Array[T.nilable(String)]) }
30
51
  def subproject_paths
31
52
  subprojects = T.let([], T::Array[String])
@@ -94,6 +115,39 @@ module Dependabot
94
115
  prefixed_proj = Regexp.quote(":#{proj.gsub(/^:/, '')}")
95
116
  /['"]#{prefixed_proj}['"].*dir\s*=.*['"](?<path>.*?)['"]/i
96
117
  end
118
+
119
+ sig { params(path: String).returns(T.nilable(String)) }
120
+ def resolve_catalog_path(path)
121
+ resolved = path.sub(%r{\A\$(?:\{(?:rootDir|settingsDir)\}|rootDir|settingsDir)/}, "")
122
+ resolved unless resolved.include?("$")
123
+ end
124
+
125
+ sig { params(string: String).returns(Integer) }
126
+ def closing_bracket_index(string)
127
+ closes_required = 1
128
+
129
+ string.chars.each_with_index do |char, index|
130
+ closes_required += 1 if char == "{"
131
+ closes_required -= 1 if char == "}"
132
+ return index if closes_required.zero?
133
+ end
134
+
135
+ 0
136
+ end
137
+
138
+ sig { returns(Regexp) }
139
+ def version_catalogs_block_regex
140
+ /\bversionCatalogs\s*(?:\.\s*(?:create|register)\s*\([^)]*\)\s*)?\{/
141
+ end
142
+
143
+ sig { returns(Regexp) }
144
+ def catalog_file_path_regex
145
+ /
146
+ \bfrom\s*\(?\s*files\s*\(?\s*
147
+ (?:layout\s*\.\s*(?:rootDirectory|settingsDirectory)\s*\.\s*file\s*\(\s*)?
148
+ (?<quote>["'])(?<path>[^"']+)\k<quote>
149
+ /x
150
+ end
97
151
  end
98
152
  end
99
153
  end
@@ -31,10 +31,6 @@ module Dependabot
31
31
  gradle/wrapper/gradle-wrapper.properties
32
32
  ).freeze
33
33
 
34
- # For now Gradle only supports library .toml files in the main gradle folder
35
- SUPPORTED_VERSION_CATALOG_FILE_PATH =
36
- %w(/gradle/libs.versions.toml).freeze
37
-
38
34
  PLUGIN_SOURCE_SET_DIRS =
39
35
  %w(src/main/java src/main/kotlin src/main/groovy src/main/resources).freeze
40
36
 
@@ -88,7 +84,7 @@ module Dependabot
88
84
  def all_buildfiles_in_build(root_dir, visited = Set.new)
89
85
  return [] unless visited.add?(root_dir)
90
86
 
91
- files = [buildfile(root_dir), settings_file(root_dir), version_catalog_file(root_dir), lockfile(root_dir),
87
+ files = [buildfile(root_dir), settings_file(root_dir), *version_catalog_files(root_dir), lockfile(root_dir),
92
88
  properties_file(root_dir)]
93
89
  .compact
94
90
  files += wrapper_files(root_dir)
@@ -266,11 +262,28 @@ module Dependabot
266
262
  end
267
263
  end
268
264
 
269
- sig { params(root_dir: String).returns(T.nilable(DependencyFile)) }
270
- def version_catalog_file(root_dir)
271
- return nil unless root_dir == "."
265
+ sig { params(root_dir: String).returns(T::Array[DependencyFile]) }
266
+ def version_catalog_files(root_dir)
267
+ # We only look for version catalogs in the root project, not in included builds.
268
+ return [] unless root_dir == "."
269
+
270
+ paths = [clean_join([root_dir, "gradle", "libs.versions.toml"])]
271
+
272
+ if (settings = settings_file(root_dir))
273
+ parser = SettingsFileParser.new(settings_file: settings)
274
+ paths += parser.version_catalog_paths.filter_map { |p| catalog_path_in_repo(root_dir, p) }
275
+ end
276
+
277
+ paths.uniq.filter_map { |p| fetch_file_if_present(p) }
278
+ end
279
+
280
+ sig { params(root_dir: String, path: String).returns(T.nilable(String)) }
281
+ def catalog_path_in_repo(root_dir, path)
282
+ joined = clean_join([root_dir, path])
283
+ return joined unless path.start_with?("/") || clean_join([".", directory, joined]).start_with?("../")
272
284
 
273
- gradle_toml_file(root_dir)
285
+ Dependabot.logger.warn("Ignoring version catalog path outside the repository: #{path}")
286
+ nil
274
287
  end
275
288
 
276
289
  # rubocop:disable Metrics/PerceivedComplexity
@@ -330,11 +343,6 @@ module Dependabot
330
343
  file
331
344
  end
332
345
 
333
- sig { params(dir: String).returns(T.nilable(DependencyFile)) }
334
- def gradle_toml_file(dir)
335
- find_first(dir, SUPPORTED_VERSION_CATALOG_FILE_PATH)
336
- end
337
-
338
346
  sig { params(dir: String).returns(T.nilable(DependencyFile)) }
339
347
  def settings_file(dir)
340
348
  find_first(dir, SUPPORTED_SETTINGS_FILE_NAMES)
@@ -0,0 +1,75 @@
1
+ # typed: strong
2
+ # frozen_string_literal: true
3
+
4
+ require "dependabot/gradle/file_parser"
5
+
6
+ module Dependabot
7
+ module Gradle
8
+ class FileParser
9
+ class LockfileParser
10
+ extend T::Sig
11
+
12
+ DEPENDENCY_REGEX = /\A(?<name>[^:\s=#]+:[^:\s=]+):(?<version>[^:\s=]+)=(?<configurations>[^\r\n]*)\z/
13
+
14
+ class Entry < T::Struct
15
+ const :name, String
16
+ const :version, String
17
+ const :configurations, T::Array[String]
18
+ end
19
+
20
+ sig { params(lockfile: Dependabot::DependencyFile).void }
21
+ def initialize(lockfile:)
22
+ @lockfile = lockfile
23
+ end
24
+
25
+ sig { returns(T::Array[Entry]) }
26
+ def entries
27
+ T.must(@lockfile.content).lines.filter_map do |line|
28
+ line = line.strip
29
+ next if line.empty? || line.start_with?("#", "empty=")
30
+
31
+ match = DEPENDENCY_REGEX.match(line)
32
+ unless match
33
+ raise Dependabot::DependencyFileNotParseable.new(@lockfile.path, "Invalid Gradle lockfile entry: #{line}")
34
+ end
35
+
36
+ configurations = T.must(match[:configurations]).split(",", -1)
37
+ if configurations.empty? || configurations.any?(&:empty?)
38
+ raise Dependabot::DependencyFileNotParseable.new(@lockfile.path, "Missing locked configurations: #{line}")
39
+ end
40
+
41
+ Entry.new(
42
+ name: T.must(match[:name]),
43
+ version: T.must(match[:version]),
44
+ configurations: configurations
45
+ )
46
+ end
47
+ end
48
+
49
+ sig { returns(T::Array[Dependabot::Dependency]) }
50
+ def parse
51
+ entries.filter_map do |entry|
52
+ unless Gradle::Version.correct?(entry.version)
53
+ Dependabot.logger.warn(
54
+ "Skipping Gradle lockfile dependency #{entry.name}: unsupported version #{entry.version}"
55
+ )
56
+ next
57
+ end
58
+
59
+ Dependabot::Dependency.new(
60
+ name: entry.name,
61
+ version: entry.version,
62
+ package_manager: "gradle",
63
+ requirements: [],
64
+ subdependency_metadata: [{
65
+ file: @lockfile.name,
66
+ version: entry.version,
67
+ configurations: entry.configurations
68
+ }]
69
+ )
70
+ end
71
+ end
72
+ end
73
+ end
74
+ end
75
+ end
@@ -54,6 +54,7 @@ module Dependabot
54
54
  end
55
55
  end
56
56
  repository_urls += own_buildfile_repository_urls
57
+ repository_urls += own_buildfile_repository_urls(lockfile_buildfile) if lockfile?
57
58
  repository_urls += settings_file_repository_urls(top_level_settings_file)
58
59
  repository_urls = repository_urls.uniq
59
60
 
@@ -73,6 +74,11 @@ module Dependabot
73
74
  sig { returns(Dependabot::DependencyFile) }
74
75
  attr_reader :target_dependency_file
75
76
 
77
+ sig { returns(T::Boolean) }
78
+ def lockfile?
79
+ File.basename(target_dependency_file.name) == "gradle.lockfile"
80
+ end
81
+
76
82
  sig { params(dependency_file: T.nilable(Dependabot::DependencyFile)).returns(T::Array[String]) }
77
83
  def inherited_repository_urls(dependency_file)
78
84
  return [] unless dependency_file
@@ -86,7 +92,7 @@ module Dependabot
86
92
  T.must(mtch.post_match[0..closing_bracket_index(mtch.post_match)])
87
93
  end
88
94
 
89
- if top_level_buildfile != target_dependency_file
95
+ if top_level_buildfile != (lockfile? ? lockfile_buildfile : target_dependency_file)
90
96
  buildfile_content.scan(/(?:^|\s)subprojects\s*\{/) do
91
97
  mtch = T.must(Regexp.last_match)
92
98
  subproject_blocks <<
@@ -97,11 +103,11 @@ module Dependabot
97
103
  repository_urls_from(subproject_blocks.join("\n"))
98
104
  end
99
105
 
100
- sig { returns(T::Array[String]) }
101
- def own_buildfile_repository_urls
102
- return [] unless top_level_buildfile
106
+ sig { params(buildfile: T.nilable(Dependabot::DependencyFile)).returns(T::Array[String]) }
107
+ def own_buildfile_repository_urls(buildfile = top_level_buildfile)
108
+ return [] unless buildfile
103
109
 
104
- buildfile_content = comment_free_content(T.must(top_level_buildfile))
110
+ buildfile_content = comment_free_content(buildfile)
105
111
 
106
112
  own_buildfile_urls = T.let([], T::Array[String])
107
113
 
@@ -118,6 +124,14 @@ module Dependabot
118
124
  own_buildfile_urls
119
125
  end
120
126
 
127
+ sig { returns(T.nilable(Dependabot::DependencyFile)) }
128
+ def lockfile_buildfile
129
+ dependency_files.find do |file|
130
+ SUPPORTED_BUILD_FILE_NAMES.include?(File.basename(file.name)) &&
131
+ File.dirname(file.name) == File.dirname(target_dependency_file.name)
132
+ end
133
+ end
134
+
121
135
  sig { params(settings_file: T.nilable(Dependabot::DependencyFile)).returns(T::Array[String]) }
122
136
  def settings_file_repository_urls(settings_file)
123
137
  return [] unless settings_file
@@ -218,7 +232,12 @@ module Dependabot
218
232
  def top_level_buildfile
219
233
  @top_level_buildfile = T.let(
220
234
  @top_level_buildfile || dependency_files.find do |f|
221
- SUPPORTED_BUILD_FILE_NAMES.include?(f.name)
235
+ if lockfile?
236
+ directory = File.dirname(top_level_settings_file&.name || target_dependency_file.name)
237
+ SUPPORTED_BUILD_FILE_NAMES.include?(File.basename(f.name)) && File.dirname(f.name) == directory
238
+ else
239
+ SUPPORTED_BUILD_FILE_NAMES.include?(f.name)
240
+ end
222
241
  end,
223
242
  T.nilable(Dependabot::DependencyFile)
224
243
  )
@@ -227,12 +246,23 @@ module Dependabot
227
246
  sig { returns(T.nilable(Dependabot::DependencyFile)) }
228
247
  def top_level_settings_file
229
248
  @top_level_settings_file = T.let(
230
- @top_level_settings_file || dependency_files.find do |f|
231
- SUPPORTED_SETTINGS_FILE_NAMES.include?(f.name)
232
- end,
249
+ @top_level_settings_file || containing_settings_file,
233
250
  T.nilable(Dependabot::DependencyFile)
234
251
  )
235
252
  end
253
+
254
+ sig { returns(T.nilable(Dependabot::DependencyFile)) }
255
+ def containing_settings_file
256
+ return dependency_files.find { |file| SUPPORTED_SETTINGS_FILE_NAMES.include?(file.name) } unless lockfile?
257
+
258
+ settings_files = dependency_files.select do |file|
259
+ next false unless SUPPORTED_SETTINGS_FILE_NAMES.include?(File.basename(file.name))
260
+
261
+ directory = File.dirname(file.name)
262
+ directory == "." || target_dependency_file.name.start_with?("#{directory}/")
263
+ end
264
+ settings_files.max_by { |file| File.dirname(file.name).length }
265
+ end
236
266
  end
237
267
  end
238
268
  end
@@ -6,6 +6,7 @@ require "toml-rb"
6
6
 
7
7
  require "dependabot/dependency"
8
8
  require "dependabot/ecosystem"
9
+ require "dependabot/experiments"
9
10
  require "dependabot/file_parsers"
10
11
  require "dependabot/file_parsers/base"
11
12
  require "dependabot/shared_helpers"
@@ -27,6 +28,7 @@ module Dependabot
27
28
  require "dependabot/file_parsers/base/dependency_set"
28
29
  require_relative "file_parser/distributions_finder"
29
30
  require_relative "file_parser/property_value_finder"
31
+ require_relative "file_parser/lockfile_parser"
30
32
 
31
33
  SUPPORTED_BUILD_FILE_NAMES = %w(build.gradle build.gradle.kts settings.gradle settings.gradle.kts).freeze
32
34
 
@@ -59,9 +61,12 @@ module Dependabot
59
61
  wrapper_properties_file.each do |properties_file|
60
62
  dependency_set += wrapper_properties_dependencies(properties_file)
61
63
  end
62
- version_catalog_file.each do |toml_file|
64
+ version_catalog_files.each do |toml_file|
63
65
  dependency_set += version_catalog_dependencies(toml_file)
64
66
  end
67
+ if Dependabot::Experiments.enabled?(:gradle_transitive_security_updates)
68
+ add_lockfile_dependencies(dependency_set)
69
+ end
65
70
  dependency_set.dependencies.reject do |dependency|
66
71
  dependency.version == "latest.integration" || dependency.version == "latest.release"
67
72
  end
@@ -735,6 +740,41 @@ module Dependabot
735
740
  )
736
741
  end
737
742
 
743
+ sig { params(dependency_set: DependencySet).void }
744
+ def add_lockfile_dependencies(dependency_set)
745
+ declared_names = dependency_set.dependencies.map { |dep| dep.name.downcase }
746
+ locked = DependencySet.new
747
+ dependency_files.select { |file| File.basename(file.name) == "gradle.lockfile" }.each do |lockfile|
748
+ LockfileParser.new(lockfile: lockfile).parse.each do |dependency|
749
+ locked << dependency unless declared_names.include?(dependency.name.downcase)
750
+ end
751
+ end
752
+ locked.dependencies.each do |dependency|
753
+ versions = locked.all_versions_for_name(dependency.name).map do |version|
754
+ lockfile_dependency(dependency, version.version)
755
+ end
756
+ dependency_set << lockfile_dependency(dependency, dependency.version, versions)
757
+ end
758
+ end
759
+
760
+ sig do
761
+ params(
762
+ dependency: Dependabot::Dependency,
763
+ version: T.nilable(String),
764
+ all_versions: T::Array[Dependabot::Dependency]
765
+ ).returns(Dependabot::Dependency)
766
+ end
767
+ def lockfile_dependency(dependency, version, all_versions = [])
768
+ Dependabot::Dependency.new(
769
+ name: dependency.name,
770
+ version: version,
771
+ package_manager: "gradle",
772
+ requirements: [],
773
+ subdependency_metadata: dependency.subdependency_metadata,
774
+ metadata: all_versions.empty? ? {} : { all_versions: all_versions }
775
+ )
776
+ end
777
+
738
778
  sig { returns(T::Array[Dependabot::DependencyFile]) }
739
779
  def wrapper_properties_file
740
780
  @wrapper_properties_file ||= T.let(
@@ -744,11 +784,9 @@ module Dependabot
744
784
  end
745
785
 
746
786
  sig { returns(T::Array[Dependabot::DependencyFile]) }
747
- def version_catalog_file
748
- @version_catalog_file ||= T.let(
749
- dependency_files.select do |f|
750
- f.name.end_with?("libs.versions.toml")
751
- end,
787
+ def version_catalog_files
788
+ @version_catalog_files ||= T.let(
789
+ dependency_files.reject(&:support_file?).select { |f| f.name.end_with?(".toml") },
752
790
  T.nilable(T::Array[Dependabot::DependencyFile])
753
791
  )
754
792
  end
@@ -0,0 +1,56 @@
1
+ # typed: strong
2
+ # frozen_string_literal: true
3
+
4
+ require "dependabot/gradle/file_updater"
5
+
6
+ module Dependabot
7
+ module Gradle
8
+ class FileUpdater
9
+ class LockfileValidator < LockfileUpdater
10
+ extend T::Sig
11
+
12
+ sig { override.params(build_file: Dependabot::DependencyFile).returns(String) }
13
+ def determine_root_dir(build_file:)
14
+ root = super
15
+ build_src_root = normalized_directory_path(build_file)[%r{\A(.*/buildSrc)(?:/|\z)}, 1]
16
+ return root unless build_src_root && build_src_root.length > root.length
17
+
18
+ build_src_root
19
+ end
20
+
21
+ sig { params(build_file: Dependabot::DependencyFile, validation_script: String).void }
22
+ def validate_lockfiles(build_file, validation_script:)
23
+ root_dir = determine_root_dir(build_file: build_file)
24
+
25
+ SharedHelpers.in_a_temporary_directory do |temp_dir|
26
+ populate_temp_directory(temp_dir)
27
+ cwd = File.join(temp_dir, root_dir.delete_prefix("/"))
28
+ FileUtils.mkdir_p(cwd)
29
+ if File.basename(root_dir) == "buildSrc" &&
30
+ %w(settings.gradle settings.gradle.kts).none? { |name| File.exist?(File.join(cwd, name)) }
31
+ File.write(File.join(cwd, "settings.gradle"), "")
32
+ end
33
+
34
+ init_script_path = File.join(cwd, "dependabot-locking-validation.init.gradle")
35
+ File.write(
36
+ init_script_path,
37
+ "gradle.projectsEvaluated {\n#{compiler_fallback_snippet}\n}\n#{validation_script}"
38
+ )
39
+ command = Shellwords.join(
40
+ [
41
+ gradle_executable_for(cwd: cwd, workspace_root: temp_dir.to_s),
42
+ "--init-script", init_script_path,
43
+ INIT_SCRIPT_TASK_NAME, "--no-daemon"
44
+ ]
45
+ )
46
+ run_lockfile_update_with_retry(
47
+ command: command, cwd: cwd, properties_file_path: File.join(cwd, "gradle.properties")
48
+ )
49
+ end
50
+ rescue SharedHelpers::HelperSubprocessFailed => e
51
+ raise Dependabot::DependencyFileNotResolvable, "Gradle could not resolve the updated lockfile: #{e.message}"
52
+ end
53
+ end
54
+ end
55
+ end
56
+ end
@@ -0,0 +1,183 @@
1
+ # typed: strong
2
+ # frozen_string_literal: true
3
+
4
+ require "base64"
5
+ require "json"
6
+ require "dependabot/gradle/file_updater"
7
+
8
+ module Dependabot
9
+ module Gradle
10
+ class FileUpdater
11
+ class TransitiveDependencyUpdater
12
+ extend T::Sig
13
+
14
+ VALIDATION_SCRIPT = <<~GRADLE
15
+ def validation = new groovy.json.JsonSlurper().parseText(new String("%<data>s".decodeBase64(), "UTF-8"))
16
+ allprojects {
17
+ tasks.create("%<task>s") { }
18
+ }
19
+ gradle.projectsEvaluated {
20
+ if (gradle.parent != null) {
21
+ return
22
+ }
23
+ def remaining = validation.expectations.collect { it }
24
+ gradle.rootProject.allprojects { target ->
25
+ validation.expectations.findAll {
26
+ new File(gradle.rootProject.projectDir, it.directory).canonicalFile == target.projectDir.canonicalFile
27
+ }.each { expected ->
28
+ def configuration = target.configurations.findByName(expected.configuration)
29
+ if (configuration == null || !configuration.canBeResolved ||
30
+ !configuration.resolutionStrategy.dependencyLockingEnabled) {
31
+ throw new GradleException("Cannot validate locked configuration " + expected.configuration)
32
+ }
33
+ def result = configuration.incoming.resolutionResult
34
+ result.allDependencies.each { dependency ->
35
+ if (dependency instanceof org.gradle.api.artifacts.result.UnresolvedDependencyResult) {
36
+ throw new GradleException("Cannot resolve updated lockfile", dependency.failure)
37
+ }
38
+ }
39
+ def selected = result.allComponents.find {
40
+ it.moduleVersion != null &&
41
+ it.moduleVersion.group + ":" + it.moduleVersion.name == validation.name
42
+ }
43
+ if (selected == null || selected.moduleVersion.version != expected.version) {
44
+ throw new GradleException("Updated lockfile did not resolve " + validation.name + ":" + expected.version)
45
+ }
46
+ remaining.remove(expected)
47
+ }
48
+ }
49
+ if (!remaining.isEmpty()) {
50
+ throw new GradleException("Could not validate all updated lockfile configurations")
51
+ }
52
+ }
53
+ GRADLE
54
+
55
+ sig do
56
+ params(
57
+ dependency: Dependabot::Dependency,
58
+ dependency_files: T::Array[Dependabot::DependencyFile],
59
+ vulnerable_versions: T::Array[String],
60
+ repo_contents_path: T.nilable(String)
61
+ ).void
62
+ end
63
+ def initialize(dependency:, dependency_files:, vulnerable_versions:, repo_contents_path: nil)
64
+ @dependency = dependency
65
+ @dependency_files = dependency_files
66
+ @vulnerable_versions = vulnerable_versions
67
+ @repo_contents_path = repo_contents_path
68
+ end
69
+
70
+ sig { params(version: String).returns(T::Array[Dependabot::DependencyFile]) }
71
+ def updated_dependency_files(version:)
72
+ lockfiles = @dependency_files.select do |file|
73
+ File.basename(file.name) == "gradle.lockfile" && target_entries(file).any?
74
+ end
75
+ if lockfiles.empty?
76
+ raise Dependabot::DependencyFileNotResolvable, "No Gradle lockfile contains #{@dependency.name}"
77
+ end
78
+
79
+ updated_lockfiles = lockfiles.map do |file|
80
+ updated_file = file.dup
81
+ updated_file.content = updated_content(file, version)
82
+ updated_file
83
+ end
84
+ validate_lockfiles(updated_lockfiles)
85
+
86
+ updated_lockfiles.reject { |file| @dependency_files.include?(file) }
87
+ end
88
+
89
+ private
90
+
91
+ sig { params(lockfiles: T::Array[Dependabot::DependencyFile]).void }
92
+ def validate_lockfiles(lockfiles)
93
+ replacements = lockfiles.to_h { |file| [file.name, file] }
94
+ files = @dependency_files.map { |file| replacements.fetch(file.name, file) }
95
+ validator = LockfileValidator.new(dependency_files: files, repo_contents_path: @repo_contents_path)
96
+ grouped = lockfiles.group_by { |file| validator.determine_root_dir(build_file: file) }
97
+ grouped.each do |root, root_files|
98
+ validator.validate_lockfiles(
99
+ T.must(root_files.first), validation_script: validation_script(root_files, root, validator)
100
+ )
101
+ end
102
+ end
103
+
104
+ sig { params(file: Dependabot::DependencyFile).returns(T::Array[FileParser::LockfileParser::Entry]) }
105
+ def target_entries(file)
106
+ FileParser::LockfileParser.new(lockfile: file).entries.select do |entry|
107
+ entry.name == @dependency.name && Gradle::Version.correct?(entry.version)
108
+ end
109
+ end
110
+
111
+ sig { params(file: Dependabot::DependencyFile).returns(T::Array[FileParser::LockfileParser::Entry]) }
112
+ def vulnerable_entries(file)
113
+ target_entries(file).select { |entry| @vulnerable_versions.include?(entry.version) }
114
+ end
115
+
116
+ sig { params(match: MatchData, version: String).returns(T::Boolean) }
117
+ def updatable_entry?(match, version)
118
+ match[:name] == @dependency.name && Gradle::Version.correct?(match[:version]) &&
119
+ (@vulnerable_versions.include?(match[:version]) || match[:version] == version)
120
+ end
121
+
122
+ sig { params(file: Dependabot::DependencyFile, version: String).returns(String) }
123
+ def updated_content(file, version)
124
+ return T.must(file.content) if vulnerable_entries(file).empty?
125
+
126
+ configurations = updated_configurations(file, version)
127
+ seen = T.let(Set.new, T::Set[String])
128
+
129
+ T.must(file.content).lines.filter_map do |line|
130
+ match = FileParser::LockfileParser::DEPENDENCY_REGEX.match(line.strip)
131
+ next line unless match && updatable_entry?(match, version)
132
+
133
+ target = target_version(T.must(match[:version]), version)
134
+ next unless seen.add?(target)
135
+
136
+ newline = line.end_with?("\r\n") ? "\r\n" : "\n"
137
+ "#{@dependency.name}:#{target}=#{T.must(configurations[target]).join(',')}#{newline}"
138
+ end.join
139
+ end
140
+
141
+ sig { params(file: Dependabot::DependencyFile, version: String).returns(T::Hash[String, T::Array[String]]) }
142
+ def updated_configurations(file, version)
143
+ configurations = T.let({}, T::Hash[String, T::Array[String]])
144
+ target_entries(file).each do |entry|
145
+ target = target_version(entry.version, version)
146
+ configurations[target] = (configurations.fetch(target, []) + entry.configurations).uniq.sort
147
+ end
148
+ configurations
149
+ end
150
+
151
+ sig { params(current: String, candidate: String).returns(String) }
152
+ def target_version(current, candidate)
153
+ return current unless @vulnerable_versions.include?(current)
154
+
155
+ [Gradle::Version.new(current), Gradle::Version.new(candidate)].max.to_s
156
+ end
157
+
158
+ sig do
159
+ params(
160
+ lockfiles: T::Array[Dependabot::DependencyFile],
161
+ root: String,
162
+ validator: LockfileValidator
163
+ ).returns(String)
164
+ end
165
+ def validation_script(lockfiles, root, validator)
166
+ expectations = lockfiles.flat_map do |file|
167
+ directory = Pathname.new(validator.normalized_directory_path(file))
168
+ .relative_path_from(Pathname.new(root)).to_s
169
+ target_entries(file).flat_map do |entry|
170
+ entry.configurations.map do |configuration|
171
+ { directory: directory, configuration: configuration, version: entry.version }
172
+ end
173
+ end
174
+ end
175
+ # Encoding data separately keeps Gradle coordinates and paths out of executable Groovy syntax.
176
+ data = Base64.strict_encode64(JSON.generate(name: @dependency.name, expectations: expectations))
177
+
178
+ format(VALIDATION_SCRIPT, data: data, task: LockfileUpdater::INIT_SCRIPT_TASK_NAME)
179
+ end
180
+ end
181
+ end
182
+ end
183
+ end
@@ -15,6 +15,8 @@ module Dependabot
15
15
  require_relative "file_updater/dependency_set_updater"
16
16
  require_relative "file_updater/property_value_updater"
17
17
  require_relative "file_updater/lockfile_updater"
18
+ require_relative "file_updater/lockfile_validator"
19
+ require_relative "file_updater/transitive_dependency_updater"
18
20
  require_relative "file_updater/wrapper_updater"
19
21
 
20
22
  SUPPORTED_BUILD_FILE_NAMES = %w(build.gradle build.gradle.kts).freeze
@@ -40,27 +42,54 @@ module Dependabot
40
42
  sig { override.returns(T::Array[::Dependabot::DependencyFile]) }
41
43
  def updated_dependency_files
42
44
  updated_files = buildfiles.dup
45
+ transitive_dependencies =
46
+ if Dependabot::Experiments.enabled?(:gradle_transitive_security_updates)
47
+ dependencies.reject(&:top_level?)
48
+ else
49
+ []
50
+ end
43
51
 
44
52
  # Loop through each of the changed requirements, applying changes to
45
53
  # all buildfiles for that change. Note that the logic is different
46
54
  # here to other languages because Java has property inheritance across
47
55
  # files (although we're not supporting it for gradle yet).
48
- dependencies.each do |dependency|
56
+ (dependencies - transitive_dependencies).each do |dependency|
49
57
  updated_files = update_buildfiles_for_dependency(
50
58
  buildfiles: updated_files,
51
59
  dependency: dependency
52
60
  )
53
61
  end
54
62
 
63
+ # Regenerating locks for direct updates would undo transitive pins applied earlier.
64
+ transitive_dependencies.each do |dependency|
65
+ updated_files = update_transitive_dependency(updated_files, dependency)
66
+ end
67
+
55
68
  updated_files = updated_files.reject { |f| buildfiles.include?(f) }
56
69
 
57
- raise "No files changed!" if updated_files.none?
70
+ raise no_files_changed_error("No files changed!") if updated_files.none?
58
71
 
59
72
  updated_files
60
73
  end
61
74
 
62
75
  private
63
76
 
77
+ sig do
78
+ params(files: T::Array[Dependabot::DependencyFile], dependency: Dependabot::Dependency)
79
+ .returns(T::Array[Dependabot::DependencyFile])
80
+ end
81
+ def update_transitive_dependency(files, dependency)
82
+ updater = TransitiveDependencyUpdater.new(
83
+ dependency: dependency,
84
+ dependency_files: files + dependency_files.select(&:support_file?),
85
+ repo_contents_path: repo_contents_path,
86
+ vulnerable_versions: dependency.metadata_string_array(:vulnerable_versions) ||
87
+ [T.must(dependency.previous_version)]
88
+ )
89
+ updated = updater.updated_dependency_files(version: T.must(dependency.version))
90
+ replace_updated_files(files, updated)
91
+ end
92
+
64
93
  sig { override.void }
65
94
  def check_required_files
66
95
  raise "No build.gradle or build.gradle.kts!" if dependency_files.empty?
@@ -66,6 +66,11 @@ module Dependabot
66
66
 
67
67
  sig { override.returns(String) }
68
68
  def maven_repo_url
69
+ unless dependency.top_level?
70
+ return dependency.source_string("url", allowed_types: ["maven_repo"]) ||
71
+ Gradle::FileParser::RepositoriesFinder::CENTRAL_REPO_URL
72
+ end
73
+
69
74
  requirement = dependency.requirements.find(&:source)
70
75
  return Gradle::FileParser::RepositoriesFinder::CENTRAL_REPO_URL unless requirement
71
76
 
@@ -402,9 +402,9 @@ module Dependabot
402
402
  sig { returns(T::Array[T::Hash[String, Object]]) }
403
403
  def dependency_repository_details
404
404
  requirement_files =
405
- dependency.requirements
406
- .filter_map(&:file)
407
- .map { |nm| dependency_files.find { |f| f.name == nm } }
405
+ (dependency.requirements.filter_map(&:file) +
406
+ (dependency.subdependency_metadata || []).filter_map { |metadata| metadata[:file] })
407
+ .map { |name| dependency_files.find { |file| file.name == name } }
408
408
 
409
409
  @dependency_repository_details ||=
410
410
  requirement_files.flat_map do |target_file|
@@ -14,6 +14,20 @@ module Dependabot
14
14
  require_relative "version_finder"
15
15
  require_relative "requirements_updater"
16
16
 
17
+ sig do
18
+ params(
19
+ requirement: Dependabot::DependencyRequirement,
20
+ other: Dependabot::DependencyRequirement
21
+ ).returns(T::Boolean)
22
+ end
23
+ def self.shared_property?(requirement, other)
24
+ property_name = requirement.metadata_string("property_name")
25
+ return false unless property_name && property_name == other.metadata_string("property_name")
26
+ return true unless [requirement, other].any? { |req| req.file&.end_with?(".toml") }
27
+
28
+ requirement.file == other.file
29
+ end
30
+
17
31
  sig do
18
32
  params(
19
33
  dependency: Dependabot::Dependency,
@@ -48,7 +62,8 @@ module Dependabot
48
62
  @update_possible = T.let(nil, T.nilable(T::Boolean))
49
63
  @updated_dependencies = T.let(nil, T.nilable(T::Array[Dependabot::Dependency]))
50
64
  @dependencies_to_update = T.let(nil, T.nilable(T::Array[Dependabot::Dependency]))
51
- @property_name = T.let(nil, T.nilable(String))
65
+ @property_requirements = T.let(nil, T.nilable(T::Array[Dependabot::DependencyRequirement]))
66
+ @property_names = T.let(nil, T.nilable(T::Array[String]))
52
67
  @dependency_set = T.let(nil, T.nilable(T::Hash[Symbol, String]))
53
68
  @updated_requirements = T.let({}, T::Hash[String, T::Array[Dependabot::DependencyRequirement]])
54
69
  end
@@ -128,20 +143,22 @@ module Dependabot
128
143
  source: nil
129
144
  ).parse.select do |dep|
130
145
  dep.requirements.any? do |r|
131
- tmp_p_name = r.metadata_string("property_name")
132
146
  tmp_dep_set = r.metadata_string_hash("dependency_set")
133
- next true if property_name && tmp_p_name == property_name
147
+ next true if property_requirements.any? { |pr| self.class.shared_property?(r, pr) }
134
148
 
135
149
  dependency_set && tmp_dep_set == dependency_set
136
150
  end
137
151
  end
138
152
  end
139
153
 
140
- sig { returns(T.nilable(String)) }
141
- def property_name
142
- @property_name ||= dependency.requirements
143
- .find { |r| r.metadata_string("property_name") }
144
- &.metadata_string("property_name")
154
+ sig { returns(T::Array[Dependabot::DependencyRequirement]) }
155
+ def property_requirements
156
+ @property_requirements ||= dependency.requirements.select { |r| r.metadata_string("property_name") }
157
+ end
158
+
159
+ sig { returns(T::Array[String]) }
160
+ def property_names
161
+ @property_names ||= property_requirements.filter_map { |r| r.metadata_string("property_name") }
145
162
  end
146
163
 
147
164
  sig { returns(T.nilable(T::Hash[Symbol, String])) }
@@ -158,7 +175,7 @@ module Dependabot
158
175
  requirements: dep.requirements,
159
176
  latest_version: target_version.to_s,
160
177
  source_url: source_url,
161
- properties_to_update: [property_name].compact
178
+ properties_to_update: property_names
162
179
  ).updated_requirements
163
180
  end
164
181
  end
@@ -94,6 +94,14 @@ module Dependabot
94
94
 
95
95
  sig { returns(T.nilable(T::Hash[Symbol, Object])) }
96
96
  def lowest_security_fix_version_details
97
+ release = security_fix_versions.first
98
+ return unless release
99
+
100
+ { version: release.version, source_url: release.url }
101
+ end
102
+
103
+ sig { returns(T::Array[Dependabot::Package::PackageRelease]) }
104
+ def security_fix_versions
97
105
  possible_versions = package_release(versions)
98
106
 
99
107
  possible_versions = filter_prerelease_versions(possible_versions)
@@ -106,16 +114,7 @@ module Dependabot
106
114
  possible_versions = filter_ignored_versions(possible_versions)
107
115
  possible_versions = filter_lower_versions(possible_versions)
108
116
 
109
- return unless possible_versions.any?
110
-
111
- version_min = possible_versions.min_by(&:version)&.version
112
-
113
- url = possible_versions.select do |v| # rubocop:disable Performance/Detect
114
- v.version.to_s == version_min.to_s
115
- end.last&.url
116
-
117
- { version: version_min,
118
- source_url: url }
117
+ possible_versions.reverse.uniq { |release| release.version.to_s }.reverse.sort_by(&:version)
119
118
  end
120
119
 
121
120
  sig { returns(T::Array[T::Hash[Symbol, Object]]) }
@@ -5,6 +5,7 @@ require "sorbet-runtime"
5
5
  require "dependabot/update_checkers"
6
6
  require "dependabot/update_checkers/base"
7
7
  require "dependabot/gradle/file_parser"
8
+ require "dependabot/gradle/file_updater"
8
9
 
9
10
  module Dependabot
10
11
  module Gradle
@@ -24,6 +25,8 @@ module Dependabot
24
25
 
25
26
  sig { override.returns(T.nilable(Dependabot::Version)) }
26
27
  def latest_resolvable_version
28
+ return lowest_resolvable_security_fix_version if transitive_dependency?
29
+
27
30
  # TODO: Resolve the build.gradle to find the latest version we could
28
31
  # update to without updating any other dependencies at the same time.
29
32
  #
@@ -43,6 +46,8 @@ module Dependabot
43
46
 
44
47
  sig { override.returns(T.nilable(Dependabot::Version)) }
45
48
  def lowest_resolvable_security_fix_version
49
+ return transitive_security_fixes.first&.version if transitive_dependency?
50
+
46
51
  return if git_dependency?
47
52
  return nil if version_comes_from_multi_dependency_property?
48
53
  return nil if version_comes_from_dependency_set?
@@ -52,6 +57,8 @@ module Dependabot
52
57
 
53
58
  sig { override.returns(T.nilable(Dependabot::Version)) }
54
59
  def latest_resolvable_version_with_no_unlock
60
+ return lowest_resolvable_security_fix_version if transitive_dependency?
61
+
55
62
  # Irrelevant, since Gradle has a single dependency file.
56
63
  #
57
64
  # For completeness we ought to resolve the build.gradle and return the
@@ -78,13 +85,129 @@ module Dependabot
78
85
 
79
86
  sig { override.returns(T::Boolean) }
80
87
  def requirements_unlocked_or_can_be?
88
+ return false if transitive_dependency?
89
+
81
90
  # If the dependency version come from a property we couldn't
82
91
  # interpolate then there's nothing we can do.
83
92
  !dependency.version&.include?("$")
84
93
  end
85
94
 
95
+ sig { override.returns(T::Boolean) }
96
+ def vulnerable?
97
+ return super unless transitive_dependency?
98
+
99
+ dependency.all_versions.compact.any? do |version|
100
+ security_advisories.any? { |advisory| advisory.affects_version?(version) }
101
+ end
102
+ end
103
+
86
104
  private
87
105
 
106
+ sig { returns(T::Boolean) }
107
+ def transitive_dependency?
108
+ !dependency.top_level? && Dependabot::Experiments.enabled?(:gradle_transitive_security_updates)
109
+ end
110
+
111
+ sig { returns(T::Array[String]) }
112
+ def locked_versions
113
+ versions = (dependency.subdependency_metadata || []).filter_map do |metadata|
114
+ version = metadata[:version]
115
+ version if version.is_a?(String)
116
+ end
117
+ (versions + [dependency.version]).compact.uniq
118
+ end
119
+
120
+ sig { returns(T.nilable(Dependabot::Version)) }
121
+ def highest_vulnerable_version
122
+ vulnerable_locked_versions.map { |version| Gradle::Version.new(version) }.max
123
+ end
124
+
125
+ sig { returns(T::Array[String]) }
126
+ def vulnerable_locked_versions
127
+ locked_versions.select do |version|
128
+ security_advisories.any? { |advisory| advisory.affects_version?(version) }
129
+ end
130
+ end
131
+
132
+ sig { params(version: T.nilable(String)).returns(Dependabot::Dependency) }
133
+ def dependency_for_version_lookup(version: nil)
134
+ return dependency unless transitive_dependency?
135
+
136
+ Dependency.new(
137
+ name: dependency.name,
138
+ version: version || highest_vulnerable_version&.to_s || dependency.version,
139
+ requirements: [],
140
+ package_manager: dependency.package_manager,
141
+ subdependency_metadata: dependency.subdependency_metadata
142
+ )
143
+ end
144
+
145
+ sig { returns(T::Array[Dependabot::Package::PackageRelease]) }
146
+ def transitive_security_fixes
147
+ @transitive_security_fixes ||= T.let(
148
+ resolve_transitive_security_fixes,
149
+ T.nilable(T::Array[Dependabot::Package::PackageRelease])
150
+ )
151
+ end
152
+
153
+ sig { returns(T::Array[Dependabot::Package::PackageRelease]) }
154
+ def resolve_transitive_security_fixes
155
+ return [] unless vulnerable?
156
+
157
+ release = version_finder.security_fix_versions.find do |candidate|
158
+ transitive_security_fix_resolvable?(candidate)
159
+ end
160
+ release ? [release] : []
161
+ end
162
+
163
+ sig { params(release: Dependabot::Package::PackageRelease).returns(T::Boolean) }
164
+ def transitive_security_fix_resolvable?(release)
165
+ compatible = vulnerable_locked_versions.all? do |version|
166
+ finder = version_finder_for(dependency_for_version_lookup(version: version))
167
+ finder.matches_dependency_version_type?(release.version)
168
+ end
169
+ raise Dependabot::DependencyFileNotResolvable, "Incompatible locked version flavors" unless compatible
170
+
171
+ FileUpdater::TransitiveDependencyUpdater.new(
172
+ dependency: dependency,
173
+ dependency_files: dependency_files,
174
+ repo_contents_path: repo_contents_path,
175
+ vulnerable_versions: vulnerable_locked_versions
176
+ ).updated_dependency_files(version: release.version.to_s)
177
+ true
178
+ rescue Dependabot::DependencyFileNotResolvable => e
179
+ Dependabot.logger.info(
180
+ "Cannot update transitive Gradle dependency #{dependency.name} to #{release.version}: #{e.message}"
181
+ )
182
+ false
183
+ end
184
+
185
+ sig { override.returns(Dependabot::Dependency) }
186
+ def updated_dependency_without_unlock
187
+ return super unless transitive_dependency?
188
+
189
+ source = { type: "maven_repo", url: transitive_security_fixes.first&.url }
190
+ Dependency.new(
191
+ name: dependency.name,
192
+ version: lowest_resolvable_security_fix_version&.to_s,
193
+ previous_version: highest_vulnerable_version&.to_s,
194
+ requirements: [],
195
+ previous_requirements: [],
196
+ package_manager: dependency.package_manager,
197
+ metadata: dependency.metadata.merge(vulnerable_versions: vulnerable_locked_versions),
198
+ subdependency_metadata: (dependency.subdependency_metadata || []).map do |metadata|
199
+ metadata.merge(source: source)
200
+ end
201
+ )
202
+ end
203
+
204
+ sig { override.returns(Dependabot::Dependency) }
205
+ def updated_dependency_with_own_req_unlock
206
+ return updated_dependency_without_unlock if transitive_dependency?
207
+
208
+ super
209
+ end
210
+
88
211
  sig { override.returns(T::Boolean) }
89
212
  def latest_version_resolvable_with_full_unlock?
90
213
  unless version_comes_from_multi_dependency_property? ||
@@ -109,6 +232,7 @@ module Dependabot
109
232
 
110
233
  sig { override.params(requirements_to_unlock: T.nilable(Symbol)).returns(T::Boolean) }
111
234
  def numeric_version_can_update?(requirements_to_unlock:)
235
+ return false if transitive_dependency? && !vulnerable?
112
236
  return false unless version_class.correct?(dependency.version)
113
237
 
114
238
  super
@@ -140,19 +264,24 @@ module Dependabot
140
264
  sig { returns(VersionFinder) }
141
265
  def version_finder
142
266
  @version_finder ||= T.let(
143
- VersionFinder.new(
144
- dependency: dependency,
145
- dependency_files: dependency_files,
146
- credentials: credentials,
147
- ignored_versions: ignored_versions,
148
- raise_on_ignored: raise_on_ignored,
149
- cooldown_options: update_cooldown,
150
- security_advisories: security_advisories
151
- ),
267
+ version_finder_for(dependency_for_version_lookup),
152
268
  T.nilable(VersionFinder)
153
269
  )
154
270
  end
155
271
 
272
+ sig { params(lookup_dependency: Dependabot::Dependency).returns(VersionFinder) }
273
+ def version_finder_for(lookup_dependency)
274
+ VersionFinder.new(
275
+ dependency: lookup_dependency,
276
+ dependency_files: dependency_files,
277
+ credentials: credentials,
278
+ ignored_versions: ignored_versions,
279
+ raise_on_ignored: raise_on_ignored,
280
+ cooldown_options: update_cooldown,
281
+ security_advisories: security_advisories
282
+ )
283
+ end
284
+
156
285
  sig { returns(MultiDependencyUpdater) }
157
286
  def multi_dependency_updater
158
287
  @multi_dependency_updater ||= T.let(
@@ -205,9 +334,7 @@ module Dependabot
205
334
  all_property_based_dependencies.any? do |dep|
206
335
  next false if dep.name == dependency.name
207
336
 
208
- dep.requirements.any? do |req|
209
- req.metadata_string("property_name") == property_name
210
- end
337
+ dep.requirements.any? { |req| MultiDependencyUpdater.shared_property?(req, requirement) }
211
338
  end
212
339
  end
213
340
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: dependabot-gradle
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.404.0
4
+ version: 0.405.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Dependabot
@@ -15,28 +15,28 @@ dependencies:
15
15
  requirements:
16
16
  - - '='
17
17
  - !ruby/object:Gem::Version
18
- version: 0.404.0
18
+ version: 0.405.0
19
19
  type: :runtime
20
20
  prerelease: false
21
21
  version_requirements: !ruby/object:Gem::Requirement
22
22
  requirements:
23
23
  - - '='
24
24
  - !ruby/object:Gem::Version
25
- version: 0.404.0
25
+ version: 0.405.0
26
26
  - !ruby/object:Gem::Dependency
27
27
  name: dependabot-maven
28
28
  requirement: !ruby/object:Gem::Requirement
29
29
  requirements:
30
30
  - - '='
31
31
  - !ruby/object:Gem::Version
32
- version: 0.404.0
32
+ version: 0.405.0
33
33
  type: :runtime
34
34
  prerelease: false
35
35
  version_requirements: !ruby/object:Gem::Requirement
36
36
  requirements:
37
37
  - - '='
38
38
  - !ruby/object:Gem::Version
39
- version: 0.404.0
39
+ version: 0.405.0
40
40
  - !ruby/object:Gem::Dependency
41
41
  name: debug
42
42
  requirement: !ruby/object:Gem::Requirement
@@ -261,12 +261,15 @@ files:
261
261
  - lib/dependabot/gradle/file_fetcher/settings_file_parser.rb
262
262
  - lib/dependabot/gradle/file_parser.rb
263
263
  - lib/dependabot/gradle/file_parser/distributions_finder.rb
264
+ - lib/dependabot/gradle/file_parser/lockfile_parser.rb
264
265
  - lib/dependabot/gradle/file_parser/property_value_finder.rb
265
266
  - lib/dependabot/gradle/file_parser/repositories_finder.rb
266
267
  - lib/dependabot/gradle/file_updater.rb
267
268
  - lib/dependabot/gradle/file_updater/dependency_set_updater.rb
268
269
  - lib/dependabot/gradle/file_updater/lockfile_updater.rb
270
+ - lib/dependabot/gradle/file_updater/lockfile_validator.rb
269
271
  - lib/dependabot/gradle/file_updater/property_value_updater.rb
272
+ - lib/dependabot/gradle/file_updater/transitive_dependency_updater.rb
270
273
  - lib/dependabot/gradle/file_updater/wrapper/command_builder.rb
271
274
  - lib/dependabot/gradle/file_updater/wrapper/executing_version_detector.rb
272
275
  - lib/dependabot/gradle/file_updater/wrapper/gradle_version_capabilities.rb
@@ -291,7 +294,7 @@ licenses:
291
294
  - MIT
292
295
  metadata:
293
296
  bug_tracker_uri: https://github.com/dependabot/dependabot-core/issues
294
- changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.404.0
297
+ changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.405.0
295
298
  rdoc_options: []
296
299
  require_paths:
297
300
  - lib