Migration to Gradle

build.gradle.kts

@@ -0,0 +1,21 @@
+@Suppress("DSL_SCOPE_VIOLATION", "RUN_IN_SCRIPT")  // https://github.com/gradle/gradle/issues/22797
+plugins {
+    id("org.cqfn.diktat.buildutils.versioning-configuration")
+    id("org.cqfn.diktat.buildutils.code-quality-convention")
+    id("org.cqfn.diktat.buildutils.publishing-configuration")
+    alias(libs.plugins.talaiot.base)
+    java
+}
+
+talaiot {
+    metrics {
+        // disabling due to problems with OSHI on some platforms
+        performanceMetrics = false
+        environmentMetrics = false
+    }
+    publishers {
+        timelinePublisher = true
+    }
+}
+
+project.description = "diKTat kotlin formatter and fixer"

diktat-common/build.gradle.kts

@@ -0,0 +1,18 @@
+@Suppress("DSL_SCOPE_VIOLATION", "RUN_IN_SCRIPT")  // https://github.com/gradle/gradle/issues/22797
+plugins {
+    id("org.cqfn.diktat.buildutils.kotlin-jvm-configuration")
+    id("org.cqfn.diktat.buildutils.code-quality-convention")
+    alias(libs.plugins.kotlin.plugin.serialization)
+}
+
+dependencies {
+    implementation(libs.kotlin.stdlib.jdk8)
+    implementation(libs.kotlinx.serialization.json.jvm)
+    api(libs.kaml)
+    implementation(libs.apache.commons.cli)
+    implementation(libs.kotlin.logging)
+    // ktlint-core is needed only for `initKtLintKLogger` method
+    implementation(libs.ktlint.core)
+    testImplementation(libs.junit.jupiter)
+    testImplementation(libs.assertj.core)
+}

diktat-dev-ksp/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+    kotlin("jvm")
+}
+
+dependencies {
+    implementation("com.google.devtools.ksp:symbol-processing-api:1.8.10-1.0.9")
+}

diktat-dev-ksp/src/main/kotlin/org/cqfn/diktat/ruleset/generation/EnumNamesSymbolProcessor.kt

@@ -0,0 +1,71 @@
+package org.cqfn.diktat.ruleset.generation
+
+import com.google.devtools.ksp.getClassDeclarationByName
+import com.google.devtools.ksp.processing.CodeGenerator
+import com.google.devtools.ksp.processing.Dependencies
+import com.google.devtools.ksp.processing.Resolver
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.symbol.ClassKind
+import com.google.devtools.ksp.symbol.KSAnnotated
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+
+/**
+ * [SymbolProcessor] to generate a class with contacts for names from provided enum
+ */
+class EnumNamesSymbolProcessor(
+    private val sourceEnumName: String,
+    private val targetPackageName: String,
+    private val targetClassName: String,
+    private val codeGenerator: CodeGenerator,
+) : SymbolProcessor {
+    override fun process(resolver: Resolver): List<KSAnnotated> {
+        val enumDeclaration = requireNotNull(resolver.getClassDeclarationByName(sourceEnumName)) {
+            "Not found class provided by property <${EnumNamesSymbolProcessorProvider.OPTION_NAME_SOURCE_ENUM_NAME}>"
+        }
+        require(enumDeclaration.classKind == ClassKind.ENUM_CLASS) {
+            "Provided class $sourceEnumName is not enum"
+        }
+
+        resolver.getNewFiles()
+            .find { it.packageName.asString() == targetPackageName && it.fileName == "$targetClassName.kt" }
+            ?.run {
+                return emptyList()
+            }
+        codeGenerator.createNewFile(
+            dependencies = Dependencies.ALL_FILES,
+            packageName = targetPackageName,
+            fileName = targetClassName,
+        ).bufferedWriter()
+            .use { writer ->
+                writer.write(autoGenerationComment)
+                writer.newLine()
+                writer.write("package $targetPackageName\n")
+                writer.newLine()
+                writer.write("import kotlin.String\n")
+                writer.newLine()
+                writer.write("object $targetClassName {\n")
+                enumDeclaration.declarations
+                    .filterIsInstance<KSClassDeclaration>()
+                    .filter { it.classKind == ClassKind.ENUM_ENTRY }
+                    .map { it.simpleName.asString() }
+                    .forEach { enumEntryName ->
+                        writer.write("    const val $enumEntryName: String = \"$enumEntryName\"\n")
+                    }
+                writer.write("}\n")
+            }
+        return emptyList()
+    }
+
+    companion object {
+        /**
+         * The comment that will be added to the generated sources file.
+         */
+        private val autoGenerationComment =
+            """
+                |/**
+                | * This document was auto generated, please don't modify it.
+                | * This document contains all enum properties from Warnings.kt as Strings.
+                | */
+            """.trimMargin()
+    }
+}

diktat-dev-ksp/src/main/kotlin/org/cqfn/diktat/ruleset/generation/EnumNamesSymbolProcessorProvider.kt

