Stdlib find operation

buildSrc/src/main/kotlin/Dependencies.kt

@@ -12,7 +12,8 @@ object Modules {
         const val operationsApi = "JsonLogicOperationsApi"
         const val core = "JsonLogicCore"
     }
-
+
+    const val core = ":core"
     const val operationsApi = ":operations-api"
     const val utils = ":utils"
 }

core/src/commonMain/kotlin/operations/array/ArrayOperation.kt

@@ -1,27 +1,24 @@
 package operations.array
 
 import LogicEvaluator
-import operations.array.unwrap.EvaluatingUnwrapStrategy
+import unwrap.EvaluatingUnwrapper
+import utils.getMappingOperationOrNull
 import utils.secondOrNull
 import kotlin.collections.Map
 
-internal interface ArrayOperation : EvaluatingUnwrapStrategy {
+internal interface ArrayOperation : EvaluatingUnwrapper {
     fun createOperationInput(
         expressionValues: List<Any?>,
         operationData: Any?,
         evaluator: LogicEvaluator
     ): ArrayOperationInputData {
         val evaluatedOperationData = unwrapDataByEvaluation(expressionValues, operationData, evaluator)
-        val mappingOperation = getMappingOperationOrNull(expressionValues)
+        val mappingOperation = expressionValues.getMappingOperationOrNull()
         val operationDefault = getOperationDefault(mappingOperation, expressionValues)
 
         return ArrayOperationInputData(evaluatedOperationData, mappingOperation, operationDefault)
     }
 
-    @Suppress("UNCHECKED_CAST")
-    private fun getMappingOperationOrNull(expression: List<Any?>) =
-        expression.secondOrNull().takeIf { isExpression(it) } as? Map<String, Any>
-
     fun getOperationDefault(mappingOperation: Map<String, Any>?, expressionValues: List<Any?>) =
         if (mappingOperation == null) {
             expressionValues.secondOrNull()

operations-api/build.gradle.kts

@@ -2,7 +2,7 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.apple.XCFramework
 
 plugins {
     kotlin("multiplatform") version Versions.kotlin
-    id("io.kotest.multiplatform") version Versions.kotest apply false
+    id("io.kotest.multiplatform") version Versions.kotest
     id(Conventions.junit)
     id(Conventions.publishing)
 }
@@ -27,9 +27,24 @@ kotlin {
         }
     }
     sourceSets {
-        val commonMain by getting
-        val commonTest by getting
-        val jvmTest by getting
+        val commonMain by getting {
+            dependencies {
+                implementation(project(Modules.utils))
+            }
+        }
+        val commonTest by getting {
+            dependencies {
+                implementation(kotlin("test"))
+                implementation(Libs.Kotest.assertionsCore)
+                implementation(Libs.Kotest.frameworkEngine)
+                implementation(Libs.Kotest.frameworkDataset)
+            }
+        }
+        val jvmTest by getting {
+            dependencies {
+                implementation(Libs.Kotest.jvmJunit5Runner)
+            }
+        }
         val iosX64Main by getting
         val iosArm64Main by getting
         val iosSimulatorArm64Main by getting

core/src/commonMain/kotlin/operations/array/unwrap/EvaluatingUnwrapStrategy.kt → operations-api/src/commonMain/kotlin/unwrap/EvaluatingUnwrapper.kt

@@ -1,19 +1,16 @@
-package operations.array.unwrap
+package unwrap
 
 import LogicEvaluator
+import utils.isExpression
 
-internal interface EvaluatingUnwrapStrategy {
+interface EvaluatingUnwrapper {
     fun unwrapDataByEvaluation(expression: List<Any?>, data: Any?, evaluator: LogicEvaluator) =
         (expression.firstOrNull().unwrapOperationData(data, evaluator) as? List<Any?>)
 
     @Suppress("UNCHECKED_CAST")
     private fun Any?.unwrapOperationData(data: Any?, evaluator: LogicEvaluator): Any? = when {
         this is List<*> -> map { it.unwrapOperationData(data, evaluator) }
-        isExpression(this) -> evaluator.evaluateLogic(this as Map<String, Any?>, data)
+        isExpression() -> evaluator.evaluateLogic(this as Map<String, Any?>, data)
         else -> this
     }
-
-    fun isExpression(value: Any?) = (value as? Map<*, *>)?.let {
-        it.isNotEmpty() && it.keys.all { key -> key is String }
-    } ?: false
 }

operations-api/src/commonTest/kotlin/unwrap/EvaluatingUnwrapperTest.kt

@@ -0,0 +1,50 @@
+package unwrap
+
+import LogicEvaluator
+import io.kotest.core.spec.style.BehaviorSpec
+import io.kotest.matchers.shouldBe
+
+class EvaluatingUnwrapperTest : BehaviorSpec({
+    val strategy: EvaluatingUnwrapper = object : EvaluatingUnwrapper {}
+    var logicEvaluator: LogicEvaluator = object : LogicEvaluator {
+        override fun evaluateLogic(expression: Map<String, Any?>, data: Any?): Any? {
+            return data
+        }
+    }
+
+    given("A simple values input") {
+        val wrappedValue = listOf(listOf(1, 2, 3))
+        `when`("unwrapped") {
+            val unwrapResult = strategy.unwrapDataByEvaluation(wrappedValue, null, logicEvaluator)
+            then("should be extracted") {
+                unwrapResult shouldBe listOf(1, 2, 3)
+            }
+        }
+    }
+
+    given("A nested values input") {
+        val wrappedValue = listOf(listOf(1, 2, 3, listOf(listOf("banana"))))
+        `when`("unwrapped") {
+            val unwrapResult = strategy.unwrapDataByEvaluation(wrappedValue, null, logicEvaluator)
+            then("should be extracted") {
+                unwrapResult shouldBe listOf(1, 2, 3, listOf(listOf("banana")))
+            }
+        }
+    }
+
+    given("An input with operation") {
+        val wrappedValue = listOf(listOf(1, 2, 3, mapOf("var" to "integers")))
+        val operationData = mapOf("integers" to listOf(4, 5))
+        logicEvaluator = object : LogicEvaluator {
+            override fun evaluateLogic(expression: Map<String, Any?>, data: Any?): Any? {
+                return listOf(4, 5)
+            }
+        }
+        `when`("unwrapped") {
+            val unwrapResult = strategy.unwrapDataByEvaluation(wrappedValue, operationData, logicEvaluator)
+            then("should be evaluated and extracted") {
+                unwrapResult shouldBe listOf(1, 2, 3, listOf(4, 5))
+            }
+        }
+    }
+})

operations-stdlib/build.gradle.kts

@@ -34,8 +34,21 @@ kotlin {
                 implementation(Libs.KotlinX.datetime)
             }
         }
-        val commonTest by getting
-        val jvmTest by getting
+        val commonTest by getting {
+            dependencies {
+                implementation(kotlin("test"))
+                implementation(Libs.Kotest.assertionsCore)
+                implementation(Libs.Kotest.frameworkEngine)
+                implementation(Libs.Kotest.frameworkDataset)
+                implementation(project(Modules.core))
+                implementation(project(Modules.utils))
+            }
+        }
+        val jvmTest by getting {
+            dependencies {
+                implementation(Libs.Kotest.jvmJunit5Runner)
+            }
+        }
         val iosX64Main by getting
         val iosArm64Main by getting
         val iosSimulatorArm64Main by getting

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

@@ -0,0 +1,16 @@
+import unwrap.EvaluatingUnwrapper
+import utils.asList
+import utils.getMappingOperationOrNull
+
+object Find : FunctionalLogicOperation, EvaluatingUnwrapper {
+    override fun invoke(expression: Any?, data: Any?, evaluator: LogicEvaluator): Any? {
+        return expression.asList.let { expressionValues ->
+            val inputData = unwrapDataByEvaluation(expressionValues, data, evaluator)
+            val predicateOperation = expressionValues.getMappingOperationOrNull()
+
+            predicateOperation?.let {
+                inputData?.find { evaluator.evaluateLogic(predicateOperation, it) == true }
+            }
+        }
+    }
+}