Change hlist format to serialise to flat array

build.sbt

@@ -17,6 +17,8 @@ def commonSettings: Seq[Setting[_]] = Seq(
   scalacOptions ++= Seq("-Ywarn-unused", "-Ywarn-unused-import"),
   scalacOptions --= // scalac 2.10 rejects some HK types under -Xfuture it seems..
     (CrossVersion partialVersion scalaVersion.value collect { case (2, 10) => List("-Xfuture", "-Ywarn-unused", "-Ywarn-unused-import") }).toList.flatten,
+  scalacOptions in console in Compile -= "-Ywarn-unused-import",
+  scalacOptions in console in Test    -= "-Ywarn-unused-import",
   previousArtifact := None, // Some(organization.value %% moduleName.value % "1.0.0"),
   publishArtifact in Compile := true,
   publishArtifact in Test := false

internal/util-cache/src/main/scala/sbt/internal/util/AdditionalFormats.scala

@@ -1,34 +0,0 @@
-package sbt.internal.util
-
-import sbt.internal.util.Types.:+:
-
-import sjsonnew.{ Builder, deserializationError, JsonFormat, Unbuilder }
-import sjsonnew.BasicJsonProtocol, BasicJsonProtocol.asSingleton
-
-trait HListFormat {
-  implicit def HConsFormat[H: JsonFormat, T <: HList: JsonFormat]: JsonFormat[H :+: T] =
-    new JsonFormat[H :+: T] {
-      override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): H :+: T =
-        jsOpt match {
-          case Some(js) =>
-            unbuilder.beginObject(js)
-            val h = unbuilder.readField[H]("h")
-            val t = unbuilder.readField[T]("t")
-            unbuilder.endObject()
-
-            HCons(h, t)
-
-          case None =>
-            deserializationError("Expect JValue but found None")
-        }
-
-      override def write[J](obj: H :+: T, builder: Builder[J]): Unit = {
-        builder.beginObject()
-        builder.addField("h", obj.head)
-        builder.addField("t", obj.tail)
-        builder.endObject()
-      }
-    }
-
-  implicit val HNilFormat: JsonFormat[HNil] = asSingleton(HNil)
-}

internal/util-cache/src/main/scala/sbt/internal/util/HListFormat.scala

@@ -0,0 +1,37 @@
+package sbt.internal.util
+
+import sjsonnew._
+import Types.:+:
+
+trait HListFormat {
+  implicit val lnilFormat1: JsonFormat[HNil] = forHNil(HNil)
+  implicit val lnilFormat2: JsonFormat[HNil.type] = forHNil(HNil)
+
+  private def forHNil[A <: HNil](hnil: A): JsonFormat[A] = new JsonFormat[A] {
+    def write[J](x: A, builder: Builder[J]): Unit = {
+      if (builder.state != BuilderState.InArray) builder.beginArray()
+      builder.endArray()
+    }
+
+    def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): A = {
+      if (unbuilder.state == UnbuilderState.InArray) unbuilder.endArray()
+      hnil
+    }
+  }
+
+  implicit def hconsFormat[H, T <: HList](implicit hf: JsonFormat[H], tf: JsonFormat[T]): JsonFormat[H :+: T] =
+    new JsonFormat[H :+: T] {
+      def write[J](hcons: H :+: T, builder: Builder[J]) = {
+        if (builder.state != BuilderState.InArray) builder.beginArray()
+        hf.write(hcons.head, builder)
+        tf.write(hcons.tail, builder)
+      }
+
+      def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]) = jsOpt match {
+        case None => HCons(hf.read(None, unbuilder), tf.read(None, unbuilder))
+        case Some(js) =>
+          if (unbuilder.state != UnbuilderState.InArray) unbuilder.beginArray(js)
+          HCons(hf.read(Some(unbuilder.nextElement), unbuilder), tf.read(Some(js), unbuilder))
+      }
+    }
+}

internal/util-cache/src/test/scala/HListFormatSpec.scala

@@ -0,0 +1,26 @@
+package sbt.internal.util
+
+import scala.json.ast.unsafe._
+import sjsonnew._, support.scalajson.unsafe._
+import CacheImplicits._
+
+class HListFormatSpec extends UnitSpec {
+  val quux = 23 :+: "quux" :+: true :+: HNil
+
+  it should "round trip quux" in assertRoundTrip(quux)
+  it should "round trip hnil" in assertRoundTrip(HNil)
+
+  it should "have a flat structure for quux" in assertJsonString(quux, """[23,"quux",true]""")
+  it should "have a flat structure for hnil" in assertJsonString(HNil, "[]")
+
+  def assertRoundTrip[A: JsonWriter: JsonReader](x: A) = {
+    val jsonString: String = toJsonString(x)
+    val jValue: JValue = Parser.parseUnsafe(jsonString)
+    val y: A = Converter.fromJson[A](jValue).get
+    assert(x === y)
+  }
+
+  def assertJsonString[A: JsonWriter](x: A, s: String) = assert(toJsonString(x) === s)
+
+  def toJsonString[A: JsonWriter](x: A): String = CompactPrinter(Converter.toJson(x).get)
+}

project/Dependencies.scala

@@ -36,7 +36,7 @@ object Dependencies {
 
   lazy val parserCombinator211 = "org.scala-lang.modules" %% "scala-parser-combinators" % "1.0.4"
 
-  lazy val sjsonnewVersion = "0.4.2"
+  lazy val sjsonnewVersion = "0.5.1"
   lazy val sjsonnew = "com.eed3si9n" %% "sjson-new-core" % sjsonnewVersion
   lazy val sjsonnewScalaJson = "com.eed3si9n" %% "sjson-new-scalajson" % sjsonnewVersion
 }