Improve the "DataClassFunction" rule

Author: ILIYANGERMANOV

src/main/kotlin/com/github/ivy/explicit/IvyExplicitRuleSetProvider.kt

@@ -1,5 +1,6 @@
 package com.github.ivy.explicit
 
+import com.github.ivy.explicit.rule.DataClassFunctionsRule
 import io.gitlab.arturbosch.detekt.api.Config
 import io.gitlab.arturbosch.detekt.api.RuleSet
 import io.gitlab.arturbosch.detekt.api.RuleSetProvider

src/main/kotlin/com/github/ivy/explicit/DataClassFunctionsRule.kt src/main/kotlin/com/github/ivy/explicit/rule/DataClassFunctionsRule.kt

@@ -1,10 +1,14 @@
-package com.github.ivy.explicit
+package com.github.ivy.explicit.rule
 
+import com.github.ivy.explicit.util.FunctionMessage
 import io.gitlab.arturbosch.detekt.api.*
+import io.gitlab.arturbosch.detekt.rules.isOverride
 import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtNamedFunction
 
 class DataClassFunctionsRule(config: Config) : Rule(config) {
+    private val functionMessage: FunctionMessage by lazy { FunctionMessage() }
+
     override val issue = Issue(
         id = "DataClassFunctions",
         severity = Severity.Maintainability,
@@ -18,16 +22,28 @@ class DataClassFunctionsRule(config: Config) : Rule(config) {
         if (klass.isData()) {
             klass.body?.declarations
                 ?.filterIsInstance<KtNamedFunction>()
+                ?.filter {
+                    // Functions overrides are fine
+                    !it.isOverride()
+                }
                 ?.forEach { function ->
                     report(
                         CodeSmell(
                             issue,
                             Entity.from(function),
-                            message = "Data class '${klass.name}' should not contain functions. " +
-                                    "Found: function ${function.name}()."
+                            message = failureMessage(klass, function)
                         )
                     )
                 }
         }
     }
+
+    private fun failureMessage(
+        klass: KtClass,
+        function: KtNamedFunction
+    ): String = buildString {
+        append("Data class '${klass.name}' should not contain functions. ")
+        append("Data classes should only model data and not define behavior. ")
+        append("Found: function '${functionMessage.signature(function)}'.")
+    }
 }

src/main/kotlin/com/github/ivy/explicit/util/FunctionMessage.kt

@@ -0,0 +1,31 @@
+package com.github.ivy.explicit.util
+
+import org.jetbrains.kotlin.psi.KtNamedFunction
+
+class FunctionMessage {
+    fun signature(function: KtNamedFunction): String {
+        // Extract the function name
+        val fName = function.name ?: ""
+
+        // Build the parameter list string
+        val inputParams = function.valueParameters.joinToString(separator = ", ") { param ->
+            "${param.name}: ${param.typeReference?.text}"
+        }
+
+        // Get the return type, considering both explicit and inferred types
+        val returnType = try {
+            when {
+                function.typeReference != null -> function.typeReference!!.text
+                function.hasBlockBody() -> "Unit" // Assume Unit for block bodies without a return type
+                function.hasDeclaredReturnType() -> function.typeReference!!.text // Explicit return type
+                else -> null
+            }
+        } catch (e: Exception) {
+            null
+        }
+        // Construct and return the formatted string
+        return "$fName($inputParams)" + if (returnType != null) {
+            ": $returnType"
+        } else ""
+    }
+}

src/test/kotlin/com/github/ivy/explicit/DataClassFunctionsRuleTest.kt src/test/kotlin/com/github/ivy/explicit/rule/DataClassFunctionsRuleTest.kt

@@ -1,18 +1,18 @@
-package com.github.ivy.explicit
+package com.github.ivy.explicit.rule
 
 import io.gitlab.arturbosch.detekt.api.Config
 import io.gitlab.arturbosch.detekt.rules.KotlinCoreEnvironmentTest
 import io.gitlab.arturbosch.detekt.test.compileAndLintWithContext
 import io.kotest.matchers.collections.shouldHaveSize
-import io.kotest.matchers.string.shouldNotBeBlank
+import io.kotest.matchers.shouldBe
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.junit.jupiter.api.Test
 
 @KotlinCoreEnvironmentTest
 internal class DataClassFunctionsRuleTest(private val env: KotlinCoreEnvironment) {
 
     @Test
-    fun `reports data class having functions`() {
+    fun `reports data class having one function`() {
         val code = """
         data class A(
             val x: Int
@@ -23,7 +23,9 @@ internal class DataClassFunctionsRuleTest(private val env: KotlinCoreEnvironment
         val findings = DataClassFunctionsRule(Config.empty).compileAndLintWithContext(env, code)
         findings shouldHaveSize 1
         val message = findings.first().message
-        message.shouldNotBeBlank()
+        message shouldBe """
+            Data class 'A' should not contain functions. Data classes should only model data and not define behavior. Found: function 'a()'.
+        """.trimIndent()
     }
 
     @Test
@@ -38,7 +40,34 @@ internal class DataClassFunctionsRuleTest(private val env: KotlinCoreEnvironment
     }
 
     @Test
-    fun `doesn't report data class with companion object`() {
+    fun `doesn't report data class with override functions`() {
+        val code = """
+        data class DisplayLoan(
+            val loan: Loan,
+            val amountPaid: Double,
+            val currencyCode: String? = getDefaultFIATCurrency().currencyCode,
+            val formattedDisplayText: String = "",
+            val percentPaid: Double = 0.0
+        ) : Reorderable {
+            override fun getItemOrderNum(): Double {
+                return loan.orderNum
+            }
+        
+            override fun withNewOrderNum(newOrderNum: Double): Reorderable {
+                return this.copy(
+                    loan = loan.copy(
+                        orderNum = newOrderNum
+                    )
+                )
+            }
+        }
+        """
+        val findings = DataClassFunctionsRule(Config.empty).compileAndLintWithContext(env, code)
+        findings shouldHaveSize 0
+    }
+
+    @Test
+    fun `doesn't report data class with functions in companion object`() {
         val code = """
         data class A(
             val x: Int