gradle-plugin: add task to merge sarif reports

diktat-gradle-plugin/build.gradle.kts

@@ -34,6 +34,7 @@ val junitVersion = project.properties.getOrDefault("junitVersion", "5.8.1") as S
 val jacocoVersion = project.properties.getOrDefault("jacocoVersion", "0.8.7") as String
 dependencies {
     implementation(kotlin("gradle-plugin-api"))
+    implementation("io.github.detekt.sarif4k:sarif4k:0.0.1")
 
     implementation("org.cqfn.diktat:diktat-common:$diktatVersion") {
         exclude("org.jetbrains.kotlin", "kotlin-compiler-embeddable")

diktat-gradle-plugin/src/main/kotlin/org/cqfn/diktat/plugin/gradle/DiktatGradlePlugin.kt

@@ -1,5 +1,7 @@
 package org.cqfn.diktat.plugin.gradle
 
+import org.cqfn.diktat.plugin.gradle.tasks.SarifReportMergeTask
+import org.cqfn.diktat.plugin.gradle.tasks.registerMergeReportsTask
 import generated.DIKTAT_VERSION
 import generated.KTLINT_VERSION
 import org.gradle.api.Plugin
@@ -26,9 +28,7 @@ class DiktatGradlePlugin : Plugin<Project> {
             diktatConfigFile = project.rootProject.file("diktat-analysis.yml")
         }
 
-        // only gradle 7+ (or maybe 6.8) will embed kotlin 1.4+, kx.serialization is incompatible with kotlin 1.3, so until then we have to use JavaExec wrapper
-        // FixMe: when gradle with kotlin 1.4 is out, proper configurable tasks should be added
-        // configuration to provide JavaExec with correct classpath
+        // Configuration that will be used as classpath for JavaExec task.
         val diktatConfiguration = project.configurations.create(DIKTAT_CONFIGURATION) { configuration ->
             configuration.isVisible = false
             configuration.dependencies.add(project.dependencies.create("com.pinterest:ktlint:$KTLINT_VERSION", closureOf<ExternalModuleDependency> {
@@ -47,6 +47,9 @@ class DiktatGradlePlugin : Plugin<Project> {
 
         project.registerDiktatCheckTask(diktatExtension, diktatConfiguration, patternSet)
         project.registerDiktatFixTask(diktatExtension, diktatConfiguration, patternSet)
+        if (project.path == project.rootProject.path) {
+            project.registerMergeReportsTask(diktatExtension)
+        }
     }
 
     companion object {

diktat-gradle-plugin/src/main/kotlin/org/cqfn/diktat/plugin/gradle/DiktatJavaExecTaskBase.kt

@@ -27,8 +27,6 @@ import org.gradle.api.tasks.util.PatternSet
 import org.gradle.util.GradleVersion
 
 import java.io.File
-import java.nio.file.Files
-import java.nio.file.Paths
 import javax.inject.Inject
 
 /**
@@ -119,7 +117,7 @@ open class DiktatJavaExecTaskBase @Inject constructor(
                     addInput(it)
                 }
 
-            add(createReporterFlag(diktatExtension))
+            add(reporterFlag(diktatExtension))
         }
         project.logger.debug("Setting JavaExec args to $args")
     }
@@ -148,57 +146,21 @@ open class DiktatJavaExecTaskBase @Inject constructor(
     @Suppress("FUNCTION_BOOLEAN_PREFIX")
     override fun getIgnoreFailures(): Boolean = ignoreFailuresProp.getOrElse(false)
 
-    private fun createReporterFlag(diktatExtension: DiktatExtension): String {
-        val flag: StringBuilder = StringBuilder()
-
+    private fun reporterFlag(diktatExtension: DiktatExtension): String = buildString {
         // appending the flag with the reporter
-        setReporter(diktatExtension, flag)
-
-        val outFlag = when {
-            // githubActions should have higher priority than a custom input
-            diktatExtension.githubActions -> {
-                val reportDir = Files.createDirectories(Paths.get("${project.buildDir}/reports/diktat"))
-                outputs.dir(reportDir)
-                ",output=${reportDir.resolve("diktat.sarif")}"
-            }
-            diktatExtension.output.isNotEmpty() -> ",output=${diktatExtension.output}"
-            else -> ""
-        }
-
-        flag.append(outFlag)
-
-        return flag.toString()
-    }
-
-    private fun setReporter(diktatExtension: DiktatExtension, flag: java.lang.StringBuilder) {
-        val name = diktatExtension.reporter.trim()
-        val validReporters = listOf("sarif", "plain", "json", "html")
-        val reporterFlag = when {
-            diktatExtension.githubActions -> {
-                if (diktatExtension.reporter.isNotEmpty()) {
-                    // githubActions should have higher priority than custom input
-                    project.logger.warn("`diktat.githubActions` is set to true, so custom reporter [$name] will be ignored and SARIF reporter will be used")
-                }
-                "--reporter=sarif"
-            }
-            name.isEmpty() -> {
-                project.logger.info("Reporter name was not set. Using 'plain' reporter")
-                "--reporter=plain"
-            }
-            name !in validReporters -> {
-                project.logger.warn("Reporter name is invalid (provided value: [$name]). Falling back to 'plain' reporter")
-                "--reporter=plain"
-            }
-            else -> "--reporter=$name"
-        }
-
-        val isSarifReporterActive = reporterFlag.contains("sarif")
-        if (isSarifReporterActive) {
+        val reporterFlag = project.createReporterFlag(diktatExtension)
+        append(reporterFlag)
+        if (isSarifReporterActive(reporterFlag)) {
             // need to set user.home specially for ktlint, so it will be able to put a relative path URI in SARIF
             systemProperty("user.home", project.rootDir.toString())
         }
 
-        flag.append(reporterFlag)
+        val outputFile = project.getOutputFile(diktatExtension)
+        if (outputFile != null) {
+            outputs.file(outputFile)
+            val outFlag = ",output=${outputFile}"
+            append(outFlag)
+        }
     }
 
     @Suppress("MagicNumber")

diktat-gradle-plugin/src/main/kotlin/org/cqfn/diktat/plugin/gradle/Utils.kt

@@ -7,6 +7,11 @@
 package org.cqfn.diktat.plugin.gradle
 
 import groovy.lang.Closure
+import org.gradle.api.Project
+import org.gradle.api.Task
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Paths
 
 @Suppress(
     "MISSING_KDOC_TOP_LEVEL",
@@ -35,3 +40,40 @@ class KotlinClosure1<in T : Any?, V : Any>(
 )
 fun <T> Any.closureOf(action: T.() -> Unit): Closure<Any?> =
     KotlinClosure1(action, this, this)
+
+fun Project.createReporterFlag(diktatExtension: DiktatExtension): String {
+    val name = diktatExtension.reporter.trim()
+    val validReporters = listOf("sarif", "plain", "json", "html")
+    val reporterFlag = when {
+        diktatExtension.githubActions -> {
+            if (diktatExtension.reporter.isNotEmpty()) {
+                // githubActions should have higher priority than custom input
+                logger.warn("`diktat.githubActions` is set to true, so custom reporter [$name] will be ignored and SARIF reporter will be used")
+            }
+            "--reporter=sarif"
+        }
+        name.isEmpty() -> {
+            logger.info("Reporter name was not set. Using 'plain' reporter")
+            "--reporter=plain"
+        }
+        name !in validReporters -> {
+            logger.warn("Reporter name is invalid (provided value: [$name]). Falling back to 'plain' reporter")
+            "--reporter=plain"
+        }
+        else -> "--reporter=$name"
+    }
+
+    return reporterFlag
+}
+
+fun isSarifReporterActive(reporterFlag: String) = reporterFlag.contains("sarif")
+
+fun Project.getOutputFile(diktatExtension: DiktatExtension): File? = when {
+    // githubActions should have higher priority than a custom input
+    diktatExtension.githubActions -> {
+        val reportDir = Files.createDirectories(Paths.get("${project.buildDir}/reports/diktat"))
+        reportDir.resolve("diktat.sarif").toFile()
+    }
+    diktatExtension.output.isNotEmpty() -> file(diktatExtension.output)
+    else -> null
+}

diktat-gradle-plugin/src/main/kotlin/org/cqfn/diktat/plugin/gradle/tasks/SarifReportMergeTask.kt

@@ -0,0 +1,85 @@
+package org.cqfn.diktat.plugin.gradle.tasks
+
+import org.cqfn.diktat.plugin.gradle.DiktatExtension
+import org.cqfn.diktat.plugin.gradle.DiktatJavaExecTaskBase
+import org.cqfn.diktat.plugin.gradle.createReporterFlag
+import org.cqfn.diktat.plugin.gradle.getOutputFile
+import org.cqfn.diktat.plugin.gradle.isSarifReporterActive
+import io.github.detekt.sarif4k.SarifSchema210
+import org.gradle.api.DefaultTask
+import org.gradle.api.Project
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.TaskExecutionException
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+
+abstract class SarifReportMergeTask : DefaultTask() {
+    @get:InputFiles
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    abstract val input: ConfigurableFileCollection
+
+    @get:OutputFile
+    abstract val output: RegularFileProperty
+
+    @TaskAction
+    fun mergeReports() {
+        val sarifReports = inputs.files
+            .filter { it.exists() }
+            .map {
+                try {
+                    Json.decodeFromString<SarifSchema210>(it.readText())
+                } catch (e: SerializationException) {
+                    logger.error("Couldn't deserialize JSON: is ${it.canonicalPath} a SARIF file?")
+                    throw TaskExecutionException(this, e)
+                }
+            }
+
+        // All reports should contain identical metadata, so we are using the first one as a base.
+        val templateReport = sarifReports.first()
+        val allResults = sarifReports.flatMap { sarifSchema ->
+            sarifSchema.runs
+                .flatMap { it.results.orEmpty() }
+        }
+        val mergedSarif = templateReport.copy(
+            runs = listOf(templateReport.runs.first().copy(results = allResults))
+        )
+
+        output.get().asFile.writeText(Json.encodeToString(mergedSarif))
+    }
+}
+
+internal fun Project.registerMergeReportsTask(diktatExtension: DiktatExtension) {
+    val reportMergeTaskTaskProvider = tasks.register("mergeDiktatReports", SarifReportMergeTask::class.java) { reportMergeTask ->
+        reportMergeTask.enabled = isSarifReporterActive(
+            createReporterFlag(diktatExtension)
+        )
+        allprojects.forEach { subproject ->
+            val diktatOutputFile =
+                subproject.extensions.findByType(DiktatExtension::class.java)?.let {
+                    subproject.getOutputFile(it)
+                }
+            diktatOutputFile?.let { reportMergeTask.input.from(it) }
+        }
+        val diktatReportsDir = "${project.buildDir}/reports/diktat"
+        reportMergeTask.outputs.dir(diktatReportsDir)
+        reportMergeTask.output.set(
+            project.file("$diktatReportsDir/diktat-merged.sarif")
+        )
+    }
+    allprojects.forEach { subproject ->
+        reportMergeTaskTaskProvider.configure {
+//            it.dependsOn(subproject.tasks.withType(DiktatJavaExecTaskBase::class.java))
+            it.shouldRunAfter(
+                subproject.tasks.withType(DiktatJavaExecTaskBase::class.java)
+            )
+        }
+    }
+}

diktat-gradle-plugin/src/test/kotlin/org/cqfn/diktat/plugin/gradle/ReporterSelectionTest.kt

@@ -0,0 +1,34 @@
+package org.cqfn.diktat.plugin.gradle
+
+import org.gradle.api.Project
+import org.gradle.api.tasks.util.PatternSet
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+class ReporterSelectionTest {
+    private val projectBuilder = ProjectBuilder.builder()
+    private lateinit var project: Project
+
+    @BeforeEach
+    fun setUp() {
+        project = projectBuilder.build()
+        // mock kotlin sources
+        project.mkdir("src/main/kotlin")
+        project.file("src/main/kotlin/Test.kt").createNewFile()
+        project.pluginManager.apply(DiktatGradlePlugin::class.java)
+    }
+
+    @Test
+    fun `should fallback to plain reporter for unknown reporter types`() {
+        val diktatExtension = DiktatExtension(PatternSet()).apply {
+            reporter = "jsonx"
+        }
+
+        Assertions.assertEquals(
+            "--reporter=plain",
+            project.createReporterFlag(diktatExtension)
+        )
+    }
+}