Implement reduce function for JsonLogicCore

Reduce function returns the logical result out of the JsonLogic
instance. Returned value is of type Any as not every result is of type
Boolean. Example: Columns objects in spark.sql col("some_column") == 5.

Author: Charles LADARI

build.sbt

@@ -66,7 +66,10 @@ osgiSettings
 
 OsgiKeys.bundleSymbolicName := "com.github.celadari.jsonlogicscala"
 
-OsgiKeys.exportPackage := Seq("com.github.celadari.jsonlogicscala")
+OsgiKeys.exportPackage := Seq("com.github.celadari.jsonlogicscala",
+                              "com.github.celadari.jsonlogicscala.core",
+                              "com.github.celadari.jsonlogicscala.operators"
+                              )
 
 OsgiKeys.privatePackage := Seq()
 

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

@@ -2,22 +2,30 @@ package com.github.celadari.jsonlogicscala.core
 
 import play.api.libs.json._
 
-object ComposeLogic {
-
-  val OPERATORS = Array("<=", "<", ">=", ">", "==", "!=", "or", "and", "xor")
 
-  private[core] def parse[T](jsonLogic: JsObject, jsonLogicData: JsObject)(implicit fmt: Reads[T]): ComposeLogic = {
-    // check for operator field
-    val fields = jsonLogic.fields
+object ComposeLogic {
 
-    // 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")
+  object BINARY_OPERATORS {
+    val LTEQ = "<="
+    val LT = "<"
+    val GTEQ = ">="
+    val GT = ">"
+    val EQ = "=="
+    val DIFF = "!="
+    val IN = "in"
+    val NOT_IN = "not in"
+    val ALL = Array(LTEQ, LT, GTEQ, GT, EQ, DIFF)
+  }
 
-    // if operator is compose logic
-    ComposeLogic(operator, readArrayOfConditions[T]((jsonLogic \ operator).get, jsonLogicData)(fmt))
+  object MULTIPLE_OPERATORS {
+    val OR = "or"
+    val AND = "and"
+    val XOR = "xor"
+    val MAX = "max"
+    val MIN = "min"
+    val ALL = Array(OR, AND, XOR, MAX, MIN)
   }
+  val OPERATORS: Array[String] = BINARY_OPERATORS.ALL ++ MULTIPLE_OPERATORS.ALL
 
   private[core] def decode(jsonLogic: JsObject, jsonLogicData: JsObject)(implicit decoder: Decoder): ComposeLogic = {
     // check for operator field
@@ -32,15 +40,6 @@ object ComposeLogic {
     ComposeLogic(operator, decodeArrayOfConditions((jsonLogic \ operator).get, jsonLogicData)(decoder))
   }
 
-  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
-  }
 
   private[core] def decodeArrayOfConditions(json: JsValue, jsonLogicData: JsObject)(implicit decoder: Decoder): Array[JsonLogicCore] = {
     val jsArray = json.asInstanceOf[JsArray]
@@ -52,19 +51,6 @@ object ComposeLogic {
       .toArray
   }
 
-
-  implicit def composeLogicReads[T](implicit fmt: Reads[T]): Reads[ComposeLogic] = new Reads[ComposeLogic] {
-
-    override def reads(json: JsValue): JsResult[ComposeLogic] = {
-      // 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(operator: String, conditions: Array[JsonLogicCore]) extends JsonLogicCore(operator)
+case class ComposeLogic(override val operator: String, conditions: Array[JsonLogicCore]) extends JsonLogicCore(operator)

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

@@ -1,25 +1,10 @@
 package com.github.celadari.jsonlogicscala.core
 
+import com.github.celadari.jsonlogicscala.operators.ReduceLogic
 import play.api.libs.json._
 
 object JsonLogicCore {
 
-  private[core] def parse[T](jsonLogic: JsObject, jsonLogicData: JsObject)(implicit fmt: Reads[T]): JsonLogicCore = {
-    // check for operator field
-    val fields = jsonLogic.fields
-
-    // if operator is data access
-    if (fields.map(_._1).contains("var")) return ValueLogic.parse[T](jsonLogic, jsonLogicData)(fmt)
-
-    // 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.parse[T](jsonLogic, jsonLogicData)(fmt)
-  }
-
   private[core] def decode(jsonLogic: JsObject, jsonLogicData: JsObject)(implicit decoder: Decoder): JsonLogicCore = {
     // check for operator field
     val fields = jsonLogic.fields
@@ -51,4 +36,9 @@ object JsonLogicCore {
 }
 
 
-abstract class JsonLogicCore(operator: String)
+abstract class JsonLogicCore(val operator: String) {
+
+  def reduce(implicit reducer: ReduceLogic): Any = {
+    reducer.reduce(this)
+  }
+}

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

@@ -1,23 +1,14 @@
 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])
-  }
-
   private[core] def decode(jsonLogic: JsObject, jsonLogicData: JsObject)(implicit decoder: Decoder): ValueLogic[_] = {
-    ValueLogic("var", decoder.decode(jsonLogic, jsonLogicData))
+    decoder.decode(jsonLogic, jsonLogicData)
   }
 
-  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]))
-    }
-  }
 }
 
