Play-json-jsoniter

README.md

@@ -2,6 +2,7 @@
 
 1. play-json-tools - Set of implicit Play-JSON `Format` helper classes. Example in [FlatFormatSpec](play-json-tools/src/test/scala/com/evolutiongaming/util/FlatFormatSpec.scala)
 1. play-json-generic - provides Format derivation for enum like adt's (sealed trait/case objects'). Examples in [EnumerationDerivalSpec](play-json-generic/src/test/scala/com/evolutiongaming/util/generic/EnumerationDerivalSpec.scala)
+1. play-json-jsoniter - provides the fastest way to convert an instance of `play.api.libs.json.JsValue` to byte array and read it back.
 
 ## Setup
 

build.sbt

@@ -16,7 +16,6 @@ val commonSettings = Seq(
   crossScalaVersions := Seq("2.13.1", "2.12.10"),
 )
 
-
 lazy val root = project
   .in(file("."))
   .disablePlugins(MimaPlugin)
@@ -28,6 +27,7 @@ lazy val root = project
   .aggregate(
     playJsonTools,
     playJsonGeneric,
+    playJsonJsoniter
   )
 
 
@@ -55,4 +55,24 @@ lazy val playJsonTools = project
       playJson,
       nel,
       scalaTest % Test,
-    ).map(excludeLog4j)))
+    ).map(excludeLog4j)))
+
+//++ 2.12.10 or ++ 2.13.1
+lazy val playJsonJsoniter = project
+  .in(file("play-json-jsoniter"))
+  .settings(commonSettings)
+  .settings(Seq(
+    moduleName := "play-json-jsoniter",
+    name       := "play-json-jsoniter",
+    libraryDependencies ++= {
+      CrossVersion.partialVersion(scalaVersion.value) match {
+        case Some((2, v)) if v >= 13 => {
+          println(s"scala version: 2.$v")
+          Seq(playJson, nel, jsoniter, scalaTest % Test, jsonGenerator % Test).map(excludeLog4j)
+        }
+        case Some((2, v)) => {
+          println(s"scala version: 2.$v")
+          Seq(playJson, nel, jsoniter, scalaTest % Test).map(excludeLog4j)
+        }
+      }
+    }))

play-json-jsoniter/src/main/scala/com/evolutiongaming/jsonitertool/PlayJsonJsoniter.scala

