Added support for type aliases in the CaseClassCodec. (mongodb#39)

SCALA-305

Author: rozza

bson/src/main/scala/org/mongodb/scala/bson/codecs/macrocodecs/CaseClassCodec.scala

@@ -109,10 +109,11 @@ private[codecs] object CaseClassCodec {
      * Removes Option type as the Option value is wrapped automatically below.
      * Throws if the case class contains a Tuple
      *
-     * @param t the type to flatten the arguments for
+     * @param at the type to flatten the arguments for
      * @return a list of the type arguments for the type
      */
-    def flattenTypeArgs(t: Type): List[c.universe.Type] = {
+    def flattenTypeArgs(at: Type): List[c.universe.Type] = {
+      val t = at.dealias
       val typeArgs = if (isMap(t)) {
         if (t.typeArgs.head != stringType) c.abort(c.enclosingPosition, "Maps must contain string types for keys")
         t.typeArgs.tail

bson/src/test/scala/org/mongodb/scala/bson/codecs/MacrosSpec.scala

@@ -88,6 +88,13 @@ class MacrosSpec extends FlatSpec with Matchers {
   case class UnsupportedTuple(value: (String, String))
   case class UnsupportedMap(value: Map[Int, Int])
 
+  type SimpleTypeAlias = Map[String, String]
+  case class ContainsSimpleTypeAlias(a: String, b: SimpleTypeAlias = Map.empty)
+  type CaseClassTypeAlias = Person
+  case class ContainsCaseClassTypeAlias(a: String, b: CaseClassTypeAlias)
+  type ADTCaseClassTypeAlias = ContainsADT
+  case class ContainsADTCaseClassTypeAlias(a: String, b: ADTCaseClassTypeAlias)
+
   "Macros" should "be able to round trip simple case classes" in {
     roundTrip(Empty(), "{}", classOf[Empty])
     roundTrip(Person("Bob", "Jones"), """{firstName: "Bob", lastName: "Jones"}""", classOf[Person])
@@ -174,16 +181,8 @@ class MacrosSpec extends FlatSpec with Matchers {
   it should "support ADT sealed case classes" in {
     val leaf = Leaf(1)
     val branch = Branch(Branch(Leaf(1), Leaf(2), 3), Branch(Leaf(4), Leaf(5), 6), 3) // scalastyle:ignore
-
-    def createJson(tree: Tree): String = {
-      tree match {
-        case l: Leaf => s"""{_t: "Leaf", value: ${l.value}}"""
-        case b: Branch => s"""{_t: "Branch", b1: ${createJson(b.b1)}, b2: ${createJson(b.b2)}, value: ${b.value}}"""
-        case _ => "{}"
-      }
-    }
-    val leafJson = createJson(leaf)
-    val branchJson = createJson(branch)
+    val leafJson = createTreeJson(leaf)
+    val branchJson = createTreeJson(branch)
 
     roundTrip(leaf, leafJson, classOf[Tree])
     roundTrip(branch, branchJson, classOf[Tree])
@@ -207,6 +206,17 @@ class MacrosSpec extends FlatSpec with Matchers {
     roundTrip(nodeB, nodeBJson, classOf[Graph])
   }
 
+  it should "support type aliases in case classes" in {
+    roundTrip(ContainsSimpleTypeAlias("c", Map("d" -> "c")), """{a: "c", b: {d: "c"}}""", classOf[ContainsSimpleTypeAlias])
+    roundTrip(ContainsCaseClassTypeAlias("c", Person("Tom", "Jones")), """{a: "c", b: {firstName: "Tom", lastName: "Jones"}}""",
+      classOf[ContainsCaseClassTypeAlias],  classOf[CaseClassTypeAlias])
+
+    val branch = Branch(Branch(Leaf(1), Leaf(2), 3), Branch(Leaf(4), Leaf(5), 6), 3) // scalastyle:ignore
+    val branchJson = createTreeJson(branch)
+    roundTrip(ContainsADTCaseClassTypeAlias("c", ContainsADT("Tom", branch)), s"""{a: "c", b: {name: "Tom", tree: $branchJson}}""",
+      classOf[ContainsADTCaseClassTypeAlias], classOf[ADTCaseClassTypeAlias], classOf[Tree])
+  }
+
   it should "support throw a CodecConfigurationException missing _t field" in {
     val missing_t = """{name: "nodeA", value: null}"""
     val registry = CodecRegistries.fromRegistries(CodecRegistries.fromProviders(classOf[Graph]), DEFAULT_CODEC_REGISTRY)
@@ -278,4 +288,12 @@ class MacrosSpec extends FlatSpec with Matchers {
 
   val documentCodec: Codec[Document] = DEFAULT_CODEC_REGISTRY.get(classOf[Document])
 
+  def createTreeJson(tree: Tree): String = {
+    tree match {
+      case l: Leaf => s"""{_t: "Leaf", value: ${l.value}}"""
+      case b: Branch => s"""{_t: "Branch", b1: ${createTreeJson(b.b1)}, b2: ${createTreeJson(b.b2)}, value: ${b.value}}"""
+      case _ => "{}"
+    }
+  }
+
 }

docs/reference/content/changelog.md

@@ -12,6 +12,7 @@ Changes between released versions
 
 ### 2.1.0
 
+  * Added support for type aliases in the CaseClassCodec. [SCALA-305](https://jira.mongodb.org/browse/SCALA-305)
   * Added the ability to ignore `None` values when encoding `Option` fields. [SCALA-300](https://jira.mongodb.org/browse/SCALA-300)
   * Added the ability to handle missing values for `Option` fields. [SCALA-299](https://jira.mongodb.org/browse/SCALA-299)
   * Improved the CaseClassCodec handling of `null` values. [SCALA-301](https://jira.mongodb.org/browse/SCALA-301)