Remove rule from NamingRules multi rule (#5212)

Co-authored-by: v.stelmashchuk <volodymyr.stelmashchuk@pm.bet>

detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNaming.kt

@@ -32,6 +32,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(

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,22 +43,16 @@ class ConstructorParameterNaming(config: Config = Config.empty) : Rule(config) {
     private val ignoreOverridden: Boolean by config(true)
 
     override fun visitParameter(parameter: KtParameter) {
-        if (parameter.isContainingExcludedClassOrObject(excludeClassPattern) || isIgnoreOverridden(parameter)) {
+        if (!parameter.isConstructor() ||
+            parameter.isContainingExcludedClassOrObject(excludeClassPattern) ||
+            isIgnoreOverridden(parameter)
+        ) {
             return
         }
 
         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(
@@ -71,5 +66,22 @@ 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 {
+        return this.ownerFunction is KtConstructor<*>
+    }
 }

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.isContainingExcludedClass(excludeClassPattern)) {
+        if (parameter.isParameterInFunction()) {
             return
         }
 
@@ -65,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)
+    }
 }

detekt-rules-naming/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/naming/NamingProvider.kt

@@ -18,9 +18,25 @@ class NamingProvider : DefaultRuleSetProvider {
         listOf(
             MatchingDeclarationName(config),
             MemberNameEqualsClassName(config),
-            NamingRules(config),
             InvalidPackageDeclaration(config),
-            NoNameShadowing(config)
+            NoNameShadowing(config),
+            TopLevelPropertyNaming(config),
+            BooleanPropertyNaming(config),
+            LambdaParameterNaming(config),
+            ConstructorParameterNaming(config),
+            ForbiddenClassName(config),
+            ClassNaming(config),
+            PackageNaming(config),
+            EnumNaming(config),
+            ObjectPropertyNaming(config),
+            FunctionParameterNaming(config),
+            FunctionNaming(config),
+            FunctionMinLength(config),
+            FunctionMaxLength(config),
+            VariableMaxLength(config),
+            VariableMinLength(config),
+            VariableNaming(config),
+            NonBooleanPropertyPrefixedWithIs(config)
         )
     )
 }

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.isPropertyTopLevelOrInCompanion()) {
+            return
+        }
         if (property.isSingleUnderscore || property.isContainingExcludedClassOrObject(excludeClassPattern)) {
             return
         }
@@ -63,6 +68,13 @@ class VariableNaming(config: Config = Config.empty) : Rule(config) {
         }
     }
 
+    private fun KtProperty.isPropertyTopLevelOrInCompanion(): Boolean {
+        return this.nameAsSafeName.isSpecial ||
+            this.getNonStrictParentOfType<KtObjectDeclaration>() != null ||
+            this.isTopLevel ||
+            this.nameIdentifier?.parent?.javaClass == null
+    }
+
     private fun report(property: KtProperty, message: String) {
         report(
             CodeSmell(
@@ -74,7 +86,6 @@ class VariableNaming(config: Config = Config.empty) : Rule(config) {
     }
 
     companion object {
-        const val VARIABLE_PATTERN = "variablePattern"
         const val EXCLUDE_CLASS_PATTERN = "excludeClassPattern"
     }
 }

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 val default: java.lang.Boolean = java.lang.Boolean(true)
+                }
+            """.trimIndent()
+            val findings = subject.compileAndLintWithContext(env, code)
+
+            assertThat(findings).hasSize(1)
+        }
+
         @Test
         fun `should warn about Java Boolean override if ignoreOverridden is false`() {
             val code = """

detekt-rules-naming/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/naming/ClassNamingSpec.kt

@@ -1,11 +1,38 @@
 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 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$"))
+        assertThat(
+            ClassNaming(config).compileAndLint(
+                """
+        class aBbD{}
+                """.trimIndent()
+            )
+        ).isEmpty()
+    }
+
     @Test
     fun `should detect no violations class with numbers`() {
         val code = """
@@ -64,4 +91,16 @@ class ClassNamingSpec {
         """.trimIndent()
         assertThat(ClassNaming().compileAndLint(code)).isEmpty()
     }
+
+    @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)
+            }
+        """.trimIndent()
+
+        assertThat(ClassNaming().compileAndLint(code)).isEmpty()
+    }
 }