Implement decoder with default decoder

Parse values in jsonLogicData using type field with decoder.
Default decoder defined but user can define its own decoder.

Author: Charles LADARI

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

@@ -6,7 +6,7 @@ object ComposeLogic {
 
   val OPERATORS = Array("<=", "<", ">=", ">", "==", "!=", "or", "and", "xor")
 
-  private[core] def parse[T](jsonLogic: JsObject, jsonLogicData: JsObject)(implicit fmt: Reads[T]): ComposeLogic[T] = {
+  private[core] def parse[T](jsonLogic: JsObject, jsonLogicData: JsObject)(implicit fmt: Reads[T]): ComposeLogic = {
     // check for operator field
     val fields = jsonLogic.fields
 
@@ -16,10 +16,23 @@ object ComposeLogic {
     if (!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))
+    ComposeLogic(operator, readArrayOfConditions[T]((jsonLogic \ operator).get, jsonLogicData)(fmt))
   }
 
-  private[core] def readArrayOfConditions[T](json: JsValue, jsonLogicData: JsObject)(implicit fmt: Reads[T]): Array[JsonLogicCore[_]] = {
+  private[core] def decode(jsonLogic: JsObject, jsonLogicData: JsObject)(implicit decoder: Decoder): ComposeLogic = {
+    // check for operator field
+    val fields = jsonLogic.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")
+
+    // if operator is compose logic
+    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
@@ -29,9 +42,20 @@ object ComposeLogic {
       .toArray
   }
 
-  implicit def composeLogicReads[T](implicit fmt: Reads[T]): Reads[ComposeLogic[T]] = new Reads[ComposeLogic[T]] {
+  private[core] def decodeArrayOfConditions(json: JsValue, jsonLogicData: JsObject)(implicit decoder: Decoder): Array[JsonLogicCore] = {
+    val jsArray = json.asInstanceOf[JsArray]
+    jsArray
+      .value
+      .map(jsValue => {
+        JsonLogicCore.decode(jsValue.asInstanceOf[JsObject], jsonLogicData)(decoder)
+      })
+      .toArray
+  }
+
+
+  implicit def composeLogicReads[T](implicit fmt: Reads[T]): Reads[ComposeLogic] = new Reads[ComposeLogic] {
 
-    override def reads(json: JsValue): JsResult[ComposeLogic[T]] = {
+    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]
@@ -43,4 +67,4 @@ object ComposeLogic {
 
 }
 
-case class ComposeLogic[T](operator: String, conditions: Array[JsonLogicCore[_]]) extends JsonLogicCore[T](operator)
+case class ComposeLogic(operator: String, conditions: Array[JsonLogicCore]) extends JsonLogicCore(operator)

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

@@ -0,0 +1,29 @@
+package com.github.celadari.jsonlogicscala.core
+
+import play.api.libs.json.{JsValue, Reads}
+
+object Decoder {
+  implicit val defaultDecoder: Decoder = new Decoder {
+    override def customDecode(json: JsValue, otherType: String)(implicit reads: Array[Reads[_]] = Array()): Any =
+      throw new NotImplementedError("You must provide a decoding method for this object.")
+  }
+}
+
+abstract class Decoder {
+  def customDecode(json: JsValue, otherType: String)(implicit reads: Array[Reads[_]]): Any
+
+  def decode(jsValue: JsValue, `type`: String)(implicit reads: Array[Reads[_]] = Array()): ValueLogic[_] = {
+    val value = `type` match {
+      case "byte" => jsValue.as[Byte]
+      case "short" => jsValue.as[Short]
+      case "int" => jsValue.as[Int]
+      case "long" => jsValue.as[Long]
+      case "string" => jsValue.as[String]
+      case "float" => jsValue.as[Float]
+      case "double" => jsValue.as[Double]
+      case "boolean" => jsValue.as[Boolean]
+      case otherType => customDecode(jsValue, otherType)(reads)
+    }
+    ValueLogic("var", value)
+  }
+}

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

@@ -4,7 +4,7 @@ import play.api.libs.json._
 
 object JsonLogicCore {
 
-  private[core] def parse[T](jsonLogic: JsObject, jsonLogicData: JsObject)(implicit fmt: Reads[T]): JsonLogicCore[T] = {
+  private[core] def parse[T](jsonLogic: JsObject, jsonLogicData: JsObject)(implicit fmt: Reads[T]): JsonLogicCore = {
     // check for operator field
     val fields = jsonLogic.fields
 
@@ -20,19 +20,35 @@ object JsonLogicCore {
     ComposeLogic.parse[T](jsonLogic, jsonLogicData)(fmt)
   }
 
-  implicit def jsonLogicCoreReads[T](implicit fmt: Reads[T]): Reads[JsonLogicCore[T]] = new Reads[JsonLogicCore[T]] {
+  private[core] def decode(jsonLogic: JsObject, jsonLogicData: JsObject)(implicit decoder: Decoder): JsonLogicCore = {
+    // check for operator field
+    val fields = jsonLogic.fields
+
+    // if operator is data access
+    if (fields.map(_._1).contains("var")) return ValueLogic.decode(jsonLogic, jsonLogicData)(decoder)
+
+    // 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.decode(jsonLogic, jsonLogicData)(decoder)
+  }
+
+  implicit def jsonLogicCoreReads(implicit decoder: Decoder): Reads[JsonLogicCore] = new Reads[JsonLogicCore] {
 
-    override def reads(json: JsValue): JsResult[JsonLogicCore[T]] = {
+    override def reads(json: JsValue): JsResult[JsonLogicCore] = {
 
       // 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(jsonLogic, jsonLogicData))
+      JsSuccess(decode(jsonLogic, jsonLogicData)(decoder))
     }
   }
 }
 
 
-abstract class JsonLogicCore[T](operator: String)
+abstract class JsonLogicCore(operator: String)

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

@@ -9,11 +9,18 @@ object ValueLogic {
     ValueLogic("var", (jsonLogicData \ pathData).as[T])
   }
 
+  private[core] def decode(jsonLogic: JsObject, jsonLogicData: JsObject)(implicit decoder: Decoder): ValueLogic[_] = {
+    val typeData = (jsonLogic \ "type").as[String]
+    val pathData = (jsonLogic \ "var").as[String]
+    val json = (jsonLogicData \ pathData).get
+    ValueLogic("var", decoder.decode(json, typeData))
+  }
+
   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[T](operator)
+case class ValueLogic[T](operator: String, value: T) extends JsonLogicCore(operator)

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

@@ -0,0 +1,37 @@
+package com.github.celadari.jsonlogicscala.operators
+
+
+object HasCompareMethod {
+
+  abstract class HasCompareMethod[A](a: A) {
+    def <[B](b: B): Boolean
+    def >[B](b: B): Boolean = ! <=(b)
+    def <=[B](b: B): Boolean = <(b) || a == b
+    def >=[B](b: B): Boolean = >(b) || a == b
+  }
+
+  implicit class ByteComparator(a: Byte) extends HasCompareMethod[Byte](a){
+    def <[B](b: B): Boolean = a < b
+  }
+
+  implicit class ShortComparator(a: Short) extends HasCompareMethod[Short](a){
+    def <[B](b: B): Boolean = a < b
+  }
+
+  implicit class IntComparator(a: Int) extends HasCompareMethod[Int](a){
+    def <[B](b: B): Boolean = a < b
+  }
+
+  implicit class FloatComparator(a: Float) extends HasCompareMethod[Float](a){
+    def <[B](b: B): Boolean = a < b
+  }
+
+  implicit class DoubleComparator(a: Double) extends HasCompareMethod[Double](a){
+    def <[B](b: B): Boolean = a < b
+  }
+
+  implicit class LongComparator(a: Long) extends HasCompareMethod[Long](a){
+    def <[B](b: B): Boolean = a < b
+  }
+
+}

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

@@ -0,0 +1,52 @@
+package com.github.celadari.jsonlogicscala.operators
+
+import scala.collection.mutable.{ArrayBuffer, ListBuffer}
+import java.lang.CharSequence
+
+object HasContainsMethod {
+  abstract class HasContainsMethod[A](a: A) {
+    def contains[B](b: B): Boolean
+  }
+
+  implicit class ArrayHasContainsMethod(arr: Array[_]) extends HasContainsMethod[Array[_]](arr) {
+    def contains[B](b: B): Boolean = arr.contains(b)
+  }
+
+  implicit class ArrayBufferHasContainsMethod(arr: ArrayBuffer[_]) extends HasContainsMethod[ArrayBuffer[_]](arr) {
+    def contains[B](b: B): Boolean = arr.contains(b)
+  }
+
+  implicit class ListHasContainsMethod(arr: List[_]) extends HasContainsMethod[List[_]](arr) {
+    def contains[B](b: B): Boolean = arr.contains(b)
+  }
+
+  implicit class ListBufferHasContainsMethod(arr: ListBuffer[_]) extends HasContainsMethod[ListBuffer[_]](arr) {
+    def contains[B](b: B): Boolean = arr.contains(b)
+  }
+
+  implicit class StringBuilderHasContainsMethod(arr: StringBuilder) extends HasContainsMethod[StringBuilder](arr) {
+    def contains[B](b: B): Boolean = arr.contains(b)
+  }
+
+  implicit class VectorHasContainsMethod(arr: Vector[_]) extends HasContainsMethod[Vector[_]](arr) {
+    def contains[B](b: B): Boolean = arr.contains(b)
+  }
+
+  implicit class MutableStackHasContainsMethod(arr: scala.collection.mutable.Stack[_]) extends HasContainsMethod[scala.collection.mutable.Stack[_]](arr) {
+    def contains[B](b: B): Boolean = arr.contains(b)
+  }
+
+  implicit class ImmutableQueueHasContainsMethod(arr: scala.collection.immutable.Queue[_]) extends HasContainsMethod[scala.collection.immutable.Queue[_]](arr) {
+    def contains[B](b: B): Boolean = arr.contains(b)
+  }
+
+  implicit class MutableQueueHasContainsMethod(arr: scala.collection.mutable.Queue[_]) extends HasContainsMethod[scala.collection.mutable.Queue[_]](arr) {
+    def contains[B](b: B): Boolean = arr.contains(b)
+  }
+
+  implicit class RangeHasContainsMethod(arr: Range) extends HasContainsMethod[Range](arr) {
+    def contains[B](b: B): Boolean = arr.contains(b)
+  }
+
+
+}