-case class ValueLogic[T](operator: String, value: T) extends JsonLogicCore(operator)
+case class ValueLogic[T](override val operator: String, value: T) extends JsonLogicCore(operator)

src/main/scala/com/github/celadari/jsonlogicscala/operators/BooleanOperator.scala

@@ -0,0 +1,54 @@
+package com.github.celadari.jsonlogicscala.operators
+
+object BooleanOperator {
+  implicit val booleanOperator: BooleanOperator = new BooleanOperator
+}
+
+
+class BooleanOperator {
+
+  // custom operators to be override by user
+  def andCustom(a: Any, b: Any): Any = throw new IllegalArgumentException(s"Invalid argument: ${(a, b)}")
+  def andCustomBoolean(a: Boolean, b: Any): Any = throw new IllegalArgumentException(s"Invalid argument: ${(a, b)}")
+  def orCustom(a: Any, b: Any): Any = throw new IllegalArgumentException(s"Invalid argument: ${(a, b)}")
+  def orCustomBoolean(a: Boolean, b: Any): Any = throw new IllegalArgumentException(s"Invalid argument: ${(a, b)}")
+  def negateCustom(value: Any): Any = throw new IllegalArgumentException(s"Invalid argument: $value")
+
+  // operators for user
+  def negate(value: Any): Any = {
+    value match {
+      case value: Boolean => !value
+      case other => negateCustom(other)
+    }
+  }
+
+  def andBoolean(a: Boolean, b: Any): Any = {
+    b match {
+      case b: Boolean => a && b
+      case other => andCustomBoolean(a, other)
+    }
+  }
+
+  def orBoolean(a: Boolean, b: Any): Any = {
+    b match {
+      case b: Boolean => a || b
+      case other => orCustomBoolean(a, other)
+    }
+  }
+
+  def and(a: Any, b: Any): Any = {
+    a match {
+      case a: Boolean => andBoolean(a, b)
+      case other => andCustom(other, b)
+    }
+  }
+
+  def or(a: Any, b: Any): Any = {
+    a match {
+      case a: Boolean => orBoolean(a, b)
+      case other => orCustom(other, b)
+    }
+  }
+
+  def xor(a: Any, b: Any): Any = or(and(negate(a), b), and(a, negate(b)))
+}

src/main/scala/com/github/celadari/jsonlogicscala/operators/CompareOperator.scala

