Add Trim operation

operations-stdlib/src/commonMain/kotlin/OperationsProvider.kt

@@ -10,6 +10,7 @@ import string.IsBlank
 import string.Length
 import string.Lowercase
 import string.ToArray
+import string.Trim
 import string.Uppercase
 
 object OperationsProvider {
@@ -32,7 +33,8 @@ object OperationsProvider {
         "joinToString" to JoinToString,
 
         "drop" to Drop,
-        "reverse" to Reverse
+        "reverse" to Reverse,
+        "trim" to Trim
     )
 
     val functionalOperations: Map<String, FunctionalLogicOperation> = mutableMapOf(

operations-stdlib/src/commonMain/kotlin/array/JoinToString.kt

@@ -13,9 +13,6 @@ object JoinToString : StandardLogicOperation {
 
     override fun evaluateLogic(expression: Any?, data: Any?): Any? = expression.asList.toOperationArguments()?.join()
 
-    private fun JoinToStringArguments.join() =
-        elementsToJoin.joinToString(separator, prefix, postfix, limit, truncated)
-
     private fun List<Any?>.toOperationArguments(): JoinToStringArguments? = runCatching {
         checkLimitArg()?.let { limit ->
             JoinToStringArguments(
@@ -35,6 +32,9 @@ object JoinToString : StandardLogicOperation {
     private fun List<Any?>.checkLimitArg() = (get(LIMIT_ARG_INDEX) as Number).takeIf {
         it.toDouble() == it.toInt().toDouble()
     }?.toInt()
+
+    private fun JoinToStringArguments.join() =
+        elementsToJoin.joinToString(separator, prefix, postfix, limit, truncated)
 }
 
 private data class JoinToStringArguments(

operations-stdlib/src/commonMain/kotlin/string/Trim.kt

@@ -0,0 +1,49 @@
+package string
+
+import operation.StandardLogicOperation
+import utils.asList
+
+object Trim : StandardLogicOperation, StringUnwrapStrategy {
+    private const val TEXT_ARG_INDEX = 0
+    private const val CHAR_ARG_INDEX = 1
+    private const val MODE_ARG_INDEX = 2
+
+    override fun evaluateLogic(expression: Any?, data: Any?): Any? =
+        expression.asList.toOperationArguments()?.invokeTrim()
+
+    private fun List<Any?>.toOperationArguments(): TrimArguments? = runCatching {
+        TrimArguments(
+            text = get(TEXT_ARG_INDEX) as String,
+            char = (get(CHAR_ARG_INDEX) as String).single(),
+            mode = (get(MODE_ARG_INDEX) as String).toTrimMode()
+        )
+    }.fold(
+        onSuccess = { it },
+        onFailure = { null }
+    )
+
+    private fun String?.toTrimMode() = when (this) {
+        "start" -> TrimMode.Start
+        "end" -> TrimMode.End
+        "bothEnds" -> TrimMode.BothEnds
+        else -> throw IllegalStateException("Invalid TrimMode value")
+    }
+
+    private fun TrimArguments.invokeTrim() = when (mode) {
+        TrimMode.Start -> this.text.trimStart(char)
+        TrimMode.End -> this.text.trimEnd(char)
+        TrimMode.BothEnds -> this.text.trim(char)
+    }
+}
+
+private data class TrimArguments(
+    val text: String,
+    val char: Char,
+    val mode: TrimMode
+)
+
+private sealed class TrimMode {
+    object Start : TrimMode()
+    object End : TrimMode()
+    object BothEnds : TrimMode()
+}

operations-stdlib/src/commonTest/kotlin/string/TrimTest.kt

@@ -0,0 +1,133 @@
+import JsonLogicResult.Failure
+import JsonLogicResult.Success
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.datatest.withData
+import io.kotest.matchers.shouldBe
+import string.Trim
+
+class TrimTest : FunSpec({
+    val operatorName = "trim"
+    val logicEngine = JsonLogicEngine.Builder()
+        .addStandardOperations(
+            mapOf(
+                operatorName to Trim
+            )
+        ).build()
+
+    withData(
+        nameFn = { input -> "Should evaluated ${input.expression} with given ${input.data} result in ${input.result}" },
+        ts = listOf(
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf("_cat_", "_", "start")
+                ),
+                result = Success("cat_")
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf("_____cat_", "_", "start")
+                ),
+                result = Success("cat_")
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf("_cat_", "_", "end")
+                ),
+                result = Success("_cat")
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf("_cat_____", "_", "end")
+                ),
+                result = Success("_cat")
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf("_cat_", "_", "bothEnds")
+                ),
+                result = Success("cat")
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf("____cat____", "_", "bothEnds")
+                ),
+                result = Success("cat")
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf("_cat_", "_", "unknown")
+                ),
+                result = Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf(listOf("_cat_"), "_", "bothEnds")
+                ),
+                result = Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf(listOf("_cat_"), "_____", "bothEnds")
+                ),
+                result = Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf(listOf("_cat_"), "", "bothEnds")
+                ),
+                result = Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf("_cat_", "_")
+                ),
+                result = Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf("_cat_")
+                ),
+                result = Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf("")
+                ),
+                result = Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf(mapOf("var" to "key"), "_", "bothEnds")
+                ),
+                data = mapOf("key" to "_cat_"),
+                result = Success("cat")
+            ),
+            TestInput(
+                expression = mapOf(
+                    operatorName to listOf(mapOf("var" to "key"), "_", "bothEnds")
+                ),
+                data = mapOf("key" to listOf("_cat_", "_cat_")),
+                result = Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(operatorName to 1.3),
+                result = Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(operatorName to null),
+                result = Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(operatorName to true),
+                result = Failure.NullResult
+            ),
+        )
+        // given
+    ) { testInput: TestInput ->
+        // when
+        val evaluationResult = logicEngine.evaluate(testInput.expression, testInput.data)
+
+        // then
+        evaluationResult shouldBe testInput.result
+    }
+})