Update instantiations of ErrorMessage

Author: yevhenii-nadtochii

model/src/main/kotlin/io/spine/validation/DistinctPolicy.kt

@@ -63,8 +63,13 @@ internal class DistinctPolicy : ValidationPolicy<FieldOptionDiscovered>() {
         checkCollection(fieldName, declaringType, event.file)
 
         val rule = SimpleRule(
-            fieldName, DistinctCollection.getDefaultInstance(), ERROR, ERROR, false
+            fieldName,
+            DistinctCollection.getDefaultInstance(),
+            DESCRIPTION,
+            errorMessage { value= ERROR },
+            false
         )
+
         return simpleRuleAdded {
             type = declaringType
             this@simpleRuleAdded.rule = rule
@@ -81,5 +86,6 @@ internal class DistinctPolicy : ValidationPolicy<FieldOptionDiscovered>() {
 
     companion object {
         private const val ERROR = "A field with `($DISTINCT) = true` must not contain duplicates."
+        private const val DESCRIPTION = "The option to mark a `repeated` field as a collection of unique elements."
     }
 }

model/src/main/kotlin/io/spine/validation/GoesPolicy.kt

@@ -39,7 +39,6 @@ import io.spine.protodata.type.resolve
 import io.spine.server.event.Just
 import io.spine.server.event.Just.Companion.just
 import io.spine.server.event.React
-import io.spine.validation.ErrorMessageFormat.EM_PLACEHOLDERS
 import io.spine.validation.event.RuleAdded
 
 /**
@@ -81,18 +80,23 @@ internal class GoesPolicy : Policy<FieldOptionDiscovered>() {
                 left = targetFieldShouldBeUnset(target)
                 operator = LogicalOperator.OR
                 right = companionFieldShouldBeSet(companion)
-                errorMessage = option.errorMessage()
                 field = target.name
-                errorMessageFormat = EM_PLACEHOLDERS
-                optionPlaceholders.putAll(mapOf(
-                    "fieldName" to target.name.value,
-                    "companionName" to companion.name.value
-                ))
+                errorMessage = errorMessage(option, target, companion)
             }
         }
         return just(rule.toEvent(target.declaringType))
     }
 
+    private fun errorMessage(option: GoesOption, target: Field, companion: Field) = errorMessage {
+        value = option.errorMessage()
+        buildtimePlaceholders.putAll(
+            mapOf(
+                "fieldName" to target.name.value,
+                "companionName" to companion.name.value
+            )
+        )
+    }
+
     /**
      * Checks that the given [target] and [companion] fields are distinct.
      *

model/src/main/kotlin/io/spine/validation/NumberRules.kt

@@ -94,7 +94,7 @@ internal constructor(
         field = this@toRule
         operator = if (inclusive) inclusiveOperator else exclusiveOperator
         otherValue = threshold
-        errorMessage = compileErrorMessage(adjective, inclusive)
+        errorMessage = errorMessage { value = compileErrorMessage(adjective, inclusive) }
         distribute = true
     }
 
@@ -111,7 +111,7 @@ internal constructor(
         right = toMaxRule().wrap()
         operator = AND
         field = this@toRangeRule
-        errorMessage = rangeErrorMessage
+        errorMessage = errorMessage { value = rangeErrorMessage }
     }
 
     private val rangeErrorMessage: String by lazy {

model/src/main/kotlin/io/spine/validation/PatternPolicy.kt

@@ -61,7 +61,7 @@ internal class PatternPolicy : Policy<FieldOptionDiscovered>() {
             field.name,
             feature,
             "String should match regex.",
-            error,
+            errorMessage { value = error },
             true
         )
         return simpleRuleAdded(field.declaringType, rule)

model/src/main/kotlin/io/spine/validation/RequiredRule.kt

@@ -46,10 +46,7 @@ internal object RequiredRule {
      */
     @Suppress("ReturnCount")
     fun forField(field: Field, errorMessage: String): Rule? {
-        val unsetValue = UnsetValue.forField(field)
-        if (unsetValue == null) {
-            return null
-        }
+        val unsetValue = UnsetValue.forField(field) ?: return null
         val integratedRule = rule(
             field, unsetValue, errorMessage, singularErrorMsg, false
         )
@@ -63,7 +60,7 @@ internal object RequiredRule {
     }
 
     private fun collectionRule(integratedRule: SimpleRule, errorMessage: String): Rule {
-        val msg = collectionErrorMessage(errorMessage)
+        val msg = errorMessage { value = collectionErrorMessage(errorMessage) }
         val withCustomErrorMessage = integratedRule.toBuilder()
             .setErrorMessage(msg)
             .build()
@@ -108,7 +105,7 @@ internal object RequiredRule {
     ): SimpleRule {
         val msg = errorMessage.ifEmpty { defaultErrorMessage }
         return simpleRule {
-            this.errorMessage = msg
+            this.errorMessage = errorMessage { this.value = msg }
             this.field = field.name
             operator = ComparisonOperator.NOT_EQUAL
             otherValue = value

model/src/main/kotlin/io/spine/validation/SimpleRules.kt

@@ -46,18 +46,17 @@ public fun SimpleRule(
     field: FieldName,
     customFeature: Message,
     description: String,
-    errorMessage: String,
+    errorMessage: ErrorMessage,
     distribute: Boolean
 ): SimpleRule {
-    require(description.isNotEmpty())
-    require(errorMessage.isNotEmpty())
     require(description.isNotBlank())
-    require(errorMessage.isNotBlank())
+    require(errorMessage.value.isNotBlank())
 
     val operator = customOperator {
         this.description = description
         feature = customFeature.pack()
     }
+
     return simpleRule {
         customOperator = operator
         this.errorMessage = errorMessage

model/src/main/kotlin/io/spine/validation/ValidatePolicy.kt

@@ -71,7 +71,7 @@ internal class ValidatePolicy : ValidationPolicy<FieldExited>() {
             RecursiveValidation.getDefaultInstance(),
             "A message field is validated by its validation rules. " +
                     "If the field is invalid, the container message is invalid as well.",
-            field!!.errorMessage,
+            errorMessage { field!!.errorMessage },
             true
         )
         return simpleRuleAdded {

model/src/main/kotlin/io/spine/validation/WhenPolicy.kt

@@ -59,7 +59,7 @@ internal class WhenPolicy : Policy<FieldOptionDiscovered>() {
             field.name,
             feature,
             errorMessage,
-            errorMessage,
+            errorMessage { value = errorMessage },
             true
         )
         return simpleRuleAdded(field.declaringType, newRule)