SourceTask in Gradle plugin

diktat-gradle-plugin/src/main/kotlin/com/saveourtool/diktat/plugin/gradle/DiktatExtension.kt

@@ -1,65 +1,63 @@
 package com.saveourtool.diktat.plugin.gradle
 
+import org.gradle.api.Action
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.Nested
 import org.gradle.api.tasks.PathSensitive
 import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.VerificationTask
 import org.gradle.api.tasks.util.PatternFilterable
-import org.gradle.api.tasks.util.PatternSet
-import java.io.File
 
 /**
  * An extension to configure diktat in build.gradle(.kts) file
- *
- * @param patternSet
  */
-open class DiktatExtension(
- private val patternSet: PatternSet
-) {
+abstract class DiktatExtension {
  /**
  * Boolean flag to support `ignoreFailures` property of [VerificationTask].
  */
- var ignoreFailures: Boolean = false
-
- /**
- * Flag that indicates whether to turn debug logging on
- */
- var debug = false
+ abstract val ignoreFailures: Property<Boolean>
 
  /**
  * Property that will be used if you need to publish the report to GitHub
  */
- var githubActions = false
+ abstract val githubActions: Property<Boolean> // = false
 
  /**
  * Type of the reporter to use
  */
- var reporter: String = ""
+ abstract val reporter: Property<String>
 
  /**
  * Destination for reporter. If empty, will write to stdout.
  */
- var output: String = ""
+ abstract val output: RegularFileProperty
 
  /**
  * Baseline file, containing a list of errors that will be ignored.
  * If this file doesn't exist, it will be created on the first invocation.
  */
- var baseline: String? = null
+ abstract val baseline: RegularFileProperty
 
  /**
  * Path to diktat yml config file. Can be either absolute or relative to project's root directory.
  * Default value: `diktat-analysis.yml` in rootDir.
  */
  @get:InputFile
  @get:PathSensitive(PathSensitivity.RELATIVE)
- lateinit var diktatConfigFile: File
+ abstract val diktatConfigFile: RegularFileProperty
+
+ /**
+ * @return [PatternFilterable] to configure input files for diktat task
+ */
+ @Nested
+ abstract fun getInputs(): PatternFilterable
 
  /**
  * Configure input files for diktat task
  *
- * @param action configuration lambda for `PatternFilterable`
+ * @param action configuration lambda for [PatternFilterable]
  */
- fun inputs(action: PatternFilterable.() -> Unit) {
- action(patternSet)
- }
+ fun inputs(action: Action<in PatternFilterable>) = action.execute(getInputs())
 }

diktat-gradle-plugin/src/main/kotlin/com/saveourtool/diktat/plugin/gradle/DiktatGradlePlugin.kt

@@ -5,7 +5,6 @@ import com.saveourtool.diktat.plugin.gradle.tasks.DiktatFixTask.Companion.regist
 import com.saveourtool.diktat.plugin.gradle.tasks.configureMergeReportsTask
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.tasks.util.PatternSet
 
 /**
  * Plugin that configures diktat and registers tasks to run diktat
@@ -17,17 +16,15 @@ class DiktatGradlePlugin : Plugin<Project> {
  */
  @Suppress("TOO_LONG_FUNCTION")
  override fun apply(project: Project) {
- val patternSet = PatternSet()
  val diktatExtension = project.extensions.create(
  DIKTAT_EXTENSION,
  DiktatExtension::class.java,
- patternSet
  ).apply {
- diktatConfigFile = project.rootProject.file("diktat-analysis.yml")
+ diktatConfigFile.set(project.rootProject.file("diktat-analysis.yml"))
  }
 
- project.registerDiktatCheckTask(diktatExtension, patternSet)
- project.registerDiktatFixTask(diktatExtension, patternSet)
+ project.registerDiktatCheckTask(diktatExtension)
+ project.registerDiktatFixTask(diktatExtension)
  project.configureMergeReportsTask(diktatExtension)
  }
 

diktat-gradle-plugin/src/main/kotlin/com/saveourtool/diktat/plugin/gradle/Utils.kt

@@ -47,24 +47,24 @@ fun <T> Any.closureOf(action: T.() -> Unit): Closure<Any?> =
  * @return CLI flag as string
  */
 fun Project.getReporterType(diktatExtension: DiktatExtension): String {
- val name = diktatExtension.reporter.trim()
+ val reporter = diktatExtension.reporter.getOrElse("")
  val validReporters = listOf("sarif", "plain", "json", "html")
  val reporterType = when {
- diktatExtension.githubActions -> {
- if (diktatExtension.reporter.isNotEmpty()) {
- logger.warn("`diktat.githubActions` is set to true, so custom reporter [$name] will be ignored and SARIF reporter will be used")
+ diktatExtension.githubActions.getOrElse(false) -> {
+ if (reporter.isNotEmpty()) {
+ logger.warn("`diktat.githubActions` is set to true, so custom reporter [$reporter] will be ignored and SARIF reporter will be used")
  }
  "sarif"
  }
- name.isEmpty() -> {
+ reporter.isEmpty() -> {
  logger.info("Reporter name was not set. Using 'plain' reporter")
  "plain"
  }
- name !in validReporters -> {
- logger.warn("Reporter name is invalid (provided value: [$name]). Falling back to 'plain' reporter")
+ reporter !in validReporters -> {
+ logger.warn("Reporter name is invalid (provided value: [$reporter]). Falling back to 'plain' reporter")
  "plain"
  }
- else -> name
+ else -> reporter
  }
 
  return reporterType
@@ -78,15 +78,14 @@ fun Project.getReporterType(diktatExtension: DiktatExtension): String {
  * @return destination [File] or null if stdout is used
  */
 internal fun Project.getOutputFile(diktatExtension: DiktatExtension): File? = when {
- diktatExtension.githubActions -> project.layout.buildDirectory
+ diktatExtension.githubActions.getOrElse(false) -> project.layout.buildDirectory
  .file("reports/diktat/diktat.sarif")
  .get()
  .asFile
  .also {
  Files.createDirectories(it.parentFile.toPath())
  }
- diktatExtension.output.isNotEmpty() -> file(diktatExtension.output)
- else -> null
+ else -> diktatExtension.output.map { it.asFile }.orNull
 }
 
 /**

diktat-gradle-plugin/src/main/kotlin/com/saveourtool/diktat/plugin/gradle/tasks/DiktatCheckTask.kt

@@ -6,7 +6,6 @@ import com.saveourtool.diktat.plugin.gradle.DiktatExtension
 import com.saveourtool.diktat.plugin.gradle.DiktatGradlePlugin
 import org.gradle.api.Project
 import org.gradle.api.tasks.TaskProvider
-import org.gradle.api.tasks.util.PatternFilterable
 import org.gradle.api.tasks.util.PatternSet
 import javax.inject.Inject
 
@@ -15,8 +14,7 @@ import javax.inject.Inject
  */
 abstract class DiktatCheckTask @Inject constructor(
  extension: DiktatExtension,
- inputs: PatternFilterable
-) : DiktatTaskBase(extension, inputs) {
+) : DiktatTaskBase(extension) {
  override fun doRun(
  runner: DiktatRunner,
  args: DiktatRunnerArguments
@@ -30,11 +28,10 @@ abstract class DiktatCheckTask @Inject constructor(
  */
  fun Project.registerDiktatCheckTask(
  diktatExtension: DiktatExtension,
- patternSet: PatternSet
  ): TaskProvider<DiktatCheckTask> =
  tasks.register(
  DiktatGradlePlugin.DIKTAT_CHECK_TASK, DiktatCheckTask::class.java,
- diktatExtension, patternSet
+ diktatExtension,
  )
  }
 }

diktat-gradle-plugin/src/main/kotlin/com/saveourtool/diktat/plugin/gradle/tasks/DiktatFixTask.kt

@@ -6,17 +6,14 @@ import com.saveourtool.diktat.plugin.gradle.DiktatExtension
 import com.saveourtool.diktat.plugin.gradle.DiktatGradlePlugin
 import org.gradle.api.Project
 import org.gradle.api.tasks.TaskProvider
-import org.gradle.api.tasks.util.PatternFilterable
-import org.gradle.api.tasks.util.PatternSet
 import javax.inject.Inject
 
 /**
  * A task to check source code by diktat
  */
 abstract class DiktatFixTask @Inject constructor(
  extension: DiktatExtension,
- inputs: PatternFilterable
-) : DiktatTaskBase(extension, inputs) {
+) : DiktatTaskBase(extension) {
  override fun doRun(
  runner: DiktatRunner,
  args: DiktatRunnerArguments
@@ -27,16 +24,14 @@ abstract class DiktatFixTask @Inject constructor(
  companion object {
  /**
  * @param diktatExtension [DiktatExtension] with some values for task configuration
- * @param patternSet [PatternSet] to discover files for diktat fix
  * @return a [TaskProvider]
  */
  fun Project.registerDiktatFixTask(
  diktatExtension: DiktatExtension,
- patternSet: PatternSet
  ): TaskProvider<DiktatFixTask> =
  tasks.register(
  DiktatGradlePlugin.DIKTAT_FIX_TASK, DiktatFixTask::class.java,
- diktatExtension, patternSet
+ diktatExtension,
  )
  }
 }

diktat-gradle-plugin/src/main/kotlin/com/saveourtool/diktat/plugin/gradle/tasks/DiktatTaskBase.kt

@@ -14,59 +14,22 @@ import com.saveourtool.diktat.ruleset.rules.DiktatRuleConfigReaderImpl
 import com.saveourtool.diktat.ruleset.rules.DiktatRuleSetFactoryImpl
 
 import generated.DIKTAT_VERSION
-import generated.KTLINT_VERSION
-import org.gradle.api.DefaultTask
 import org.gradle.api.GradleException
-import org.gradle.api.file.FileCollection
-import org.gradle.api.tasks.IgnoreEmptyDirectories
-import org.gradle.api.tasks.InputFiles
 import org.gradle.api.tasks.Internal
-import org.gradle.api.tasks.PathSensitive
-import org.gradle.api.tasks.PathSensitivity
-import org.gradle.api.tasks.SkipWhenEmpty
+import org.gradle.api.tasks.SourceTask
 import org.gradle.api.tasks.TaskAction
 import org.gradle.api.tasks.VerificationTask
-import org.gradle.api.tasks.util.PatternFilterable
 
 import java.nio.file.Path
 
 /**
  * A base task to run `diktat`
  *
- * @param inputs
  * @property extension
  */
-@Suppress("WRONG_NEWLINES", "Deprecation")
 abstract class DiktatTaskBase(
  @get:Internal internal val extension: DiktatExtension,
- private val inputs: PatternFilterable
-) : DefaultTask(), VerificationTask, com.saveourtool.diktat.plugin.gradle.DiktatJavaExecTaskBase {
- /**
- * Files that will be analyzed by diktat
- */
- @get:IgnoreEmptyDirectories
- @get:SkipWhenEmpty
- @get:PathSensitive(PathSensitivity.RELATIVE)
- @get:InputFiles
- val actualInputs: FileCollection by lazy {
- if (inputs.includes.isEmpty() && inputs.excludes.isEmpty()) {
- inputs.include("src/**/*.kt")
- }
- project.objects.fileCollection().from(
- project.fileTree("${project.projectDir}").apply {
- exclude("${project.buildDir}")
- }
- .matching(inputs)
- )
- }
-
- /**
- * Whether diktat should be executed
- */
- @get:Internal
- internal val shouldRun: Boolean by lazy {
- !actualInputs.isEmpty
- }
+) : SourceTask(), VerificationTask {
  private val diktatRunnerFactory by lazy {
  DiktatRunnerFactory(
  diktatRuleConfigReader = DiktatRuleConfigReaderImpl(),
@@ -78,10 +41,10 @@ abstract class DiktatTaskBase(
  }
  private val diktatRunnerArguments by lazy {
  DiktatRunnerArguments(
- configFile = extension.diktatConfigFile.toPath(),
+ configFile = extension.diktatConfigFile.get().asFile.toPath(),
  sourceRootDir = project.projectDir.toPath(),
- files = actualInputs.files.map { it.toPath() },
- baselineFile = extension.baseline?.let { project.file(it).toPath() },
+ files = source.files.map { it.toPath() },
+ baselineFile = extension.baseline.map { it.asFile.toPath() }.orNull,
  reporterType = project.getReporterType(extension),
  reporterOutput = project.getOutputFile(extension)?.outputStream(),
  loggingListener = object : DiktatProcessorListener {
@@ -105,7 +68,15 @@ abstract class DiktatTaskBase(
  }
 
  init {
- ignoreFailures = extension.ignoreFailures
+ ignoreFailures = extension.ignoreFailures.getOrElse(false)
+ extension.getInputs().run {
+ if (includes.isEmpty() && excludes.isEmpty()) {
+ patternSet.include("src/**/*.kt")
+ } else {
+ patternSet.setIncludes(includes)
+ patternSet.setExcludes(excludes)
+ }
+ }
  }
 
  /**
@@ -115,14 +86,8 @@ abstract class DiktatTaskBase(
  */
  @TaskAction
  fun run() {
- if (extension.debug) {
- project.logger.lifecycle("Running diktat $DIKTAT_VERSION with ktlint $KTLINT_VERSION")
- }
- if (!shouldRun) {
- /*
- If ktlint receives empty patterns, it implicitly uses **/*.kt, **/*.kts instead.
- This can lead to diktat analyzing gradle buildscripts and so on. We want to prevent it.
- */
+ project.logger.lifecycle("Running diktat $DIKTAT_VERSION")
+ if (source.isEmpty) {
  project.logger.warn("Inputs for $name do not exist, will not run diktat")
  project.logger.info("Skipping diktat execution")
  } else {

diktat-gradle-plugin/src/main/kotlin/com/saveourtool/diktat/plugin/gradle/tasks/SarifReportMergeTask.kt

@@ -96,7 +96,7 @@ internal fun Project.configureMergeReportsTask(diktatExtension: DiktatExtension)
  reportMergeTask.shouldRunAfter(tasks.withType(DiktatTaskBase::class.java))
  }
  }
- tasks.withType(DiktatTaskBase::class.java).configureEach { diktatJavaExecTaskBase ->
- diktatJavaExecTaskBase.finalizedBy(rootProject.tasks.withType(SarifReportMergeTask::class.java))
+ tasks.withType(DiktatTaskBase::class.java).configureEach { diktatTaskBase ->
+ diktatTaskBase.finalizedBy(rootProject.tasks.withType(SarifReportMergeTask::class.java))
  }
 }