Migrate to KtLint 0.48.2

.editorconfig

@@ -1,3 +1,6 @@
+# https://editorconfig.org
+root = true
+
 [*]
 charset = utf-8
 indent_size = 4
@@ -99,3 +102,9 @@ ij_kotlin_while_on_new_line = false
 ij_kotlin_wrap_elvis_expressions = 1
 ij_kotlin_wrap_expression_body_functions = 1
 ij_kotlin_wrap_first_method_in_call_chain = false
+
+# disable ktlint rules
+ktlint_standard = disabled
+ktlint_experimental = disabled
+ktlint_test = disabled
+ktlint_custom = disabled

.github/workflows/build_and_test.yml

@@ -113,7 +113,7 @@ jobs:
         if: matrix.type == 'ktlint'
         run: |
           filename=$(ls -1 diktat-*.jar | head -n1)
-          echo DIKTAT_RUN="java -jar ktlint -R \"$filename\" --disabled_rules=standard,experimental,test,custom" >> $GITHUB_ENV
+          echo DIKTAT_RUN="java -jar ktlint -R \"$filename\"" >> $GITHUB_ENV
         shell: bash
 
       - name: Download diktat cli jar

diktat-ktlint-engine/src/main/kotlin/org/cqfn/diktat/ktlint/DiktatBaselineFactoryImpl.kt

@@ -6,7 +6,8 @@ import org.cqfn.diktat.api.DiktatProcessorListener
 import org.cqfn.diktat.api.DiktatProcessorListener.Companion.closeAfterAllAsProcessorListener
 import org.cqfn.diktat.ktlint.DiktatErrorImpl.Companion.wrap
 import org.cqfn.diktat.ktlint.DiktatReporterImpl.Companion.wrap
-import com.pinterest.ktlint.core.internal.loadBaseline
+import com.pinterest.ktlint.core.api.Baseline
+import com.pinterest.ktlint.core.api.loadBaseline
 import com.pinterest.ktlint.reporter.baseline.BaselineReporter
 import java.io.PrintStream
 import java.nio.file.Path
@@ -16,17 +17,15 @@ import kotlin.io.path.outputStream
 /**
  * A factory to create or generate [DiktatBaseline] using `KtLint`
  */
