Merge pull request kifi#4 from vital-software/fix/remove-robust-json-parsing

Remove robust json parsing

Author: pulasthibandara

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## [Unreleased]
 
+- Removed robust Json parsing implementation. Moving
+this to the client package to have more control.
+
 ## [0.5.0] - 2018-08-09
 
 ### Breaking changes

src/main/scala/com/github/vitalsoftware/macros/JsonFormatAnnotation.scala

@@ -48,53 +48,31 @@ class jsonMacro(useDefaults: Boolean) {
       }
     }
 
-    /**
-     * Generates implicit json.Formats that fallback to the defaults is the initial parsing fails.
-     */
     def jsonFormatter(className: TypeName, fields: List[ValDef]) = {
       fields.length match {
         case 0 => c.abort(c.enclosingPosition, "Cannot create json formatter for case class with no fields")
         case _ =>
-          val lowPriorityFormats = if (useDefaults) {
-            q"private val lowPriorityFormats = play.api.libs.json.Json.using[play.api.libs.json.Json.WithDefaultValues].format[$className]"
+          if (useDefaults) {
+            q"implicit val jsonAnnotationFormat = play.api.libs.json.Json.using[play.api.libs.json.Json.WithDefaultValues].format[$className]"
           } else {
-            q"private val lowPriorityFormats = play.api.libs.json.Json.format[$className]"
+            q"implicit val jsonAnnotationFormat = play.api.libs.json.Json.format[$className]"
           }
-
-          Seq(
-            lowPriorityFormats,
-            q"""
-                private val robustReads = new play.api.libs.json.Reads[$className] {
-                  override def reads(json: play.api.libs.json.JsValue) = lowPriorityFormats.reads(json) match {
-                    case s: play.api.libs.json.JsSuccess[_] => s
-                    case e: play.api.libs.json.JsError =>
-                      val transforms = e.errors.map(_._1)
-                        .filter(_.path.size == 1)
-                        .map(_.json.prune)
-                        .reduce(_ andThen _)
-
-                      json.transform(transforms).flatMap(lowPriorityFormats.reads _).orElse(e)
-                  }
-                }
-              """,
-            q"implicit val jsonAnnotationFormat = play.api.libs.json.Format(robustReads, lowPriorityFormats)"
-          )
       }
     }
 
-    def modifiedCompanion(compDeclOpt: Option[ModuleDef], format: Seq[Tree], className: TypeName) = {
+    def modifiedCompanion(compDeclOpt: Option[ModuleDef], format: ValDef, className: TypeName) = {
       compDeclOpt map { compDecl =>
         // Add the formatter to the existing companion object
         val q"object $obj extends ..$bases { ..$body }" = compDecl
         q"""
           object $obj extends ..$bases {
             ..$body
-            ..$format
+            $format
           }
         """
       } getOrElse {
         // Create a companion object with the formatter
-        q"object ${className.toTermName} { ..$format }"
+        q"object ${className.toTermName} { $format }"
       }
     }
 

src/test/scala/com/github/vitalsoftware/macros/JsonFormatAnnotationTest.scala

@@ -3,22 +3,20 @@ package com.github.vitalsoftware.macros
 import org.specs2.mutable.Specification
 import play.api.libs.json._
 
-@json case class Person(name: String, age: Int, gender: Option[String])
-@jsonDefaults case class Person2(name: String, age: Int = 7, gender: Option[String] = None)
-@jsonDefaults case class Test(f1: Int = 1, f2:  String = "2", f3: Boolean = true, f4: Option[Test])
+@json case class Person(name: String, age: Int)
+@jsonDefaults case class Person2(name: String, age: Int = 7)
 
 class JsonFormatAnnotationTest extends Specification {
 
   "@json annotation" should {
 
     "create correct formatter for case class with >= 2 fields" in {
 
-      val person = Person("Victor Hugo", 46, Some("Male"))
+      val person = Person("Victor Hugo", 46)
       val json = Json.toJson(person)
       json === Json.obj(
         "name" -> "Victor Hugo",
-        "age" -> 46,
-        "gender" -> "Male"
+        "age" -> 46
       )
       Json.fromJson[Person](json).asOpt must beSome(person)
     }
@@ -37,55 +35,4 @@ class JsonFormatAnnotationTest extends Specification {
       Json.fromJson[Person2](Json.obj("name" -> "Victor Hugo")).asOpt must beSome(person)
     }
   }
-
-  "robustParsing" should {
-    "make invalid option values None" in {
-      val json = Json.obj(
-        "name" -> "Victor Hugo",
-        "age" -> 46,
-        "gender" -> true
-      )
-
-      Json.fromJson[Person](json).asOpt must beSome(Person("Victor Hugo", 46, None))
-      Json.fromJson[Person2](json).asOpt must beSome(Person2("Victor Hugo", 46))
-    }
-
-    "make invalid values with defaults fallback to the default" in {
-      val json = Json.obj(
-        "name" -> "Victor Hugo",
-        "age" -> "non age"
-      )
-
-      Json.fromJson[Person2](json).asOpt must beSome(Person2("Victor Hugo", 7))
-    }
-
-    "throw on invalid values which are not optional or default" in {
-      val json = Json.obj(
-        "name" -> "Victor Hugo",
-        "age" -> "non age"
-      )
-
-      val result = Json.fromJson[Person](json)
-
-      result match {
-        case e: JsError =>
-          e.errors.head._1.path.head.asInstanceOf[KeyPathNode].key mustEqual("age")
-          e.errors.head._2.head.message must contain("error.expected.jsnumber")
-        case _ =>
-          result must beAnInstanceOf[JsError]
-      }
-    }
-
-    "multiple defaults must get replaced" in {
-      val json = Json.obj("f1" -> "str", "f2" -> false, "f3" -> 3, "f4" -> "not test")
-      val result = Json.fromJson[Test](json)
-      result match {
-        case JsSuccess(value, paths) =>
-          value mustEqual(Test(f4 = None))
-          paths.path.map(_.toString) must contain(allOf("/f1", "/f2", "/f3", "/f4"))
-            .setMessage("success result should contain paths of failed keys")
-        case _ => result must beAnInstanceOf[JsSuccess[Test]]
-      }
-    }
-  }
 }

version.sbt

@@ -1 +1 @@
-version in ThisBuild := "0.5.1-SNAPSHOT"
+version in ThisBuild := "0.6.0-SNAPSHOT"