LimeDocRulesValidator: ease validation of placeholders

This change introduces a new optional configuration
parameter for rules: 'resolvePlaceholder'. If the rule
is intended to only check if placeholder is used then
this parameter ease the regex -- we can just specify:
'@Placeholder <NAME>'.

Signed-off-by: Patryk Wrobel <183546751+pwrobeldev@users.noreply.github.com>

Author: pwrobeldev

gluecodium/src/main/java/com/here/gluecodium/validator/LimeDocRulesValidator.kt

@@ -87,7 +87,14 @@ class LimeDocRulesValidator(
                 continue
             }
 
-            val applyResult = regex.containsMatchIn(element.comment.getFor(platform))
+            val validatedComment =
+                if (rule.resolvePlaceholders) {
+                    element.comment.getFor(platform)
+                } else {
+                    element.comment.getForWithoutResolvingPlaceholder(platform)
+                }
+
+            val applyResult = regex.containsMatchIn(validatedComment)
             if (!applyResult) {
                 logRuleApplicationFailed(rule, element, platform)
                 result = false

gluecodium/src/main/java/com/here/gluecodium/validator/LimeDocValidationRule.kt

@@ -27,5 +27,6 @@ data class LimeDocValidationRule(
     val limeElements: List<String>,
     val regex: String,
     val isWarningOnly: Boolean,
+    val resolvePlaceholders: Boolean = true,
     val platforms: List<String> = listOf(),
 )

gluecodium/src/test/java/com/here/gluecodium/validator/LimeDocRulesValidatorTest.kt

@@ -899,7 +899,7 @@ class LimeDocRulesValidatorTest {
     }
 
     @Test
-    fun validationOfCommentWithResolvedPlaceholder() {
+    fun validationPassesForCommentWithResolvedPlaceholder() {
         // Given a class in LimeModel, which obeys the rules.
         allElements[outerTypePath.toString()] =
             LimeClass(
@@ -916,7 +916,7 @@ class LimeDocRulesValidatorTest {
                     ),
             )
 
-        // And given a correct validation rule for classes that uses the placeholder.
+        // And given a correct validation rule for classes.
         val docValidationRules: List<LimeDocValidationRule> =
             listOf(
                 LimeDocValidationRule(
@@ -937,6 +937,82 @@ class LimeDocRulesValidatorTest {
         assertTrue(validationResult)
     }
 
+    @Test
+    fun validationPassesForCommentWithoutResolvedPlaceholder() {
+        // Given a class in LimeModel, which obeys the rules.
+        allElements[outerTypePath.toString()] =
+            LimeClass(
+                path = outerTypePath,
+                comment =
+                    LimeComment(
+                        path = outerTypePath.child("comment"),
+                        taggedSections =
+                            listOf(
+                                "" to "This is some important outer type class. ",
+                                "Placeholder" to "AvailableOnline",
+                            ),
+                        placeholders = mapOf("AvailableOnline" to LimeComment("This type is available only online")),
+                    ),
+            )
+
+        // And given a correct validation rule for classes that uses the placeholder but does not resolve it.
+        val docValidationRules: List<LimeDocValidationRule> =
+            listOf(
+                LimeDocValidationRule(
+                    name = "SPECIAL_RULE",
+                    limeElements = listOf("class"),
+                    regex = "@Placeholder AvailableOnline",
+                    isWarningOnly = false,
+                    resolvePlaceholders = false,
+                ),
+            )
+
+        // And given correctly constructed validator.
+        val validator = LimeDocRulesValidator(mockk(relaxed = true), docValidationRules, allGenerators)
+
+        // When trying to verify if rules are obeyed.
+        val validationResult = validator.validate(limeModel)
+
+        // Then validation passes.
+        assertTrue(validationResult)
+    }
+
+    @Test
+    fun validationFailsForCommentWithoutResolvedPlaceholder() {
+        // Given a class in LimeModel, which does not obey the rules.
+        allElements[outerTypePath.toString()] =
+            LimeClass(
+                path = outerTypePath,
+                comment =
+                    LimeComment(
+                        path = outerTypePath.child("comment"),
+                        taggedSections =
+                            listOf("" to "This is some important outer type class. "),
+                    ),
+            )
+
+        // And given a correct validation rule for classes that uses the placeholder but does not resolve it.
+        val docValidationRules: List<LimeDocValidationRule> =
+            listOf(
+                LimeDocValidationRule(
+                    name = "SPECIAL_RULE",
+                    limeElements = listOf("class"),
+                    regex = "@Placeholder AvailableOnline",
+                    isWarningOnly = false,
+                    resolvePlaceholders = false,
+                ),
+            )
+
+        // And given correctly constructed validator.
+        val validator = LimeDocRulesValidator(mockk(relaxed = true), docValidationRules, allGenerators)
+
+        // When trying to verify if rules are obeyed.
+        val validationResult = validator.validate(limeModel)
+
+        // Then validation fails.
+        assertFalse(validationResult)
+    }
+
     @Test
     fun validationPassesForRuleForTwoPlatforms() {
         // Given a class in LimeModel, which obeys the rules.

lime-runtime/src/main/java/com/here/gluecodium/model/lime/LimeComment.kt

@@ -51,6 +51,18 @@ class LimeComment(
             .joinToString("") { if (!isPlaceholder(it.first)) it.second else resolvePlaceholder(it.second, platform) }
             .trim()
 
+    fun getForWithoutResolvingPlaceholder(platform: String) =
+        taggedSections
+            .filter { it.first == "" || it.first == platform || isPlaceholder(it.first) }
+            .joinToString("") {
+                if (!isPlaceholder(it.first)) {
+                    it.second
+                } else {
+                    "{ @Placeholder ${it.second} }"
+                }
+            }
+            .trim()
+
     fun withPath(newPath: LimePath) = LimeComment(newPath, taggedSections, isExcluded, placeholders)
 
     fun withExcluded(newExcluded: Boolean): LimeComment {