From 1c36c4b38bd151efe4d94f7dd90980fcbff501c0 Mon Sep 17 00:00:00 2001 From: "v.stelmashchuk" Date: Wed, 10 Aug 2022 11:54:31 +0300 Subject: [PATCH 01/15] Remove rule from NamingRules multi rule --- .../detekt/rules/naming/NamingProvider.kt | 14 +++- .../detekt/rules/naming/NamingRules.kt | 70 ------------------- 2 files changed, 13 insertions(+), 71 deletions(-) diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt index 65a4017f5c0..dd23d772edf 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt @@ -20,7 +20,19 @@ class NamingProvider : DefaultRuleSetProvider { MemberNameEqualsClassName(config), NamingRules(config), InvalidPackageDeclaration(config), - NoNameShadowing(config) + NoNameShadowing(config), + VariableNaming(config), + TopLevelPropertyNaming(config), + BooleanPropertyNaming(config), + LambdaParameterNaming(config), + FunctionParameterNaming(config), + ConstructorParameterNaming(config), + ForbiddenClassName(config), + ClassNaming(config), + PackageNaming(config), + FunctionNaming(config), + EnumNaming(config), + ObjectPropertyNaming(config), ) ) } diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRules.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRules.kt index cc675cb5260..d3b424c11e5 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRules.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRules.kt @@ -2,66 +2,28 @@ package io.gitlab.arturbosch.detekt.rules.naming import io.gitlab.arturbosch.detekt.api.Config import io.gitlab.arturbosch.detekt.api.Rule -import org.jetbrains.kotlin.psi.KtClassOrObject -import org.jetbrains.kotlin.psi.KtConstructor -import org.jetbrains.kotlin.psi.KtEnumEntry -import org.jetbrains.kotlin.psi.KtLambdaExpression import org.jetbrains.kotlin.psi.KtNamedDeclaration import org.jetbrains.kotlin.psi.KtNamedFunction -import org.jetbrains.kotlin.psi.KtObjectDeclaration -import org.jetbrains.kotlin.psi.KtPackageDirective -import org.jetbrains.kotlin.psi.KtParameter import org.jetbrains.kotlin.psi.KtProperty -import org.jetbrains.kotlin.psi.KtVariableDeclaration -import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType class NamingRules(config: Config = Config.empty) : @Suppress("DEPRECATION") io.gitlab.arturbosch.detekt.api.MultiRule() { - private val variableNamingRule = VariableNaming(config) private val variableMinNameLengthRule = VariableMinLength(config) private val variableMaxNameLengthRule = VariableMaxLength(config) - private val topLevelPropertyRule = TopLevelPropertyNaming(config) - private val objectConstantNamingRule = ObjectPropertyNaming(config) private val nonBooleanPropertyPrefixedWithIsRule = NonBooleanPropertyPrefixedWithIs(config) - private val packageNamingRule = PackageNaming(config) - private val classOrObjectNamingRule = ClassNaming(config) - private val enumEntryNamingRule = EnumNaming(config) - private val functionNamingRule = FunctionNaming(config) private val functionMaxNameLengthRule = FunctionMaxLength(config) private val functionMinNameLengthRule = FunctionMinLength(config) - private val forbiddenClassNameRule = ForbiddenClassName(config) - private val constructorParameterNamingRule = ConstructorParameterNaming(config) - private val functionParameterNamingRule = FunctionParameterNaming(config) - private val lambdaParameterNamingRule = LambdaParameterNaming(config) - private val booleanPropertyNamingRule = BooleanPropertyNaming(config) override val rules: List = listOf( - variableNamingRule, variableMinNameLengthRule, variableMaxNameLengthRule, - topLevelPropertyRule, - objectConstantNamingRule, nonBooleanPropertyPrefixedWithIsRule, - packageNamingRule, - classOrObjectNamingRule, - enumEntryNamingRule, - functionNamingRule, functionMaxNameLengthRule, functionMinNameLengthRule, - forbiddenClassNameRule, - constructorParameterNamingRule, - functionParameterNamingRule, - lambdaParameterNamingRule, - booleanPropertyNamingRule, ) - override fun visitPackageDirective(directive: KtPackageDirective) { - super.visitPackageDirective(directive) - packageNamingRule.runIfActive { visitPackageDirective(directive) } - } - override fun visitNamedDeclaration(declaration: KtNamedDeclaration) { if (declaration.nameAsSafeName.isSpecial) { return @@ -70,21 +32,12 @@ class NamingRules(config: Config = Config.empty) : when (declaration) { is KtProperty -> handleProperty(declaration) is KtNamedFunction -> handleFunction(declaration) - is KtEnumEntry -> enumEntryNamingRule.runIfActive { visitEnumEntry(declaration) } - is KtClassOrObject -> handleClassOrObject(declaration) - is KtParameter -> handleParameter(declaration) } } super.visitNamedDeclaration(declaration) } - private fun handleClassOrObject(declaration: KtClassOrObject) { - classOrObjectNamingRule.runIfActive { visitClassOrObject(declaration) } - forbiddenClassNameRule.runIfActive { visitClassOrObject(declaration) } - } - private fun handleFunction(declaration: KtNamedFunction) { - functionNamingRule.runIfActive { visitNamedFunction(declaration) } functionMaxNameLengthRule.runIfActive { visitNamedFunction(declaration) } functionMinNameLengthRule.runIfActive { visitNamedFunction(declaration) } } @@ -93,28 +46,5 @@ class NamingRules(config: Config = Config.empty) : variableMaxNameLengthRule.runIfActive { visitProperty(declaration) } variableMinNameLengthRule.runIfActive { visitProperty(declaration) } nonBooleanPropertyPrefixedWithIsRule.runIfActive { visitProperty(declaration) } - booleanPropertyNamingRule.runIfActive { visitProperty(declaration) } - - when { - declaration.isTopLevel -> topLevelPropertyRule.runIfActive { visitProperty(declaration) } - declaration.withinObjectDeclaration() -> objectConstantNamingRule.runIfActive { visitProperty(declaration) } - else -> variableNamingRule.runIfActive { visitProperty(declaration) } - } } - - private fun handleParameter(declaration: KtParameter) { - when (declaration.ownerFunction) { - is KtConstructor<*> -> constructorParameterNamingRule.runIfActive { visitParameter(declaration) } - is KtNamedFunction -> functionParameterNamingRule.runIfActive { visitParameter(declaration) } - } - } - - override fun visitLambdaExpression(lambdaExpression: KtLambdaExpression) { - super.visitLambdaExpression(lambdaExpression) - lambdaExpression.valueParameters - .forEach { lambdaParameterNamingRule.runIfActive { visitParameter(it) } } - } - - private fun KtVariableDeclaration.withinObjectDeclaration(): Boolean = - this.getNonStrictParentOfType() != null } From eb4d7e8ffce7f75d8462fd891011b3c1a68cbb43 Mon Sep 17 00:00:00 2001 From: "v.stelmashchuk" Date: Wed, 10 Aug 2022 12:31:02 +0300 Subject: [PATCH 02/15] Move tests to correct files (finish work with all rule exclude lenght) --- .../detekt/rules/naming/ClassNamingSpec.kt | 13 ++ .../detekt/rules/naming/EnumNamingSpec.kt | 18 +- .../detekt/rules/naming/FunctionNamingSpec.kt | 73 +++++++ .../NamingConventionCustomPatternSpec.kt | 190 ------------------ .../naming/NamingConventionLengthSpec.kt | 8 - .../detekt/rules/naming/PackageNamingSpec.kt | 7 + .../naming/TopLevelPropertyNamingSpec.kt | 18 ++ .../detekt/rules/naming/VariableNamingSpec.kt | 50 +++++ 8 files changed, 178 insertions(+), 199 deletions(-) delete mode 100644 detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionCustomPatternSpec.kt diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNamingSpec.kt index 15eb171da22..e7ff3e9808f 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNamingSpec.kt @@ -1,11 +1,24 @@ package io.gitlab.arturbosch.detekt.rules.naming +import io.gitlab.arturbosch.detekt.test.TestConfig import io.gitlab.arturbosch.detekt.test.assertThat import io.gitlab.arturbosch.detekt.test.compileAndLint import org.junit.jupiter.api.Test class ClassNamingSpec { + @Test + fun `should use custom name for method and class`() { + val config = TestConfig(mapOf(ClassNaming.CLASS_PATTERN to "^aBbD$")) + assertThat( + ClassNaming(config).compileAndLint( + """ + class aBbD{} + """ + ) + ).isEmpty() + } + @Test fun `should detect no violations class with numbers`() { val code = """ diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt index ac6cda15e40..c2364012bec 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt @@ -1,11 +1,27 @@ package io.gitlab.arturbosch.detekt.rules.naming +import io.gitlab.arturbosch.detekt.test.TestConfig import io.gitlab.arturbosch.detekt.test.assertThat import io.gitlab.arturbosch.detekt.test.compileAndLint +import org.assertj.core.api.Assertions import org.junit.jupiter.api.Test class EnumNamingSpec { + @Test + fun `should use custom name for enum`() { + val rule = EnumNaming(TestConfig(mapOf(EnumNaming.ENUM_PATTERN to "^(enum1)|(enum2)$"))) + Assertions.assertThat( + rule.compileAndLint( + """ + enum class aBbD { + enum1, enum2 + } + """ + ) + ).isEmpty() + } + @Test fun `should detect no violation`() { val findings = EnumNaming().compileAndLint( @@ -25,7 +41,7 @@ class EnumNamingSpec { default } """ - assertThat(NamingRules().compileAndLint(code)).hasSize(1) + assertThat(EnumNaming().compileAndLint(code)).hasSize(1) } @Test diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionNamingSpec.kt index 59dc5ca0635..b778b3b815d 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionNamingSpec.kt @@ -4,7 +4,10 @@ import io.gitlab.arturbosch.detekt.api.SourceLocation import io.gitlab.arturbosch.detekt.test.TestConfig import io.gitlab.arturbosch.detekt.test.assertThat import io.gitlab.arturbosch.detekt.test.compileAndLint +import org.assertj.core.api.Assertions +import org.junit.jupiter.api.Nested import org.junit.jupiter.api.Test +import java.util.regex.PatternSyntaxException class FunctionNamingSpec { @@ -109,4 +112,74 @@ class FunctionNamingSpec { """ assertThat(FunctionNaming().compileAndLint(code)).hasStartSourceLocations(SourceLocation(1, 5)) } + + @Test + fun `should use custom name for method`() { + val config = TestConfig(mapOf(FunctionNaming.FUNCTION_PATTERN to "^`.+`$")) + assertThat( + FunctionNaming(config).compileAndLint( + """ + class Foo { + fun `name with back ticks`(){ + + } + } + """ + ) + ).isEmpty() + } + + @Test + fun shouldExcludeClassesFromFunctionNaming() { + val code = """ + class Bar { + fun MYFun() {} + } + + object Foo { + fun MYFun() {} + } + """ + val config = TestConfig(mapOf(FunctionNaming.EXCLUDE_CLASS_PATTERN to "Foo|Bar")) + Assertions.assertThat(FunctionNaming(config).compileAndLint(code)).isEmpty() + } + + @Test + fun `should report a function name that begins with a backtick, capitals, and spaces`() { + val subject = FunctionNaming() + val code = "fun `Hi bye`() = 3" + subject.compileAndLint(code) + Assertions.assertThat(subject.findings).hasSize(1) + } + + @Nested + inner class `exclude class pattern function regex code cases` { + private val excludeClassPatternFunctionRegexCode = """ + class Bar { + fun MYFun() {} + } + + object Foo { + fun MYFun() {} + } + """ + + @Test + fun shouldNotFailWithInvalidRegexWhenDisabledFunctionNaming() { + val configRules = mapOf( + "active" to "false", + FunctionNaming.EXCLUDE_CLASS_PATTERN to "*Foo" + ) + val config = TestConfig(configRules) + Assertions.assertThat(FunctionNaming(config).compileAndLint(excludeClassPatternFunctionRegexCode)).isEmpty() + } + + @Test + fun shouldFailWithInvalidRegexFunctionNaming() { + val config = TestConfig(mapOf(FunctionNaming.EXCLUDE_CLASS_PATTERN to "*Foo")) + Assertions.assertThatExceptionOfType(PatternSyntaxException::class.java).isThrownBy { + FunctionNaming(config).compileAndLint(excludeClassPatternFunctionRegexCode) + } + } + } } diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionCustomPatternSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionCustomPatternSpec.kt deleted file mode 100644 index 9e80565fa30..00000000000 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionCustomPatternSpec.kt +++ /dev/null @@ -1,190 +0,0 @@ -package io.gitlab.arturbosch.detekt.rules.naming - -import io.gitlab.arturbosch.detekt.test.TestConfig -import io.gitlab.arturbosch.detekt.test.compileAndLint -import org.assertj.core.api.Assertions.assertThat -import org.assertj.core.api.Assertions.assertThatExceptionOfType -import org.junit.jupiter.api.Test -import java.util.regex.PatternSyntaxException - -class NamingConventionCustomPatternSpec { - - val configCustomRules = - object : TestConfig() { - override fun subConfig(key: String): TestConfig = this - - @Suppress("UNCHECKED_CAST") - override fun valueOrDefault(key: String, default: T): T = - when (key) { - FunctionNaming.FUNCTION_PATTERN -> "^`.+`$" as T - ClassNaming.CLASS_PATTERN -> "^aBbD$" as T - VariableNaming.VARIABLE_PATTERN -> "^123var$" as T - TopLevelPropertyNaming.CONSTANT_PATTERN -> "^lowerCaseConst$" as T - EnumNaming.ENUM_PATTERN -> "^(enum1)|(enum2)$" as T - PackageNaming.PACKAGE_PATTERN -> "^(package_1)$" as T - FunctionMaxLength.MAXIMUM_FUNCTION_NAME_LENGTH -> 50 as T - else -> default - } - } - - val testConfig = - object : TestConfig() { - override fun subConfig(key: String): TestConfig = - when (key) { - FunctionNaming::class.simpleName -> configCustomRules - FunctionMaxLength::class.simpleName -> configCustomRules - ClassNaming::class.simpleName -> configCustomRules - VariableNaming::class.simpleName -> configCustomRules - TopLevelPropertyNaming::class.simpleName -> configCustomRules - EnumNaming::class.simpleName -> configCustomRules - PackageNaming::class.simpleName -> configCustomRules - else -> this - } - - override fun valueOrDefault(key: String, default: T): T = default - } - - val excludeClassPatternVariableRegexCode = """ - class Bar { - val MYVar = 3 - } - - object Foo { - val MYVar = 3 - } - """ - - val excludeClassPatternFunctionRegexCode = """ - class Bar { - fun MYFun() {} - } - - object Foo { - fun MYFun() {} - } - """ - - @Test - fun `should use custom name for method and class`() { - val rule = NamingRules(testConfig) - assertThat( - rule.compileAndLint( - """ - class aBbD{ - fun `name with back ticks`(){ - val `123var` = "" - } - - companion object { - const val lowerCaseConst = "" - } - } - """ - ) - ).isEmpty() - } - - @Test - fun `should use custom name for constant`() { - val rule = NamingRules(testConfig) - assertThat( - rule.compileAndLint( - """ - class aBbD{ - companion object { - const val lowerCaseConst = "" - } - } - """ - ) - ).isEmpty() - } - - @Test - fun `should use custom name for enum`() { - val rule = NamingRules(testConfig) - assertThat( - rule.compileAndLint( - """ - class aBbD{ - enum class aBbD { - enum1, enum2 - } - } - """ - ) - ).isEmpty() - } - - @Test - fun `should use custom name for package`() { - val rule = NamingRules(testConfig) - assertThat(rule.compileAndLint("package package_1")).isEmpty() - } - - @Test - fun shouldExcludeClassesFromVariableNaming() { - val code = """ - class Bar { - val MYVar = 3 - } - - object Foo { - val MYVar = 3 - } - """ - val config = TestConfig(mapOf(VariableNaming.EXCLUDE_CLASS_PATTERN to "Foo|Bar")) - assertThat(VariableNaming(config).compileAndLint(code)).isEmpty() - } - - @Test - fun shouldNotFailWithInvalidRegexWhenDisabledVariableNaming() { - val configValues = mapOf( - "active" to "false", - VariableNaming.EXCLUDE_CLASS_PATTERN to "*Foo" - ) - val config = TestConfig(configValues) - assertThat(VariableNaming(config).compileAndLint(excludeClassPatternVariableRegexCode)).isEmpty() - } - - @Test - fun shouldFailWithInvalidRegexVariableNaming() { - val config = TestConfig(mapOf(VariableNaming.EXCLUDE_CLASS_PATTERN to "*Foo")) - assertThatExceptionOfType(PatternSyntaxException::class.java).isThrownBy { - VariableNaming(config).compileAndLint(excludeClassPatternVariableRegexCode) - } - } - - @Test - fun shouldExcludeClassesFromFunctionNaming() { - val code = """ - class Bar { - fun MYFun() {} - } - - object Foo { - fun MYFun() {} - } - """ - val config = TestConfig(mapOf(FunctionNaming.EXCLUDE_CLASS_PATTERN to "Foo|Bar")) - assertThat(FunctionNaming(config).compileAndLint(code)).isEmpty() - } - - @Test - fun shouldNotFailWithInvalidRegexWhenDisabledFunctionNaming() { - val configRules = mapOf( - "active" to "false", - FunctionNaming.EXCLUDE_CLASS_PATTERN to "*Foo" - ) - val config = TestConfig(configRules) - assertThat(FunctionNaming(config).compileAndLint(excludeClassPatternFunctionRegexCode)).isEmpty() - } - - @Test - fun shouldFailWithInvalidRegexFunctionNaming() { - val config = TestConfig(mapOf(FunctionNaming.EXCLUDE_CLASS_PATTERN to "*Foo")) - assertThatExceptionOfType(PatternSyntaxException::class.java).isThrownBy { - FunctionNaming(config).compileAndLint(excludeClassPatternFunctionRegexCode) - } - } -} diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionLengthSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionLengthSpec.kt index 6df83b026ee..8536c7f3860 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionLengthSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionLengthSpec.kt @@ -99,12 +99,4 @@ class NamingConventionLengthSpec { subject.compileAndLint(code) assertThat(subject.findings).isEmpty() } - - @Test - fun `should report a function name that begins with a backtick, capitals, and spaces`() { - val subject = NamingRules() - val code = "fun `Hi bye`() = 3" - subject.compileAndLint(code) - assertThat(subject.findings).hasSize(1) - } } diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/PackageNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/PackageNamingSpec.kt index 345ecc679eb..f736cf91f98 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/PackageNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/PackageNamingSpec.kt @@ -1,11 +1,18 @@ package io.gitlab.arturbosch.detekt.rules.naming +import io.gitlab.arturbosch.detekt.test.TestConfig import io.gitlab.arturbosch.detekt.test.compileAndLint import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test class PackageNamingSpec { + @Test + fun `should use custom name for package`() { + val rule = NamingRules(TestConfig(PackageNaming.PACKAGE_PATTERN to "^(package_1)$")) + assertThat(rule.compileAndLint("package package_1")).isEmpty() + } + @Test fun `should ignore the issue by alias suppression`() { assertThat( diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt index 08acf313755..e301090f335 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt @@ -1,5 +1,7 @@ package io.gitlab.arturbosch.detekt.rules.naming +import io.gitlab.arturbosch.detekt.test.TestConfig +import io.gitlab.arturbosch.detekt.test.compileAndLint import io.gitlab.arturbosch.detekt.test.lint import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Nested @@ -9,6 +11,22 @@ class TopLevelPropertyNamingSpec { val subject = TopLevelPropertyNaming() + @Test + fun `should use custom name top level propeties`() { + assertThat( + NamingRules(TestConfig(mapOf(TopLevelPropertyNaming.CONSTANT_PATTERN to "^lowerCaseConst$"))).compileAndLint( + """ + class Foo{ + companion object { + const val lowerCaseConst = "" + } + } + """ + ) + ).isEmpty() + } + + @Nested inner class `constants on top level` { diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt index 78c33c6982d..427bd9c874e 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt @@ -4,10 +4,60 @@ import io.gitlab.arturbosch.detekt.api.SourceLocation import io.gitlab.arturbosch.detekt.test.TestConfig import io.gitlab.arturbosch.detekt.test.assertThat import io.gitlab.arturbosch.detekt.test.compileAndLint +import org.assertj.core.api.Assertions +import org.junit.jupiter.api.Nested import org.junit.jupiter.api.Test +import java.util.regex.PatternSyntaxException class VariableNamingSpec { + @Nested + inner class `Exclude class pattern cases`() { + + private val excludeClassPatternVariableRegexCode = """ + class Bar { + val MYVar = 3 + } + + object Foo { + val MYVar = 3 + } + """ + + @Test + fun shouldNotFailWithInvalidRegexWhenDisabledVariableNaming() { + val configValues = mapOf( + "active" to "false", + VariableNaming.EXCLUDE_CLASS_PATTERN to "*Foo" + ) + val config = TestConfig(configValues) + Assertions.assertThat(VariableNaming(config).compileAndLint(excludeClassPatternVariableRegexCode)).isEmpty() + } + + @Test + fun shouldFailWithInvalidRegexVariableNaming() { + val config = TestConfig(mapOf(VariableNaming.EXCLUDE_CLASS_PATTERN to "*Foo")) + Assertions.assertThatExceptionOfType(PatternSyntaxException::class.java).isThrownBy { + VariableNaming(config).compileAndLint(excludeClassPatternVariableRegexCode) + } + } + } + + @Test + fun shouldExcludeClassesFromVariableNaming() { + val code = """ + class Bar { + val MYVar = 3 + } + + object Foo { + val MYVar = 3 + } + """ + val config = TestConfig(mapOf(VariableNaming.EXCLUDE_CLASS_PATTERN to "Foo|Bar")) + Assertions.assertThat(VariableNaming(config).compileAndLint(code)).isEmpty() + } + @Test fun `should detect all positive cases`() { val code = """ From 3771dec861a563a6e1c280c6284b1c818e34f449 Mon Sep 17 00:00:00 2001 From: "v.stelmashchuk" Date: Wed, 10 Aug 2022 12:40:52 +0300 Subject: [PATCH 03/15] Fixed imports --- .../rules/naming/BooleanPropertyNamingSpec.kt | 34 +++++++++---------- .../detekt/rules/naming/EnumNamingSpec.kt | 2 +- .../detekt/rules/naming/FunctionNamingSpec.kt | 10 +++--- 3 files changed, 23 insertions(+), 23 deletions(-) diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/BooleanPropertyNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/BooleanPropertyNamingSpec.kt index 0b112ef86c2..6d1d7bd3830 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/BooleanPropertyNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/BooleanPropertyNamingSpec.kt @@ -180,7 +180,7 @@ class BooleanPropertyNamingSpec(val env: KotlinCoreEnvironment) { } @Test - fun `should not warn about Java Boolean override by default`() { + fun `should not warn about Java Boolean override in data class by default`() { val code = """ interface Test { val default: java.lang.Boolean @@ -193,6 +193,22 @@ class BooleanPropertyNamingSpec(val env: KotlinCoreEnvironment) { assertThat(findings).hasSize(1) } + @Test + fun `should not warn about Java Boolean override by default`() { + val code = """ + interface Test { + val default: java.lang.Boolean + } + + class TestImpl : Test { + override var default: java.lang.Boolean = java.lang.Boolean(true) + } + """ + val findings = subject.compileAndLintWithContext(env, code) + + assertThat(findings).hasSize(1) + } + @Test fun `should warn about Java Boolean override if ignoreOverridden is false`() { val code = """ @@ -514,22 +530,6 @@ class BooleanPropertyNamingSpec(val env: KotlinCoreEnvironment) { assertThat(findings).hasSize(1) } - @Test - fun `should not warn about Java Boolean override by default`() { - val code = """ - interface Test { - val default: java.lang.Boolean - } - - class TestImpl : Test { - override var default: java.lang.Boolean = java.lang.Boolean(true) - } - """ - val findings = subject.compileAndLintWithContext(env, code) - - assertThat(findings).hasSize(1) - } - @Test fun `should warn about Java Boolean override if ignoreOverridden is false`() { val code = """ diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt index c2364012bec..cd24653b909 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt @@ -3,7 +3,7 @@ package io.gitlab.arturbosch.detekt.rules.naming import io.gitlab.arturbosch.detekt.test.TestConfig import io.gitlab.arturbosch.detekt.test.assertThat import io.gitlab.arturbosch.detekt.test.compileAndLint -import org.assertj.core.api.Assertions +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test class EnumNamingSpec { diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionNamingSpec.kt index b778b3b815d..41744ff4501 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionNamingSpec.kt @@ -4,7 +4,7 @@ import io.gitlab.arturbosch.detekt.api.SourceLocation import io.gitlab.arturbosch.detekt.test.TestConfig import io.gitlab.arturbosch.detekt.test.assertThat import io.gitlab.arturbosch.detekt.test.compileAndLint -import org.assertj.core.api.Assertions +import org.assertj.core.api.Assertions.assertThatExceptionOfType import org.junit.jupiter.api.Nested import org.junit.jupiter.api.Test import java.util.regex.PatternSyntaxException @@ -141,7 +141,7 @@ class FunctionNamingSpec { } """ val config = TestConfig(mapOf(FunctionNaming.EXCLUDE_CLASS_PATTERN to "Foo|Bar")) - Assertions.assertThat(FunctionNaming(config).compileAndLint(code)).isEmpty() + assertThat(FunctionNaming(config).compileAndLint(code)).isEmpty() } @Test @@ -149,7 +149,7 @@ class FunctionNamingSpec { val subject = FunctionNaming() val code = "fun `Hi bye`() = 3" subject.compileAndLint(code) - Assertions.assertThat(subject.findings).hasSize(1) + assertThat(subject.findings).hasSize(1) } @Nested @@ -171,13 +171,13 @@ class FunctionNamingSpec { FunctionNaming.EXCLUDE_CLASS_PATTERN to "*Foo" ) val config = TestConfig(configRules) - Assertions.assertThat(FunctionNaming(config).compileAndLint(excludeClassPatternFunctionRegexCode)).isEmpty() + assertThat(FunctionNaming(config).compileAndLint(excludeClassPatternFunctionRegexCode)).isEmpty() } @Test fun shouldFailWithInvalidRegexFunctionNaming() { val config = TestConfig(mapOf(FunctionNaming.EXCLUDE_CLASS_PATTERN to "*Foo")) - Assertions.assertThatExceptionOfType(PatternSyntaxException::class.java).isThrownBy { + assertThatExceptionOfType(PatternSyntaxException::class.java).isThrownBy { FunctionNaming(config).compileAndLint(excludeClassPatternFunctionRegexCode) } } From 7f7d688b417605c50fdcdcdd78338e195784139c Mon Sep 17 00:00:00 2001 From: "v.stelmashchuk" Date: Wed, 10 Aug 2022 12:44:32 +0300 Subject: [PATCH 04/15] Fixed boolean propeties test --- .../detekt/rules/naming/BooleanPropertyNamingSpec.kt | 2 +- .../io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/BooleanPropertyNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/BooleanPropertyNamingSpec.kt index 6d1d7bd3830..02da1f4bd87 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/BooleanPropertyNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/BooleanPropertyNamingSpec.kt @@ -201,7 +201,7 @@ class BooleanPropertyNamingSpec(val env: KotlinCoreEnvironment) { } class TestImpl : Test { - override var default: java.lang.Boolean = java.lang.Boolean(true) + override val default: java.lang.Boolean = java.lang.Boolean(true) } """ val findings = subject.compileAndLintWithContext(env, code) diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt index cd24653b909..c8e10790211 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/EnumNamingSpec.kt @@ -3,7 +3,6 @@ package io.gitlab.arturbosch.detekt.rules.naming import io.gitlab.arturbosch.detekt.test.TestConfig import io.gitlab.arturbosch.detekt.test.assertThat import io.gitlab.arturbosch.detekt.test.compileAndLint -import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test class EnumNamingSpec { @@ -11,7 +10,7 @@ class EnumNamingSpec { @Test fun `should use custom name for enum`() { val rule = EnumNaming(TestConfig(mapOf(EnumNaming.ENUM_PATTERN to "^(enum1)|(enum2)$"))) - Assertions.assertThat( + assertThat( rule.compileAndLint( """ enum class aBbD { From 3c2c424f32f26b9d3780ba37184530b3f15b5899 Mon Sep 17 00:00:00 2001 From: "v.stelmashchuk" Date: Wed, 10 Aug 2022 17:46:11 +0300 Subject: [PATCH 05/15] Fixed false positive into Variable name rule --- .../detekt/rules/naming/VariableNaming.kt | 9 +++ .../naming/TopLevelPropertyNamingSpec.kt | 1 - .../detekt/rules/naming/VariableNamingSpec.kt | 78 +++++++++++++++++-- 3 files changed, 82 insertions(+), 6 deletions(-) diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt index d47f1e8991d..76e10c577e2 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt @@ -13,7 +13,9 @@ import io.gitlab.arturbosch.detekt.api.internal.Configuration import io.gitlab.arturbosch.detekt.rules.identifierName import io.gitlab.arturbosch.detekt.rules.isOverride import io.gitlab.arturbosch.detekt.rules.naming.util.isContainingExcludedClassOrObject +import org.jetbrains.kotlin.psi.KtObjectDeclaration import org.jetbrains.kotlin.psi.KtProperty +import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType import org.jetbrains.kotlin.psi.psiUtil.isPrivate import org.jetbrains.kotlin.resolve.calls.util.isSingleUnderscore @@ -43,6 +45,9 @@ class VariableNaming(config: Config = Config.empty) : Rule(config) { private val ignoreOverridden: Boolean by config(true) override fun visitProperty(property: KtProperty) { + if (property.isPropertyTopLeveleOrInCompanion()) { + return + } if (property.isSingleUnderscore || property.isContainingExcludedClassOrObject(excludeClassPattern)) { return } @@ -63,6 +68,10 @@ class VariableNaming(config: Config = Config.empty) : Rule(config) { } } + private fun KtProperty.isPropertyTopLeveleOrInCompanion(): Boolean { + return this.nameAsSafeName.isSpecial || this.getNonStrictParentOfType() == null || this.isTopLevel || this.nameIdentifier?.parent?.javaClass == null + } + private fun report(property: KtProperty, message: String) { report( CodeSmell( diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt index e301090f335..0c28ee4eac0 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt @@ -26,7 +26,6 @@ class TopLevelPropertyNamingSpec { ).isEmpty() } - @Nested inner class `constants on top level` { diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt index 427bd9c874e..f88f1c895e4 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt @@ -4,7 +4,7 @@ import io.gitlab.arturbosch.detekt.api.SourceLocation import io.gitlab.arturbosch.detekt.test.TestConfig import io.gitlab.arturbosch.detekt.test.assertThat import io.gitlab.arturbosch.detekt.test.compileAndLint -import org.assertj.core.api.Assertions +import org.assertj.core.api.Assertions.assertThatExceptionOfType import org.junit.jupiter.api.Nested import org.junit.jupiter.api.Test import java.util.regex.PatternSyntaxException @@ -12,7 +12,7 @@ import java.util.regex.PatternSyntaxException class VariableNamingSpec { @Nested - inner class `Exclude class pattern cases`() { + inner class `Exclude class pattern cases` { private val excludeClassPatternVariableRegexCode = """ class Bar { @@ -31,13 +31,13 @@ class VariableNamingSpec { VariableNaming.EXCLUDE_CLASS_PATTERN to "*Foo" ) val config = TestConfig(configValues) - Assertions.assertThat(VariableNaming(config).compileAndLint(excludeClassPatternVariableRegexCode)).isEmpty() + assertThat(VariableNaming(config).compileAndLint(excludeClassPatternVariableRegexCode)).isEmpty() } @Test fun shouldFailWithInvalidRegexVariableNaming() { val config = TestConfig(mapOf(VariableNaming.EXCLUDE_CLASS_PATTERN to "*Foo")) - Assertions.assertThatExceptionOfType(PatternSyntaxException::class.java).isThrownBy { + assertThatExceptionOfType(PatternSyntaxException::class.java).isThrownBy { VariableNaming(config).compileAndLint(excludeClassPatternVariableRegexCode) } } @@ -55,7 +55,7 @@ class VariableNamingSpec { } """ val config = TestConfig(mapOf(VariableNaming.EXCLUDE_CLASS_PATTERN to "Foo|Bar")) - Assertions.assertThat(VariableNaming(config).compileAndLint(code)).isEmpty() + assertThat(VariableNaming(config).compileAndLint(code)).isEmpty() } @Test @@ -103,6 +103,74 @@ class VariableNamingSpec { assertThat(VariableNaming().compileAndLint(code)).isEmpty() } + @Test + fun `should not flag global member properties`() { + val code = """ + const val DEFAULT_FLOAT_CONVERSION_FACTOR: Int = 100 + private const val QUOTES = "\"" + """ + assertThat(VariableNaming().compileAndLint(code)).isEmpty() + } + + @Test + fun `should not flag lambda fun arguments`() { + val code = """ + fun foo() { + listOf>().flatMap { (test, left) -> print("H") } + } + fun bar() { + listOf>().flatMap { (right, _) -> print("H") } + } + """ + assertThat(VariableNaming().compileAndLint(code)).isEmpty() + } + + @Test + fun `should not flag member properties into companion object`() { + val code = """ + class Foo { + companion object { + val TWENTY_MINS: Debt = + Debt(0, 0, 20) + val TEN_MINS: Debt = + Debt(0, 0, 10) + val FIVE_MINS: Debt = + Debt(0, 0, 5) + private const val HOURS_PER_DAY = 24 + private const val MINUTES_PER_HOUR = 60 + + const val ACTIVE_KEY: String = "active" + } + } + """ + assertThat(VariableNaming().compileAndLint(code)).isEmpty() + } + + @Test + fun `should not try catch member properties into companion object`() { + val code = """ + fun Config.valueOrDefaultCommaSeparated( + key: String, + default: List + ): List { + fun fallBack() = valueOrDefault(key, default.joinToString(",")) + .trim() + .commaSeparatedPattern(",", ";") + .toList() + + return try { + valueOrDefault(key, default) + } catch (_: IllegalStateException) { + fallBack() + } catch (_: ClassCastException) { + fallBack() + } + } + """ + assertThat(VariableNaming().compileAndLint(code)).isEmpty() + } + + @Test fun `doesn't ignore overridden member properties if ignoreOverridden is false`() { val code = """ From 0db0dfdb0ebaf6d5ad44a5d461565303b3688254 Mon Sep 17 00:00:00 2001 From: "v.stelmashchuk" Date: Wed, 10 Aug 2022 18:18:45 +0300 Subject: [PATCH 06/15] Add new test to variable naming --- .../detekt/rules/naming/NamingProvider.kt | 1 - .../detekt/rules/naming/VariableNaming.kt | 7 ++-- .../detekt/rules/naming/VariableNamingSpec.kt | 34 +++++++++++++++++++ 3 files changed, 37 insertions(+), 5 deletions(-) diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt index dd23d772edf..58aa55dd8f1 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt @@ -18,7 +18,6 @@ class NamingProvider : DefaultRuleSetProvider { listOf( MatchingDeclarationName(config), MemberNameEqualsClassName(config), - NamingRules(config), InvalidPackageDeclaration(config), NoNameShadowing(config), VariableNaming(config), diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt index 76e10c577e2..38f73a70bf9 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt @@ -45,7 +45,7 @@ class VariableNaming(config: Config = Config.empty) : Rule(config) { private val ignoreOverridden: Boolean by config(true) override fun visitProperty(property: KtProperty) { - if (property.isPropertyTopLeveleOrInCompanion()) { + if (property.isPropertyTopLevelOrInCompanion()) { return } if (property.isSingleUnderscore || property.isContainingExcludedClassOrObject(excludeClassPattern)) { @@ -68,8 +68,8 @@ class VariableNaming(config: Config = Config.empty) : Rule(config) { } } - private fun KtProperty.isPropertyTopLeveleOrInCompanion(): Boolean { - return this.nameAsSafeName.isSpecial || this.getNonStrictParentOfType() == null || this.isTopLevel || this.nameIdentifier?.parent?.javaClass == null + private fun KtProperty.isPropertyTopLevelOrInCompanion(): Boolean { + return this.nameAsSafeName.isSpecial || this.getNonStrictParentOfType() != null || this.isTopLevel || this.nameIdentifier?.parent?.javaClass == null } private fun report(property: KtProperty, message: String) { @@ -83,7 +83,6 @@ class VariableNaming(config: Config = Config.empty) : Rule(config) { } companion object { - const val VARIABLE_PATTERN = "variablePattern" const val EXCLUDE_CLASS_PATTERN = "excludeClassPattern" } } diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt index f88f1c895e4..1ff66ef4e26 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt @@ -58,6 +58,40 @@ class VariableNamingSpec { assertThat(VariableNaming(config).compileAndLint(code)).isEmpty() } + @Test + fun test() { + val code = """ + data class ReportPath(val kind: String, val path: Path) { + + companion object { + private const val NUM_OF_PARTS_UNIX = 2 + private const val NUM_OF_PARTS_WINDOWS = 3 + private const val REPORT_PATH_SEPARATOR = ":" + + fun from(input: String): ReportPath { + val parts = input.split(REPORT_PATH_SEPARATOR) + + val path = when (val partsSize = parts.size) { + NUM_OF_PARTS_UNIX -> parts[1] + NUM_OF_PARTS_WINDOWS -> parts.slice(1 until partsSize).joinToString(REPORT_PATH_SEPARATOR) + else -> error( + "Input must consist of two parts for Unix OSs or three for Windows (report-id:path)." + ) + } + + val kind = parts[0] + require(kind.isNotEmpty()) { "The kind of report must not be empty (path)" } + require(path.isNotEmpty()) { "The path of the report must not be empty (kind)" } + return ReportPath(kind, Paths.get(path)) + } + } + } + + """ + + assertThat(VariableNaming().compileAndLint(code)).isEmpty() + } + @Test fun `should detect all positive cases`() { val code = """ From e0596ac64a500f9b9ae4ab755a38f8647c274d5e Mon Sep 17 00:00:00 2001 From: "v.stelmashchuk" Date: Wed, 10 Aug 2022 23:50:31 +0300 Subject: [PATCH 07/15] Fixed rules --- .../naming/ConstructorParameterNaming.kt | 3 + .../rules/naming/FunctionParameterNaming.kt | 3 + .../detekt/rules/naming/NamingProvider.kt | 4 + .../detekt/rules/naming/NamingRules.kt | 50 --------- .../rules/naming/FunctionMaxLengthSpec.kt | 34 ++++++ .../rules/naming/FunctionMinLengthSpec.kt | 34 ++++++ .../naming/NamingConventionLengthSpec.kt | 102 ------------------ .../detekt/rules/naming/NamingRulesSpec.kt | 19 ---- .../detekt/rules/naming/PackageNamingSpec.kt | 2 +- .../naming/TopLevelPropertyNamingSpec.kt | 2 +- .../rules/naming/VariableMaxLengthSpec.kt | 32 ++++++ .../rules/naming/VariableMinLengthSpec.kt | 62 +++++++++++ 12 files changed, 174 insertions(+), 173 deletions(-) delete mode 100644 detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRules.kt create mode 100644 detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMaxLengthSpec.kt create mode 100644 detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt delete mode 100644 detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionLengthSpec.kt delete mode 100644 detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRulesSpec.kt create mode 100644 detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMaxLengthSpec.kt create mode 100644 detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMinLengthSpec.kt diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt index 93e22644765..3db245969f6 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt @@ -42,6 +42,9 @@ class ConstructorParameterNaming(config: Config = Config.empty) : Rule(config) { private val ignoreOverridden: Boolean by config(true) override fun visitParameter(parameter: KtParameter) { + if (parameter.nameAsSafeName.isSpecial || parameter.nameIdentifier?.parent?.javaClass == null) { + return + } if (parameter.isContainingExcludedClassOrObject(excludeClassPattern) || isIgnoreOverridden(parameter)) { return } diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt index b4bce92d201..f951a7afa08 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt @@ -46,6 +46,9 @@ class FunctionParameterNaming(config: Config = Config.empty) : Rule(config) { private val ignoreOverridden: Boolean by configWithFallback(::ignoreOverriddenFunctions, true) override fun visitParameter(parameter: KtParameter) { + if (parameter.nameAsSafeName.isSpecial || parameter.nameIdentifier?.parent?.javaClass == null) { + return + } if (parameter.isContainingExcludedClass(excludeClassPattern)) { return } diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt index 58aa55dd8f1..dc952f63d40 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt @@ -32,6 +32,10 @@ class NamingProvider : DefaultRuleSetProvider { FunctionNaming(config), EnumNaming(config), ObjectPropertyNaming(config), + FunctionMinLength(config), + FunctionMaxLength(config), + VariableMaxLength(config), + VariableMaxLength(config), ) ) } diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRules.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRules.kt deleted file mode 100644 index d3b424c11e5..00000000000 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRules.kt +++ /dev/null @@ -1,50 +0,0 @@ -package io.gitlab.arturbosch.detekt.rules.naming - -import io.gitlab.arturbosch.detekt.api.Config -import io.gitlab.arturbosch.detekt.api.Rule -import org.jetbrains.kotlin.psi.KtNamedDeclaration -import org.jetbrains.kotlin.psi.KtNamedFunction -import org.jetbrains.kotlin.psi.KtProperty - -class NamingRules(config: Config = Config.empty) : - @Suppress("DEPRECATION") - io.gitlab.arturbosch.detekt.api.MultiRule() { - - private val variableMinNameLengthRule = VariableMinLength(config) - private val variableMaxNameLengthRule = VariableMaxLength(config) - private val nonBooleanPropertyPrefixedWithIsRule = NonBooleanPropertyPrefixedWithIs(config) - private val functionMaxNameLengthRule = FunctionMaxLength(config) - private val functionMinNameLengthRule = FunctionMinLength(config) - - override val rules: List = listOf( - variableMinNameLengthRule, - variableMaxNameLengthRule, - nonBooleanPropertyPrefixedWithIsRule, - functionMaxNameLengthRule, - functionMinNameLengthRule, - ) - - override fun visitNamedDeclaration(declaration: KtNamedDeclaration) { - if (declaration.nameAsSafeName.isSpecial) { - return - } - if (declaration.nameIdentifier?.parent?.javaClass != null) { - when (declaration) { - is KtProperty -> handleProperty(declaration) - is KtNamedFunction -> handleFunction(declaration) - } - } - super.visitNamedDeclaration(declaration) - } - - private fun handleFunction(declaration: KtNamedFunction) { - functionMaxNameLengthRule.runIfActive { visitNamedFunction(declaration) } - functionMinNameLengthRule.runIfActive { visitNamedFunction(declaration) } - } - - private fun handleProperty(declaration: KtProperty) { - variableMaxNameLengthRule.runIfActive { visitProperty(declaration) } - variableMinNameLengthRule.runIfActive { visitProperty(declaration) } - nonBooleanPropertyPrefixedWithIsRule.runIfActive { visitProperty(declaration) } - } -} diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMaxLengthSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMaxLengthSpec.kt new file mode 100644 index 00000000000..c9407766aef --- /dev/null +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMaxLengthSpec.kt @@ -0,0 +1,34 @@ +package io.gitlab.arturbosch.detekt.rules.naming + +import io.gitlab.arturbosch.detekt.test.TestConfig +import io.gitlab.arturbosch.detekt.test.compileAndLint +import org.assertj.core.api.Assertions +import org.junit.jupiter.api.Test + +class FunctionMaxLengthSpec { + + @Test + fun `should report a function name that is too long base on config`() { + val subject = FunctionMaxLength(TestConfig(mapOf("maximumFunctionNameLength" to 10))) + val code = "fun thisFunctionLongName() = 3" + subject.compileAndLint(code) + Assertions.assertThat(subject.findings).hasSize(1) + } + + @Test + fun `should report a function name that is too long`() { + val subject = FunctionMaxLength() + val code = "fun thisFunctionIsDefinitelyWayTooLongAndShouldBeMuchShorter() = 3" + subject.compileAndLint(code) + Assertions.assertThat(subject.findings).hasSize(1) + } + + @Test + fun `should not report a function name that is okay`() { + val subject = FunctionMaxLength() + val code = "fun three() = 3" + subject.compileAndLint(code) + Assertions.assertThat(subject.findings).isEmpty() + } + +} diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt new file mode 100644 index 00000000000..017574f4c3f --- /dev/null +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt @@ -0,0 +1,34 @@ +package io.gitlab.arturbosch.detekt.rules.naming + +import io.gitlab.arturbosch.detekt.test.TestConfig +import io.gitlab.arturbosch.detekt.test.compileAndLint +import org.assertj.core.api.Assertions +import org.junit.jupiter.api.Test + +class FunctionMinLengthSpec { + + @Test + fun `should report a function name that is too short`() { + val subject = FunctionMinLength() + val code = "fun a() = 3" + subject.compileAndLint(code) + Assertions.assertThat(subject.findings).hasSize(1) + } + + @Test + fun `should report a function name that is too short base on config`() { + val subject = FunctionMinLength(TestConfig(mapOf("minimumFunctionNameLength" to 5))) + val code = "fun four() = 3" + subject.compileAndLint(code) + Assertions.assertThat(subject.findings).hasSize(1) + } + + @Test + fun `should not report a function name that is okay`() { + val subject = FunctionMinLength() + val code = "fun three() = 3" + subject.compileAndLint(code) + Assertions.assertThat(subject.findings).isEmpty() + } + +} diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionLengthSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionLengthSpec.kt deleted file mode 100644 index 8536c7f3860..00000000000 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingConventionLengthSpec.kt +++ /dev/null @@ -1,102 +0,0 @@ -package io.gitlab.arturbosch.detekt.rules.naming - -import io.gitlab.arturbosch.detekt.test.TestConfig -import io.gitlab.arturbosch.detekt.test.compileAndLint -import org.assertj.core.api.Assertions.assertThat -import org.junit.jupiter.api.Nested -import org.junit.jupiter.api.Test - -class NamingConventionLengthSpec { - - @Test - fun `should not report underscore variable names`() { - val subject = NamingRules() - val code = """ - fun getResult(): Pair = TODO() - fun function() { - val (_, status) = getResult() - } - """ - subject.compileAndLint(code) - assertThat(subject.findings).isEmpty() - } - - @Test - fun `should not report a variable with single letter name`() { - val subject = NamingRules() - val code = "private val a = 3" - subject.compileAndLint(code) - assertThat(subject.findings).isEmpty() - } - - @Nested - inner class `VariableMinLength rule with a custom minimum length` { - - val variableMinLength = - VariableMinLength(TestConfig(mapOf(VariableMinLength.MINIMUM_VARIABLE_NAME_LENGTH to "2"))) - - @Test - fun `reports a very short variable name`() { - val code = "private val a = 3" - assertThat(variableMinLength.compileAndLint(code)).hasSize(1) - } - - @Test - fun `does not report a variable with only a single underscore`() { - val code = """ - class C { - val prop: (Int) -> Unit = { _ -> Unit } - } - """ - assertThat(variableMinLength.compileAndLint(code)).isEmpty() - } - } - - @Test - fun `should not report a variable with 64 letters`() { - val subject = NamingRules() - val code = "private val varThatIsExactly64LettersLongWhichYouMightNotWantToBelieveInLolz = 3" - subject.compileAndLint(code) - assertThat(subject.findings).isEmpty() - } - - @Test - fun `should report a variable name that is too long`() { - val subject = NamingRules() - val code = "private val thisVariableIsDefinitelyWayTooLongLongerThanEverythingAndShouldBeMuchShorter = 3" - subject.compileAndLint(code) - assertThat(subject.findings).hasSize(1) - } - - @Test - fun `should not report a variable name that is okay`() { - val subject = NamingRules() - val code = "private val thisOneIsCool = 3" - subject.compileAndLint(code) - assertThat(subject.findings).isEmpty() - } - - @Test - fun `should report a function name that is too short`() { - val subject = NamingRules() - val code = "fun a() = 3" - subject.compileAndLint(code) - assertThat(subject.findings).hasSize(1) - } - - @Test - fun `should report a function name that is too long`() { - val subject = NamingRules() - val code = "fun thisFunctionIsDefinitelyWayTooLongAndShouldBeMuchShorter() = 3" - subject.compileAndLint(code) - assertThat(subject.findings).hasSize(1) - } - - @Test - fun `should not report a function name that is okay`() { - val subject = NamingRules() - val code = "fun three() = 3" - subject.compileAndLint(code) - assertThat(subject.findings).isEmpty() - } -} diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRulesSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRulesSpec.kt deleted file mode 100644 index 2efa8e4adaf..00000000000 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingRulesSpec.kt +++ /dev/null @@ -1,19 +0,0 @@ -package io.gitlab.arturbosch.detekt.rules.naming - -import io.gitlab.arturbosch.detekt.test.assertThat -import io.gitlab.arturbosch.detekt.test.compileAndLint -import org.junit.jupiter.api.Test - -class NamingRulesSpec { - - @Test - fun `should not detect any`() { - val code = """ - data class D(val i: Int, val j: Int) - fun doStuff() { - val (_, HOLY_GRAIL) = D(5, 4) - } - """ - assertThat(NamingRules().compileAndLint(code)).isEmpty() - } -} diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/PackageNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/PackageNamingSpec.kt index f736cf91f98..e98f20cde34 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/PackageNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/PackageNamingSpec.kt @@ -9,7 +9,7 @@ class PackageNamingSpec { @Test fun `should use custom name for package`() { - val rule = NamingRules(TestConfig(PackageNaming.PACKAGE_PATTERN to "^(package_1)$")) + val rule = PackageNaming(TestConfig(PackageNaming.PACKAGE_PATTERN to "^(package_1)$")) assertThat(rule.compileAndLint("package package_1")).isEmpty() } diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt index 0c28ee4eac0..23640414f7e 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/TopLevelPropertyNamingSpec.kt @@ -14,7 +14,7 @@ class TopLevelPropertyNamingSpec { @Test fun `should use custom name top level propeties`() { assertThat( - NamingRules(TestConfig(mapOf(TopLevelPropertyNaming.CONSTANT_PATTERN to "^lowerCaseConst$"))).compileAndLint( + TopLevelPropertyNaming(TestConfig(mapOf(TopLevelPropertyNaming.CONSTANT_PATTERN to "^lowerCaseConst$"))).compileAndLint( """ class Foo{ companion object { diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMaxLengthSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMaxLengthSpec.kt new file mode 100644 index 00000000000..187d437f2b2 --- /dev/null +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMaxLengthSpec.kt @@ -0,0 +1,32 @@ +package io.gitlab.arturbosch.detekt.rules.naming + +import io.gitlab.arturbosch.detekt.test.assertThat +import io.gitlab.arturbosch.detekt.test.compileAndLint +import org.junit.jupiter.api.Test + +class VariableMaxLengthSpec { + + @Test + fun `should not report underscore variable names`() { + val code = """ + fun getResult(): Pair = TODO() + fun function() { + val (_, status) = getResult() + } + """ + assertThat(VariableMaxLength().compileAndLint(code)).isEmpty() + } + + @Test + fun `should not report a variable with 64 letters`() { + val code = "private val varThatIsExactly64LettersLongWhichYouMightNotWantToBelieveInLolz = 3" + assertThat(VariableMaxLength().compileAndLint(code)).isEmpty() + } + + @Test + fun `should report a variable name that is too long`() { + val code = "private val thisVariableIsDefinitelyWayTooLongLongerThanEverythingAndShouldBeMuchShorter = 3" + assertThat(VariableMaxLength().compileAndLint(code)).hasSize(1) + } + +} diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMinLengthSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMinLengthSpec.kt new file mode 100644 index 00000000000..1fd91bad575 --- /dev/null +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMinLengthSpec.kt @@ -0,0 +1,62 @@ +package io.gitlab.arturbosch.detekt.rules.naming + +import io.gitlab.arturbosch.detekt.test.TestConfig +import io.gitlab.arturbosch.detekt.test.compileAndLint +import org.assertj.core.api.Assertions +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test + +class VariableMinLengthSpec { + + @Nested + inner class `VariableMinLength rule with a custom minimum length` { + + val variableMinLength = + VariableMinLength(TestConfig(mapOf(VariableMinLength.MINIMUM_VARIABLE_NAME_LENGTH to "2"))) + + @Test + fun `reports a very short variable name`() { + val code = "private val a = 3" + Assertions.assertThat(variableMinLength.compileAndLint(code)).hasSize(1) + } + + @Test + fun `does not report a variable with only a single underscore`() { + val code = """ + class C { + val prop: (Int) -> Unit = { _ -> Unit } + } + """ + Assertions.assertThat(variableMinLength.compileAndLint(code)).isEmpty() + } + } + + @Test + fun `should not report a variable name that is okay`() { + val subject = VariableMinLength() + val code = "private val thisOneIsCool = 3" + subject.compileAndLint(code) + Assertions.assertThat(subject.findings).isEmpty() + } + + @Test + fun `should not report a variable with single letter name`() { + val subject = VariableMinLength() + val code = "private val a = 3" + subject.compileAndLint(code) + Assertions.assertThat(subject.findings).isEmpty() + } + + @Test + fun `should not report underscore variable names`() { + val subject = VariableMinLength() + val code = """ + fun getResult(): Pair = TODO() + fun function() { + val (_, status) = getResult() + } + """ + subject.compileAndLint(code) + Assertions.assertThat(subject.findings).isEmpty() + } +} From 8cca46f357ed5c2c59eae5cd9da416890391d625 Mon Sep 17 00:00:00 2001 From: "v.stelmashchuk" Date: Thu, 11 Aug 2022 00:10:14 +0300 Subject: [PATCH 08/15] Fixed namming rules, add check for skip validation --- .../detekt/rules/naming/ClassNaming.kt | 4 ++++ .../naming/ConstructorParameterNaming.kt | 3 ++- .../rules/naming/FunctionParameterNaming.kt | 3 ++- .../detekt/rules/naming/NamingProvider.kt | 1 + .../detekt/rules/naming/VariableNaming.kt | 5 ++++- .../rules/naming/FunctionMaxLengthSpec.kt | 19 ++++++++----------- .../rules/naming/FunctionMinLengthSpec.kt | 1 - .../rules/naming/VariableMaxLengthSpec.kt | 1 - .../detekt/rules/naming/VariableNamingSpec.kt | 1 - 9 files changed, 21 insertions(+), 17 deletions(-) diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNaming.kt index ed3b209aa6e..7a86ad784c3 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNaming.kt @@ -12,6 +12,7 @@ import io.gitlab.arturbosch.detekt.api.internal.ActiveByDefault import io.gitlab.arturbosch.detekt.api.internal.Configuration import io.gitlab.arturbosch.detekt.rules.identifierName import org.jetbrains.kotlin.psi.KtClassOrObject +import org.jetbrains.kotlin.psi.KtConstructor /** * Reports class or object names that do not follow the specified naming convention. @@ -32,6 +33,9 @@ class ClassNaming(config: Config = Config.empty) : Rule(config) { private val classPattern: Regex by config("[A-Z][a-zA-Z0-9]*") { it.toRegex() } override fun visitClassOrObject(classOrObject: KtClassOrObject) { + if (classOrObject.nameAsSafeName.isSpecial || classOrObject.nameIdentifier?.parent?.javaClass == null) { + return + } if (!classOrObject.identifierName().removeSurrounding("`").matches(classPattern)) { report( CodeSmell( diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt index 3db245969f6..cf290d75954 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt @@ -13,6 +13,7 @@ import io.gitlab.arturbosch.detekt.api.internal.Configuration import io.gitlab.arturbosch.detekt.rules.identifierName import io.gitlab.arturbosch.detekt.rules.isOverride import io.gitlab.arturbosch.detekt.rules.naming.util.isContainingExcludedClassOrObject +import org.jetbrains.kotlin.psi.KtConstructor import org.jetbrains.kotlin.psi.KtParameter import org.jetbrains.kotlin.psi.psiUtil.isPrivate @@ -42,7 +43,7 @@ class ConstructorParameterNaming(config: Config = Config.empty) : Rule(config) { private val ignoreOverridden: Boolean by config(true) override fun visitParameter(parameter: KtParameter) { - if (parameter.nameAsSafeName.isSpecial || parameter.nameIdentifier?.parent?.javaClass == null) { + if (parameter.nameAsSafeName.isSpecial || parameter.nameIdentifier?.parent?.javaClass == null || parameter.ownerFunction !is KtConstructor<*>) { return } if (parameter.isContainingExcludedClassOrObject(excludeClassPattern) || isIgnoreOverridden(parameter)) { diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt index f951a7afa08..7456c1409c4 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt @@ -15,6 +15,7 @@ import io.gitlab.arturbosch.detekt.api.internal.Configuration import io.gitlab.arturbosch.detekt.rules.identifierName import io.gitlab.arturbosch.detekt.rules.isOverride import io.gitlab.arturbosch.detekt.rules.naming.util.isContainingExcludedClass +import org.jetbrains.kotlin.psi.KtNamedFunction import org.jetbrains.kotlin.psi.KtParameter /** @@ -46,7 +47,7 @@ class FunctionParameterNaming(config: Config = Config.empty) : Rule(config) { private val ignoreOverridden: Boolean by configWithFallback(::ignoreOverriddenFunctions, true) override fun visitParameter(parameter: KtParameter) { - if (parameter.nameAsSafeName.isSpecial || parameter.nameIdentifier?.parent?.javaClass == null) { + if (parameter.nameAsSafeName.isSpecial || parameter.nameIdentifier?.parent?.javaClass == null || parameter.ownerFunction !is KtNamedFunction) { return } if (parameter.isContainingExcludedClass(excludeClassPattern)) { diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt index dc952f63d40..4231fc1ae88 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt @@ -36,6 +36,7 @@ class NamingProvider : DefaultRuleSetProvider { FunctionMaxLength(config), VariableMaxLength(config), VariableMaxLength(config), + NonBooleanPropertyPrefixedWithIs(config) ) ) } diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt index 38f73a70bf9..1c13e70c016 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNaming.kt @@ -69,7 +69,10 @@ class VariableNaming(config: Config = Config.empty) : Rule(config) { } private fun KtProperty.isPropertyTopLevelOrInCompanion(): Boolean { - return this.nameAsSafeName.isSpecial || this.getNonStrictParentOfType() != null || this.isTopLevel || this.nameIdentifier?.parent?.javaClass == null + return this.nameAsSafeName.isSpecial || + this.getNonStrictParentOfType() != null || + this.isTopLevel || + this.nameIdentifier?.parent?.javaClass == null } private fun report(property: KtProperty, message: String) { diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMaxLengthSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMaxLengthSpec.kt index c9407766aef..40cfd15441a 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMaxLengthSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMaxLengthSpec.kt @@ -1,34 +1,31 @@ package io.gitlab.arturbosch.detekt.rules.naming import io.gitlab.arturbosch.detekt.test.TestConfig +import io.gitlab.arturbosch.detekt.test.assertThat import io.gitlab.arturbosch.detekt.test.compileAndLint -import org.assertj.core.api.Assertions import org.junit.jupiter.api.Test class FunctionMaxLengthSpec { @Test fun `should report a function name that is too long base on config`() { - val subject = FunctionMaxLength(TestConfig(mapOf("maximumFunctionNameLength" to 10))) val code = "fun thisFunctionLongName() = 3" - subject.compileAndLint(code) - Assertions.assertThat(subject.findings).hasSize(1) + assertThat( + FunctionMaxLength(TestConfig(mapOf("maximumFunctionNameLength" to 10))) + .compileAndLint(code) + ) + .hasSize(1) } @Test fun `should report a function name that is too long`() { - val subject = FunctionMaxLength() val code = "fun thisFunctionIsDefinitelyWayTooLongAndShouldBeMuchShorter() = 3" - subject.compileAndLint(code) - Assertions.assertThat(subject.findings).hasSize(1) + assertThat(FunctionMaxLength().compileAndLint(code)).hasSize(1) } @Test fun `should not report a function name that is okay`() { - val subject = FunctionMaxLength() val code = "fun three() = 3" - subject.compileAndLint(code) - Assertions.assertThat(subject.findings).isEmpty() + assertThat(FunctionMaxLength().compileAndLint(code)).isEmpty() } - } diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt index 017574f4c3f..c2fefc42faa 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt @@ -30,5 +30,4 @@ class FunctionMinLengthSpec { subject.compileAndLint(code) Assertions.assertThat(subject.findings).isEmpty() } - } diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMaxLengthSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMaxLengthSpec.kt index 187d437f2b2..54ae548d3b4 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMaxLengthSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMaxLengthSpec.kt @@ -28,5 +28,4 @@ class VariableMaxLengthSpec { val code = "private val thisVariableIsDefinitelyWayTooLongLongerThanEverythingAndShouldBeMuchShorter = 3" assertThat(VariableMaxLength().compileAndLint(code)).hasSize(1) } - } diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt index 1ff66ef4e26..534e61c7c93 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt @@ -204,7 +204,6 @@ class VariableNamingSpec { assertThat(VariableNaming().compileAndLint(code)).isEmpty() } - @Test fun `doesn't ignore overridden member properties if ignoreOverridden is false`() { val code = """ From ae82f56b9530dc06da10598546daf6ebba827beb Mon Sep 17 00:00:00 2001 From: "v.stelmashchuk" Date: Thu, 11 Aug 2022 00:14:09 +0300 Subject: [PATCH 09/15] Fixed detekt config --- detekt-core/src/main/resources/default-detekt-config.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/detekt-core/src/main/resources/default-detekt-config.yml b/detekt-core/src/main/resources/default-detekt-config.yml index 59de0ada0e4..ff264ca5513 100644 --- a/detekt-core/src/main/resources/default-detekt-config.yml +++ b/detekt-core/src/main/resources/default-detekt-config.yml @@ -367,9 +367,6 @@ naming: VariableMaxLength: active: false maximumVariableNameLength: 64 - VariableMinLength: - active: false - minimumVariableNameLength: 1 VariableNaming: active: true variablePattern: '[a-z][A-Za-z0-9]*' From 566834fcea7421b12b4205927aecab4e8082cbde Mon Sep 17 00:00:00 2001 From: "v.stelmashchuk" Date: Thu, 11 Aug 2022 00:36:09 +0300 Subject: [PATCH 10/15] Fixed dublicate rules --- detekt-core/src/main/resources/default-detekt-config.yml | 3 +++ .../arturbosch/detekt/rules/naming/NamingProvider.kt | 8 ++++---- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/detekt-core/src/main/resources/default-detekt-config.yml b/detekt-core/src/main/resources/default-detekt-config.yml index ff264ca5513..59de0ada0e4 100644 --- a/detekt-core/src/main/resources/default-detekt-config.yml +++ b/detekt-core/src/main/resources/default-detekt-config.yml @@ -367,6 +367,9 @@ naming: VariableMaxLength: active: false maximumVariableNameLength: 64 + VariableMinLength: + active: false + minimumVariableNameLength: 1 VariableNaming: active: true variablePattern: '[a-z][A-Za-z0-9]*' diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt index 4231fc1ae88..f6b6e242029 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt @@ -20,22 +20,22 @@ class NamingProvider : DefaultRuleSetProvider { MemberNameEqualsClassName(config), InvalidPackageDeclaration(config), NoNameShadowing(config), - VariableNaming(config), TopLevelPropertyNaming(config), BooleanPropertyNaming(config), LambdaParameterNaming(config), - FunctionParameterNaming(config), ConstructorParameterNaming(config), ForbiddenClassName(config), ClassNaming(config), PackageNaming(config), - FunctionNaming(config), EnumNaming(config), ObjectPropertyNaming(config), + FunctionParameterNaming(config), + FunctionNaming(config), FunctionMinLength(config), FunctionMaxLength(config), VariableMaxLength(config), - VariableMaxLength(config), + VariableMinLength(config), + VariableNaming(config), NonBooleanPropertyPrefixedWithIs(config) ) ) From bbb0ca947438d617eb0ef2c71991a0c15261a31e Mon Sep 17 00:00:00 2001 From: Vova Stelmashchuk Date: Tue, 16 Aug 2022 22:28:12 +0300 Subject: [PATCH 11/15] Fixed linter issues --- .../detekt/rules/naming/ClassNaming.kt | 1 - .../rules/naming/ConstructorParameterNaming.kt | 5 ++++- .../rules/naming/FunctionParameterNaming.kt | 12 ++++++++---- .../rules/naming/FunctionMinLengthSpec.kt | 17 +++++++---------- .../rules/naming/VariableMinLengthSpec.kt | 18 ++++++------------ 5 files changed, 25 insertions(+), 28 deletions(-) diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNaming.kt index 7a86ad784c3..122966a22fd 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNaming.kt @@ -12,7 +12,6 @@ import io.gitlab.arturbosch.detekt.api.internal.ActiveByDefault import io.gitlab.arturbosch.detekt.api.internal.Configuration import io.gitlab.arturbosch.detekt.rules.identifierName import org.jetbrains.kotlin.psi.KtClassOrObject -import org.jetbrains.kotlin.psi.KtConstructor /** * Reports class or object names that do not follow the specified naming convention. diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt index cf290d75954..5cea81a3922 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt @@ -43,7 +43,10 @@ class ConstructorParameterNaming(config: Config = Config.empty) : Rule(config) { private val ignoreOverridden: Boolean by config(true) override fun visitParameter(parameter: KtParameter) { - if (parameter.nameAsSafeName.isSpecial || parameter.nameIdentifier?.parent?.javaClass == null || parameter.ownerFunction !is KtConstructor<*>) { + if (parameter.nameAsSafeName.isSpecial || + parameter.nameIdentifier?.parent?.javaClass == null || + parameter.ownerFunction !is KtConstructor<*> + ) { return } if (parameter.isContainingExcludedClassOrObject(excludeClassPattern) || isIgnoreOverridden(parameter)) { diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt index 7456c1409c4..27c4e60e7c1 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionParameterNaming.kt @@ -47,10 +47,7 @@ class FunctionParameterNaming(config: Config = Config.empty) : Rule(config) { private val ignoreOverridden: Boolean by configWithFallback(::ignoreOverriddenFunctions, true) override fun visitParameter(parameter: KtParameter) { - if (parameter.nameAsSafeName.isSpecial || parameter.nameIdentifier?.parent?.javaClass == null || parameter.ownerFunction !is KtNamedFunction) { - return - } - if (parameter.isContainingExcludedClass(excludeClassPattern)) { + if (parameter.isParameterInFunction()) { return } @@ -69,4 +66,11 @@ class FunctionParameterNaming(config: Config = Config.empty) : Rule(config) { ) } } + + private fun KtParameter.isParameterInFunction(): Boolean { + return this.nameAsSafeName.isSpecial || + (this.nameIdentifier?.parent?.javaClass == null) || + (this.ownerFunction !is KtNamedFunction) || + this.isContainingExcludedClass(excludeClassPattern) + } } diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt index c2fefc42faa..62760f3e6ed 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/FunctionMinLengthSpec.kt @@ -2,32 +2,29 @@ package io.gitlab.arturbosch.detekt.rules.naming import io.gitlab.arturbosch.detekt.test.TestConfig import io.gitlab.arturbosch.detekt.test.compileAndLint -import org.assertj.core.api.Assertions +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test class FunctionMinLengthSpec { @Test fun `should report a function name that is too short`() { - val subject = FunctionMinLength() val code = "fun a() = 3" - subject.compileAndLint(code) - Assertions.assertThat(subject.findings).hasSize(1) + assertThat(FunctionMinLength().compileAndLint(code)).hasSize(1) } @Test fun `should report a function name that is too short base on config`() { - val subject = FunctionMinLength(TestConfig(mapOf("minimumFunctionNameLength" to 5))) val code = "fun four() = 3" - subject.compileAndLint(code) - Assertions.assertThat(subject.findings).hasSize(1) + assertThat( + FunctionMinLength(TestConfig(mapOf("minimumFunctionNameLength" to 5))) + .compileAndLint(code) + ).hasSize(1) } @Test fun `should not report a function name that is okay`() { - val subject = FunctionMinLength() val code = "fun three() = 3" - subject.compileAndLint(code) - Assertions.assertThat(subject.findings).isEmpty() + assertThat(FunctionMinLength().compileAndLint(code)).isEmpty() } } diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMinLengthSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMinLengthSpec.kt index 1fd91bad575..65c9f4dcbd6 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMinLengthSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableMinLengthSpec.kt @@ -2,7 +2,7 @@ package io.gitlab.arturbosch.detekt.rules.naming import io.gitlab.arturbosch.detekt.test.TestConfig import io.gitlab.arturbosch.detekt.test.compileAndLint -import org.assertj.core.api.Assertions +import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Nested import org.junit.jupiter.api.Test @@ -17,7 +17,7 @@ class VariableMinLengthSpec { @Test fun `reports a very short variable name`() { val code = "private val a = 3" - Assertions.assertThat(variableMinLength.compileAndLint(code)).hasSize(1) + assertThat(variableMinLength.compileAndLint(code)).hasSize(1) } @Test @@ -27,36 +27,30 @@ class VariableMinLengthSpec { val prop: (Int) -> Unit = { _ -> Unit } } """ - Assertions.assertThat(variableMinLength.compileAndLint(code)).isEmpty() + assertThat(variableMinLength.compileAndLint(code)).isEmpty() } } @Test fun `should not report a variable name that is okay`() { - val subject = VariableMinLength() val code = "private val thisOneIsCool = 3" - subject.compileAndLint(code) - Assertions.assertThat(subject.findings).isEmpty() + assertThat(VariableMinLength().compileAndLint(code)).isEmpty() } @Test fun `should not report a variable with single letter name`() { - val subject = VariableMinLength() val code = "private val a = 3" - subject.compileAndLint(code) - Assertions.assertThat(subject.findings).isEmpty() + assertThat(VariableMinLength().compileAndLint(code)).isEmpty() } @Test fun `should not report underscore variable names`() { - val subject = VariableMinLength() val code = """ fun getResult(): Pair = TODO() fun function() { val (_, status) = getResult() } """ - subject.compileAndLint(code) - Assertions.assertThat(subject.findings).isEmpty() + assertThat(VariableMinLength().compileAndLint(code)).isEmpty() } } From 70582b325cc0a91b2f495170444d79e5b1ae6834 Mon Sep 17 00:00:00 2001 From: Vova Stelmashchuk Date: Tue, 16 Aug 2022 22:54:03 +0300 Subject: [PATCH 12/15] Fixed kotlin code into tests snniped --- ...uspendFunWithCoroutineScopeReceiverSpec.kt | 2 + .../detekt/rules/naming/VariableNamingSpec.kt | 92 +------------------ 2 files changed, 4 insertions(+), 90 deletions(-) diff --git a/detekt-rules-coroutines/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/coroutines/SuspendFunWithCoroutineScopeReceiverSpec.kt b/detekt-rules-coroutines/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/coroutines/SuspendFunWithCoroutineScopeReceiverSpec.kt index 80924a523a0..7a7b4287873 100644 --- a/detekt-rules-coroutines/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/coroutines/SuspendFunWithCoroutineScopeReceiverSpec.kt +++ b/detekt-rules-coroutines/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/coroutines/SuspendFunWithCoroutineScopeReceiverSpec.kt @@ -115,6 +115,8 @@ class SuspendFunWithCoroutineScopeReceiverSpec(val env: KotlinCoreEnvironment) { fun `no reports when suspend function has Long as receiver`() { val code = """ import kotlinx.coroutines.delay + import kotlinx.coroutines.launch + import kotlinx.coroutines.CoroutineScope suspend fun Long.foo() = coroutineScope { launch { diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt index 534e61c7c93..12af91a2dbd 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/VariableNamingSpec.kt @@ -58,40 +58,6 @@ class VariableNamingSpec { assertThat(VariableNaming(config).compileAndLint(code)).isEmpty() } - @Test - fun test() { - val code = """ - data class ReportPath(val kind: String, val path: Path) { - - companion object { - private const val NUM_OF_PARTS_UNIX = 2 - private const val NUM_OF_PARTS_WINDOWS = 3 - private const val REPORT_PATH_SEPARATOR = ":" - - fun from(input: String): ReportPath { - val parts = input.split(REPORT_PATH_SEPARATOR) - - val path = when (val partsSize = parts.size) { - NUM_OF_PARTS_UNIX -> parts[1] - NUM_OF_PARTS_WINDOWS -> parts.slice(1 until partsSize).joinToString(REPORT_PATH_SEPARATOR) - else -> error( - "Input must consist of two parts for Unix OSs or three for Windows (report-id:path)." - ) - } - - val kind = parts[0] - require(kind.isNotEmpty()) { "The kind of report must not be empty (path)" } - require(path.isNotEmpty()) { "The path of the report must not be empty (kind)" } - return ReportPath(kind, Paths.get(path)) - } - } - } - - """ - - assertThat(VariableNaming().compileAndLint(code)).isEmpty() - } - @Test fun `should detect all positive cases`() { val code = """ @@ -137,73 +103,19 @@ class VariableNamingSpec { assertThat(VariableNaming().compileAndLint(code)).isEmpty() } - @Test - fun `should not flag global member properties`() { - val code = """ - const val DEFAULT_FLOAT_CONVERSION_FACTOR: Int = 100 - private const val QUOTES = "\"" - """ - assertThat(VariableNaming().compileAndLint(code)).isEmpty() - } - @Test fun `should not flag lambda fun arguments`() { val code = """ fun foo() { - listOf>().flatMap { (test, left) -> print("H") } + listOf>().flatMap { (left, right) -> listOf(left, right) } } fun bar() { - listOf>().flatMap { (right, _) -> print("H") } - } - """ - assertThat(VariableNaming().compileAndLint(code)).isEmpty() - } - - @Test - fun `should not flag member properties into companion object`() { - val code = """ - class Foo { - companion object { - val TWENTY_MINS: Debt = - Debt(0, 0, 20) - val TEN_MINS: Debt = - Debt(0, 0, 10) - val FIVE_MINS: Debt = - Debt(0, 0, 5) - private const val HOURS_PER_DAY = 24 - private const val MINUTES_PER_HOUR = 60 - - const val ACTIVE_KEY: String = "active" - } + listOf>().flatMap { (right, _) -> listOf(right) } } """ assertThat(VariableNaming().compileAndLint(code)).isEmpty() } - @Test - fun `should not try catch member properties into companion object`() { - val code = """ - fun Config.valueOrDefaultCommaSeparated( - key: String, - default: List - ): List { - fun fallBack() = valueOrDefault(key, default.joinToString(",")) - .trim() - .commaSeparatedPattern(",", ";") - .toList() - - return try { - valueOrDefault(key, default) - } catch (_: IllegalStateException) { - fallBack() - } catch (_: ClassCastException) { - fallBack() - } - } - """ - assertThat(VariableNaming().compileAndLint(code)).isEmpty() - } - @Test fun `doesn't ignore overridden member properties if ignoreOverridden is false`() { val code = """ From 879f56f7383acfc76de026c34e2c7f806a957d75 Mon Sep 17 00:00:00 2001 From: Vova Stelmashchuk Date: Wed, 7 Sep 2022 23:03:34 +0300 Subject: [PATCH 13/15] Add test for ClassName rule, no violations for abstract class implementation --- .../detekt/rules/naming/ClassNamingSpec.kt | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNamingSpec.kt b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNamingSpec.kt index aa3a971bb3b..43b5d5b89cd 100644 --- a/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNamingSpec.kt +++ b/detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNamingSpec.kt @@ -7,6 +7,20 @@ import org.junit.jupiter.api.Test class ClassNamingSpec { + @Test + fun `should detekt no violations for abstract class implementation`() { + val code = """ + abstract class AbstractClass { + abstract fun foo() + } + val foo = object : AbstractClass() { + override fun foo() {} + } + """.trimIndent() + + assertThat(ClassNaming().compileAndLint(code)).isEmpty() + } + @Test fun `should use custom name for method and class`() { val config = TestConfig(mapOf(ClassNaming.CLASS_PATTERN to "^aBbD$")) From 7126c8d29ed54abc6959b7c24f85ee7d5f62bc9c Mon Sep 17 00:00:00 2001 From: Vova Stelmashchuk Date: Wed, 7 Sep 2022 23:36:23 +0300 Subject: [PATCH 14/15] Remove unused code from constructor parameter namming rule --- .../rules/naming/ConstructorParameterNaming.kt | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt index 5cea81a3922..b35061acca9 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt @@ -43,15 +43,12 @@ class ConstructorParameterNaming(config: Config = Config.empty) : Rule(config) { private val ignoreOverridden: Boolean by config(true) override fun visitParameter(parameter: KtParameter) { - if (parameter.nameAsSafeName.isSpecial || - parameter.nameIdentifier?.parent?.javaClass == null || - parameter.ownerFunction !is KtConstructor<*> + if (!parameter.isConstructor() || + parameter.isContainingExcludedClassOrObject(excludeClassPattern) || + isIgnoreOverridden(parameter) ) { return } - if (parameter.isContainingExcludedClassOrObject(excludeClassPattern) || isIgnoreOverridden(parameter)) { - return - } val identifier = parameter.identifierName() if (parameter.isPrivate()) { @@ -61,7 +58,7 @@ class ConstructorParameterNaming(config: Config = Config.empty) : Rule(config) { issue, Entity.from(parameter), message = "Constructor private parameter names should " + - "match the pattern: $privateParameterPattern" + "match the pattern: $privateParameterPattern" ) ) } @@ -79,4 +76,8 @@ class ConstructorParameterNaming(config: Config = Config.empty) : Rule(config) { } private fun isIgnoreOverridden(parameter: KtParameter) = ignoreOverridden && parameter.isOverride() + + private fun KtParameter.isConstructor(): Boolean { + return this.ownerFunction is KtConstructor<*> + } } From b1f5e1909f45d28df7b1cf0904202f292b49b827 Mon Sep 17 00:00:00 2001 From: Vova Stelmashchuk Date: Wed, 7 Sep 2022 23:43:30 +0300 Subject: [PATCH 15/15] Fixed the linter issue --- .../naming/ConstructorParameterNaming.kt | 24 +++++++++++-------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt index b35061acca9..83fed496c18 100644 --- a/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt +++ b/detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ConstructorParameterNaming.kt @@ -52,16 +52,7 @@ class ConstructorParameterNaming(config: Config = Config.empty) : Rule(config) { val identifier = parameter.identifierName() if (parameter.isPrivate()) { - if (!identifier.matches(privateParameterPattern)) { - report( - CodeSmell( - issue, - Entity.from(parameter), - message = "Constructor private parameter names should " + - "match the pattern: $privateParameterPattern" - ) - ) - } + visitPrivateParameter(parameter) } else { if (!identifier.matches(parameterPattern)) { report( @@ -75,6 +66,19 @@ class ConstructorParameterNaming(config: Config = Config.empty) : Rule(config) { } } + private fun visitPrivateParameter(parameter: KtParameter) { + val identifier = parameter.identifierName() + if (!identifier.matches(privateParameterPattern)) { + report( + CodeSmell( + issue, + Entity.from(parameter), + message = "Constructor private parameter names should match the pattern: $privateParameterPattern" + ) + ) + } + } + private fun isIgnoreOverridden(parameter: KtParameter) = ignoreOverridden && parameter.isOverride() private fun KtParameter.isConstructor(): Boolean {