Added project filter for reports

Resolves #584

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

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2017-2023 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.configurator.BuildConfigurator
+import kotlinx.kover.gradle.plugin.test.functional.framework.starter.SlicedGeneratedTest
+
+internal class ReportProjectFilterTests {
+    private val subprojectPath = ":common"
+
+    @SlicedGeneratedTest(allLanguages = true)
+    fun BuildConfigurator.testInclude() {
+        addProjectWithKover(subprojectPath) {
+            sourcesFrom("multiproject-common")
+        }
+
+        addProjectWithKover {
+            sourcesFrom("multiproject-user")
+            dependencyKover(subprojectPath)
+
+            kover {
+                reports {
+                    filters {
+                        includes {
+                            // show classes only from ':common' project
+                            projects.add(":c?m*")
+                        }
+                    }
+                }
+            }
+        }
+
+        run(":koverXmlReport") {
+            xmlReport {
+                classCounter("org.jetbrains.CommonClass").assertCovered()
+                classCounter("org.jetbrains.CommonInternalClass").assertCovered()
+                classCounter("org.jetbrains.UserClass").assertAbsent()
+            }
+        }
+    }
+
+    @SlicedGeneratedTest(allLanguages = true)
+    fun BuildConfigurator.testExclude() {
+        addProjectWithKover(subprojectPath) {
+            sourcesFrom("multiproject-common")
+        }
+
+        addProjectWithKover {
+            sourcesFrom("multiproject-user")
+            dependencyKover(subprojectPath)
+
+            kover {
+                reports {
+                    filters {
+                        excludes {
+                            // exclude classes from ':common' project
+                            projects.add(":c?m*")
+                        }
+                    }
+                }
+            }
+        }
+
+        run(":koverXmlReport") {
+            xmlReport {
+                classCounter("org.jetbrains.CommonClass").assertAbsent()
+                classCounter("org.jetbrains.CommonInternalClass").assertAbsent()
+                classCounter("org.jetbrains.UserClass").assertCovered()
+            }
+        }
+    }
+
+    @SlicedGeneratedTest(allLanguages = true)
+    fun BuildConfigurator.testIncludeAndExclude() {
+        addProjectWithKover(subprojectPath) {
+            sourcesFrom("multiproject-common")
+        }
+
+        addProjectWithKover {
+            sourcesFrom("multiproject-user")
+            dependencyKover(subprojectPath)
+
+            kover {
+                reports {
+                    filters {
+                        includes {
+                            // include all projects
+                            projects.add(":*")
+                        }
+                        excludes {
+                            // exclude classes from ':common' project
+                            projects.add(":c?m*")
+                        }
+                    }
+                }
+            }
+        }
+
+        run(":koverXmlReport") {
+            xmlReport {
+                classCounter("org.jetbrains.CommonClass").assertAbsent()
+                classCounter("org.jetbrains.CommonInternalClass").assertAbsent()
+                classCounter("org.jetbrains.UserClass").assertCovered()
+            }
+        }
+    }
+}

kover-gradle-plugin/src/main/kotlin/kotlinx/kover/gradle/plugin/appliers/tasks/VariantReportsSet.kt

@@ -213,7 +213,8 @@ internal class VariantReportsSet(
         return project.provider {
             ReportFilters(
                 includesImpl.classes.get(), includesImpl.annotations.get(),
-                excludesImpl.classes.get(), excludesImpl.annotations.get()
+                excludesImpl.classes.get(), excludesImpl.annotations.get(),
+                includesImpl.projects.get(), excludesImpl.projects.get(),
             )
         }
     }

kover-gradle-plugin/src/main/kotlin/kotlinx/kover/gradle/plugin/commons/Artifacts.kt

@@ -11,6 +11,7 @@ import java.io.Serializable
  * The contents of a single Kover artifact.
  */
 internal class ArtifactContent(
+    val path: String,
     val sources: Set<File>,
     val outputs: Set<File>,
     val reports: Set<File>
@@ -26,16 +27,21 @@ internal class ArtifactContent(
             reports += it.reports
         }
 
-        return ArtifactContent(sources, outputs, reports)
+        return ArtifactContent(path, sources, outputs, reports)
     }
 
     fun existing(): ArtifactContent {
         return ArtifactContent(
+            path,
             sources.filter { it.exists() }.toSet(),
             outputs.filter { it.exists() }.toSet(),
             reports.filter { it.exists() }.toSet()
         )
     }
+
+    companion object {
+        val Empty = ArtifactContent("", emptySet(), emptySet(), emptySet())
+    }
 }
 
 
