Implemented protype of Kover Aggregated Plugin

README.md

@@ -113,6 +113,12 @@ in this case report will be generated for current project joined with `:another:
 
 **More examples of Gradle plugin applying can be found in [example folder](kover-gradle-plugin/examples)**
 
+## Kover Aggregated Plugin
+Kover Aggregated Plugin as a prototype of Gradle Settings plugin, created to simplify the setup of multi-project builds. 
+It is in its infancy, it is recommended to use it only for test or pet projects.
+
+Refer to the [documentation](https://kotlin.github.io/kotlinx-kover/gradle-plugin/aggregated.html) for details. 
+
 ## Kover CLI
 Standalone JVM application used for offline instrumentation and generation of human-readable reports.
 

build-logic/src/main/kotlin/kotlinx/kover/conventions/kover-publishing-conventions.gradle.kts

@@ -210,3 +210,8 @@ val Project.sourceSets: SourceSetContainer
 
 val SourceSetContainer.main: NamedDomainObjectProvider<SourceSet>
     get() = named<SourceSet>("main")
+
+signing {
+    // disable signing if private key isn't passed
+    isRequired = findProperty("libs.sign.key.private") != null
+}

kover-gradle-plugin/api/kover-gradle-plugin.api

@@ -1,3 +1,16 @@
+public abstract interface class kotlinx/kover/gradle/aggregation/settings/dsl/KoverSettingsExtension {
+	public abstract fun enableCoverage ()V
+	public abstract fun getReports ()Lkotlinx/kover/gradle/aggregation/settings/dsl/ReportsSettings;
+	public abstract fun reports (Lorg/gradle/api/Action;)V
+}
+
+public abstract interface class kotlinx/kover/gradle/aggregation/settings/dsl/ReportsSettings {
+	public abstract fun getExcludedClasses ()Lorg/gradle/api/provider/SetProperty;
+	public abstract fun getExcludedProjects ()Lorg/gradle/api/provider/SetProperty;
+	public abstract fun getIncludedClasses ()Lorg/gradle/api/provider/SetProperty;
+	public abstract fun getIncludedProjects ()Lorg/gradle/api/provider/SetProperty;
+}
+
 public final class kotlinx/kover/gradle/plugin/KoverGradlePlugin : org/gradle/api/Plugin {
 	public fun <init> ()V
 	public synthetic fun apply (Ljava/lang/Object;)V

kover-gradle-plugin/build.gradle.kts

@@ -42,6 +42,7 @@ val functionalTestImplementation = "functionalTestImplementation"
 
 dependencies {
     implementation(project(":kover-features-jvm"))
+    implementation(project(":kover-jvm-agent"))
     // exclude transitive dependency on stdlib, the Gradle version should be used
     compileOnly(kotlin("stdlib"))
     compileOnly(libs.gradlePlugin.kotlin)
@@ -52,6 +53,13 @@ dependencies {
 
     snapshotRelease(project(":kover-features-jvm"))
     snapshotRelease(project(":kover-jvm-agent"))
+
+    functionalTestImplementation(gradleTestKit())
+    // dependencies only for plugin's classpath to work with Kotlin Multi-Platform and Android plugins
+    functionalTestImplementation("org.jetbrains.kotlin:kotlin-gradle-plugin:$embeddedKotlinVersion")
+    functionalTestImplementation("org.jetbrains.kotlin:kotlin-compiler-embeddable:$embeddedKotlinVersion")
+    functionalTestImplementation("org.jetbrains.kotlin:kotlin-compiler-runner:$embeddedKotlinVersion")
+
 }
 
 kotlin {
@@ -70,7 +78,20 @@ val functionalTest by tasks.registering(Test::class) {
     useJUnitPlatform()
 
     dependsOn(tasks.collectRepository)
+
+    // While gradle testkit supports injection of the plugin classpath it doesn't allow using dependency notation
+    // to determine the actual runtime classpath for the plugin. It uses isolation, so plugins applied by the build
+    // script are not visible in the plugin classloader. This means optional dependencies (dependent on applied plugins -
+    // for example kotlin multiplatform) are not visible even if they are in regular gradle use. This hack will allow
+    // extending the classpath. It is based upon: https://docs.gradle.org/6.0/userguide/test_kit.html#sub:test-kit-classpath-injection
+    // Create a configuration to register the dependencies against
     doFirst {
+        val file = File(temporaryDir, "plugin-classpath.txt")
+        file.writeText(sourceSets["functionalTest"].compileClasspath
+            .filter { it.name.startsWith("stdlib") }
+            .joinToString("\n"))
+        systemProperties["plugin-classpath"] = file.absolutePath
+
         // basic build properties
         setSystemPropertyFromProject("kover.test.kotlin.version")
 
@@ -87,7 +108,7 @@ val functionalTest by tasks.registering(Test::class) {
         systemProperties["junit.jupiter.execution.parallel.config.fixed.parallelism"] =
             junitParallelism?.toIntOrNull()?.toString() ?: "2"
         // this is necessary if tests are run for debugging, in this case it is more difficult to stop at the test you need when they are executed in parallel and you are not sure on which test the execution will pause
-        systemProperties["junit.jupiter.execution.parallel.enabled"] = if (junitParallelism == "no") "false" else "true"
+        systemProperties["junit.jupiter.execution.parallel.enabled"] = if (junitParallelism == "no") "false" else "false"
 
 
         // customizing functional tests
@@ -180,11 +201,6 @@ extensions.configure<Kover_publishing_conventions_gradle.KoverPublicationExtensi
     addPublication.set(false)
 }
 
-signing {
-    // disable signing if private key isn't passed
-    isRequired = findProperty("libs.sign.key.private") != null
-}
-
 gradlePlugin {
     website.set("https://github.com/Kotlin/kotlinx-kover")
     vcsUrl.set("https://github.com/Kotlin/kotlinx-kover.git")
@@ -199,3 +215,18 @@ gradlePlugin {
         }
     }
 }
+
+gradlePlugin {
+    website.set("https://github.com/Kotlin/kotlinx-kover")
+    vcsUrl.set("https://github.com/Kotlin/kotlinx-kover.git")
+
+    plugins {
+        create("KoverSettingsPlugin") {
+            id = "org.jetbrains.kotlinx.kover.settings"
+            implementationClass = "kotlinx.kover.gradle.aggregation.settings.KoverSettingsGradlePlugin"
+            displayName = "Gradle Plugin for Kotlin Code Coverage Tools"
+            description = "Evaluate code coverage for projects written in Kotlin"
+            tags.addAll("kover", "kotlin", "coverage", "settings plugin")
+        }
+    }
+}

kover-gradle-plugin/docs/aggregated.md

@@ -0,0 +1,67 @@
+# Kover Aggregated Plugin
+
+## Quickstart
+This plugin is a prototype for testing ideas related to an alternative configuration method.
+
+The main difference from the existing Kover Gradle Plugin is the reactive content of the report: only those classes and tests that were compiled and executed within the same build get into the report.
+
+To use the plugin, just add into a `settings.gradle.kts` file 
+```kotlin
+plugins {
+    id("org.jetbrains.kotlinx.kover.settings") version "0.8.1"
+}
+```
+**There is no need to apply Kover plugin in other places, the `org.jetbrains.kotlinx.kover` plug-in should not be applied anywhere.**
+
+To measure coverage you should pass special `-Pkover` argument to Gradle CLI command and call the command to generate the corresponding report `koverHtmlReport` or `koverXmlReport`.
+Example, if you want to measure the coverage of the `test` task:
+```shell
+./gradlew test -Pkover koverHtmlReport
+```
+
+Only those classes that were compiled as part of the current Gradle build are included in the report.
+If no compilation tasks were called in the build, the report will be empty.
+
+The report covers only those tests that were run as part of the current build.
+If no tests were called in the assembly, then the coverage for all classes will be 0.
+
+## Configuring
+At the moment, Kover Settings Plugin allows to configure reports minimally.
+
+There are two ways to configure, using a build script in `settings.gradle.kts` and CLI
+
+Acceptable settings in `settings.gradle.kts` and their equivalent in CLI
+```kotlin
+kover {
+    // -Pkover
+    enableCoverage()
+
+    reports {
+        // -Pkover.classes.from=:a
+        includedProjects.add(":a")
+
+        // -Pkover.classes.from.excludes=:b
+        excludedProjects.add(":b")
+
+        // -Pkover.classes.includes=classes.to.exclude.*
+        includedClasses.add("classes.to.include.*")
+
+        // -Pkover.classes.excludes=classes.to.include.*
+        excludedClasses.add("classes.to.exclude.*")
+    }
+}
+```
+
+For example, the following setting is in `settings.gradle.kts`
+```kotlin
+kover {
+    enableCoverage()
+
+    reports {
+        excludedClasses.add("org.test.MyClass*")
+    }
+}
+```
+fully equivalent to Gradle CLI arguments `-Pkover -Pkover.classes.excludes=org.test.MyClass*`
+
+**Any of the specified settings or DSL is preliminary and can be deleted or changed without maintaining backward compatibility**

kover-gradle-plugin/src/functionalTest/kotlin/kotlinx/kover/gradle/plugin/test/functional/cases/ReportsCachingTests.kt

@@ -3,7 +3,6 @@
  */
 package kotlinx.kover.gradle.plugin.test.functional.cases
 
-import kotlinx.kover.gradle.plugin.commons.CoverageToolVendor
 import kotlinx.kover.gradle.plugin.test.functional.framework.configurator.*
 import kotlinx.kover.gradle.plugin.test.functional.framework.starter.*
 

kover-gradle-plugin/src/functionalTest/kotlin/kotlinx/kover/gradle/plugin/test/functional/cases/SettingsPluginTests.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2017-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.kover.gradle.plugin.test.functional.cases
+
+import kotlinx.kover.gradle.plugin.test.functional.framework.checker.CheckerContext
+import kotlinx.kover.gradle.plugin.test.functional.framework.starter.TemplateTest
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+internal class SettingsPluginTests {
+    @TemplateTest("settings-plugin", [":tasks"])
+    fun CheckerContext.testNoReportTasks() {
+        taskOutput(":tasks") {
+            assertFalse("koverXmlReport" in this)
+            assertFalse("koverHtmlReport" in this)
+        }
+    }
+
+    @TemplateTest("settings-plugin", ["test"])
+    fun CheckerContext.testNoInstrumentation() {
+        checkDefaultBinReport(false)
+        subproject("subproject") {
+            checkDefaultBinReport(false)
+        }
+    }
+
+    @TemplateTest("settings-plugin", ["-Pkover", ":tasks", "-Dorg.gradle.unsafe.isolated-projects=true", "--configuration-cache", "--build-cache"])
+    fun CheckerContext.testHasReportTasks() {
+        taskOutput(":tasks") {
+            assertTrue("koverXmlReport" in this)
+            assertTrue("koverHtmlReport" in this)
+        }
+    }
+
+    @TemplateTest("settings-plugin", ["-Pkover", "koverXmlReport", "-Dorg.gradle.unsafe.isolated-projects=true", "--configuration-cache", "--build-cache"])
+    fun CheckerContext.testNoCompilations() {
+        xmlReport {
+            classCounter("tests.settings.root.RootClass").assertAbsent()
+            classCounter("tests.settings.subproject.SubprojectClass").assertAbsent()
+        }
+    }
+
+    @TemplateTest("settings-plugin", ["-Pkover", ":compileKotlin", "koverXmlReport", "-Dorg.gradle.unsafe.isolated-projects=true", "--configuration-cache", "--build-cache"])
+    fun CheckerContext.testCompilationOnlyForRoot() {
+        xmlReport {
+            classCounter("tests.settings.root.RootClass").assertFullyMissed()
+            classCounter("tests.settings.subproject.SubprojectClass").assertAbsent()
+        }
+    }
+
+    @TemplateTest("settings-plugin", ["-Pkover", ":subproject:compileKotlin", ":test", "koverXmlReport", "-Dorg.gradle.unsafe.isolated-projects=true", "--configuration-cache", "--build-cache"])
+    fun CheckerContext.testRootAndOnlyCompileSubproject() {
+        xmlReport {
+            classCounter("tests.settings.root.RootClass").assertFullyCovered()
+            classCounter("tests.settings.subproject.SubprojectClass").assertFullyMissed()
+        }
+    }
+
+
+    @TemplateTest("settings-plugin", ["-Pkover", "test", "koverXmlReport", "-Dorg.gradle.unsafe.isolated-projects=true", "--configuration-cache", "--build-cache"])
+    fun CheckerContext.testAll() {
+        xmlReport {
+            classCounter("tests.settings.root.RootClass").assertFullyCovered()
+            classCounter("tests.settings.subproject.SubprojectClass").assertFullyCovered()
+        }
+    }
+
+    @TemplateTest("settings-plugin", ["-Pkover", "test", "koverXmlReport", "-Pkover.classes.from.excludes=:subproject", "-Dorg.gradle.unsafe.isolated-projects=true", "--configuration-cache", "--build-cache"])
+    fun CheckerContext.testExcludeSubproject() {
+        xmlReport {
+            classCounter("tests.settings.root.RootClass").assertFullyCovered()
+            classCounter("tests.settings.subproject.SubprojectClass").assertAbsent()
+        }
+    }
+
+    @TemplateTest("settings-plugin", ["-Pkover", "test", "koverXmlReport", "-Pkover.classes.excludes=tests.settings.subproject.*", "-Dorg.gradle.unsafe.isolated-projects=true", "--configuration-cache", "--build-cache"])
+    fun CheckerContext.testExcludeClasses() {
+        xmlReport {
+            classCounter("tests.settings.root.RootClass").assertFullyCovered()
+            classCounter("tests.settings.subproject.SubprojectClass").assertAbsent()
+        }
+    }
+}

kover-gradle-plugin/src/functionalTest/kotlin/kotlinx/kover/gradle/plugin/test/functional/framework/writer/SettingsWriter.kt

@@ -15,6 +15,7 @@ internal fun FormattedWriter.writePluginManagement(language: ScriptLanguage,
     call("resolutionStrategy") {
         call("eachPlugin") {
             line("if (requested.id.id == \"org.jetbrains.kotlinx.kover\") { useVersion(\"$koverVersion\") }")
+            line("if (requested.id.id == \"org.jetbrains.kotlinx.kover.settings\") { useVersion(\"$koverVersion\") }")
             if (overrideKotlinVersion != null) {
                 line("if (requested.id.id == \"org.jetbrains.kotlin.jvm\") useVersion(\"$overrideKotlinVersion\")")
                 line("if (requested.id.id == \"org.jetbrains.kotlin.multiplatform\") useVersion(\"$overrideKotlinVersion\")")

kover-gradle-plugin/src/functionalTest/templates/builds/settings-plugin/build.gradle.kts

@@ -0,0 +1,8 @@
+plugins {
+    kotlin("jvm") version ("2.0.0")
+}
+
+dependencies {
+    testImplementation(kotlin("test"))
+}
+

kover-gradle-plugin/src/functionalTest/templates/builds/settings-plugin/settings.gradle.kts

@@ -0,0 +1,20 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        mavenCentral()
+    }
+}
+
+plugins {
+    id("org.jetbrains.kotlinx.kover.settings") version "SNAPSHOT"
+}
+
+buildCache {
+    local {
+        directory = "$settingsDir/build-cache"
+    }
+}
+
+rootProject.name = "settings-plugin"
+
+include(":subproject")

kover-gradle-plugin/src/functionalTest/templates/builds/settings-plugin/src/main/kotlin/RootClass.kt

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2017-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package tests.settings.root
+
+class RootClass {
+    fun action() {
+        println("It's root class")
+    }
+}

kover-gradle-plugin/src/functionalTest/templates/builds/settings-plugin/src/test/kotlin/RootTest.kt

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2017-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package tests.settings.root
+
+import kotlin.test.Test
+
+class RootTest {
+    @Test
+    fun test() {
+        RootClass().action()
+    }
+}

kover-gradle-plugin/src/functionalTest/templates/builds/settings-plugin/subproject/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+    kotlin("jvm")
+}
+
+dependencies {
+    testImplementation(kotlin("test"))
+}

kover-gradle-plugin/src/functionalTest/templates/builds/settings-plugin/subproject/src/main/kotlin/SubprojectClass.kt

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2017-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package tests.settings.subproject
+
+class SubprojectClass {
+    fun action() {
+        println("It's class from the subproject")
+    }
+}

kover-gradle-plugin/src/functionalTest/templates/builds/settings-plugin/subproject/src/test/kotlin/ATest.kt

@@ -0,0 +1,10 @@
+package tests.settings.subproject
+
+import kotlin.test.Test
+
+class SubprojectTest {
+    @Test
+    fun test() {
+        SubprojectClass().action()
+    }
+}