@@ -0,0 +1,115 @@
+package com.evolutiongaming.jsonitertool
+
+import com.github.plokhotnyuk.jsoniter_scala.core._
+import play.api.libs.json._
+
+object PlayJsonJsoniter {
+
+  implicit val jsValueCodec: JsonValueCodec[JsValue] =
+    new JsonValueCodec[JsValue] {
+
+      /**
+       * The implementation was borrowed from: https://github.com/plokhotnyuk/jsoniter-scala/blob/e80d51019b39efacff9e695de97dce0c23ae9135/jsoniter-scala-benchmark/src/main/scala/io/circe/CirceJsoniter.scala
+       * and adapted to meet PlayJson criteria.
+       */
+      override def decodeValue(in: JsonReader, default: JsValue): JsValue = {
+        var b = in.nextToken
+        if (b == 'n') in.readNullOrError(default, "expected `null` value")
+        else if (b == '"') {
+          in.rollbackToken()
+          JsString(in.readString(null))
+        } else if (b == 'f' || b == 't') {
+          in.rollbackToken()
+          if (in.readBoolean()) JsTrue else JsFalse
+        } else if (b == '-' || (b >= '0' && b <= '9')) {
+          JsNumber(
+            {
+              in.rollbackToken
+              in.setMark
+              try {
+                do {
+                  b = in.nextByte
+                } while ((b >= '0' && b <= '9') || b == '-')
+              } catch {
+                case _: JsonReaderException => /* ignore end of input error */
+              } finally in.rollbackToMark
+              //PlayJson specific thing, since it uses BigDecimal to represent all numbers.
+              in.readBigDecimal(null)
+            }
+          )
+        } else if (b == '[') {
+          JsArray(
+            if (in.isNextToken(']')) Vector.empty[JsValue]
+            else {
+              in.rollbackToken()
+              var i = 0
+              var arr = new Array[JsValue](4)
+              do {
+                if (i == arr.length) arr = java.util.Arrays.copyOf(arr, i << 1)
+                arr(i) = decodeValue(in, default)
+                i += 1
+              } while (in.isNextToken(','))
+
+              (if (in.isCurrentToken(']'))
+                if (i == arr.length) arr else java.util.Arrays.copyOf(arr, i)
+              else in.arrayEndOrCommaError()).toVector
+            })
+        } else if (b == '{') {
+          new JsObject(
+            if (in.isNextToken('}')) scala.collection.mutable.Map.empty[String, JsValue]
+            else {
+              val underlying = scala.collection.mutable.LinkedHashMap[String, JsValue]()
+              in.rollbackToken()
+
+              do {
+                underlying.put(in.readKeyAsString(), decodeValue(in, default))
+              } while (in.isNextToken(','))
+
+              if (!in.isCurrentToken('}'))
+                in.objectEndOrCommaError()
+
+              underlying
+            }
+          )
+        } else in.decodeError("expected JSON value")
+      }
+
+      override def encodeValue(jsValue: JsValue, out: JsonWriter): Unit =
+        jsValue match {
+          case JsBoolean(b) =>
+            out.writeVal(b)
+          case JsString(value) =>
+            out.writeVal(value)
+          case JsNumber(value) =>
+            out.writeVal(value)
+          case JsArray(items) =>
+            out.writeArrayStart()
+            items.foreach(encodeValue(_, out))
+            out.writeArrayEnd()
+          case JsObject(kvs) =>
+            out.writeObjectStart()
+            kvs.foreach {
+              case (k, v) =>
+                out.writeKey(k)
+                encodeValue(v, out)
+            }
+            out.writeObjectEnd()
+          case JsNull =>
+            out.writeNull()
+        }
+
+      override val nullValue: JsValue = JsNull
+    }
+
+  /**
+   * @see See [[com.github.plokhotnyuk.jsoniter_scala.core.writeToArray]]
+   */
+  def serialize(payload: JsValue): Array[Byte] =
+    writeToArray(payload)
+
+  /**
+   * @see See [[com.github.plokhotnyuk.jsoniter_scala.core.readFromArray]]
+   */
+  def deserialize(bytes: Array[Byte]): JsValue =
+    readFromArray[JsValue](bytes)
+}

play-json-jsoniter/src/test/scala-2.12/com/evolutiongaming/jsonitertool/JsoniterSpec.scala

@@ -0,0 +1,34 @@
+package com.evolutiongaming.jsonitertool
+
+import com.evolutiongaming.jsonitertool.TestData.DataLine
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatest.matchers.should.Matchers
+import play.api.libs.json.{JsSuccess, Json}
+import TestData._
+
+class JsoniterSpec extends AnyFunSuite with Matchers {
+
+  test("Write using PlayJson -> Read using Jsoniter: Compare bytes") {
+
+    val expected: DataLine = Json.fromJson[DataLine](Json.parse(TestData.jsonBody))
+      .fold(errs => throw new Exception(s"Parsing error: ${errs.mkString(",")}"), identity)
+
+    val jsValue = Json.toJson(expected)
+    val bts0 = PlayJsonJsoniter.serialize(jsValue)
+    val bts1 = Json.toBytes(jsValue)
+    java.util.Arrays.compare(bts0, bts1) shouldEqual 0
+
+  }
+
+  test("Write using PlayJson -> Read using Jsoniter: Compare objects") {
+
+    val expected: DataLine = Json.fromJson[DataLine](Json.parse(TestData.jsonBody))
+      .fold(errs => throw new Exception(s"Parsing error: ${errs.mkString(",")}"), identity)
+
+    val bts = Json.toBytes(Json.toJson(expected))
+    val jsValue = PlayJsonJsoniter.deserialize(bts)
+    val actual = Json.fromJson[DataLine](jsValue)
+
+    JsSuccess(expected) shouldEqual actual
+  }
+}

play-json-jsoniter/src/test/scala-2.12/com/evolutiongaming/jsonitertool/TestData.scala

@@ -0,0 +1,88 @@
+package com.evolutiongaming.jsonitertool
+
+import play.api.libs.json.Json
+
+object TestData {
+
+  case class Friend(id: Int, name: String)
+
+  case class DataLine(
+    id: String,
+    index: Int,
+    guid: String,
+    isActive: Boolean,
+    balance: String,
+    picture: String,
+    age: Int,
+    eyeColor: String,
+    name: String,
+    gender: String,
+    company: String,
+    phone: String,
+    address: String,
+    about: String,
+    registered: String,
+    latitude: Double,
+    longitude: Double,
+    tags: List[String],
+    friends: List[Friend],
+    greeting: String,
+    favoriteFruit: String
+  )
+
+  val jsonBody =
+    """
+      |  {
+      |    "id": "576278df40bd978bc65ddb06",
+      |    "index": 0,
+      |    "guid": "e4c30481-84f3-4193-a83c-fe0435348774",
+      |    "isActive": true,
+      |    "balance": "$1,355.27",
+      |    "picture": "http://placehold.it/32x32",
+      |    "age": 26,
+      |    "eyeColor": "green",
+      |    "name": "Stewart Navarro",
+      |    "gender": "male",
+      |    "company": "NORSUP",
+      |    "phone": "+1 (916) 543-2895",
+      |    "address": "133 Stillwell Place, wrtywrt",
+      |    "about": "Eiusmod excepteur do esse minim nisi occaecat enim non dolor labore ipsum ut. Fugiat deserunt est pariatur pariatur. Laboris aute cillum tempor in exercitation laboris laboris fugiat velit enim ut ad. Ea labore commodo consectetur ut anim anim sint consectetur commodo.\r\n",
+      |    "registered": "2015-05-01T05:24:06 -10:00",
+      |    "latitude": -29.132033,
+      |    "longitude": -58.249295,
+      |    "tags": [
+      |      "sunt",
+      |      "Lorem",
+      |      "adipisicing",
+      |      "duis",
+      |      "nulla",
+      |      "sint",
+      |      "fugiat"
+      |    ],
+      |    "friends": [
+      |      {
+      |        "id": 0,
+      |        "name": "Yates Pruitt"
+      |      },
+      |      {
+      |        "id": 1,
+      |        "name": "Chen Henry"
+      |      },
+      |      {
+      |        "id": 2,
+      |        "name": "Miranda Vincent"
+      |      }
+      |    ],
+      |    "greeting": "Hello, Stewart Navarro! You have 7 unread messages",
+      |    "favoriteFruit": "strawberry"
+      |  }
+          """.stripMargin
+
+
+  implicit val a = Json.reads[Friend]
+  implicit val b = Json.writes[Friend]
+
+  implicit val c = Json.reads[DataLine]
+  implicit val d = Json.writes[DataLine]
+
+}

play-json-jsoniter/src/test/scala-2.13/com/evolutiongaming/jsonitertool/PlayJsonImplicits.scala

@@ -0,0 +1,14 @@
+package com.evolutiongaming.jsonitertool
+
+import play.api.libs.json.Json
+import com.evolutiongaming.jsonitertool.TestDataGenerators.{Address, User}
+
+trait PlayJsonImplicits {
+
+  implicit val e = Json.reads[Address]
+  implicit val f = Json.writes[Address]
+
+  implicit val g = Json.reads[User]
+  implicit val h = Json.writes[User]
+
+}

