Add a task that checks for dependency version upgrades

Author: jjohannes

gradle/plugins/src/main/kotlin/org.example.gradle.check.dependency-versions.gradle.kts

@@ -1,3 +1,4 @@
+import org.example.gradle.tasks.DependencyVersionUpgradesCheck
 import org.example.gradle.tasks.JavaVersionConsistencyCheck
 
 plugins { id("java-platform") }
@@ -14,3 +15,32 @@ tasks.register<JavaVersionConsistencyCheck>("checkVersionConsistency") {
 tasks.named("qualityCheck") { dependsOn(tasks.named("checkVersionConsistency")) }
 
 tasks.named("qualityGate") { dependsOn(tasks.named("checkVersionConsistency")) }
+
+val latestReleases =
+    configurations.dependencyScope("dependencyVersionUpgrades") {
+        withDependencies {
+            add(project.dependencies.platform(project(project.path)))
+            configurations.api.get().dependencies.forEach {
+                add(project.dependencies.platform("${it.group}:${it.name}:latest.release") { isTransitive = false })
+            }
+            configurations.api.get().dependencyConstraints.forEach {
+                add(project.dependencies.create("${it.group}:${it.name}:latest.release") { isTransitive = false })
+            }
+        }
+    }
+val latestReleasesPath =
+    configurations.resolvable("latestReleasesPath") {
+        attributes.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
+        attributes.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
+        extendsFrom(latestReleases.get())
+    }
+
+tasks.register<DependencyVersionUpgradesCheck>("checkForDependencyVersionUpgrades") {
+    group = HelpTasksPlugin.HELP_GROUP
+    projectName.set(project.name)
+    dependencies.set(configurations.api.get().dependencies.map { "${it.group}:${it.name}:${it.version}" })
+    dependencyConstraints.set(
+        configurations.api.get().dependencyConstraints.map { "${it.group}:${it.name}:${it.version}" }
+    )
+    latestReleasesResolutionResult.set(latestReleasesPath.map { it.incoming.resolutionResult.allComponents })
+}

gradle/plugins/src/main/kotlin/org/example/gradle/tasks/DependencyVersionUpgradesCheck.kt

@@ -0,0 +1,56 @@
+package org.example.gradle.tasks
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.artifacts.result.ResolvedComponentResult
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.SetProperty
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.TaskAction
+
+/** Checks if new versions are available for what is declared in the platform. */
+abstract class DependencyVersionUpgradesCheck : DefaultTask() {
+
+    @get:Internal abstract val projectName: Property<String>
+
+    @get:Internal abstract val dependencies: SetProperty<String>
+
+    @get:Internal abstract val dependencyConstraints: SetProperty<String>
+
+    @get:Internal abstract val latestReleasesResolutionResult: SetProperty<ResolvedComponentResult>
+
+    @TaskAction
+    fun check() {
+        val platformDependencyUpgrades =
+            dependencies.get().filter { declared -> declared.resolvedVersion() != declared.version() }
+        val constraintUpgrades =
+            dependencyConstraints.get().filter { declared -> declared.resolvedVersion() != declared.version() }
+        if (platformDependencyUpgrades.isNotEmpty() || constraintUpgrades.isNotEmpty()) {
+            println(
+                """
+                    Upgrade the following dependency versions in 'gradle/versions/build.gradle.kts' (dependencies {} block):
+                    
+                        ${platformDependencyUpgrades.joinToString("\n                        ") { "api(platform(\"${it.ga()}:${it.resolvedVersion()}\"))" }}    
+                    
+                    Upgrade the following dependency versions in 'gradle/versions/build.gradle.kts' (dependencies.constraints {} block):
+                    
+                        ${constraintUpgrades.joinToString("\n                        ") { "api(\"${it.ga()}:${it.resolvedVersion()}\")" }}
+                    
+                    If we cannot perform an upgrade, please add a '{ version { reject("...") } }' statement and a comment
+                    for the versions we cannot support at the moment.
+                """
+                    .trimIndent()
+            )
+        }
+    }
+
+    private fun String.ga() = substring(0, lastIndexOf(":"))
+
+    private fun String.version() = substring(lastIndexOf(":") + 1)
+
+    private fun String.resolvedVersion() =
+        latestReleasesResolutionResult
+            .get()
+            .find { it.moduleVersion!!.module.toString() == ga() }
+            ?.moduleVersion
+            ?.version ?: version() // if no fitting version could be determined, return the declared one
+}