Lenght & size operators

operations-stdlib/src/commonMain/kotlin/Find.kt → operations-stdlib/src/commonMain/kotlin/array/Find.kt

@@ -1,3 +1,6 @@
+package array
+
+import LogicEvaluator
 import operation.FunctionalLogicOperation
 import unwrap.EvaluatingUnwrapper
 import utils.asList

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

@@ -0,0 +1,16 @@
+package array
+
+import operation.StandardLogicOperation
+import utils.asList
+import utils.isSingleNullList
+
+object Size : StandardLogicOperation {
+    override fun evaluateLogic(expression: Any?, data: Any?): Any? {
+        return when (val firstItem = expression.asList.firstOrNull()) {
+            firstItem.isSingleNullList() -> null
+            is Map<*, *> -> firstItem.size
+            is List<*> -> firstItem.size
+            else -> null
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+package string
+
+import operation.StandardLogicOperation
+
+object Length : StandardLogicOperation, StringUnwrapStrategy {
+    override fun evaluateLogic(expression: Any?, data: Any?): Any? = unwrapValueAsString(expression)?.length
+}

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

@@ -1,9 +1,7 @@
 package string
 
-import operation.StandardLogicOperation
 import utils.asList
 
-
 internal interface StringUnwrapStrategy {
     fun unwrapValueAsString(wrappedValue: Any?): String? =
         with(wrappedValue.asList) {

operations-stdlib/src/commonTest/kotlin/FindTest.kt → operations-stdlib/src/commonTest/kotlin/array/FindTest.kt

@@ -1,54 +1,56 @@
-import JsonLogicResult.Failure
-import JsonLogicResult.Success
+package array
+
+import JsonLogicEngine
+import TestInput
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.datatest.withData
 import io.kotest.matchers.shouldBe
 
 class FindTest : FunSpec({
     val logicEngine = JsonLogicEngine.Builder().addFunctionalOperation("find", Find).build()
-    
+
     withData(
         nameFn = { input -> "Should evaluated ${input.expression} with given ${input.data} result in ${input.result}" },
         ts = listOf(
             TestInput(
                 expression = mapOf("find" to 1.3),
-                result = Failure.NullResult
+                result = JsonLogicResult.Failure.NullResult
             ),
             TestInput(
                 expression = mapOf("find" to "banana"),
-                result = Failure.NullResult
+                result = JsonLogicResult.Failure.NullResult
             ),
             TestInput(
                 expression = mapOf("find" to null),
-                result = Failure.NullResult
+                result = JsonLogicResult.Failure.NullResult
             ),
             TestInput(
                 expression = mapOf("find" to true),
-                result = Failure.NullResult
+                result = JsonLogicResult.Failure.NullResult
             ),
             TestInput(
                 expression = mapOf("find" to emptyList<Any>()),
-                result = Failure.NullResult
+                result = JsonLogicResult.Failure.NullResult
             ),
             TestInput(
                 expression = mapOf("find" to listOf(null, mapOf("var" to ""))),
-                result = Failure.NullResult
+                result = JsonLogicResult.Failure.NullResult
             ),
             TestInput(
                 expression = mapOf("find" to listOf(emptyList<String>(), mapOf("var" to ""))),
-                result = Failure.NullResult
+                result = JsonLogicResult.Failure.NullResult
             ),
             TestInput(
                 expression = mapOf("find" to listOf(listOf(false, false), mapOf("var" to ""))),
-                result = Failure.NullResult
+                result = JsonLogicResult.Failure.NullResult
             ),
             TestInput(
                 expression = mapOf("find" to listOf(listOf(true, false), mapOf("var" to ""))),
-                result = Success(true)
+                result = JsonLogicResult.Success(true)
             ),
             TestInput(
                 expression = mapOf("find" to listOf(listOf(true, false))),
-                result = Failure.NullResult
+                result = JsonLogicResult.Failure.NullResult
             ),
             TestInput(
                 expression = mapOf(
@@ -62,23 +64,23 @@ class FindTest : FunSpec({
                     )
                 ),
                 data = mapOf("integers" to listOf(1, 2, 3, 4, 5)),
-                result = Success(3)
+                result = JsonLogicResult.Success(3)
             ),
             TestInput(
                 expression = mapOf("find" to listOf(listOf(-1, 1, 2, 3), mapOf(">" to listOf(mapOf("var" to ""), 0)))),
-                result = Success(1)
+                result = JsonLogicResult.Success(1)
             ),
             TestInput(
                 expression = mapOf("find" to listOf(listOf(0, 0, 0, 0), mapOf("==" to listOf(mapOf("var" to ""), 0)))),
-                result = Success(0)
+                result = JsonLogicResult.Success(0)
             ),
             TestInput(
                 expression = mapOf("find" to listOf(listOf(0, 0, 0, 0), mapOf("===" to listOf(mapOf("var" to ""), 0)))),
-                result = Success(0)
+                result = JsonLogicResult.Success(0)
             ),
             TestInput(
                 expression = mapOf("find" to listOf(listOf(0, 0, 0, 0), mapOf("!=" to listOf(mapOf("var" to ""), 0)))),
-                result = Failure.NullResult
+                result = JsonLogicResult.Failure.NullResult
             ),
             TestInput(
                 expression = mapOf(
@@ -87,11 +89,11 @@ class FindTest : FunSpec({
                         mapOf(">" to listOf(mapOf("var" to ""), 0))
                     )
                 ),
-                result = Success(3)
+                result = JsonLogicResult.Success(3)
             ),
             TestInput(
                 expression = mapOf("find" to listOf(listOf(-1, 1, 2, 3), mapOf("<" to listOf(mapOf("var" to ""), 0)))),
-                result = Success(-1)
+                result = JsonLogicResult.Success(-1)
             ),
             TestInput(
                 expression = mapOf(
@@ -100,7 +102,7 @@ class FindTest : FunSpec({
                         mapOf("==" to listOf(mapOf("var" to ""), "apple"))
                     )
                 ),
-                result = Success("apple")
+                result = JsonLogicResult.Success("apple")
             ),
             TestInput(
                 expression = mapOf(
@@ -110,7 +112,7 @@ class FindTest : FunSpec({
                     )
                 ),
                 data = mapOf("fruits" to listOf("apple", "banana", "pineapple")),
-                result = Success("pineapple")
+                result = JsonLogicResult.Success("pineapple")
             ),
             TestInput(
                 expression = mapOf(
@@ -119,7 +121,7 @@ class FindTest : FunSpec({
                         mapOf("<" to listOf(mapOf("var" to ""), 0))
                     )
                 ),
-                result = Failure.NullResult
+                result = JsonLogicResult.Failure.NullResult
             ),
         )
         // given

operations-stdlib/src/commonTest/kotlin/array/SizeTest.kt

@@ -0,0 +1,105 @@
+package array
+
+import JsonLogicEngine
+import TestInput
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.datatest.withData
+import io.kotest.matchers.shouldBe
+
+class SizeTest : FunSpec({
+    val logicEngine = JsonLogicEngine.Builder().addStandardOperation("size", Size).build()
+
+    withData(
+        nameFn = { input -> "Should evaluated ${input.expression} with given ${input.data} result in ${input.result}" },
+        ts = listOf(
+            TestInput(
+                expression = mapOf("size" to listOf(listOf("test"))),
+                result = JsonLogicResult.Success(1)
+            ),
+            TestInput(
+                expression = mapOf("size" to listOf(listOf("test", "test2"), "a")),
+                result = JsonLogicResult.Success(2)
+            ),
+            TestInput(
+                expression = mapOf(
+                    "size" to listOf(
+                        mapOf("var" to "fruits"),
+                        mapOf("var" to "fruits2")
+                    )
+                ),
+                data = mapOf("fruits" to listOf(listOf("apple"), "banana", "pineapple"), "fruits2" to "testFruit"),
+                result = JsonLogicResult.Success(3)
+            ),
+            TestInput(
+                expression = mapOf(
+                    "size" to mapOf("var" to "fruits")
+                ),
+                data = mapOf("fruits" to listOf(listOf(listOf("apple"), "banana", "pineapple"))),
+                result = JsonLogicResult.Success(3)
+            ),
+            TestInput(
+                expression = mapOf(
+                    "size" to mapOf(
+                        "if" to listOf(
+                            mapOf("<" to listOf(mapOf("var" to "temp"), 0)),
+                            "freezing",
+                            mapOf("<" to listOf(mapOf("var" to "temp"), 100)),
+                            listOf(listOf("liquid", "test", "b", "c")),
+                            "gas"
+                        )
+                    )
+                ),
+                data = mapOf("temp" to 55),
+                result = JsonLogicResult.Success(4)
+            ),
+            TestInput(
+                expression = mapOf("size" to listOf<Any>(listOf<Any>())),
+                result = JsonLogicResult.Success(0)
+            ),
+            TestInput(
+                expression = mapOf(
+                    "size" to mapOf(
+                        "if" to listOf(
+                            mapOf("<" to listOf(mapOf("var" to "temp"), 100)),
+                            listOf("liquid", "test", "b", "c"),
+                            "gas"
+                        )
+                    )
+                ),
+                data = mapOf("temp" to 55),
+                result = JsonLogicResult.Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(
+                    "size" to 1
+                ),
+                result = JsonLogicResult.Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(
+                    "size" to 1521414312
+                ),
+                result = JsonLogicResult.Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(
+                    "size" to null
+                ),
+                result = JsonLogicResult.Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf(
+                    "size" to "aa"
+                ),
+                result = JsonLogicResult.Failure.NullResult
+            ),
+        )
+        // given
+    ) { testInput: TestInput ->
+        // when
+        val evaluationResult = logicEngine.evaluate(testInput.expression, testInput.data)
+
+        // then
+        evaluationResult shouldBe testInput.result
+    }
+})

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

@@ -0,0 +1,96 @@
+package string
+
+import JsonLogicEngine
+import TestInput
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.datatest.withData
+import io.kotest.matchers.shouldBe
+
+class LengthTest : FunSpec({
+    val logicEngine = JsonLogicEngine.Builder()
+        .addStandardOperation("length", Length).build()
+    // given
+    withData(
+        nameFn = { input -> "Should evaluated ${input.expression} with given ${input.data} result in ${input.result}" },
+        ts = listOf(
+            TestInput(
+                expression = mapOf("length" to "test"),
+                result = JsonLogicResult.Success(4)
+            ),
+            TestInput(
+                expression = mapOf(
+                    "length" to mapOf("var" to "fruits")
+                ),
+                data = mapOf("fruits" to listOf("apple")),
+                result = JsonLogicResult.Success(5)
+            ),
+            TestInput(
+                expression = mapOf("length" to ""),
+                result = JsonLogicResult.Success(0)
+            ),
+            TestInput(
+                expression = mapOf(
+                    "length" to "this is very very very  very very very  very very very  very very " +
+                        " very very very  very very very  very very very  very very very  very very very  very very" +
+                        " very very  very very very  very very very  very very very  very very very  very very very" +
+                        " very very very  very very very  very very very  very very very  very very very  long text"
+                ),
+                result = JsonLogicResult.Success(336)
+            ),
+            TestInput(
+                expression = mapOf(
+                    "length" to mapOf(
+                        "if" to listOf(
+                            mapOf("<" to listOf(mapOf("var" to "temp"), 0)), "freezing"
+                        )
+                    )
+                ),
+                data = mapOf("temp" to -20),
+                result = JsonLogicResult.Success(8)
+            ),
+            TestInput(
+                expression = mapOf(
+                    "length" to mapOf(
+                        "if" to listOf(
+                            mapOf("<" to listOf(mapOf("var" to "temp"), 0)), "freezing",
+                            mapOf("<" to listOf(mapOf("var" to "temp"), 100)), "liquid",
+                            "gas"
+                        )
+                    )
+                ),
+                data = mapOf("temp" to 55),
+                result = JsonLogicResult.Success(6)
+            ),
+            TestInput(
+                expression = mapOf("length" to 123455),
+                result = JsonLogicResult.Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf("length" to -123455),
+                result = JsonLogicResult.Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf("length" to 0),
+                result = JsonLogicResult.Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf("length" to 10.0),
+                result = JsonLogicResult.Failure.NullResult
+            ),
+
+            TestInput(
+                expression = mapOf("length" to listOf("test", "test2")),
+                result = JsonLogicResult.Failure.NullResult
+            ),
+            TestInput(
+                expression = mapOf("length" to mapOf("test" to "test2")),
+                result = JsonLogicResult.Failure.MissingOperation
+            ),
+        )
+    ) { testInput: TestInput ->
+        // when
+        val evaluationResult = logicEngine.evaluate(testInput.expression, testInput.data)
+        // then
+        evaluationResult shouldBe testInput.result
+    }
+})