From 0bac1175a60c31d9ef1bed26d8c70e5245b83183 Mon Sep 17 00:00:00 2001 From: wakingrufus Date: Fri, 13 Jan 2023 15:05:22 -0600 Subject: [PATCH] support ktlint 0.46-0.48 add tests for 0.44 and 0.45 as well This resolves #589 This resolves #607 --- CHANGELOG.md | 4 + .../gradle/ktlint/worker/KtLintInvocation.kt | 320 ++++++++++++++++++ .../gradle/ktlint/worker/KtLintRuleLoader.kt | 36 ++ .../gradle/ktlint/worker/KtLintWorkAction.kt | 108 +++--- .../gradle/ktlint/AbstractPluginTest.kt | 12 +- .../gradle/ktlint/ConfigurationCacheTest.kt | 4 +- .../gradle/ktlint/DisabledRulesTest.kt | 26 +- .../ktlint/KtLintSupportedVersionsTest.kt | 8 +- .../ktlint/KtlintBaselineSupportTest.kt | 10 +- .../gradle/ktlint/KtlintPluginTest.kt | 10 +- .../gradle/ktlint/testdsl/testDsl.kt | 4 +- 11 files changed, 466 insertions(+), 76 deletions(-) create mode 100644 plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintInvocation.kt create mode 100644 plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintRuleLoader.kt diff --git a/CHANGELOG.md b/CHANGELOG.md index 0c63ed11..6490ba0a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/). ## [Unreleased] +### Added + +- The plugin will now work with ktlint `0.46.1` - `0.48.1` + ## [11.0.0] - 2022-08-24 ### Changed diff --git a/plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintInvocation.kt b/plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintInvocation.kt new file mode 100644 index 00000000..27fb0528 --- /dev/null +++ b/plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintInvocation.kt @@ -0,0 +1,320 @@ +package org.jlleitschuh.gradle.ktlint.worker + +import com.pinterest.ktlint.core.LintError +import com.pinterest.ktlint.core.api.FeatureInAlphaState +import java.io.File +import kotlin.reflect.KFunction +import kotlin.reflect.full.findParameterByName +import kotlin.reflect.full.instanceParameter +import kotlin.reflect.full.memberFunctions +import kotlin.reflect.full.memberProperties +import kotlin.reflect.full.primaryConstructor + +/** + * An abstraction for invoking ktlint across all breaking changes between versions + */ +internal sealed interface KtLintInvocation { + fun invokeLint(file: File, cb: (LintError, Boolean) -> Unit) + fun invokeFormat(file: File, cb: (LintError, Boolean) -> Unit): String +} + +sealed interface KtLintInvocationFactory + +/** + * Implementation for invoking ktlint prior to 0.46.0 + * Does not use reflection because the API is the same as the version of ktlint this project is compiled against + */ +internal class LegacyParamsInvocation( + private val editorConfigPath: String?, + private val ruleSets: Set, + private val userData: Map, + private val debug: Boolean +) : KtLintInvocation { + companion object Factory : KtLintInvocationFactory { + fun initialize( + editorConfigPath: String?, + ruleSets: Set, + userData: Map, + debug: Boolean + ): KtLintInvocation = LegacyParamsInvocation( + editorConfigPath = editorConfigPath, + ruleSets = ruleSets, + userData = userData, + debug = debug + ) + } + + private fun buildParams(file: File, cb: (LintError, Boolean) -> Unit): com.pinterest.ktlint.core.KtLint.Params { + val script = !file.name.endsWith(".kt", ignoreCase = true) + return com.pinterest.ktlint.core.KtLint.Params( + fileName = file.absolutePath, + text = file.readText(), + ruleSets = ruleSets, + userData = userData, + debug = debug, + editorConfigPath = editorConfigPath, + script = script, + cb = cb + ) + } + + override fun invokeLint(file: File, cb: (LintError, Boolean) -> Unit) { + com.pinterest.ktlint.core.KtLint.lint(buildParams(file, cb)) + } + + override fun invokeFormat(file: File, cb: (LintError, Boolean) -> Unit): String { + return com.pinterest.ktlint.core.KtLint.format(buildParams(file, cb)) + } +} + +/** + * Implementation for invoking ktlint 0.46.x + */ +@OptIn(FeatureInAlphaState::class) +internal class ExperimentalParamsInvocation( + private val editorConfigPath: String?, + private val ruleSets: Set, + private val userData: Map, + private val debug: Boolean +) : KtLintInvocation { + companion object Factory : KtLintInvocationFactory { + fun initialize( + editorConfigPath: String?, + ruleSets: Set, + userData: Map, + debug: Boolean + ): KtLintInvocation = ExperimentalParamsInvocation( + editorConfigPath = editorConfigPath, + ruleSets = ruleSets, + userData = userData, + debug = debug + ) + } + + private fun buildParams( + file: File, + cb: (LintError, Boolean) -> Unit + ): com.pinterest.ktlint.core.KtLint.ExperimentalParams { + val script = !file.name.endsWith(".kt", ignoreCase = true) + val ctor = experimentalParamsClass!!.kotlin.primaryConstructor + val editorConfigOverride = userDataToEditorConfigOverride(userData) + return ctor!!.callBy( + mapOf( + ctor.findParameterByName("fileName")!! to file.absolutePath, + ctor.findParameterByName("text")!! to file.readText(), + ctor.findParameterByName("ruleSets")!! to ruleSets, + ctor.findParameterByName("cb")!! to cb, + ctor.findParameterByName("script")!! to script, + ctor.findParameterByName("editorConfigPath")!! to editorConfigPath, + ctor.findParameterByName("debug")!! to debug, + ctor.findParameterByName("editorConfigOverride")!! to editorConfigOverride + ) + ) as com.pinterest.ktlint.core.KtLint.ExperimentalParams + } + + override fun invokeLint(file: File, cb: (LintError, Boolean) -> Unit) { + com.pinterest.ktlint.core.KtLint.lint(buildParams(file, cb)) + } + + override fun invokeFormat(file: File, cb: (LintError, Boolean) -> Unit): String { + return com.pinterest.ktlint.core.KtLint.format(buildParams(file, cb)) + } +} + +fun getCodeStyle(styleName: String): Any { + return try { + Class.forName("com.pinterest.ktlint.core.api.DefaultEditorConfigProperties\$CodeStyleValue") + .getDeclaredField(styleName).get(null) + } catch (e: ClassNotFoundException) { + (Class.forName("com.pinterest.ktlint.core.api.editorconfig.CodeStyleValue").enumConstants as Array>).first { + it.name == styleName + } + } +} + +fun getEditorConfigPropertyClass(): Class<*> { + return try { + Class.forName("com.pinterest.ktlint.core.api.UsesEditorConfigProperties\$EditorConfigProperty") + } catch (e: ClassNotFoundException) { + Class.forName("com.pinterest.ktlint.core.api.editorconfig.EditorConfigProperty") + } +} + +@Suppress("UnnecessaryOptInAnnotation") +@OptIn(FeatureInAlphaState::class) +fun userDataToEditorConfigOverride(userData: Map): Any { + val defaultEditorConfigPropertiesClass = + Class.forName("com.pinterest.ktlint.core.api.DefaultEditorConfigProperties") + val defaultEditorConfigProperties = defaultEditorConfigPropertiesClass.kotlin.objectInstance + val codeStyle = getCodeStyle(if (userData["android"]?.toBoolean() == true) "android" else "official") + val editorConfigOverrideClass = Class.forName("com.pinterest.ktlint.core.api.EditorConfigOverride") + val editorConfigOverride = editorConfigOverrideClass.kotlin.primaryConstructor!!.call() + val addMethod = editorConfigOverrideClass.getDeclaredMethod("add", getEditorConfigPropertyClass(), Any::class.java) + addMethod.isAccessible = true + val disabledRulesProperty = + defaultEditorConfigPropertiesClass.kotlin.memberProperties.firstOrNull { it.name == "ktlintDisabledRulesProperty" } + ?: defaultEditorConfigPropertiesClass.kotlin.memberProperties.first { it.name == "disabledRulesProperty" } + val codeStyleSetProperty = + defaultEditorConfigPropertiesClass.kotlin.memberProperties.first { it.name == "codeStyleSetProperty" } + addMethod.invoke( + editorConfigOverride, disabledRulesProperty.getter.call(defaultEditorConfigProperties), + userData["disabled_rules"] + ) + addMethod.invoke(editorConfigOverride, codeStyleSetProperty.getter.call(defaultEditorConfigProperties), codeStyle) + return editorConfigOverride +} + +/** + * Implementation for invoking ktlint 0.47.x + */ +@OptIn(FeatureInAlphaState::class) +internal class ExperimentalParamsProviderInvocation( + private val editorConfigPath: String?, + private val ruleProviders: Set, + private val userData: Map, + private val debug: Boolean, +) : KtLintInvocation { + companion object Factory : KtLintInvocationFactory { + fun initialize( + editorConfigPath: String?, + ruleProviders: Set, + userData: Map, + debug: Boolean + ): ExperimentalParamsProviderInvocation = + ExperimentalParamsProviderInvocation(editorConfigPath, ruleProviders, userData, debug) + } + + private fun buildParams( + file: File, + cb: (LintError, Boolean) -> Unit + ): com.pinterest.ktlint.core.KtLint.ExperimentalParams { + val script = !file.name.endsWith(".kt", ignoreCase = true) + val ctor = experimentalParamsClass!!.kotlin.primaryConstructor + val editorConfigOverride = userDataToEditorConfigOverride(userData) + return ctor!!.callBy( + mapOf( + ctor.findParameterByName("fileName")!! to file.absolutePath, + ctor.findParameterByName("text")!! to file.readText(), + ctor.findParameterByName("ruleProviders")!! to ruleProviders, + ctor.findParameterByName("cb")!! to cb, + ctor.findParameterByName("script")!! to script, + ctor.findParameterByName("editorConfigPath")!! to editorConfigPath, + ctor.findParameterByName("debug")!! to debug, + ctor.findParameterByName("editorConfigOverride")!! to editorConfigOverride + ) + ) as com.pinterest.ktlint.core.KtLint.ExperimentalParams + } + + override fun invokeLint(file: File, cb: (LintError, Boolean) -> Unit) { + com.pinterest.ktlint.core.KtLint.lint(buildParams(file, cb)) + } + + override fun invokeFormat(file: File, cb: (LintError, Boolean) -> Unit): String { + return com.pinterest.ktlint.core.KtLint.format(buildParams(file, cb)) + } +} + +/** + * Implementation for invoking ktlint >= 0.48 + * This should be the long term API. + * We can't compile against this version though, since it is compiled on a newer version of kotlin than gradle embeds. + */ +internal class RuleEngineInvocation( + private val engine: Any, + private val lintMethod: KFunction<*>, + private val formatMethod: KFunction<*> +) : KtLintInvocation { + companion object Factory : KtLintInvocationFactory { + fun initialize(ruleProviders: Set, userData: Map): RuleEngineInvocation { + val editorConfigOverride = userDataToEditorConfigOverride(userData) + val ctor = ruleEngineClass!!.kotlin.primaryConstructor + val engine = ctor!!.callBy( + mapOf( + ctor.findParameterByName("ruleProviders")!! to ruleProviders, + ctor.findParameterByName("editorConfigOverride")!! to editorConfigOverride + ) + ) + val lintMethod = engine::class.memberFunctions.first { + it.name == "lint" && it.parameters.map { it.name }.containsAll(setOf("code", "filePath", "callback")) + } + val formatMethod = engine::class.memberFunctions.first { + it.name == "format" && it.parameters.map { it.name }.containsAll(setOf("code", "filePath", "callback")) + } + return RuleEngineInvocation(engine, lintMethod, formatMethod) + } + } + + override fun invokeLint(file: File, cb: (LintError, Boolean) -> Unit) { + lintMethod.callBy( + mapOf( + lintMethod.instanceParameter!! to engine, + lintMethod.findParameterByName("code")!! to file.readText(), + lintMethod.findParameterByName("filePath")!! to file.absoluteFile.toPath(), + lintMethod.findParameterByName("callback")!! to { le: LintError -> cb.invoke(le, false) } + ) + ) + } + + override fun invokeFormat(file: File, cb: (LintError, Boolean) -> Unit): String { + return formatMethod.callBy( + mapOf( + formatMethod.instanceParameter!! to engine, + formatMethod.findParameterByName("code")!! to file.readText(), + formatMethod.findParameterByName("filePath")!! to file.absoluteFile.toPath(), + formatMethod.findParameterByName("callback")!! to cb + ) + ) as String + } +} + +/** + * detect the params class for ktlint < 0.46 + */ +val legacyParamsClass: Class<*>? by lazy { + try { + Class.forName("com.pinterest.ktlint.core.KtLint\$Params") + } catch (e: Exception) { + null + } +} + +/** + * detect the params class for ktlint 0.46.x and 0.47.x + */ +val experimentalParamsClass: Class<*>? by lazy { + try { + Class.forName("com.pinterest.ktlint.core.KtLint\$ExperimentalParams") + } catch (e: Exception) { + null + } +} + +/** + * detect the RuleEngine class for ktlint >= 0.48.0 + */ +val ruleEngineClass: Class<*>? by lazy { + try { + Class.forName("com.pinterest.ktlint.core.KtLintRuleEngine") + } catch (e: Exception) { + null + } +} + +internal fun selectInvocation(): KtLintInvocationFactory? { + if (legacyParamsClass != null) { + return LegacyParamsInvocation + } + if (ruleEngineClass != null) { + return RuleEngineInvocation + } + return experimentalParamsClass?.let { + val ctor = it.kotlin.primaryConstructor + if (ctor?.findParameterByName("ruleProviders") != null) { + // ktlint = 0.47.x + ExperimentalParamsProviderInvocation + } else { + // ktlint = 0.46.x + ExperimentalParamsInvocation + } + } +} diff --git a/plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintRuleLoader.kt b/plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintRuleLoader.kt new file mode 100644 index 00000000..dcc0cf0f --- /dev/null +++ b/plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintRuleLoader.kt @@ -0,0 +1,36 @@ +package org.jlleitschuh.gradle.ktlint.worker + +import java.util.ServiceLoader +import kotlin.reflect.full.memberProperties + +/** + * Old API for loading rules available prior to ktlint 0.47.0 + */ +internal fun loadRuleSetsFromClasspathWithRuleSetProvider(): Map { + return ServiceLoader + .load(com.pinterest.ktlint.core.RuleSetProvider::class.java) + .associateBy { + val key = it.get().id + // Adapted from KtLint CLI module + if (key == "standard") "\u0000$key" else key + } + .mapValues { it.value.get() } +} + +/** + * New API for loading rules available in ktlint 0.47+ + */ +internal fun loadRuleSetsFromClasspathWithRuleSetProviderV2(): Map> { + val ruleSetProviderV2Class = Class.forName("com.pinterest.ktlint.core.RuleSetProviderV2") + val idProperty = ruleSetProviderV2Class.kotlin.memberProperties.first{it.name == "id"} + val getRuleProviders = ruleSetProviderV2Class.getDeclaredMethod("getRuleProviders") + return ServiceLoader + .load(ruleSetProviderV2Class) + .associateBy { + val key = idProperty.getter.call(it) as String + // Adapted from KtLint CLI module + if (key == "standard") "\u0000$key" else key + }.mapValues { + getRuleProviders.invoke(it.value) as Set + } +} diff --git a/plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintWorkAction.kt b/plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintWorkAction.kt index 76728d26..0ea2bccd 100644 --- a/plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintWorkAction.kt +++ b/plugin/src/main/kotlin/org/jlleitschuh/gradle/ktlint/worker/KtLintWorkAction.kt @@ -2,9 +2,6 @@ package org.jlleitschuh.gradle.ktlint.worker import com.pinterest.ktlint.core.KtLint import com.pinterest.ktlint.core.LintError -import com.pinterest.ktlint.core.ParseException -import com.pinterest.ktlint.core.RuleSet -import com.pinterest.ktlint.core.RuleSetProvider import net.swiftzer.semver.SemVer import org.apache.commons.io.input.MessageDigestCalculatingInputStream import org.gradle.api.GradleException @@ -20,7 +17,6 @@ import java.io.File import java.io.ObjectInputStream import java.io.ObjectOutputStream import java.io.Serializable -import java.util.ServiceLoader @Suppress("UnstableApiUsage") abstract class KtLintWorkAction : WorkAction { @@ -28,11 +24,6 @@ abstract class KtLintWorkAction : WorkAction() val formattedFiles = mutableMapOf() + val ktlintInvoker: KtLintInvocation = when (val ktlintInvokerFactory = selectInvocation()) { + is LegacyParamsInvocation.Factory -> { + ktlintInvokerFactory.initialize( + editorConfigPath = additionalEditorConfig, + ruleSets = loadRuleSetsFromClasspathWithRuleSetProvider().filterRules( + parameters.enableExperimental.getOrElse(false), + parameters.disabledRules.getOrElse(emptySet()) + ), + userData = userData, + debug = debug + ) + } + + is ExperimentalParamsInvocation.Factory -> { + ktlintInvokerFactory.initialize( + editorConfigPath = additionalEditorConfig, + ruleSets = loadRuleSetsFromClasspathWithRuleSetProvider().filterRules( + parameters.enableExperimental.getOrElse(false), + parameters.disabledRules.getOrElse(emptySet()) + ), + userData = userData, + debug = debug + ) + } + + is ExperimentalParamsProviderInvocation.Factory -> { + ktlintInvokerFactory.initialize( + editorConfigPath = additionalEditorConfig, + ruleProviders = loadRuleSetsFromClasspathWithRuleSetProviderV2().filterRules( + parameters.enableExperimental.getOrElse(false), + parameters.disabledRules.getOrElse(emptySet()) + ).flatten().toSet(), + userData = userData, + debug = debug + ) + } + + is RuleEngineInvocation.Factory -> { + ktlintInvokerFactory.initialize( + loadRuleSetsFromClasspathWithRuleSetProviderV2().filterRules( + parameters.enableExperimental.getOrElse(false), + parameters.disabledRules.getOrElse(emptySet()) + ).flatten().toSet(), userData + ) + } + + null -> { + throw GradleException("Incompatible ktlint version ${parameters.ktLintVersion}") + } + } + parameters.filesToLint.files.forEach { val errors = mutableListOf>() - val ktLintParameters = KtLint.Params( - fileName = it.absolutePath, - text = it.readText(), - ruleSets = ruleSets, - userData = userData, - debug = debug, - editorConfigPath = additionalEditorConfig, - script = !it.name.endsWith(".kt", ignoreCase = true), - cb = { lintError, isCorrected -> - errors.add(lintError to isCorrected) - } - ) try { if (formatSource) { val currentFileContent = it.readText() - val updatedFileContent = KtLint.format(ktLintParameters) + val updatedFileContent = ktlintInvoker.invokeFormat(it) { lintError, isCorrected -> + errors.add(lintError to isCorrected) + } if (updatedFileContent != currentFileContent) { formattedFiles[it] = contentHash(it) it.writeText(updatedFileContent) } } else { - KtLint.lint(ktLintParameters) + ktlintInvoker.invokeLint(it) { lintError, isCorrected -> + errors.add(lintError to isCorrected) + } } - } catch (e: ParseException) { + } catch (e: RuntimeException) { throw GradleException( "KtLint failed to parse file: ${it.absolutePath}", e @@ -126,24 +160,14 @@ abstract class KtLintWorkAction : WorkAction - ): Set = loadRuleSetsFromClasspath() - .filterKeys { enableExperimental || it != "experimental" } - .filterKeys { !(disabledRules.contains("standard") && it == "\u0000standard") } - .toSortedMap() - .mapValues { it.value.get() } - .values - .toSet() - - private fun loadRuleSetsFromClasspath(): Map = ServiceLoader - .load(RuleSetProvider::class.java) - .associateBy { - val key = it.get().id - // Adapted from KtLint CLI module - if (key == "standard") "\u0000$key" else key - } + /** + * Apply filter logic in a generic way that works with old and new rule loading APIs + */ + private fun Map.filterRules(enableExperimental: Boolean, disabledRules: Set): Set { + return this.filterKeys { enableExperimental || it != "experimental" } + .filterKeys { !(disabledRules.contains("standard") && it == "\u0000standard") } + .toSortedMap().mapValues { it.value }.values.toSet() + } interface KtLintWorkParameters : WorkParameters { val filesToLint: ConfigurableFileCollection diff --git a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/AbstractPluginTest.kt b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/AbstractPluginTest.kt index 47907f94..d46f4211 100644 --- a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/AbstractPluginTest.kt +++ b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/AbstractPluginTest.kt @@ -30,10 +30,10 @@ abstract class AbstractPluginTest { protected fun File.withCleanSources() = createSourceFile( - "src/main/kotlin/clean-source.kt", + "src/main/kotlin/CleanSource.kt", """ val foo = "bar" - + """.trimIndent() ) @@ -41,21 +41,21 @@ abstract class AbstractPluginTest { "kotlin-script.kts", """ println("zzz") - + """.trimIndent() ) protected fun File.withFailingKotlinScript() = createSourceFile( "kotlin-script-fail.kts", """ - println("zzz") - + println("zzz") + """.trimIndent() ) protected fun File.withAlternativeFailingSources(baseDir: String) = - createSourceFile("$baseDir/fail-source.kt", """val foo = "bar"""") + createSourceFile("$baseDir/FailSource.kt", """val foo = "bar"""") protected fun File.createSourceFile(sourceFilePath: String, contents: String) { diff --git a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/ConfigurationCacheTest.kt b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/ConfigurationCacheTest.kt index 8fdb1e90..b3be3a20 100644 --- a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/ConfigurationCacheTest.kt +++ b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/ConfigurationCacheTest.kt @@ -20,7 +20,7 @@ class ConfigurationCacheTest : AbstractPluginTest() { internal fun configurationCacheForCheckTask(gradleVersion: GradleVersion) { project(gradleVersion) { createSourceFile( - "src/main/kotlin/clean-source.kt", + "src/main/kotlin/CleanSource.kt", """ val foo = "bar" @@ -51,7 +51,7 @@ class ConfigurationCacheTest : AbstractPluginTest() { fun configurationCacheForFormatTasks(gradleVersion: GradleVersion) { project(gradleVersion) { createSourceFile( - "src/main/kotlin/clean-source.kt", + "src/main/kotlin/CleanSource.kt", """ val foo = "bar" """.trimIndent() diff --git a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/DisabledRulesTest.kt b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/DisabledRulesTest.kt index 918d0ee7..f7f067d9 100644 --- a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/DisabledRulesTest.kt +++ b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/DisabledRulesTest.kt @@ -21,13 +21,13 @@ class DisabledRulesTest : AbstractPluginTest() { //language=Groovy buildGradle.appendText( """ - + ktlint.disabledRules = ["final-newline"] """.trimIndent() ) createSourceFile( - "src/main/kotlin/clean-source.kt", + "src/main/kotlin/CleanSource.kt", """ val foo = "bar" """.trimIndent() @@ -46,20 +46,20 @@ class DisabledRulesTest : AbstractPluginTest() { //language=Groovy buildGradle.appendText( """ - + ktlint.disabledRules = ["final-newline", "no-consecutive-blank-lines"] """.trimIndent() ) createSourceFile( - "src/main/kotlin/clean-source.kt", + "src/main/kotlin/CleanSource.kt", """ fun some() { - - + + print("Woohoo!") } - + val foo = "bar" """.trimIndent() ) @@ -75,18 +75,18 @@ class DisabledRulesTest : AbstractPluginTest() { fun lintRuleDisabledInTheCode(gradleVersion: GradleVersion) { project(gradleVersion) { createSourceFile( - "src/main/kotlin/clean-source.kt", + "src/main/kotlin/CleanSource.kt", """ /* ktlint-disable no-consecutive-blank-lines */ fun some() { - - + + print("Woohoo!") } /* ktlint-enable no-consecutive-blank-lines */ - + val foo = "bar" - + """.trimIndent() ) @@ -103,7 +103,7 @@ class DisabledRulesTest : AbstractPluginTest() { //language=Groovy buildGradle.appendText( """ - + ktlint.version = "0.34.0" ktlint.disabledRules = ["final-newline"] """.trimIndent() diff --git a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtLintSupportedVersionsTest.kt b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtLintSupportedVersionsTest.kt index f1b870a9..39d6cf50 100644 --- a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtLintSupportedVersionsTest.kt +++ b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtLintSupportedVersionsTest.kt @@ -102,7 +102,7 @@ class KtLintSupportedVersionsTest : AbstractPluginTest() { "0.36.0", "0.37.1", "0.37.2", - // "0.38.0" has been compiled with Kotlin apiLevel 1.4 and not supported by Gradle plugins + "0.38.0", "0.38.1", "0.39.0", "0.40.0", @@ -112,6 +112,12 @@ class KtLintSupportedVersionsTest : AbstractPluginTest() { // "0.43.0" does not work on JDK1.8 // "0.43.1" asked not to use it "0.43.2", + "0.44.0", + "0.45.2", + "0.46.1", + "0.47.1", + "0.48.0", + "0.48.1" ).also { // "0.37.0" is failing on Windows machines that is fixed in the next version if (!OS.WINDOWS.isCurrentOs) it.add("0.37.0") diff --git a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtlintBaselineSupportTest.kt b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtlintBaselineSupportTest.kt index 5b9504c1..5c0d45e6 100644 --- a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtlintBaselineSupportTest.kt +++ b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtlintBaselineSupportTest.kt @@ -31,7 +31,7 @@ class KtlintBaselineSupportTest : AbstractPluginTest() { - + """.trimIndent() ) } @@ -58,7 +58,7 @@ class KtlintBaselineSupportTest : AbstractPluginTest() { | | | - | + | | | | @@ -90,7 +90,7 @@ class KtlintBaselineSupportTest : AbstractPluginTest() { - + """.trimIndent() ) } @@ -106,7 +106,7 @@ class KtlintBaselineSupportTest : AbstractPluginTest() { //language=Groovy buildGradle.appendText( """ - + ktlint { version.set("0.40.0") } @@ -157,7 +157,7 @@ class KtlintBaselineSupportTest : AbstractPluginTest() { //language=Groovy buildGradle.appendText( """ - + ktlint { version.set("0.40.0") } diff --git a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtlintPluginTest.kt b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtlintPluginTest.kt index ac9d8493..69e2a134 100644 --- a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtlintPluginTest.kt +++ b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/KtlintPluginTest.kt @@ -133,7 +133,7 @@ class KtlintPluginTest : AbstractPluginTest() { buildGradle.appendText( """ - ktlint.filter { exclude("**/fail-source.kt") } + ktlint.filter { exclude("**/FailSource.kt") } """.trimIndent() ) @@ -313,7 +313,7 @@ class KtlintPluginTest : AbstractPluginTest() { build( ":$CHECK_PARENT_TASK_NAME", - "-P$FILTER_INCLUDE_PROPERTY_NAME=src/main/kotlin/clean-source.kt" + "-P$FILTER_INCLUDE_PROPERTY_NAME=src/main/kotlin/CleanSource.kt" ) { assertThat(task(":$mainSourceSetCheckTaskName")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } @@ -330,7 +330,7 @@ class KtlintPluginTest : AbstractPluginTest() { build( ":$CHECK_PARENT_TASK_NAME", - "-P$FILTER_INCLUDE_PROPERTY_NAME=src\\main\\kotlin\\clean-source.kt" + "-P$FILTER_INCLUDE_PROPERTY_NAME=src\\main\\kotlin\\CleanSource.kt" ) { assertThat(task(":$mainSourceSetCheckTaskName")?.outcome).isEqualTo(TaskOutcome.SUCCESS) } @@ -346,13 +346,13 @@ class KtlintPluginTest : AbstractPluginTest() { buildGradle.appendText( """ - ktlint.filter { exclude("**/fail-source.kt") } + ktlint.filter { exclude("**/FailSource.kt") } """.trimIndent() ) build( ":$CHECK_PARENT_TASK_NAME", - "-P$FILTER_INCLUDE_PROPERTY_NAME=src/main/kotlin/fail-source.kt" + "-P$FILTER_INCLUDE_PROPERTY_NAME=src/main/kotlin/FailSource.kt" ) { assertThat(task(":$mainSourceSetCheckTaskName")?.outcome).isEqualTo(TaskOutcome.SKIPPED) } diff --git a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/testdsl/testDsl.kt b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/testdsl/testDsl.kt index 61bb4f6c..805e70ef 100644 --- a/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/testdsl/testDsl.kt +++ b/plugin/src/test/kotlin/org/jlleitschuh/gradle/ktlint/testdsl/testDsl.kt @@ -100,8 +100,8 @@ class TestProject( } companion object { - const val CLEAN_SOURCES_FILE = "src/main/kotlin/clean-source.kt" - const val FAIL_SOURCE_FILE = "src/main/kotlin/fail-source.kt" + const val CLEAN_SOURCES_FILE = "src/main/kotlin/CleanSource.kt" + const val FAIL_SOURCE_FILE = "src/main/kotlin/FailSource.kt" } }