Support trait familly in type classes

Author: rodrigotn

build.sbt

@@ -5,7 +5,7 @@ lazy val supportedScalaVersions = List(scala212, scala213)
 lazy val commonSettings = Seq(
   name := "play-json-mapping",
   organization := "null-vector",
-  version := "1.0.4",
+  version := "1.1.0",
   scalaVersion := scala213,
   crossScalaVersions := supportedScalaVersions,
   scalacOptions := Seq(

core/src/test/scala/org/nullvector/JsonMapperSpec.scala renamed to core/src/test/scala/org/nullvector/api/json/JsonMapperSpec.scala

@@ -1,6 +1,10 @@
-package org.nullvector
+package org.nullvector.api.json
 
-import org.nullvector.domian._
+import java.time.LocalDateTime
+import java.util.Locale
+
+import org.joda.time.DateTime
+import org.nullvector.api.json.domian.{DaysOpen, Location, Monday, Money, OperationSchedule, Place, Product, ProductId, Resident, Sunday, SupportedTypes}
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers._
 import play.api.libs.json.{Format, Json, JsonConfiguration, Reads, Writes}
@@ -38,6 +42,16 @@ class JsonMapperSpec extends AnyFlatSpec {
     jsValue.as[OperationSchedule].availableDay shouldBe Monday
   }
 
+  it should "mapping of trait family inside type class" in {
+    import JsonMapper._
+    val example = DaysOpen(List(Monday, Sunday))
+    implicit val conf = JsonConfiguration(typeNaming = typeNaming)
+    implicit val x = mappingOf[DaysOpen]
+    val jsValue = example.asJson
+
+    jsValue.as[DaysOpen] shouldBe example
+  }
+
   it should "create a format mapping with enum" in {
     import JsonMapper._
     implicit val m: Format[Money] = mappingOf[Money]
@@ -67,27 +81,28 @@ class JsonMapperSpec extends AnyFlatSpec {
 
   it should "creat mapping with AnyVal" in {
     import JsonMapper._
-    implicit val m = mappingOf[Product]
+    implicit val m = mappingOf[domian.Product]
 
     val json = Product(new ProductId(23), "Train").asJson
     println(json)
   }
 
   it should "creat a read mapping with AnyVal" in {
     import JsonMapper._
-    implicit val m = readsOf[Product]
+    implicit val m = readsOf[domian.Product]
 
     Json
       .parse("""{"productId":23,"name":"Train"}""")
-      .as[Product] shouldBe Product(new ProductId(23), "Train")
+      .as[domian.Product] shouldBe Product(new ProductId(23), "Train")
   }
 
   it should "creat a write mapping with AnyVal" in {
     import JsonMapper._
-    implicit val m = writesOf[Product]
+    implicit val m = writesOf[domian.Product]
 
     Product(new ProductId(23), "Train")
       .asJson.toString() shouldBe """{"productId":23,"name":"Train"}"""
   }
+
 }
 

core/src/test/scala/org/nullvector/domian/Domin.scala renamed to core/src/test/scala/org/nullvector/api/json/domian/Domin.scala

@@ -1,4 +1,9 @@
-package org.nullvector.domian
+package org.nullvector.api.json.domian
+
+import java.time.LocalDateTime
+import java.util.Locale
+
+import org.joda.time.DateTime
 
 case class Location(lat: Double, long: Double)
 case class Resident(name: String, age: Int, role: Option[String])
@@ -18,6 +23,8 @@ case object Monday extends Day
 
 case object Sunday extends Day
 
+case class DaysOpen(days: List[Day])
+
 case class Money(amount: BigDecimal, currency: Money.Currency) {
 
   def +(aMoney: Money): Money = copy(amount + aMoney.amount)
@@ -36,3 +43,9 @@ object Money extends Enumeration {
 final class ProductId(val int: Int) extends AnyVal
 
 case class Product(productId: ProductId, name: String)
+
+case class SupportedTypes(
+                           localDateTime: LocalDateTime,
+                           dateTime: DateTime,
+                           locale: Locale
+                         )

macros/src/main/scala/org/nullvector/JsonMapper.scala renamed to macros/src/main/scala/org/nullvector/api/json/JsonMapper.scala

@@ -1,4 +1,4 @@
-package org.nullvector
+package org.nullvector.api.json
 
 import play.api.libs.json.JsonConfiguration.Aux
 import play.api.libs.json.JsonNaming.SnakeCase

macros/src/main/scala/org/nullvector/JsonMapperMacroFactory.scala renamed to macros/src/main/scala/org/nullvector/api/json/JsonMapperMacroFactory.scala

@@ -1,6 +1,6 @@
-package org.nullvector
+package org.nullvector.api.json
 
-import org.nullvector.tree.Tree
+import org.nullvector.api.json.tree.{Tree => NTree}
 import play.api.libs.json.{Format, JsonConfiguration, Reads, Writes}
 
 import scala.reflect.macros.blackbox
@@ -65,47 +65,48 @@ private object JsonMapperMacroFactory {
 
 
   private def extractTypes(context: blackbox.Context)
-                          (rootType: context.universe.Type): org.nullvector.tree.Tree[context.universe.Type] = {
+                          (rootType: context.universe.Type): NTree[context.universe.Type] = {
     import context.universe._
     val enumType = context.typeOf[Enumeration]
     val anyValType = context.typeOf[AnyVal]
 
-    def extractAll(caseType: context.universe.Type): org.nullvector.tree.Tree[context.universe.Type] = {
+    def extractAll(caseType: context.universe.Type): NTree[context.universe.Type] = {
       def isSupprtedTrait(aTypeClass: ClassSymbol) = aTypeClass.isTrait && aTypeClass.isSealed && !aTypeClass.fullName.startsWith("scala")
+      def isCaseOrTrait(aType: context.universe.Type) = aType.typeSymbol.asClass.isCaseClass || isSupprtedTrait(aType.typeSymbol.asClass)
 
       def extaracCaseClassesFromTypeArgs(classType: Type): List[Type] = {
         classType.typeArgs.collect {
-          case argType if argType.typeSymbol.asClass.isCaseClass => List(classType, argType)
+          case argType if isCaseOrTrait(argType) => List(classType, argType)
           case t => extaracCaseClassesFromTypeArgs(t)
         }.flatten
       }
 
       val caseTypeAsClass = caseType.typeSymbol.asClass
+
       if (caseTypeAsClass.isCaseClass) {
-        Tree(caseType,
+        tree.Tree(caseType,
           caseType.decls
             .collect { case method: MethodSymbol if method.isCaseAccessor =>
               val returnType = method.returnType
               returnType.toString // This is needed to materialize the type (WTF!!)
               returnType
             }
             .collect {
-              case aType if aType <:< anyValType => List(Tree(aType))
+              case aType if aType <:< anyValType => List(NTree(aType))
               case aType if aType.typeSymbol.owner.isType &&
                 aType.typeSymbol.owner.asType.toType =:= enumType =>
-                List(Tree(aType))
-              case aType if aType.typeSymbol.asClass.isCaseClass || isSupprtedTrait(aType.typeSymbol.asClass) => List(extractAll(aType))
+                List(NTree(aType))
+              case aType if isCaseOrTrait(aType) => List(extractAll(aType))
               case aType => extaracCaseClassesFromTypeArgs(aType).map(arg => extractAll(arg))
             }
             .flatten.toList
-
         )
       }
       else if (isSupprtedTrait(caseTypeAsClass)) {
         val subclasses = caseTypeAsClass.knownDirectSubclasses
-        Tree(caseType, subclasses.map(aType => extractAll(aType.asClass.toType)).toList)
+        tree.Tree(caseType, subclasses.map(aType => extractAll(aType.asClass.toType)).toList)
       }
-      else Tree.empty
+      else NTree.empty
     }
 
     extractAll(rootType)

macros/src/main/scala/org/nullvector/tree/Tree.scala renamed to macros/src/main/scala/org/nullvector/api/json/tree/Tree.scala

@@ -1,4 +1,4 @@
-package org.nullvector.tree
+package org.nullvector.api.json.tree
 
 sealed trait Tree[E] extends Iterable[E] {
 

macros/src/test/scala/org/nullvector/TreeSpec.scala renamed to macros/src/test/scala/org/nullvector/api/json/TreeSpec.scala

@@ -1,6 +1,6 @@
-package org.nullvector
+package org.nullvector.api.json
 
-import org.nullvector.tree.Tree
+import org.nullvector.api.json.tree.Tree
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers