enable writing with encoder

Author: celadari

README.md

@@ -212,6 +212,53 @@ to a `JsonLogicCore` instance.
 A decoder defines how to write a JSON string/[JsValue](https://www.playframework.com/documentation/latest/api/scala/play/api/libs/json/JsValue.html)
 from a `JsonLogicCore` instance.
 
+* **`Encoder` class must be instantiated** if you need to stringify a Scala object.
+    ```scala
+    implicit val encoder: Encoder = new Encoder // useless if only basic built-in types
+    val json = Json.stringify(Json.toJson(json).as[JsonLogicCore])
+    ```
+  *Json-logic-scala* comes with built-in `Encoder` for basic/built-in types.
+
+* **Custom scala object/classes**:
+    - You *don't need to change built-in naming convention*.
+        Just instantiate `Encoder` class and define its `customValueAndType` method.
+        ```scala
+        implicit val encoder = new Encoder{
+            override def customValueAndType(value: Any): (String, JsValue) =
+                  value match {
+                        case value: Car => ("car", Json.toJson(value))
+                        case value: Plane => ("plane", Json.toJson(value))
+                        case _ => throw new IllegalArgumentException("Wrong argument.")
+                  }
+        }
+        ```
+        To do so, you just need to indicate new `"type"` field value along with their Scala class/type.
+        You can also override `encode` method instead of `customValueAndType`.
+
+    - You *need to change built-in naming convention*.
+        Just instantiate `Encoder` class and override its `getJsValueAndType` method.
+        ```scala
+        implicit val encoder = new Encoder{
+            override def getJsValueAndType(value: Any): (String, JsValue) = {
+                value match {
+                      case value: String => ("my_custom_string", JsString(value))
+                      case value: MyCustomClass => ("my_custom_class", Json.toJson(value))
+                      ...
+                }
+        }
+        ```
+
+    - Take note that you must provide Play JSON library a `Writes` typeclass to define how to write your specific type.
+    For [more information on defining a `Writes` typeclass](https://github.com/playframework/play-json#reading-and-writing-objects).
+    Fortunately, you usually don't need to implement a `Writes` typleclass directly.
+    Play JSON comes equipped with some convenient macros to convert to and from case classes.
+    In the following, you just need to define in *companion object* of `case class Car`:
+        ```scala
+        object Car {
+            implicit val carWrites: Writes[Car] = Json.writes[Car]
+        }
+        ```
+
 ## 5. Evaluating logical expression: reduce
 Evaluating a logical expression and getting its result if the main interest for most cases.
 Generally, logic/rules are received from another language/application and we want to apply this logic

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

@@ -2,28 +2,27 @@ package com.github.celadari.jsonlogicscala.core
 
 import play.api.libs.json._
 
-
 object ComposeLogic {
 
   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)
+    val LTEQ: String = "<="
+    val LT: String = "<"
+    val GTEQ: String = ">="
+    val GT: String = ">"
+    val EQ: String = "=="
+    val DIFF: String = "!="
+    val IN: String = "in"
+    val NOT_IN: String = "not in"
+    val ALL: Array[String] = Array(LTEQ, LT, GTEQ, GT, EQ, DIFF)
   }
 
   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 OR: String = "or"
+    val AND: String = "and"
+    val XOR: String = "xor"
+    val MAX: String = "max"
+    val MIN: String = "min"
+    val ALL: Array[String] = Array(OR, AND, XOR, MAX, MIN)
   }
   val OPERATORS: Array[String] = BINARY_OPERATORS.ALL ++ MULTIPLE_OPERATORS.ALL
 
@@ -40,7 +39,6 @@ object ComposeLogic {
     ComposeLogic(operator, decodeArrayOfConditions((jsonLogic \ operator).get, jsonLogicData)(decoder))
   }
 
-
   private[core] def decodeArrayOfConditions(json: JsValue, jsonLogicData: JsObject)(implicit decoder: Decoder): Array[JsonLogicCore] = {
     val jsArray = json.asInstanceOf[JsArray]
     jsArray
@@ -51,6 +49,22 @@ object ComposeLogic {
       .toArray
   }
 
+  private[core] def encode(composeLogic: ComposeLogic)
+                          (implicit encoder: Encoder): (JsValue, JsObject) = {
+    // retrieve compose logic attributes
+    val operator = composeLogic.operator
+    val conditions = composeLogic.conditions
+
+    // create js map operator -> conditions
+    val (jsonLogic, jsonLogicData) = encodeArrayOfConditions(conditions)(encoder)
+    (JsObject(Map(operator -> jsonLogic)), jsonLogicData)
+  }
+
+  private[core] def encodeArrayOfConditions(conditions: Array[JsonLogicCore])(implicit encoder: Encoder): (JsValue, JsObject) = {
+    val (jsonLogics, jsonLogicData) = conditions.map(jsonLogic => JsonLogicCore.encode(jsonLogic)(encoder)).unzip
+    (JsArray(jsonLogics), jsonLogicData.reduce(_ ++ _))
+  }
+
 }
 
 case class ComposeLogic(override val operator: String, conditions: Array[JsonLogicCore]) extends JsonLogicCore(operator)

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

@@ -0,0 +1,42 @@
+package com.github.celadari.jsonlogicscala.core
+
+import play.api.libs.json._
+
+object Encoder {
+  implicit val defaultEncoder: Encoder = new Encoder {
+    override def customValueAndType(value: Any): (String, JsValue) =
+      throw new NotImplementedError("You must provide a decoding method for this object.")
+  }
+}
+
+abstract class Encoder {
+  def customValueAndType(value: Any): (String, JsValue)
+
+  def getJsValueAndType(value: Any): (String, JsValue) = {
+    value match {
+      case value: String => ("string", JsString(value))
+      case value: Byte => ("byte", JsNumber(value.toInt))
+      case value: Short => ("short", JsNumber(value.toInt))
+      case value: Int => ("int", JsNumber(value))
+      case value: Long => ("long", JsNumber(value))
+      case value: Float => ("float", JsNumber(value.toDouble))
+      case value: Double => ("double", JsNumber(value))
+      case value: Boolean => ("boolean", JsBoolean(value))
+      case arr: Array[_] => {
+        if (arr.isEmpty) ("array[]", JsArray.empty)
+        else {
+          val (typesArr, jsArrs) = arr.map(getJsValueAndType).unzip
+          (s"array[${typesArr.head}]", JsArray(jsArrs))
+        }
+      }
+      case otherType => customValueAndType(otherType)
+    }
+  }
+
+  def encode(valueLogic: ValueLogic[_]): (String, String, JsValue) = {
+    val codenameData = valueLogic.codename
+
+    val (typeData, jsValue) = getJsValueAndType(valueLogic.value)
+    (typeData, codenameData, jsValue)
+  }
+}

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

@@ -21,6 +21,14 @@ object JsonLogicCore {
     ComposeLogic.decode(jsonLogic, jsonLogicData)(decoder)
   }
 
+  private[core] def encode(jsonLogic: JsonLogicCore)(implicit encoder: Encoder): (JsValue, JsObject) = {
+    // if operator is data access
+    jsonLogic match {
+      case valueLogic: ValueLogic[_] => ValueLogic.encode(valueLogic)(encoder)
+      case composeLogic: ComposeLogic => ComposeLogic.encode(composeLogic)(encoder)
+    }
+  }
+
   implicit def jsonLogicCoreReads(implicit decoder: Decoder): Reads[JsonLogicCore] = new Reads[JsonLogicCore] {
 
     override def reads(json: JsValue): JsResult[JsonLogicCore] = {
@@ -33,6 +41,17 @@ object JsonLogicCore {
       JsSuccess(decode(jsonLogic, jsonLogicData)(decoder))
     }
   }
+
+  implicit def jsonLogicCoreWrites(implicit encoder: Encoder): Writes[JsonLogicCore] = new Writes[JsonLogicCore] {
+
+    override def writes(jsonLogicCore: JsonLogicCore): JsValue = {
+      // apply writing
+      val (jsonLogic, jsonLogicData) = encode(jsonLogicCore)(encoder)
+
+      // return final result
+      JsArray(Array(jsonLogic, jsonLogicData))
+    }
+  }
 }
 
 

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

@@ -1,6 +1,6 @@
 package com.github.celadari.jsonlogicscala.core
 
-
+import java.util.UUID.randomUUID
 import play.api.libs.json._
 
 object ValueLogic {
@@ -9,6 +9,20 @@ object ValueLogic {
     decoder.decode(jsonLogic, jsonLogicData)
   }
 
+  private[core] def encode(valueLogic: ValueLogic[_])(implicit encoder: Encoder): (JsValue, JsObject) = {
+    // retrieve valueLogic information
+    val (typeData, codenameData, jsonData) = encoder.encode(valueLogic)
+
+    // construct jsonLogic component and jsonLogicData component
+    val jsonLogic = JsObject(Map("var" -> JsString(codenameData), "type" -> JsString(typeData)))
+    val jsonLogicData = JsObject(Map(codenameData -> jsonData))
+    (jsonLogic, jsonLogicData)
+  }
+
 }
 
-case class ValueLogic[T](override val operator: String, value: T) extends JsonLogicCore(operator)
+case class ValueLogic[T](
+                          override val operator: String,
+                          value: T,
+                          codename: String = randomUUID.toString
+                        ) extends JsonLogicCore(operator)

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

@@ -25,7 +25,7 @@ class ContainsOperator {
 
   def contains(a: Any, b: Any): Any = {
     a match {
-      case a: Array[_] => a.contains(b)
+      case a: Array[Any] => a.contains(b)
       case a: List[_] => a.contains(b)
       case a: ArrayBuffer[_] => a.contains(b)
       case a: mutable.Seq[_] => a.contains(b)