Merge pull request AVSystem#104 from AVSystem/commons-hocon

commons-hocon module with HoconInput for GenCodec

Author: ghik

build.sbt

@@ -177,6 +177,7 @@ lazy val `commons-jvm` = project.in(file(".jvm"))
     `commons-rest`,
     `commons-jetty`,
     `commons-mongo`,
+    `commons-hocon`,
     `commons-spring`,
     `commons-redis`,
     `commons-akka`,
@@ -370,16 +371,24 @@ lazy val `commons-redis` = project
     parallelExecution in Test := false,
   )
 
-lazy val `commons-spring` = project
+lazy val `commons-hocon` = project
   .dependsOn(`commons-core` % CompileAndTest)
   .settings(
     jvmCommonSettings,
     libraryDependencies ++= Seq(
-      "org.springframework" % "spring-context" % springVersion,
       "com.typesafe" % "config" % typesafeConfigVersion,
     ),
   )
 
+lazy val `commons-spring` = project
+  .dependsOn(`commons-hocon` % CompileAndTest)
+  .settings(
+    jvmCommonSettings,
+    libraryDependencies ++= Seq(
+      "org.springframework" % "spring-context" % springVersion,
+    ),
+  )
+
 lazy val `commons-akka` = project
   .dependsOn(`commons-core` % CompileAndTest)
   .settings(

commons-core/jvm/src/test/scala/com/avsystem/commons/serialization/JCodecTestBase.scala

@@ -1,6 +1,8 @@
 package com.avsystem.commons
 package serialization
 
-trait JCodecTestBase extends CodecTestBase {
+import CodecTestData._
+
+trait JCodecTestBase extends AbstractCodecTest {
   val jTreeMap = stringMap(new JTreeMap[String, Int])
 }

commons-core/jvm/src/test/scala/com/avsystem/commons/serialization/JGenCodecTest.scala

@@ -5,15 +5,15 @@ import java.lang.annotation.RetentionPolicy
 
 import scala.collection.immutable.ListMap
 
-class JGenCodecTest extends JCodecTestBase {
+class JGenCodecTest extends JCodecTestBase with SimpleIOCodecTest {
   test("java collection test (TreeMap)") {
-    testWriteRead[JSortedMap[String, Int]](jTreeMap, ListMap("1" -> 1, "2" -> 2, "3" -> 3))
-    testWriteRead[JNavigableMap[String, Int]](jTreeMap, ListMap("1" -> 1, "2" -> 2, "3" -> 3))
-    testWriteRead[JTreeMap[String, Int]](jTreeMap, ListMap("1" -> 1, "2" -> 2, "3" -> 3))
+    testWrite[JSortedMap[String, Int]](jTreeMap, ListMap("1" -> 1, "2" -> 2, "3" -> 3))
+    testWrite[JNavigableMap[String, Int]](jTreeMap, ListMap("1" -> 1, "2" -> 2, "3" -> 3))
+    testWrite[JTreeMap[String, Int]](jTreeMap, ListMap("1" -> 1, "2" -> 2, "3" -> 3))
   }
 
   test("java enum test") {
-    testWriteRead(RetentionPolicy.RUNTIME, "RUNTIME")
-    testWriteRead(RetentionPolicy.SOURCE, "SOURCE")
+    testWrite(RetentionPolicy.RUNTIME, "RUNTIME")
+    testWrite(RetentionPolicy.SOURCE, "SOURCE")
   }
 }

commons-core/src/main/scala/com/avsystem/commons/serialization/InputOutput.scala

@@ -306,18 +306,20 @@ trait ObjectInput extends Any with SequentialInput { self =>
     * present in the object, regardless of field order assumed by [[nextField]].
     * `Opt.Empty` is returned when field is absent or always when this `ObjectInput` does not support random field
     * access (in which case it must preserve field order instead).
-    * NOTE: calling [[peekField]] and using [[FieldInput]] returned by it MUST NOT change state of this `ObjectInput`.
+    * NOTE: calling [[peekField]] and using [[com.avsystem.commons.serialization.FieldInput FieldInput]] returned by
+    * it MUST NOT change state of this `ObjectInput`.
     * Therefore, it cannot in any way influence results returned by [[nextField]] and [[hasNext]].
-    * For example, if a [[FieldInput]] for particular field has already been
+    * For example, if a [[com.avsystem.commons.serialization.FieldInput FieldInput]] for particular field has already been
     * accessed using [[peekField]] but has not yet been returned by [[nextField]] then it MUST be returned at some
     * point in the future by [[nextField]].
     */
   def peekField(name: String): Opt[FieldInput] = Opt.Empty
 
   /**
-    * Tries to obtain [[FieldInput]] for field with specified name, either by using [[peekField]] (assuming format with
-    * random field access) or [[nextField]] (assuming format that preserves field order). A codec that uses this method
-    * must ensure that it reads fields in the same order as they were written using `writeField` on [[ObjectOutput]].
+    * Tries to obtain [[com.avsystem.commons.serialization.FieldInput FieldInput]] for field with specified name,
+    * either by using [[peekField]] (assuming format with random field access) or [[nextField]] (assuming format that
+    * preserves field order). A codec that uses this method must ensure that it reads fields in the same order as they
+    * were written using `writeField` on [[ObjectOutput]].
     */
   def getNextNamedField(name: String): FieldInput =
     peekField(name).getOrElse {

commons-core/src/test/scala-2.12/com/avsystem/commons/serialization/OverloadedApplyCodecTest.scala

@@ -1,15 +1,15 @@
 package com.avsystem.commons
 package serialization
 
-class OverloadedApplyCodecTest extends CodecTestBase {
+class OverloadedApplyCodecTest extends SimpleIOCodecTest {
   case class OverloadedApply(private val fields: Map[String, Int])
   object OverloadedApply extends HasGenCodec[OverloadedApply] {
     def apply(fields: Seq[Int]): OverloadedApply = OverloadedApply(fields.toMapBy(_.toString))
     def unapply(oa: OverloadedApply): Option[Seq[Int]] = Some(oa.fields.values.toSeq)
   }
 
   test("overloaded apply/unapply") {
-    testWriteRead(OverloadedApply(List(1, 2, 3)),
+    testWrite(OverloadedApply(List(1, 2, 3)),
       Map("fields" -> List(1, 2, 3))
     )
   }

commons-core/src/test/scala/com/avsystem/commons/serialization/AbstractCodecTest.scala

@@ -0,0 +1,32 @@
+package com.avsystem.commons
+package serialization
+
+import org.scalactic.source.Position
+import org.scalatest.FunSuite
+
+trait AbstractCodecTest extends FunSuite {
+  def assertSameTypeValue[T](v1: T, v2: T)(implicit pos: Position): Unit = {
+    assert(v1 == v2)
+    assert(v1 == null || v1.getClass == v2.getClass)
+  }
+
+  type Raw
+
+  def writeToOutput(write: Output => Unit): Raw
+  def createInput(raw: Raw): Input
+
+  def testWrite[T: GenCodec](value: T, expectedRepr: Raw)(implicit pos: Position): Unit = {
+    val repr = writeToOutput(GenCodec.write[T](_, value))
+    assert(repr == expectedRepr)
+  }
+
+  def testRead[T: GenCodec](repr: Raw, expected: T)(implicit pos: Position): Unit = {
+    assert(expected == GenCodec.read[T](createInput(repr)))
+  }
+
+  def testRoundtrip[T: GenCodec](value: T)(implicit pos: Position): Unit = {
+    val written: Raw = writeToOutput(GenCodec.write[T](_, value))
+    val readBack = GenCodec.read[T](createInput(written))
+    assertSameTypeValue(value, readBack)
+  }
+}