play-json-jsoniter/src/test/scala-2.13/com/evolutiongaming/jsonitertool/PlayJsonWithJsoniterBackendSpec.scala

@@ -0,0 +1,50 @@
+package com.evolutiongaming.jsonitertool
+
+import com.evolutiongaming.jsonitertool.TestDataGenerators.{User, genUser}
+import org.scalacheck.Prop.forAll
+import org.scalacheck.{Arbitrary, Gen, Test}
+import play.api.libs.json.Json
+
+//sbt playJsonJsoniter/test:"runMain com.evolutiongaming.jsonitertool.PlayJsonWithJsoniterBackendSpec"
+object PlayJsonWithJsoniterBackendSpec extends org.scalacheck.Properties("PlayJsonWithJsoniterBackend") {
+  val Size = 200
+
+  override def overrideParameters(p: Test.Parameters): Test.Parameters =
+    p.withMinSuccessfulTests(Size)
+
+  implicit def generator: Arbitrary[User] = Arbitrary(genUser)
+
+  property("Write using PlayJson -> Read using Jsoniter") = forAll { user: User =>
+    val jsValue = Json.toJson(user)
+    val bts = Json.toBytes(jsValue)
+    //println(s"${line.name}: ${bts.size / 1024} kb")
+    val actJsValue = PlayJsonJsoniter.deserialize(bts)
+    user == Json.fromJson[User](actJsValue).get
+  }
+
+  property("Write using PlayJson -> Read using Jsoniter. Batch") = forAll(
+    Gen.containerOfN[Vector, User](Size, genUser),
+  ) { batch: Vector[User] =>
+    val bools = batch.map { user =>
+      val jsValue = Json.toJson(user)
+      val bts = Json.toBytes(jsValue)
+      val actJsValue = PlayJsonJsoniter.deserialize(bts)
+      user == Json.fromJson[User](actJsValue).get
+    }
+
+    bools.find(_ == false).isEmpty
+  }
+
+  property("Write using Jsoniter -> Read using Jsoniter. Batch") = forAll(
+    Gen.containerOfN[Vector, User](Size, genUser),
+  ) { batch: Vector[User] =>
+    val bools = batch.map { user =>
+      val jsValue = Json.toJson(user)
+      val bts = PlayJsonJsoniter.serialize(jsValue)
+      val actJsValue = PlayJsonJsoniter.deserialize(bts)
+      user == Json.fromJson[User](actJsValue).get
+    }
+
+    bools.find(_ == false).isEmpty
+  }
+}

play-json-jsoniter/src/test/scala-2.13/com/evolutiongaming/jsonitertool/RandomJsonArraysSpec.scala

@@ -0,0 +1,28 @@
+package com.evolutiongaming.jsonitertool
+
+import org.scalacheck.Prop.forAll
+import org.scalacheck.{Arbitrary, Gen, Test}
+import play.api.libs.json.Json
+import valuegen.RandomJsArrayGen
+
+//sbt playJsonJsoniter/test:"runMain com.evolutiongaming.jsonitertool.RandomJsonArraysSpec"
+object RandomJsonArraysSpec extends org.scalacheck.Properties("RandomJsonSpec") {
+
+  val Size = 5000
+
+  //produces any imaginable Json array
+  def randomArrayGen: Gen[value.JsArray] = RandomJsArrayGen()
+
+  implicit def generator: Arbitrary[value.JsArray] = Arbitrary(randomArrayGen)
+
+  override def overrideParameters(p: Test.Parameters): Test.Parameters =
+    p.withMinSuccessfulTests(Size)
+
+  property("Random json arrays") = forAll { array: value.JsArray =>
+    val json = array.toString
+    val jsValue = Json.parse(json)
+    val bts = PlayJsonJsoniter.serialize(jsValue)
+    val actJsValue = PlayJsonJsoniter.deserialize(bts)
+    jsValue == actJsValue
+  }
+}