-@Suppress("DEPRECATION")
 class DiktatBaselineFactoryImpl : DiktatBaselineFactory {
     override fun tryToLoad(
         baselineFile: Path,
         sourceRootDir: Path,
     ): DiktatBaseline? = loadBaseline(baselineFile.absolutePathString())
-        .takeUnless { it.baselineGenerationNeeded }
+        .takeIf { it.status == Baseline.Status.VALID }
         ?.let { ktLintBaseline ->
             DiktatBaseline { file ->
-                ktLintBaseline.baselineRules
-                    ?.get(file.relativePathStringTo(sourceRootDir))
+                ktLintBaseline.lintErrorsPerFile[file.relativePathStringTo(sourceRootDir)]
                     .orEmpty()
                     .map { it.wrap() }
                     .toSet()

diktat-ktlint-engine/src/main/kotlin/org/cqfn/diktat/ktlint/DiktatProcessorFactoryImpl.kt

@@ -5,85 +5,56 @@ import org.cqfn.diktat.DiktatProcessorFactory
 import org.cqfn.diktat.api.DiktatCallback
 import org.cqfn.diktat.api.DiktatRuleSet
 import org.cqfn.diktat.ktlint.DiktatErrorImpl.Companion.wrap
-import org.cqfn.diktat.ktlint.KtLintRuleSetWrapper.Companion.toKtLint
-import org.cqfn.diktat.util.isKotlinScript
-
-import com.pinterest.ktlint.core.KtLint
+import org.cqfn.diktat.ktlint.KtLintRuleWrapper.Companion.toKtLint
+import com.pinterest.ktlint.core.Code
+import com.pinterest.ktlint.core.KtLintRuleEngine
 import com.pinterest.ktlint.core.LintError
-import com.pinterest.ktlint.core.api.EditorConfigOverride
-
-import java.nio.charset.StandardCharsets
 import java.nio.file.Path
 
-import kotlin.io.path.absolutePathString
-import kotlin.io.path.readText
-
-private typealias KtLintCallback = (LintError, Boolean) -> Unit
+private typealias FormatCallback = (LintError, Boolean) -> Unit
+private typealias LintCallback = (LintError) -> Unit
 
 /**
  * A factory to create [DiktatProcessor] using [DiktatProcessorFactory] and `KtLint` as engine
  */
 class DiktatProcessorFactoryImpl : DiktatProcessorFactory {
-    override fun invoke(diktatRuleSet: DiktatRuleSet): DiktatProcessor = object : DiktatProcessor {
-        override fun fix(file: Path, callback: DiktatCallback): String = KtLint.format(file.toKtLintParams(diktatRuleSet, callback))
-        override fun fix(
-            code: String,
-            isScript: Boolean,
-            callback: DiktatCallback
-        ): String = KtLint.format(code.toKtLintParams(isScript, diktatRuleSet, callback))
-        override fun check(file: Path, callback: DiktatCallback) = KtLint.lint(file.toKtLintParams(diktatRuleSet, callback))
-        override fun check(
-            code: String,
-            isScript: Boolean,
-            callback: DiktatCallback
-        ) = KtLint.lint(code.toKtLintParams(isScript, diktatRuleSet, callback))
+    override fun invoke(diktatRuleSet: DiktatRuleSet): DiktatProcessor {
+        val ktLintRuleEngine = diktatRuleSet.toKtLintEngine()
+        return object : DiktatProcessor {
+            override fun fix(
+                file: Path,
+                callback: DiktatCallback,
+            ): String = ktLintRuleEngine.format(file.toKtLint(), callback.toKtLintForFormat())
+            override fun fix(
+                code: String,
+                isScript: Boolean,
+                callback: DiktatCallback
+            ): String = ktLintRuleEngine.format(code.toKtLint(isScript), callback.toKtLintForFormat())
+            override fun check(
+                file: Path,
+                callback: DiktatCallback,
+            ) = ktLintRuleEngine.lint(file.toKtLint(), callback.toKtLintForLint())
+            override fun check(
+                code: String,
+                isScript: Boolean,
+                callback: DiktatCallback
+            ) = ktLintRuleEngine.lint(code.toKtLint(isScript), callback.toKtLintForLint())
+        }
     }
 
     companion object {
-        private fun Path.toKtLintParams(
-            diktatRuleSet: DiktatRuleSet,
-            callback: DiktatCallback,
-        ): KtLint.ExperimentalParams = ktLintParams(
-            fileName = absolutePathString(),
-            text = readText(StandardCharsets.UTF_8).replace("\r\n", "\n").replace("\r", "\n"),
-            isScript = isKotlinScript(),
-            diktatRuleSet = diktatRuleSet,
-            callback = callback,
-        )
+        private fun DiktatRuleSet.toKtLintEngine(): KtLintRuleEngine = KtLintRuleEngine(ruleProviders = toKtLint())
 
-        private fun String.toKtLintParams(
-            isScript: Boolean,
-            diktatRuleSet: DiktatRuleSet,
-            callback: DiktatCallback,
-        ): KtLint.ExperimentalParams = ktLintParams(
-            fileName = if (isScript) "test.kts" else "test.kt",
-            text = this,
-            isScript = isScript,
-            diktatRuleSet = diktatRuleSet,
-            callback = callback,
-        )
+        private fun Path.toKtLint(): Code = Code.CodeFile(this.toFile())
 
-        private fun ktLintParams(
-            fileName: String,
-            text: String,
-            isScript: Boolean,
-            diktatRuleSet: DiktatRuleSet,
-            callback: DiktatCallback,
-        ): KtLint.ExperimentalParams = KtLint.ExperimentalParams(
-            fileName = fileName,
-            text = text,
-            ruleSets = setOf(diktatRuleSet.toKtLint()),
-            userData = emptyMap(),
-            cb = callback.toKtLint(),
-            script = isScript,
-            editorConfigPath = null,
-            debug = false,  // we do not use it
-            editorConfigOverride = EditorConfigOverride.emptyEditorConfigOverride,
-            isInvokedFromCli = false
-        )
+        private fun String.toKtLint(isScript: Boolean): Code = Code.CodeSnippet(this, isScript)
 
-        private fun DiktatCallback.toKtLint(): KtLintCallback = { error, isCorrected ->
+        private fun DiktatCallback.toKtLintForFormat(): FormatCallback = { error, isCorrected ->
             this(error.wrap(), isCorrected)
         }
+
+        private fun DiktatCallback.toKtLintForLint(): LintCallback = { error ->
+            this(error.wrap(), false)
+        }
     }
 }

diktat-ktlint-engine/src/main/kotlin/org/cqfn/diktat/ktlint/DiktatReporterFactoryImpl.kt

@@ -7,8 +7,8 @@ import com.pinterest.ktlint.core.ReporterProvider
 import com.pinterest.ktlint.reporter.checkstyle.CheckStyleReporterProvider
 import com.pinterest.ktlint.reporter.html.HtmlReporterProvider
 import com.pinterest.ktlint.reporter.json.JsonReporterProvider
+import com.pinterest.ktlint.reporter.plain.Color
 import com.pinterest.ktlint.reporter.plain.PlainReporterProvider
-import com.pinterest.ktlint.reporter.plain.internal.Color
 import com.pinterest.ktlint.reporter.sarif.SarifReporterProvider
 import java.io.OutputStream
 import java.io.PrintStream

diktat-ktlint-engine/src/main/kotlin/org/cqfn/diktat/ktlint/KtLintRuleWrapper.kt

@@ -1,8 +1,10 @@
 package org.cqfn.diktat.ktlint
 
 import org.cqfn.diktat.api.DiktatRule
+import org.cqfn.diktat.api.DiktatRuleSet
 import org.cqfn.diktat.common.config.rules.DIKTAT_RULE_SET_ID
 import com.pinterest.ktlint.core.Rule
+import com.pinterest.ktlint.core.RuleProvider
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 
 private typealias EmitType = (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit
@@ -18,17 +20,26 @@ class KtLintRuleWrapper(
     id = rule.id.qualifiedWithRuleSetId(DIKTAT_RULE_SET_ID),
     visitorModifiers = createVisitorModifiers(rule, prevRule),
 ) {
-    @Deprecated(
-        "Marked for deletion in ktlint 0.48.0",
-        replaceWith = ReplaceWith("beforeVisitChildNodes(node, autoCorrect, emit)"),
-    )
-    override fun visit(
+    override fun beforeVisitChildNodes(
         node: ASTNode,
         autoCorrect: Boolean,
         emit: EmitType,
     ) = rule.invoke(node, autoCorrect, emit)
 
     companion object {
+        private fun Sequence<DiktatRule>.wrapRules(): Sequence<Rule> = runningFold(null as KtLintRuleWrapper?) { prevRule, diktatRule ->
+            KtLintRuleWrapper(diktatRule, prevRule)
+        }.filterNotNull()
+
+        /**
+         * @return [Set] of __KtLint__'s [RuleProvider]s created from [DiktatRuleSet]
+         */
+        fun DiktatRuleSet.toKtLint(): Set<RuleProvider> = rules
+            .asSequence()
+            .wrapRules()
+            .map { it.asProvider() }
+            .toSet()
+
         private fun createVisitorModifiers(
             rule: DiktatRule,
             prevRule: KtLintRuleWrapper?,
@@ -51,5 +62,10 @@ class KtLintRuleWrapper(
          * @return a rule to which a logic is delegated
          */
         internal fun Rule.unwrap(): DiktatRule = (this as? KtLintRuleWrapper)?.rule ?: error("Provided rule ${javaClass.simpleName} is not wrapped by diktat")
+
+        /**
+         * @return wraps [Rule] to [RuleProvider]
+         */
+        internal fun Rule.asProvider(): RuleProvider = RuleProvider { this }
     }
 }

diktat-ktlint-engine/src/test/kotlin/org/cqfn/diktat/ktlint/KtLintRuleSetWrapperTest.kt → diktat-ktlint-engine/src/test/kotlin/org/cqfn/diktat/ktlint/KtLintRuleWrapperTest.kt

@@ -1,19 +1,21 @@
 package org.cqfn.diktat.ktlint
 
+import com.pinterest.ktlint.core.Code
+import com.pinterest.ktlint.core.KtLintRuleEngine
 import org.cqfn.diktat.api.DiktatErrorEmitter
 import org.cqfn.diktat.api.DiktatRule
 import org.cqfn.diktat.api.DiktatRuleSet
-import org.cqfn.diktat.ktlint.KtLintRuleSetWrapper.Companion.toKtLint
+import org.cqfn.diktat.ktlint.KtLintRuleWrapper.Companion.toKtLint
 import org.cqfn.diktat.ktlint.KtLintRuleWrapper.Companion.unwrap
-import com.pinterest.ktlint.core.KtLint
 import com.pinterest.ktlint.core.Rule
+import com.pinterest.ktlint.core.RuleProvider
 import org.assertj.core.api.Assertions.assertThat
 import org.intellij.lang.annotations.Language
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
 
-class KtLintRuleSetWrapperTest {
+class KtLintRuleWrapperTest {
     @Test
     fun `check KtLintRuleSetWrapper with duplicate`() {
         val rule = mockRule("rule")
@@ -27,12 +29,12 @@ class KtLintRuleSetWrapperTest {
         val rule1 = mockRule(id = "rule-first")
         val rule2 = mockRule(id = "rule-second")
 
-        val orderedRuleSet = DiktatRuleSet(listOf(rule1, rule2)).toKtLint()
+        val orderedRuleProviders = DiktatRuleSet(listOf(rule1, rule2)).toKtLint()
 
-        val orderedRuleSetIterator = orderedRuleSet.rules.iterator()
-        val orderedRule1 = orderedRuleSetIterator.next()
-        val orderedRule2 = orderedRuleSetIterator.next()
-        Assertions.assertFalse(orderedRuleSetIterator.hasNext(), "Extra elements after ordering")
+        val orderedRuleProviderIterator = orderedRuleProviders.iterator()
+        val orderedRule1 = orderedRuleProviderIterator.next().createNewRuleInstance()
+        val orderedRule2 = orderedRuleProviderIterator.next().createNewRuleInstance()
+        Assertions.assertFalse(orderedRuleProviderIterator.hasNext(), "Extra elements after ordering")
 
         Assertions.assertEquals(rule1, orderedRule1.unwrap(), "First rule is modified")
 
@@ -74,18 +76,18 @@ class KtLintRuleSetWrapperTest {
         /*
          * Make sure OrderedRuleSet preserves the order.
          */
-        val ruleSet = DiktatRuleSet(rules).toKtLint()
-        assertThat(ruleSet.rules.map(Rule::id)).containsExactlyElementsOf(rules.map(DiktatRule::id).map { it.qualifiedWithRuleSetId() })
+        val ruleProviders = DiktatRuleSet(rules).toKtLint()
+        assertThat(ruleProviders.map(RuleProvider::createNewRuleInstance).map(Rule::id))
+            .containsExactlyElementsOf(rules.map(DiktatRule::id).map { it.qualifiedWithRuleSetId() })
 
         @Language("kotlin")
         val code = "fun foo() { }"
 
-        KtLint.lint(
-            KtLint.ExperimentalParams(
-                fileName = "TestFileName.kt",
-                text = code,
-                ruleSets = listOf(ruleSet),
-                cb = { _, _ -> },
+        KtLintRuleEngine(
+            ruleProviders = ruleProviders
+        ).lint(
+            code = Code.CodeSnippet(
+                content = code
             )
         )
 
@@ -123,20 +125,13 @@ class KtLintRuleSetWrapperTest {
          *            |
          *            V
          * C(File) -> C(Node) -> C(Leaf)
-         *
-         * val expectedRuleInvocationOrder = rules.asSequence()
-         *     .map(Rule::id)
-         *     .flatMap { ruleId ->
-         *         generateSequence { ruleId }.take(astNodeCount)
-         *     }
-         *     .toList()
          */
-        val expectedRuleInvocationOrder = generateSequence {
-            rules.map(DiktatRule::id)
-        }
-            .take(astNodeCount)
-            .flatten()
-            .toList()
+         val expectedRuleInvocationOrder = rules.asSequence()
+              .map(DiktatRule::id)
+              .flatMap { ruleId ->
+                  generateSequence { ruleId }.take(astNodeCount)
+              }
+              .toList()
 
         assertThat(actualRuleInvocationOrder)
             .containsExactlyElementsOf(expectedRuleInvocationOrder)