Add comments with a list of regexes to ForbiddenComment

detekt-core/src/main/resources/default-detekt-config.yml

@@ -566,7 +566,7 @@ style:
         value: 'java.lang.annotation.Inherited'
   ForbiddenComment:
     active: true
-    values:
+    comments:
       - 'FIXME:'
       - 'STOPSHIP:'
       - 'TODO:'

detekt-core/src/main/resources/deprecation.properties

@@ -16,6 +16,7 @@ potential-bugs>IgnoredReturnValue>restrictToAnnotatedMethods=Use `restrictToConf
 potential-bugs>LateinitUsage>excludeAnnotatedProperties=Use `ignoreAnnotated` instead
 potential-bugs>MissingWhenCase=Rule deprecated as compiler performs this check by default
 potential-bugs>RedundantElseInWhen=Rule deprecated as compiler performs this check by default
+style>ForbiddenComment>values=Use `comments` instead, make sure you escape your text for Regular Expressions.
 style>ForbiddenPublicDataClass=Rule migrated to `libraries` ruleset plugin
 style>FunctionOnlyReturningConstant>excludeAnnotatedFunction=Use `ignoreAnnotated` instead
 style>LibraryCodeMustSpecifyReturnType=Rule migrated to `libraries` ruleset plugin

detekt-rules-style/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/style/ForbiddenComment.kt

@@ -38,7 +38,13 @@ class ForbiddenComment(config: Config = Config.empty) : Rule(config) {
     )
 
     @Configuration("forbidden comment strings")
-    private val values: List<String> by config(listOf("FIXME:", "STOPSHIP:", "TODO:"))
+    @Deprecated("Use `comments` instead, make sure you escape your text for Regular Expressions.")
+    private val values: List<String> by config(emptyList())
+
+    @Configuration("forbidden comment string patterns")
+    private val comments: List<Regex> by config(listOf("FIXME:", "STOPSHIP:", "TODO:")) {
+        it.map(String::toRegex)
+    }
 
     @Configuration("ignores comments which match the specified regular expression. For example `Ticket|Task`.")
     private val allowedPatterns: Regex by config("", String::toRegex)
@@ -63,6 +69,7 @@ class ForbiddenComment(config: Config = Config.empty) : Rule(config) {
     private fun checkForbiddenComment(text: String, comment: PsiElement) {
         if (allowedPatterns.pattern.isNotEmpty() && allowedPatterns.containsMatchIn(text)) return
 
+        @Suppress("DEPRECATION")
         values.forEach {
             if (text.contains(it, ignoreCase = true)) {
                 report(
@@ -74,6 +81,18 @@ class ForbiddenComment(config: Config = Config.empty) : Rule(config) {
                 )
             }
         }
+
+        comments.forEach {
+            if (it.containsMatchIn(text)) {
+                report(
+                    CodeSmell(
+                        issue,
+                        Entity.from(comment),
+                        getErrorMessage(it.pattern)
+                    )
+                )
+            }
+        }
     }
 
     private fun getErrorMessage(value: String): String =

detekt-rules-style/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/ForbiddenCommentSpec.kt

@@ -1,3 +1,5 @@
+@file:Suppress("ClassName")
+
 package io.gitlab.arturbosch.detekt.rules.style
 
 import io.gitlab.arturbosch.detekt.test.TestConfig
@@ -8,6 +10,7 @@ import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 
 private const val VALUES = "values"
+private const val COMMENTS = "comments"
 private const val ALLOWED_PATTERNS = "allowedPatterns"
 private const val MESSAGE = "customMessage"
 
@@ -75,6 +78,15 @@ class ForbiddenCommentSpec {
             assertThat(findings).hasSize(1)
         }
 
+        @Test
+        fun `should report violation in single line block comment`() {
+            val code = """
+                /*TODO: I need to fix this.*/
+            """.trimIndent()
+            val findings = ForbiddenComment().compileAndLint(code)
+            assertThat(findings).hasSize(1)
+        }
+
         @Test
         fun `should report violation in KDoc`() {
             val code = """
@@ -98,7 +110,7 @@ class ForbiddenCommentSpec {
 
         @Nested
         inner class `when given Banana` {
-            val config = TestConfig(VALUES to "Banana")
+            val config = TestConfig(COMMENTS to "Banana")
 
             @Test
             @DisplayName("should not report TODO: usages")
@@ -138,7 +150,7 @@ class ForbiddenCommentSpec {
         @Nested
         @DisplayName("when given listOf(\"banana\")")
         inner class ListOfBanana {
-            val config = TestConfig(VALUES to listOf("Banana"))
+            val config = TestConfig(COMMENTS to listOf("Banana"))
 
             @Test
             @DisplayName("should not report TODO: usages")
@@ -235,4 +247,60 @@ class ForbiddenCommentSpec {
             assertThat(findings.first().message).isEqualTo(expectedMessage)
         }
     }
+
+    @Nested
+    inner class `custom value pattern is configured` {
+        private val patternStr = """^//( )?(?i)REVIEW\b"""
+        private val messageConfig = TestConfig(
+            COMMENTS to listOf("STOPSHIP", patternStr),
+        )
+
+        @Test
+        fun `should not report a finding when review doesn't match the pattern`() {
+            val comment = "// to express in the preview that it's not a normal TextView."
+            val findings = ForbiddenComment(messageConfig).compileAndLint(comment)
+            assertThat(findings).isEmpty()
+        }
+
+        @Test
+        fun `should report a finding when STOPSHIP is present`() {
+            val comment = "// STOPSHIP to express in the preview that it's not a normal TextView."
+            val findings = ForbiddenComment(messageConfig).compileAndLint(comment)
+            assertThat(findings).hasSize(1)
+            io.gitlab.arturbosch.detekt.test.assertThat(findings[0])
+                .hasMessage(String.format(ForbiddenComment.DEFAULT_ERROR_MESSAGE, "STOPSHIP"))
+        }
+
+        @Test
+        fun `should report a finding when review pattern is matched with comment with leading space`() {
+            val comment = "// REVIEW foo -> flag"
+            val findings = ForbiddenComment(messageConfig).compileAndLint(comment)
+            assertThat(findings).hasSize(1)
+            io.gitlab.arturbosch.detekt.test.assertThat(findings[0])
+                .hasMessage(String.format(ForbiddenComment.DEFAULT_ERROR_MESSAGE, patternStr))
+        }
+
+        @Test
+        fun `should report a finding when review pattern is matched with comment with out leading space`() {
+            val comment = "//REVIEW foo -> flag"
+            val findings = ForbiddenComment(messageConfig).compileAndLint(comment)
+            assertThat(findings).hasSize(1)
+            io.gitlab.arturbosch.detekt.test.assertThat(findings[0])
+                .hasMessage(String.format(ForbiddenComment.DEFAULT_ERROR_MESSAGE, patternStr))
+        }
+
+        @Test
+        fun `should report a finding matching two patterns`() {
+            val comment = "// REVIEW foo -> flag STOPSHIP"
+            val findings = ForbiddenComment(messageConfig).compileAndLint(comment)
+            assertThat(findings).hasSize(2)
+        }
+
+        @Test
+        fun `should report a finding matching a pattern contained in the comment`() {
+            val comment = "// foo STOPSHIP bar"
+            val findings = ForbiddenComment(messageConfig).compileAndLint(comment)
+            assertThat(findings).hasSize(1)
+        }
+    }
 }