feature to detekt self-invocation and fixed detekt issues

Author: NordCoderd

AGENTS.md

@@ -42,6 +42,9 @@ Typical cases to cover per rule:
 - Correct stereotype with file-level helpers in same file → pass
 - Unannotated class alone in constrained location → fail
 
+Strictly use: /test-driven-development skill.
+Warning: RED phase test failing not because compilation error but not expected behavior.
+
 ### 2. Implement the rule
 
 Add the rule `object` to the relevant `*Rules.kt` in `src/main/kotlin/.../rules/<category>/`. Use `hasAnnotationWithName(SpringAnnotations.*)` (not `hasAnnotationOf`). Group by `containingFile` when file-level helper exemptions are needed.
@@ -65,3 +68,4 @@ Add one bullet to the matching section in `README.md` under `## Rule Set`. Forma
 ### 7. Run `./gradlew codeBaseline`
 
 Must pass clean: tests + detekt + 90% coverage floor.
+Strictly denied/prohibited: suppress any violations, removing, excluding tests, disabling any quality gates.

README.md

@@ -11,7 +11,7 @@ Maven Central: https://central.sonatype.com/artifact/dev.protsenko/spring-boot-c
 Add dependency to your `build.gradle.kts` or `build.gradle`:
 
 ```kotlin
-implementation("dev.protsenko:spring-boot-code-guard:1.0.8")
+implementation("dev.protsenko:spring-boot-code-guard:1.0.9")
 ```
 
 ## Usage
@@ -126,6 +126,10 @@ Passing an unknown key throws an error listing all registered rule keys. Excludi
 - `CodeGuard:noStackTracePrint`: Spring bean classes must not call `printStackTrace()` directly; use structured logging so stack traces are captured by the application logging pipeline.
 - `CodeGuard:noProxyAnnotationsOnPrivateMethods`: `@Transactional`, `@Cacheable`, `@CacheEvict`, `@CachePut`, and `@Async` must not be placed on `private` methods — Spring proxy cannot intercept private methods, so the annotation is silently ignored.
 
+### Proxy
+
+- `CodeGuard:noSelfInvocationOfProxyMethods`: Methods annotated with `@Transactional`, `@Cacheable`, `@CacheEvict`, `@CachePut`, or `@Async` must not invoke another proxy-annotated method on the same class; Spring AOP proxy is bypassed on self-invocation, so the callee annotation is silently ignored.
+
 ### JPA
 
 - `CodeGuard:entityId`: Every `@Entity` class (or one of its parents within the same codebase) must declare a field annotated with `@Id`, as JPA requires a primary key to track entity identity.

build.gradle.kts

@@ -11,7 +11,7 @@ plugins {
 }
 
 group = "dev.protsenko"
-version = "1.0.8"
+version = "1.0.9"
 
 repositories {
     mavenCentral()
@@ -20,6 +20,7 @@ repositories {
 dependencies {
     // Konsist needs to be in api/implementation scope as our rules use its types
     api("com.lemonappdev:konsist:0.17.3")
+    implementation("org.jetbrains.kotlin:kotlin-compiler-embeddable:2.0.21")
 
     testImplementation(kotlin("test"))
     testImplementation("org.springframework.boot:spring-boot-starter-data-jpa:4.0.5")
@@ -35,10 +36,6 @@ tasks.test {
     useJUnitPlatform()
 }
 
-detekt {
-    config.setFrom(files("detekt.yml"))
-}
-
 tasks.withType<KotlinCompile>().configureEach {
     compilerOptions {
         allWarningsAsErrors.set(true)
@@ -100,8 +97,13 @@ tasks.withType<PublishToMavenRepository>().configureEach {
     }
 }
 
+detekt {
+    config.setFrom(rootProject.file("detekt.yml"))
+    buildUponDefaultConfig = true
+}
+
 tasks.register("codeBaseline") {
-    dependsOn("clean", "test", "detekt", "koverVerify")
+    dependsOn("clean", "test", "detektMain", "koverVerify")
     description = "Runs tests, Detekt, and Kover verification"
     group = "verification"
 }

detekt.yml

@@ -1,4 +1,3 @@
-build:
-  excludes:
-    # Exclude test fixture violation files from detekt checks
-    - '**/fixtures/violations/**'
+complexity:
+  TooManyFunctions:
+    thresholdInClasses: 15

src/main/kotlin/dev/protsenko/codeguard/core/RuleBuilder.kt

@@ -29,7 +29,7 @@ annotation class SpringBootRuleDsl
  * Context for configuring rules within a specific category.
  */
 @SpringBootRuleDsl
-abstract class RuleContext {
+open class RuleContext {
     protected val builder = RuleBuilder()
 
     /**

src/main/kotlin/dev/protsenko/codeguard/core/SpringBootRulesConfiguration.kt

@@ -10,6 +10,8 @@ import dev.protsenko.codeguard.rules.naming.NamingRuleContext
 import dev.protsenko.codeguard.rules.naming.allNamingRules
 import dev.protsenko.codeguard.rules.packages.PackageRuleContext
 import dev.protsenko.codeguard.rules.packages.allPackageRules
+import dev.protsenko.codeguard.rules.proxy.ProxyRuleContext
+import dev.protsenko.codeguard.rules.proxy.allProxyRules
 import dev.protsenko.codeguard.rules.web.WebRuleContext
 import dev.protsenko.codeguard.rules.web.allWebRules
 
@@ -71,6 +73,15 @@ class SpringBootRulesConfiguration {
         allRules.addAll(context.getRules())
     }
 
+    /**
+     * Configure Spring proxy rules (@Transactional, caching, async interception).
+     */
+    fun proxy(block: ProxyRuleContext.() -> Unit) {
+        val context = ProxyRuleContext()
+        context.block()
+        allRules.addAll(context.getRules())
+    }
+
     /**
      * Exclude rules by suppress key. Order-independent — exclusions are applied at verify() time.
      * Throws if a key does not match any registered rule, or if all rules are excluded.
@@ -79,35 +90,29 @@ class SpringBootRulesConfiguration {
         excludedKeys.addAll(keys)
     }
 
-    private fun activeRules(): List<SpringBootRule> {
-        if (excludedKeys.isEmpty()) return allRules.toList()
-
-        val registeredKeys = allRules.map { it.suppressKey }
-        val unknownKeys = excludedKeys.filter { it !in registeredKeys }
-        if (unknownKeys.isNotEmpty()) {
-            throw IllegalArgumentException(
+    private val activeRules: List<SpringBootRule>
+        get() {
+            if (excludedKeys.isEmpty()) return allRules.toList()
+            val registeredKeys = allRules.map { it.suppressKey }
+            val unknownKeys = excludedKeys.filter { it !in registeredKeys }
+            require(unknownKeys.isEmpty()) {
                 "Cannot exclude unknown rule(s): ${unknownKeys.joinToString(", ")}. " +
-                    "Registered rules: ${registeredKeys.joinToString(", ")}",
-            )
-        }
-
-        val active = allRules.filterNot { it.suppressKey in excludedKeys }
-        if (active.isEmpty()) {
-            throw IllegalArgumentException(
-                "No rules remaining after exclusions — at least one rule must be active.",
-            )
+                    "Registered rules: ${registeredKeys.joinToString(", ")}"
+            }
+            val active = allRules.filterNot { it.suppressKey in excludedKeys }
+            require(active.isNotEmpty()) {
+                "No rules remaining after exclusions — at least one rule must be active."
+            }
+            return active
         }
 
-        return active
-    }
-
     /**
      * Verify all configured rules against the scope.
      * Runs every rule and collects all violations before throwing,
      * so the full list of problems is reported in a single error.
      */
     fun verify() {
-        val failures = activeRules().mapNotNull { rule ->
+        val failures = activeRules.mapNotNull { rule ->
             try {
                 rule.verify(scope)
                 null
@@ -124,7 +129,7 @@ class SpringBootRulesConfiguration {
      * Verify configured rules and collect per-rule results without throwing.
      */
     fun verifyWithResults(): List<RuleResult> =
-        activeRules().map { rule ->
+        activeRules.map { rule ->
             try {
                 rule.verify(scope)
                 RuleResult.Success
@@ -145,6 +150,7 @@ class SpringBootRulesConfiguration {
         allRules.addAll(allJpaRules)
         allRules.addAll(allNamingRules)
         allRules.addAll(allPackageRules)
+        allRules.addAll(allProxyRules)
         allRules.addAll(allWebRules)
     }
 

…/codeguard/rules/general/GeneralRules.kt …nko/codeguard/rules/general/CoreRules.ktsrc/main/kotlin/dev/protsenko/codeguard/rules/general/GeneralRules.kt renamed to src/main/kotlin/dev/protsenko/codeguard/rules/general/CoreRules.kt src/main/kotlin/dev/protsenko/codeguard/rules/general/GeneralRules.kt renamed to src/main/kotlin/dev/protsenko/codeguard/rules/general/CoreRules.kt

@@ -120,7 +120,8 @@ object CoreRules {
                             "${klass.name} extends $parentName"
                         }
                     throw AssertionError(
-                        "Custom exception classes should extend RuntimeException or proper Spring exceptions: $violatingClasses",
+                        "Custom exception classes should extend RuntimeException or proper Spring " +
+                            "exceptions: $violatingClasses",
                     )
                 }
             }
@@ -166,15 +167,16 @@ object CoreRules {
                     .notSuppressedFunctions(suppressKey)
                     .filter { it.hasModifier(KoModifier.PRIVATE) }
                     .forEach { function ->
-                        val annotation = SpringAnnotations.proxyAnnotations
+                        SpringAnnotations.proxyAnnotations
                             .firstOrNull { function.hasAnnotationWithName(it) }
-                            ?: return@forEach
-                        val annotationName = annotation.substringAfterLast(".")
-                        throw AssertionError(
-                            "${function.containingDeclaration}.${function.name} is private and " +
-                                    "annotated with @$annotationName — Spring proxy cannot intercept private methods, " +
-                                    "the annotation will be silently ignored.",
-                        )
+                            ?.let { annotation ->
+                                val annotationName = annotation.substringAfterLast(".")
+                                throw AssertionError(
+                                    "${function.containingDeclaration}.${function.name} is private and " +
+                                        "annotated with @$annotationName — Spring proxy cannot intercept " +
+                                        "private methods, the annotation will be silently ignored.",
+                                )
+                            }
                     }
             }
         }

src/main/kotlin/dev/protsenko/codeguard/rules/general/GeneralRuleContext.kt

@@ -58,4 +58,5 @@ class GeneralRuleContext : RuleContext() {
     fun noProxyAnnotationsOnPrivateMethods() {
         builder.addRule(CoreRules.noProxyAnnotationsOnPrivateMethodsRule)
     }
+
 }

src/main/kotlin/dev/protsenko/codeguard/rules/jpa/JpaRules.kt

@@ -28,24 +28,15 @@ object JpaRules {
                     .notSuppressedClasses(suppressKey)
                     .withAnnotationNamed(SpringAnnotations.entityAnnotations)
                     .forEach { entity ->
-                        var current = entity
                         val visitedClassNames = mutableSetOf<String>()
-                        var hasIdField = false
-
-                        while (visitedClassNames.add(current.name)) {
-                            val hasIdInCurrentClass =
-                                current
-                                    .properties()
+                        val hasIdField = generateSequence(entity) { current ->
+                            current.parentClass?.name?.let { classesByName[it] }
+                        }.takeWhile { visitedClassNames.add(it.name) }
+                            .any { klass ->
+                                klass.properties()
                                     .any { it.hasAnnotationWithName(SpringAnnotations.idAnnotations) }
-                            if (hasIdInCurrentClass) {
-                                hasIdField = true
-                                break
                             }
 
-                            val parentName = current.parentClass?.name ?: break
-                            current = classesByName[parentName] ?: break
-                        }
-
                         if (!hasIdField) {
                             throw AssertionError(
                                 "@Entity class ${entity.name} must have a field annotated with @Id",

src/main/kotlin/dev/protsenko/codeguard/rules/naming/NamingRules.kt

@@ -106,7 +106,8 @@ object NamingRules {
                         if (violations.isNotEmpty()) {
                             val violatingClasses = violations.joinToString(", ") { it.name }
                             throw AssertionError(
-                                "Exception handler classes should end with 'ExceptionHandler' or 'Advice': $violatingClasses",
+                                "Exception handler classes should end with " +
+                                    "'ExceptionHandler' or 'Advice': $violatingClasses",
                             )
                         }
                     }
@@ -130,7 +131,8 @@ object NamingRules {
                         if (violations.isNotEmpty()) {
                             val violatingClasses = violations.joinToString(", ") { it.name }
                             throw AssertionError(
-                                "Classes with @ConfigurationProperties annotation should end with 'Properties': $violatingClasses",
+                                "Classes with @ConfigurationProperties annotation " +
+                                    "should end with 'Properties': $violatingClasses",
                             )
                         }
                     }