@@ -0,0 +1,36 @@
+package org.cqfn.diktat.ruleset.generation
+
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
+import com.google.devtools.ksp.processing.SymbolProcessorProvider
+
+/**
+ * [SymbolProcessorProvider] for [EnumNamesSymbolProcessor]
+ */
+class EnumNamesSymbolProcessorProvider : SymbolProcessorProvider {
+    override fun create(
+        environment: SymbolProcessorEnvironment,
+    ): SymbolProcessor = EnumNamesSymbolProcessor(
+        sourceEnumName = environment.options.getValue(OPTION_NAME_SOURCE_ENUM_NAME),
+        targetPackageName = environment.options.getValue(OPTION_NAME_TARGET_PACKAGE_NAME),
+        targetClassName = environment.options.getValue(OPTION_NAME_TARGET_CLASS_NAME),
+        codeGenerator = environment.codeGenerator,
+    )
+
+    companion object {
+        /**
+         * Option name to specify `enumName`
+         */
+        const val OPTION_NAME_SOURCE_ENUM_NAME = "sourceEnumName"
+
+        /**
+         * Option name to specify `packageName` for target class
+         */
+        const val OPTION_NAME_TARGET_PACKAGE_NAME = "targetPackageName"
+
+        /**
+         * Option name to specify `className` for target class
+         */
+        const val OPTION_NAME_TARGET_CLASS_NAME = "targetClassName"
+    }
+}

diktat-dev-ksp/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider

@@ -0,0 +1 @@
+org.cqfn.diktat.ruleset.generation.EnumNamesSymbolProcessorProvider

diktat-gradle-plugin/build.gradle.kts

@@ -1,42 +1,19 @@
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform.getCurrentOperatingSystem
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     `java-gradle-plugin`
-    kotlin("jvm") version "1.8.10"
-    jacoco
+    id("org.cqfn.diktat.buildutils.kotlin-jvm-configuration")
+    id("org.cqfn.diktat.buildutils.code-quality-convention")
     id("pl.droidsonroids.jacoco.testkit") version "1.0.9"
     id("org.gradle.test-retry") version "1.5.2"
 }
 
-repositories {
-    flatDir {
-        // to use snapshot diktat without necessary installing
-        dirs("../diktat-common/target")
-        content {
-            includeGroup("org.cqfn.diktat")
-        }
-    }
-    mavenCentral()
-    mavenLocal {
-        // to use snapshot diktat
-        content {
-            includeGroup("org.cqfn.diktat")
-        }
-    }
-}
-
-// default value is needed for correct gradle loading in IDEA; actual value from maven is used during build
-// To debug gradle plugin, please set `diktatVersion` manually to the current maven project version.
-val ktlintVersion = project.properties.getOrDefault("ktlintVersion", "0.46.1") as String
-val diktatVersion = project.version.takeIf { it.toString() != Project.DEFAULT_VERSION } ?: "1.2.3"
-val junitVersion = project.properties.getOrDefault("junitVersion", "5.8.1") as String
-val jacocoVersion = project.properties.getOrDefault("jacocoVersion", "0.8.7") as String
 dependencies {
     implementation(kotlin("gradle-plugin-api"))
-    implementation("io.github.detekt.sarif4k:sarif4k:0.3.0")
+    implementation(libs.sarif4k.jvm)
 
-    implementation("org.cqfn.diktat:diktat-common:$diktatVersion") {
+    api(projects.diktatCommon) {
         exclude("org.jetbrains.kotlin", "kotlin-compiler-embeddable")
         exclude("org.jetbrains.kotlin", "kotlin-stdlib-jdk8")
         exclude("org.jetbrains.kotlin", "kotlin-stdlib-jdk7")
@@ -45,15 +22,21 @@ dependencies {
         exclude("org.slf4j", "slf4j-log4j12")
     }
 
-    testImplementation("org.junit.jupiter:junit-jupiter-api:$junitVersion")
-    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:$junitVersion")
+    testImplementation(libs.junit.jupiter.api)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+
+    // FIXME: it should come as transitive dependency from projects.diktatCommon
+    implementation(libs.kotlinx.serialization.json)
 }
 
 val generateVersionsFile by tasks.registering {
     val versionsFile = File("$buildDir/generated/src/generated/Versions.kt")
+    val diktatVersion = project.version.toString()
+    val ktlintVersion = libs.versions.ktlint.get()
 
     inputs.property("diktat version", diktatVersion)
     inputs.property("ktlint version", ktlintVersion)
+
     outputs.file(versionsFile)
 
     doFirst {
@@ -100,11 +83,10 @@ val functionalTestTask by tasks.register<Test>("functionalTest")
 tasks.withType<Test> {
     useJUnitPlatform()
 }
-jacoco.toolVersion = jacocoVersion
 
 // === integration testing
 // fixme: should probably use KotlinSourceSet instead
-val functionalTest = sourceSets.create("functionalTest") {
+val functionalTest: SourceSet = sourceSets.create("functionalTest") {
     compileClasspath += sourceSets.main.get().output + configurations.testRuntimeClasspath.get()
     runtimeClasspath += output + compileClasspath
 }