@@ -0,0 +1,105 @@
+package com.github.celadari.jsonlogicscala.operators
+
+
+object CompareOperator {
+  implicit val cmpOperator: CompareOperator = new CompareOperator
+}
+
+class CompareOperator {
+
+  // custom operators to be override by user
+  def negateCustom(value: Any): Any = throw new IllegalArgumentException(s"Invalid argument: $value")
+  def cmpCustomLong(a: Long, b: Any): Any = throw new IllegalArgumentException(s"Invalid argument: $b")
+  def cmpCustomDouble(a: Double, b: Any) = throw new IllegalArgumentException(s"Invalid argument: $b")
+  def cmpCustom(a: Any, b: Any): Any = throw new IllegalArgumentException(s"Invalid argument: ${(a, b)}")
+  def eqCustomLong(a: Long, b: Any): Any = throw new IllegalArgumentException(s"Invalid argument: $b")
+  def eqCustomDouble(a: Double, b: Any) = throw new IllegalArgumentException(s"Invalid argument: $b")
+  def eqCustom(a: Any, b: Any): Any = throw new IllegalArgumentException(s"Invalid argument: ${(a, b)}")
+
+  // operators for user
+  def lt(a: Any, b: Any): Any = cmp(a, b)
+  def lteq(a: Any, b: Any): Any = negate(gt(a, b))
+  def gteq(a: Any, b: Any): Any = negate(lt(a, b))
+  def gt(a: Any, b: Any): Any = lt(b, a)
+
+  def diff(a: Any, b: Any): Any = negate(eq(a, b))
+
+  def eq(a: Any, b: Any): Any = {
+    a match{
+      case a: Byte => eqLong(a.asInstanceOf[Long], b)
+      case a: Short => eqLong(a.asInstanceOf[Long], b)
+      case a: Int => eqLong(a.asInstanceOf[Long], b)
+      case a: Long => eqLong(a, b)
+      case a: Float => eqDouble(a.asInstanceOf[Double], b)
+      case a: Double => eqDouble(a, b)
+      case other => eqCustom(other, b)
+    }
+  }
+
+  def negate(value: Any): Any = {
+    value match {
+      case value: Boolean => !value
+      case other => negateCustom(other)
+    }
+  }
+
+  def eqLong(a: Long, b: Any): Any = {
+    b match {
+      case b: Byte => a == b
+      case b: Short => a == b
+      case b: Int => a == b
+      case b: Long => a == b
+      case b: Float => a == b
+      case b: Double => a == b
+      case other => eqCustomLong(a, other)
+    }
+  }
+
+  def eqDouble(a: Double, b: Any): Any = {
+    b match {
+      case b: Byte => a == b
+      case b: Short => a == b
+      case b: Int => a == b
+      case b: Long => a == b
+      case b: Float => a == b
+      case b: Double => a == b
+      case other => eqCustomDouble(a, other)
+    }
+  }
+
+  def cmpLong(a: Long, b: Any): Any = {
+    b match {
+      case b: Byte => a < b
+      case b: Short => a < b
+      case b: Int => a < b
+      case b: Long => a < b
+      case b: Float => a < b
+      case b: Double => a < b
+      case other => cmpCustomLong(a, other)
+    }
+  }
+
+  def cmpDouble(a: Double, b: Any): Any = {
+    b match {
+      case b: Byte => a < b
+      case b: Short => a < b
+      case b: Int => a < b
+      case b: Long => a < b
+      case b: Float => a < b
+      case b: Double => a < b
+      case other => cmpCustomDouble(a, other)
+    }
+  }
+
+  def cmp(a: Any, b: Any): Any = {
+    a match {
+      case a: Byte => cmpLong(a.asInstanceOf[Long], b)
+      case a: Short => cmpLong(a.asInstanceOf[Long], b)
+      case a: Int => cmpLong(a.asInstanceOf[Long], b)
+      case a: Long => cmpLong(a, b)
+      case a: Float => cmpDouble(a.asInstanceOf[Double], b)
+      case a: Double => cmpDouble(a, b)
+      case other => cmpCustom(other, b)
+    }
+  }
+}

src/main/scala/com/github/celadari/jsonlogicscala/operators/ContainsOperator.scala

@@ -0,0 +1,38 @@
+package com.github.celadari.jsonlogicscala.operators
+
+import scala.collection.mutable
+import scala.collection.mutable.{ArrayBuffer, ListBuffer}
+
+object ContainsOperator {
+  implicit val containsOperator: ContainsOperator = new ContainsOperator
+}
+
+class ContainsOperator {
+
+  // custom operators to be override by user
+  def containsCustom(a: Any, b: Any): Any = throw new IllegalArgumentException(s"Invalid argument: ${(a, b)}")
+  def negateCustom(value: Any): Any = throw new IllegalArgumentException(s"Invalid argument: $value")
+
+  // operators for user
+  def containsNot(a: Any, b: Any): Any = negate(contains(a, b))
+
+  def negate(value: Any): Any = {
+    value match {
+      case value: Boolean => !value
+      case other => negateCustom(other)
+    }
+  }
+
+  def contains(a: Any, b: Any): Any = {
+    a match {
+      case a: Array[_] => a.contains(b)
+      case a: List[_] => a.contains(b)
+      case a: ArrayBuffer[_] => a.contains(b)
+      case a: mutable.Seq[_] => a.contains(b)
+      case a: ListBuffer[_] => a.contains(b)
+      case a: mutable.Stack[_] => a.contains(b)
+      case a: mutable.Queue[_] => a.contains(b)
+      case other => containsCustom(other, b)
+    }
+  }
+}