@@ -47,22 +53,24 @@ internal fun ArtifactContent.write(artifactFile: File, rootDir: File) {
     val outputs = outputs.joinToString("\n") { it.toRelativeString(rootDir) }
     val reports = reports.joinToString("\n") { it.toRelativeString(rootDir) }
 
-    artifactFile.writeText("$sources\n\n$outputs\n\n$reports")
+    artifactFile.writeText("$path\n$sources\n\n$outputs\n\n$reports")
 }
 
 /**
  * Read Kover artifact content from the file.
  */
 internal fun File.parseArtifactFile(rootDir: File): ArtifactContent {
-    if (!exists() || !name.endsWith(".artifact")) return ArtifactContent(emptySet(), emptySet(), emptySet())
+    if (!exists() || !name.endsWith(".artifact")) return ArtifactContent.Empty
 
     val iterator = readLines().iterator()
+    val projectPath = iterator.next()
+    if (!projectPath.startsWith(':')) return ArtifactContent.Empty
 
     val sources = iterator.groupUntil { it.isEmpty() }.map { rootDir.resolve(it) }.toSet()
     val outputs = iterator.groupUntil { it.isEmpty() }.map { rootDir.resolve(it) }.toSet()
     val reports = iterator.groupUntil { it.isEmpty() }.map { rootDir.resolve(it) }.toSet()
 
-    return ArtifactContent(sources, outputs, reports)
+    return ArtifactContent(projectPath, sources, outputs, reports)
 }
 
 private fun <T> Iterator<T>.groupUntil(block: (T) -> Boolean): List<T> {

kover-gradle-plugin/src/main/kotlin/kotlinx/kover/gradle/plugin/commons/Types.kt

@@ -75,7 +75,11 @@ internal data class ReportFilters(
     @get:Input
     val excludesClasses: Set<String> = emptySet(),
     @get:Input
-    val excludesAnnotations: Set<String> = emptySet()
+    val excludesAnnotations: Set<String> = emptySet(),
+    @get:Input
+    val includeProjects: Set<String> = emptySet(),
+    @get:Input
+    val excludeProjects: Set<String> = emptySet(),
 ): Serializable
 
 internal open class VerificationRule @Inject constructor(

kover-gradle-plugin/src/main/kotlin/kotlinx/kover/gradle/plugin/dsl/KoverReportsConfig.kt

@@ -13,6 +13,7 @@ import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
+import org.gradle.api.provider.SetProperty
 
 /**
  * Configuration of Kover reports.
@@ -467,6 +468,7 @@ public interface KoverReportFiltersConfig {
      *      classes("com.example.FooBar?", "com.example.*Bar")
      *      packages("com.example.subpackage")
      *      annotatedBy("*Generated*")
+     *      projects.add(":my:project-path")
      *  }
      *  ```
      * Excludes have priority over includes.
@@ -481,6 +483,7 @@ public interface KoverReportFiltersConfig {
      *  includes {
      *      classes("com.example.FooBar?", "com.example.*Bar")
      *      packages("com.example.subpackage")
+     *      projects.add(":my:project-path")
      *  }
      *  ```
      * Excludes have priority over includes.
@@ -500,6 +503,7 @@ public interface KoverReportFiltersConfig {
  *          val somePackages =
  *          packages(listOf("foo.b?r", "com.*.example"))
  *          annotatedBy("*Generated*", "com.example.KoverExclude")
+ *          projects.add(":my:project-path")
  *      }
  * ```
  */
@@ -672,6 +676,19 @@ public interface KoverReportFilter {
      */
     public fun annotatedBy(vararg annotationName: Provider<String>)
 
+    /**
+     * Add all classes in specified project. Only the project path is used (starts with a colon).
+     *
+     * It is acceptable to use `*` and `?` wildcards,
+     * `*` means any number of arbitrary characters (including no chars), `?` means one arbitrary character.
+     *
+     * Example:
+     * ```
+     *  projects.add(":my:project-path")
+     * ```
+     */
+    val projects: SetProperty<String>
+
     /**
      * Add all classes generated by Android plugin to filters.
      *

kover-gradle-plugin/src/main/kotlin/kotlinx/kover/gradle/plugin/dsl/internal/ReportsImpl.kt

@@ -326,11 +326,13 @@ internal abstract class KoverReportFilterImpl: KoverReportFilter {
     internal fun extendsFrom(other: KoverReportFilterImpl) {
         classes.addAll(other.classes)
         annotations.addAll(other.annotations)
+        projects.addAll(other.projects)
     }
 
     internal fun clean() {
         classes.empty()
         annotations.empty()
+        projects.empty()
     }
 
     private fun String.packageAsClass(): String = "$this.*"

kover-gradle-plugin/src/main/kotlin/kotlinx/kover/gradle/plugin/tasks/reports/AbstractKoverReportTask.kt

@@ -4,6 +4,7 @@
 
 package kotlinx.kover.gradle.plugin.tasks.reports
 
+import kotlinx.kover.features.jvm.KoverFeatures
 import kotlinx.kover.gradle.plugin.commons.*
 import kotlinx.kover.gradle.plugin.tools.*
 import org.gradle.api.*
@@ -38,8 +39,8 @@ internal abstract class AbstractKoverReportTask : DefaultTask() {
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
     internal val externalSources: Provider<Set<File>> = externalArtifacts.elements.map {
-        val content = ArtifactContent(emptySet(), emptySet(), emptySet())
-        content.joinWith(it.map { file -> file.asFile.parseArtifactFile(rootDir) }).sources
+        val content = ArtifactContent.Empty
+        content.joinWith(it.map { file -> file.asFile.parseArtifactFile(rootDir).filterArtifact() }).sources
     }
 
     /**
@@ -48,8 +49,8 @@ internal abstract class AbstractKoverReportTask : DefaultTask() {
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
     internal val externalReports: Provider<Set<File>> = externalArtifacts.elements.map {
-        val content = ArtifactContent(emptySet(), emptySet(), emptySet())
-        content.joinWith(it.map { file -> file.asFile.parseArtifactFile(rootDir) }).reports
+        val content = ArtifactContent.Empty
+        content.joinWith(it.map { file -> file.asFile.parseArtifactFile(rootDir).filterArtifact() }).reports
     }
 
     /**
@@ -58,7 +59,7 @@ internal abstract class AbstractKoverReportTask : DefaultTask() {
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
     internal val localSources: Provider<Set<File>> = localArtifact.map {
-        it.asFile.parseArtifactFile(rootDir).sources
+        it.asFile.parseArtifactFile(rootDir).filterArtifact().sources
     }
 
     /**
@@ -67,7 +68,7 @@ internal abstract class AbstractKoverReportTask : DefaultTask() {
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
     internal val localReports: Provider<Set<File>> = localArtifact.map {
-        it.asFile.parseArtifactFile(rootDir).reports
+        it.asFile.parseArtifactFile(rootDir).filterArtifact().reports
     }
 
     @get:Nested
@@ -94,8 +95,36 @@ internal abstract class AbstractKoverReportTask : DefaultTask() {
     }
 
     private fun collectAllFiles(): ArtifactContent {
-        val local = localArtifact.get().asFile.parseArtifactFile(rootDir)
-        return local.joinWith(externalArtifacts.files.map { it.parseArtifactFile(rootDir) }).existing()
+        val local = localArtifact.get().asFile.parseArtifactFile(rootDir).filterArtifact()
+        return local.joinWith(externalArtifacts.files.map { it.parseArtifactFile(rootDir).filterArtifact() }).existing()
+    }
+
+    private fun ArtifactContent.filterArtifact(): ArtifactContent {
+        println("START FILTER")
+        val reportFilters = filters.get()
+        println("FILTER INCLUDES ${reportFilters.includeProjects}")
+        if (reportFilters.includeProjects.isNotEmpty()) {
+            println("INCLUDED = ${reportFilters.includeProjects}")
+            val notIncluded = reportFilters.includeProjects.none { filter ->
+                KoverFeatures.koverWildcardToRegex(filter).toRegex().matches(path)
+            }
+            if (notIncluded) {
+                println("INCLUDED FILTER")
+                return ArtifactContent.Empty
+            }
+        }
+        println("FILTER EXCLUDES ${reportFilters.excludeProjects}")
+        if (reportFilters.excludeProjects.isNotEmpty()) {
+            val excluded = reportFilters.excludeProjects.any { filter ->
+                KoverFeatures.koverWildcardToRegex(filter).toRegex().matches(path)
+            }
+            if (excluded) {
+                println("EXCLUDED FILTER")
+                return ArtifactContent.Empty
+            }
+        }
+        println("FILTERED OK")
+        return this
     }
 }
 

kover-gradle-plugin/src/main/kotlin/kotlinx/kover/gradle/plugin/tasks/services/KoverArtifactGenerationTask.kt

@@ -42,9 +42,11 @@ internal abstract class KoverArtifactGenerationTask : DefaultTask() {
 
     private val rootDir: File = project.rootDir
 
+    private val projectPath: String = project.path
+
     @TaskAction
     fun generate() {
-        val mainContent = ArtifactContent(sources.toSet(), outputDirs.toSet(), reports.toSet())
+        val mainContent = ArtifactContent(projectPath, sources.toSet(), outputDirs.toSet(), reports.toSet())
         val additional = additionalArtifacts.files.map { it.parseArtifactFile(rootDir) }
         mainContent.joinWith(additional).write(artifactFile.get().asFile, rootDir)
     }