Json with jsonLogic and jsonLogicData

Implementation with two components jsonLogic and data for applying logic
rules.

Author: Charles LADARI

src/main/scala/com/github/celadari/jsonlogicscala/core/ComposeLogic.scala

@@ -6,32 +6,41 @@ object ComposeLogic {
 
   val OPERATORS = Array("<=", "<", ">=", ">", "==", "!=", "or", "and", "xor")
 
-  implicit def composeLogicReads[T](implicit fmt: Reads[T]): Reads[ComposeLogic[T]] = new Reads[ComposeLogic[T]] {
+  private[core] def parse[T](jsonLogic: JsObject, jsonLogicData: JsObject)(implicit fmt: Reads[T]): ComposeLogic[T] = {
+    // check for operator field
+    val fields = jsonLogic.fields
 
-    override def reads(json: JsValue): JsResult[ComposeLogic[T]] = {
-      // check for operator field
-      val fields = json.asInstanceOf[JsObject].fields
+    // check for compose logic operator field
+    if (fields.length > 1) throw new Error("JSON object is supposed to have only one operator field.")
+    val operator = fields.head._1
+    if (!OPERATORS.contains(operator)) throw new Error(s"Invalid parsed operator: $operator")
 
-      // check for compose logic operator field
-      if (fields.length > 1) throw new Error("JSON object is supposed to have only one operator field.")
-      val operator = fields.head._1
-      if (!ComposeLogic.OPERATORS.contains(operator)) throw new Error(s"Invalid parsed operator: $operator")
+    // if operator is compose logic
+    ComposeLogic[T](operator, readArrayOfConditions[T]((jsonLogic \ operator).get, jsonLogicData)(fmt))
+  }
 
-      // if operator is compose logic
-      JsSuccess(ComposeLogic[T](operator, readArrayOfConditions((json \ operator).get)))
-    }
+  private[core] def readArrayOfConditions[T](json: JsValue, jsonLogicData: JsObject)(implicit fmt: Reads[T]): Array[JsonLogicCore[_]] = {
+    val jsArray = json.asInstanceOf[JsArray]
+    jsArray
+      .value
+      .map(jsValue => {
+        JsonLogicCore.parse[T](jsValue.asInstanceOf[JsObject], jsonLogicData)(fmt)
+      })
+      .toArray
+  }
 
-    def readArrayOfConditions(json: JsValue): Array[JsonLogicCore[_]] = {
-      val jsArray = json.asInstanceOf[JsArray]
-      jsArray
-        .value
-        .map(jsValue => {
-          JsonLogicCore.jsonLogicCoreReads[T].reads(jsValue).get
-        })
-        .toArray
-    }
+  implicit def composeLogicReads[T](implicit fmt: Reads[T]): Reads[ComposeLogic[T]] = new Reads[ComposeLogic[T]] {
+
+    override def reads(json: JsValue): JsResult[ComposeLogic[T]] = {
+      // split json in two components jsonLogic and jsonLogicData
+      val jsonLogic = (json \ 0).getOrElse(JsObject.empty).asInstanceOf[JsObject]
+      val jsonLogicData = (json \ 1).getOrElse(JsObject.empty).asInstanceOf[JsObject]
 
+      // apply reading with distinguished components: logic and data
+      JsSuccess(parse[T](jsonLogic, jsonLogicData)(fmt))
+    }
   }
+
 }
 
 case class ComposeLogic[T](operator: String, conditions: Array[JsonLogicCore[_]]) extends JsonLogicCore[T](operator)

src/main/scala/com/github/celadari/jsonlogicscala/core/JsonLogicCore.scala

@@ -4,35 +4,32 @@ import play.api.libs.json._
 
 object JsonLogicCore {
 
-  implicit def jsonLogicCoreReads[T](implicit fmt: Reads[T]): Reads[JsonLogicCore[T]] = new Reads[JsonLogicCore[T]] {
+  private[core] def parse[T](jsonLogic: JsObject, jsonLogicData: JsObject)(implicit fmt: Reads[T]): JsonLogicCore[T] = {
+    // check for operator field
+    val fields = jsonLogic.fields
 
-    def readArrayOfConditions(json: JsValue): Array[JsonLogicCore[_]] = {
-      val jsArray = json.asInstanceOf[JsArray]
-      jsArray
-        .value
-        .map(jsValue => {
-          reads(jsValue).get
-        })
-        .toArray
-    }
+    // if operator is data access
+    if (fields.map(_._1).contains("var")) return ValueLogic.parse[T](jsonLogic, jsonLogicData)(fmt)
 
-    override def reads(json: JsValue): JsResult[JsonLogicCore[T]] = {
-        // JsValue is supposed to be JsArray
-        val jsObject = json.asInstanceOf[JsObject]
+    // check for compose logic operator field
+    if (fields.length > 1) throw new Error("JSON object is supposed to have only one operator field.")
+    val operator = fields.head._1
+    if (!ComposeLogic.OPERATORS.contains(operator)) throw new Error(s"Invalid parsed operator: $operator")
 
-        // check for operator field
-        val fields = jsObject.fields
+    // if operator is compose logic
+    ComposeLogic.parse[T](jsonLogic, jsonLogicData)(fmt)
+  }
 
-        // if operator is data access
-        if (fields.map(_._1).contains("var")) return JsSuccess(ValueLogic.valueLogicReads[T](fmt).reads(jsObject).get)
+  implicit def jsonLogicCoreReads[T](implicit fmt: Reads[T]): Reads[JsonLogicCore[T]] = new Reads[JsonLogicCore[T]] {
+
+    override def reads(json: JsValue): JsResult[JsonLogicCore[T]] = {
 
-        // check for compose logic operator field
-        if (fields.length > 1) throw new Error("JSON object is supposed to have only one operator field.")
-        val operator = fields.head._1
-        if (!ComposeLogic.OPERATORS.contains(operator)) throw new Error(s"Invalid parsed operator: $operator")
+      // split json in two components jsonLogic and jsonLogicData
+      val jsonLogic = (json \ 0).getOrElse(JsObject.empty).asInstanceOf[JsObject]
+      val jsonLogicData = (json \ 1).getOrElse(JsObject.empty).asInstanceOf[JsObject]
 
-        // if operator is compose logic
-        JsSuccess(ComposeLogic.composeLogicReads[T].reads(jsObject).get)
+      // apply reading with distinguished components: logic and data
+      JsSuccess(parse(jsonLogic, jsonLogicData))
     }
   }
 }

src/main/scala/com/github/celadari/jsonlogicscala/core/ValueLogic.scala

@@ -3,6 +3,12 @@ package com.github.celadari.jsonlogicscala.core
 import play.api.libs.json._
 
 object ValueLogic {
+
+  private[core] def parse[T](jsonLogic: JsObject, jsonLogicData: JsObject)(implicit fmt: Reads[T]): ValueLogic[T] = {
+    val pathData = (jsonLogic \ "var").as[String]
+    ValueLogic("var", (jsonLogicData \ pathData).as[T])
+  }
+
   implicit def valueLogicReads[T](implicit fmt: Reads[T]): Reads[ValueLogic[T]] = new Reads[ValueLogic[T]] {
     override def reads(json: JsValue): JsResult[ValueLogic[T]] = {
       JsSuccess(ValueLogic("var", (json \ "var").as[T]))