Added support for class naming in DefType and introduced new RW methods with customizable class names

Author: darkfrog26

core/shared/src/main/scala/fabric/define/DefType.scala

@@ -34,6 +34,8 @@ sealed trait DefType {
 
   def describe(desc: String): DefType = DefType.Described(this, Some(desc))
 
+  def withClassName(cn: String): DefType = DefType.Classed(this, cn)
+
   def isOpt: Boolean = false
 
   def isNull: Boolean = false
@@ -82,6 +84,9 @@ object DefType {
 
   private def dt2V(dt: DefType): Json = dt match {
     case Described(inner, desc) => withDesc(dt2V(inner).asObj, desc)
+    case Classed(inner, cn) =>
+      val base = dt2V(inner).asObj
+      base.merge(fabric.Obj("className" -> str(cn))).asObj
     case Obj(map, cn, desc) => withDesc(
         obj(
           "type" -> str("object"),
@@ -111,6 +116,11 @@ object DefType {
 
   private def readDesc(o: fabric.Obj): Option[String] = o.get("description").map(_.asString)
 
+  private def withClass(dt: DefType, o: fabric.Obj): DefType = o.get("className").map(_.asString) match {
+    case Some(cn) => Classed(dt, cn)
+    case None => dt
+  }
+
   private def v2dt(v: Json): DefType = {
     val o = v.asObj
     val desc = readDesc(o)
@@ -130,20 +140,20 @@ object DefType {
         )
       case "array" => Arr(t = v2dt(o.value("value")), description = desc)
       case "optional" => Opt(v2dt(o.value("value")), description = desc)
-      case "string" => desc.fold[DefType](Str)(Str.describe)
+      case "string" => withClass(desc.fold[DefType](Str)(Str.describe), o)
       case "numeric" => o.value("precision").asString match {
-          case "integer" => desc.fold[DefType](Int)(Int.describe)
-          case "decimal" => desc.fold[DefType](Dec)(Dec.describe)
+          case "integer" => withClass(desc.fold[DefType](Int)(Int.describe), o)
+          case "decimal" => withClass(desc.fold[DefType](Dec)(Dec.describe), o)
         }
-      case "boolean" => desc.fold[DefType](Bool)(Bool.describe)
+      case "boolean" => withClass(desc.fold[DefType](Bool)(Bool.describe), o)
       case "enum" => Enum(o.value("values").asVector.toList, o.get("className").map(_.asString), description = desc)
       case "poly" => Poly(
           o.value("values").asMap.map { case (key, json) => key -> v2dt(json) },
           o.get("className").map(_.asString),
           description = desc
         )
-      case "json" => desc.fold[DefType](Json)(Json.describe)
-      case "null" => desc.fold[DefType](Null)(Null.describe)
+      case "json" => withClass(desc.fold[DefType](Json)(Json.describe), o)
+      case "null" => withClass(desc.fold[DefType](Null)(Null.describe), o)
     }
   }
 
@@ -174,6 +184,7 @@ object DefType {
   }
   case class Arr(t: DefType, override val description: Option[String] = None) extends DefType {
     override def className: Option[String] = None
+    def apply(className: String): DefType = Classed(this, className)
     override def describe(desc: String): Arr = copy(description = Some(desc))
 
     override def merge(that: DefType): DefType = that match {
@@ -210,11 +221,13 @@ object DefType {
   }
   case object Str extends DefType {
     override def className: Option[String] = None
+    def apply(className: String): DefType = Classed(Str, className)
 
     override protected def template(path: JsonPath, config: TemplateConfig): Json = str(config.string(path))
   }
   case object Int extends DefType {
     override def className: Option[String] = None
+    def apply(className: String): DefType = Classed(Int, className)
 
     override def merge(that: DefType): DefType = that match {
       case DefType.Dec => that
@@ -225,6 +238,7 @@ object DefType {
   }
   case object Dec extends DefType {
     override def className: Option[String] = None
+    def apply(className: String): DefType = Classed(Dec, className)
 
     override def merge(that: DefType): DefType = that match {
       case DefType.Int => this
@@ -235,11 +249,13 @@ object DefType {
   }
   case object Bool extends DefType {
     override def className: Option[String] = None
+    def apply(className: String): DefType = Classed(Bool, className)
 
     override protected def template(path: JsonPath, config: TemplateConfig): Json = bool(config.bool(path))
   }
   case object Json extends DefType {
     override def className: Option[String] = None
+    def apply(className: String): DefType = Classed(Json, className)
 
     override protected def template(path: JsonPath, config: TemplateConfig): Json = config.json(path)
   }
@@ -265,6 +281,17 @@ object DefType {
     override def merge(that: DefType): DefType = dt.merge(that)
     override protected def template(path: JsonPath, config: TemplateConfig): Json = dt.template(path, config)
   }
+  case class Classed(dt: DefType, cn: String) extends DefType {
+    override def className: Option[String] = Some(cn)
+    override def description: Option[String] = dt.description
+    override def isOpt: Boolean = dt.isOpt
+    override def isNull: Boolean = dt.isNull
+    override def opt: DefType = Classed(dt.opt, cn)
+    override def withClassName(cn: String): DefType = copy(cn = cn)
+    override def describe(desc: String): DefType = Classed(dt.describe(desc), cn)
+    override def merge(that: DefType): DefType = dt.merge(that)
+    override protected def template(path: JsonPath, config: TemplateConfig): Json = dt.template(path, config)
+  }
   case object Null extends DefType {
     override def className: Option[String] = None
 

core/shared/src/main/scala/fabric/define/FabricGenerator.scala

@@ -53,6 +53,9 @@ object FabricGenerator {
       }
       def typeFor(name: String, dt: DefType): String = dt match {
         case DefType.Described(inner, _) => typeFor(name, inner)
+        case DefType.Classed(inner, cn) =>
+          val simpleName = if (cn.contains('.')) cn.substring(cn.lastIndexOf('.') + 1) else cn
+          simpleName
         case DefType.Obj(map, _, _) =>
           val className = resolver(name)
           additional = generate(className, map) :: additional

core/shared/src/main/scala/fabric/rw/RW.scala

@@ -64,12 +64,52 @@ object RW extends CompileRW {
     override val definition: DefType = DefType.Enum(list.map(t => Str(asString(t))), Some(className))
   }
 
-  def string[T](asString: T => String, fromString: String => T): RW[T] = new RW[T] {
+  def string[T](asString: T => String, fromString: String => T, className: Option[String] = None): RW[T] = new RW[T] {
     override def write(value: Json): T = fromString(value.asString)
 
     override def read(t: T): Json = str(asString(t))
 
-    override def definition: DefType = DefType.Str
+    override def definition: DefType = className.fold[DefType](DefType.Str)(DefType.Str(_))
+  }
+
+  def int[T](asInt: T => Int, fromInt: Int => T, className: Option[String] = None): RW[T] = new RW[T] {
+    override def write(value: Json): T = fromInt(value.asInt)
+
+    override def read(t: T): Json = asInt(t).json
+
+    override def definition: DefType = className.fold[DefType](DefType.Int)(DefType.Int(_))
+  }
+
+  def long[T](asLong: T => Long, fromLong: Long => T, className: Option[String] = None): RW[T] = new RW[T] {
+    override def write(value: Json): T = fromLong(value.asLong)
+
+    override def read(t: T): Json = asLong(t).json
+
+    override def definition: DefType = className.fold[DefType](DefType.Int)(DefType.Int(_))
+  }
+
+  def double[T](asDouble: T => Double, fromDouble: Double => T, className: Option[String] = None): RW[T] = new RW[T] {
+    override def write(value: Json): T = fromDouble(value.asDouble)
+
+    override def read(t: T): Json = num(asDouble(t))
+
+    override def definition: DefType = className.fold[DefType](DefType.Dec)(DefType.Dec(_))
+  }
+
+  def dec[T](asDec: T => BigDecimal, fromDec: BigDecimal => T, className: Option[String] = None): RW[T] = new RW[T] {
+    override def write(value: Json): T = fromDec(value.asBigDecimal)
+
+    override def read(t: T): Json = num(asDec(t))
+
+    override def definition: DefType = className.fold[DefType](DefType.Dec)(DefType.Dec(_))
+  }
+
+  def bool[T](asBool: T => Boolean, fromBool: Boolean => T, className: Option[String] = None): RW[T] = new RW[T] {
+    override def write(value: Json): T = fromBool(value.asBool.value)
+
+    override def read(t: T): Json = fabric.Bool(asBool(t))
+
+    override def definition: DefType = className.fold[DefType](DefType.Bool)(DefType.Bool(_))
   }
 
   def wrapped[T](key: String, asJson: T => Json, fromJson: Json => T, definition: DefType = DefType.Json): RW[T] =