Add support for coroutines version verification in CheckVersionCompatibility task

build-logic/src/main/kotlin/io/github/composegears/valkyrie/task/CheckVersionCompatibility.kt

@@ -3,35 +3,47 @@ package io.github.composegears.valkyrie.task
 import net.swiftzer.semver.SemVer
 import org.gradle.api.DefaultTask
 import org.gradle.api.GradleException
-import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.MapProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.TaskAction
 
 abstract class CheckVersionCompatibility : DefaultTask() {
 
+    /** Maps each resolved coordinate (`group:name:version`) to the list of coordinates that depend on it. */
     @get:Input
-    abstract val resolvedComponents: ListProperty<String>
+    abstract val resolvedComponents: MapProperty<String, List<String>>
 
     @get:Input
     abstract val maxKotlinVersion: Property<String>
 
     @get:Input
     abstract val maxComposeVersion: Property<String>
 
+    @get:Input
+    abstract val maxCoroutinesVersion: Property<String>
+
     @TaskAction
     fun check() {
         val maxKotlin = SemVer.parse(maxKotlinVersion.get())
         val maxCompose = SemVer.parse(maxComposeVersion.get())
+        val maxCoroutines = SemVer.parse(maxCoroutinesVersion.get())
 
         val violations = resolvedComponents.get()
-            .mapNotNull { coordinate ->
+            .mapNotNull { (coordinate, dependents) ->
                 val (group, name, version) = coordinate.split(":")
+                val requiredBy = if (dependents.isNotEmpty()) {
+                    "\n" + dependents.joinToString("\n") { "\t\t  - $it" }
+                } else {
+                    ""
+                }
                 when {
                     group == "org.jetbrains.kotlin" && SemVer.parse(version) > maxKotlin ->
-                        "\t- $group:$name:$version  (max supported: $maxKotlin)"
+                        "\t- $group:$name:$version  (max supported: $maxKotlin)$requiredBy"
                     group.startsWith("org.jetbrains.compose") && SemVer.parse(version) > maxCompose ->
-                        "\t- $group:$name:$version  (max supported: $maxCompose)"
+                        "\t- $group:$name:$version  (max supported: $maxCompose)$requiredBy"
+                    group == "org.jetbrains.kotlinx" && name.startsWith("kotlinx-coroutines") && SemVer.parse(version) > maxCoroutines ->
+                        "\t- $group:$name:$version  (max supported: $maxCoroutines)$requiredBy"
                     else -> null
                 }
             }
@@ -45,6 +57,6 @@ abstract class CheckVersionCompatibility : DefaultTask() {
                 },
             )
         }
-        logger.lifecycle("✅ All dependencies are compatible (kotlin ≤ $maxKotlin, compose ≤ $maxCompose)")
+        logger.lifecycle("✅ All dependencies are compatible (kotlin ≤ $maxKotlin, compose ≤ $maxCompose, coroutines ≤ $maxCoroutines)")
     }
 }

gradle/libs.versions.toml

@@ -1,5 +1,7 @@
 [versions]
 compose = "1.10.0"
+# https://plugins.jetbrains.com/docs/intellij/using-kotlin.html#coroutinesLibraries
+coroutines = "1.10.2"
 intellij = "2.13.1"
 jacoco = "0.8.13"
 jdkRelease = "21"
@@ -46,7 +48,7 @@ assertk = "com.willowtreeapps.assertk:assertk:0.28.1"
 junit5-jupiter = "org.junit.jupiter:junit-jupiter:6.0.3"
 junit-launcher = "org.junit.platform:junit-platform-launcher:6.0.3"
 junit4 = "junit:junit:4.13.2"
-kotlin-coroutines-test = "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2"
+kotlin-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" }
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
 
 semver = "net.swiftzer.semver:semver:2.1.0"

tools/idea-plugin/build.gradle.kts

@@ -181,10 +181,18 @@ tasks.register<CheckVersionCompatibility>("checkVersionCompatibility") {
         dependencies.addAll(configurations.getByName("implementation").dependencies)
     }
     resolvedComponents = checkConfig.map { config ->
-        config.incoming.resolutionResult.allComponents
-            .mapNotNull { it.moduleVersion }
-            .map { "${it.group}:${it.name}:${it.version}" }
+        val result = mutableMapOf<String, MutableSet<String>>()
+        for (component in config.incoming.resolutionResult.allComponents) {
+            val mv = component.moduleVersion ?: continue
+            val coordinate = "${mv.group}:${mv.name}:${mv.version}"
+            val dependents = result.getOrPut(coordinate) { mutableSetOf() }
+            component.dependents.forEach { dep ->
+                dep.from.moduleVersion?.let { dependents.add("${it.group}:${it.name}:${it.version}") }
+            }
+        }
+        result.toSortedMap().mapValues { (_, deps) -> deps.sorted() }
     }
     maxKotlinVersion = libs.versions.kotlin
     maxComposeVersion = libs.versions.compose
+    maxCoroutinesVersion = libs.versions.coroutines
 }