Resolve #54 Shared config objects (#56)

Author: carueda

build.sbt

@@ -1,4 +1,4 @@
-lazy val tscfgVersion = setVersion("0.9.93")
+lazy val tscfgVersion = setVersion("0.9.94")
 
 organization := "com.github.carueda"
 name := "tscfg"

changelog.md

@@ -1,3 +1,12 @@
+2019-09-14 - 0.9.94
+
+- resolve #54 "Shared config objects"
+    - initial implementation
+    - only exercised with the explicit use of `@define` annotation
+    - scoping should be handled already
+    - no support for recursive type
+      (example spec would look like issue54c.spec.conf)
+
 2019-09-03 - 0.9.93
 
 - fix #55 "Regex not properly captured".

readme.md

@@ -26,6 +26,7 @@ The generated code only depends on the Typesafe Config library.
   - [list type](#list-type)
   - [object type](#object-type)
   - [optional object or list](#optional-object-or-list)
+  - [shared object](#shared-object)
 - [configuration template](#configuration-template)
 - [FAQ](#faq)
 - [tests](#tests)
@@ -431,6 +432,31 @@ As with basic types, the meaning of an optional object or list is that the corre
 value will be `null` (or `Optional.empty()`) (`None` in Scala) when the corresponding actual entry is missing in
 a given configuration instance.
 
+### shared object
+
+As of 0.9.94 there's initial, experimental support for shared objects (#54). 
+This is exercised by using the `@define` annotation:
+
+```properties
+#@define
+Struct {
+  c: string
+  d: int
+}
+
+example {
+  a: Struct
+  b: [ Struct ]
+}
+```
+
+In this example, the annotation will only generate the definition of the
+corresponding class `Struct` in the wrapper but not the member of that
+type itself. Then, the type can be referenced for other definitions.
+
+> Note: current support is in terms of the referenced object being always
+> *required*. `a: "Struct?"`, for example, is not supported.
+> Also, `@define` is only supported for an object, not for a basic type or list. 
 
 ## configuration template
 

src/main/resources/application.conf

@@ -1 +1 @@
-tscfg.version = 0.9.93
+tscfg.version = 0.9.94

src/main/scala/tscfg/ModelBuilder.scala

@@ -2,7 +2,7 @@ package tscfg
 
 import com.typesafe.config._
 import tscfg.generators.tsConfigUtil
-import tscfg.model.{DURATION, SIZE}
+import tscfg.model.{AnnType, DURATION, ObjectType, SIZE}
 import tscfg.model.durations.ms
 
 import scala.collection.JavaConverters._
@@ -35,37 +35,53 @@ class ModelBuilder(assumeAllRequired: Boolean = false) {
 
   def build(conf: Config): ModelBuildResult = {
     warns.clear()
-    ModelBuildResult(objectType = fromConfig(conf),
+    ModelBuildResult(objectType = fromConfig(Namespace.root, conf),
       warnings = warns.toList.sortBy(_.line))
   }
 
   private val warns = collection.mutable.ArrayBuffer[Warning]()
 
-  private def fromConfig(conf: Config): model.ObjectType = {
+  private def fromConfig(namespace: Namespace, conf: Config): model.ObjectType = {
+    // do two passes as lightbend config does not necessarily preserve member order:
+    val ot = fromConfig1(namespace, conf)
+    fromConfig2(namespace, ot)
+  }
+
+  private def fromConfig1(namespace: Namespace, conf: Config): model.ObjectType = {
     val memberStructs = getMemberStructs(conf)
     val members: immutable.Map[String, model.AnnType] = memberStructs.map { childStruct ⇒
       val name = childStruct.name
       val cv = conf.getValue(name)
 
       val (childType, optional, default) = {
         if (childStruct.isLeaf) {
-          val typ = fromConfigValue(cv)
           val valueString = util.escapeValue(cv.unwrapped().toString)
-          if (typ == model.STRING) {
-            toAnnBasicType(valueString) match {
-              case Some(annBasicType) ⇒
-                annBasicType
-              case None ⇒
-                (typ, true, Some(valueString))
-            }
+
+          getTypeFromConfigValue(namespace, cv, valueString) match {
+            case typ: model.STRING.type ⇒
+              namespace.resolveDefine(valueString) match {
+                case Some(ort) ⇒
+                  (ort, false, None)
+
+                case None ⇒
+                  toAnnBasicType(valueString) match {
+                    case Some(annBasicType) ⇒
+                      annBasicType
+
+                    case None ⇒
+                      (typ, true, Some(valueString))
+                  }
+              }
+
+            case typ: model.BasicType ⇒
+              (typ, true, Some(valueString))
+
+            case typ ⇒
+              (typ, false, None)
           }
-          else if (typ.isInstanceOf[model.BasicType])
-            (typ, true, Some(valueString))
-          else
-            (typ, false, None)
         }
         else {
-          (fromConfig(conf.getConfig(name)), false, None)
+          (fromConfig(namespace.extend(name), conf.getConfig(name)), false, None)
         }
       }
 
@@ -89,15 +105,51 @@ class ModelBuilder(assumeAllRequired: Boolean = false) {
       //  s"assumeAllRequired=$assumeAllRequired optFromComments=$optFromComments " +
       //  s"adjName=$adjName")
 
-      adjName -> model.AnnType(childType,
+      val annType = model.AnnType(childType,
         optional      = effOptional,
         default       = effDefault,
         comments      = commentsOpt
       )
+
+      if (annType.isDefine) {
+        namespace.addDefine(name, childType)
+      }
+
+      adjName -> annType
+
     }.toMap
     model.ObjectType(members)
   }
 
+  private def fromConfig2(namespace: Namespace, ot: model.ObjectType): model.ObjectType = {
+    val resolvedMembers = ot.members.map { case (name, annType) ⇒
+      val modAnnType = annType.t match {
+
+        case _:model.STRING.type ⇒
+          annType.default match {
+            case Some(strValue) ⇒
+              namespace.resolveDefine(strValue) match {
+                case Some(ort) ⇒ AnnType(ort)
+                case _ ⇒ annType
+              }
+
+            case None ⇒ annType
+          }
+
+        //// the following would be part of changes to allow recursive type
+        //case ot:ObjectType ⇒
+        //  val ot2 = fromConfig2(namespace, ot)
+        //  AnnType(ot2)
+
+        case _ ⇒ annType
+      }
+
+      name → modAnnType
+    }
+
+    model.ObjectType(resolvedMembers)
+  }
+
   private case class Struct(name: String, members: mutable.HashMap[String, Struct] = mutable.HashMap.empty) {
     def isLeaf: Boolean = members.isEmpty
     // $COVERAGE-OFF$
@@ -151,14 +203,14 @@ class ModelBuilder(assumeAllRequired: Boolean = false) {
     structs("").members.values.toList
   }
 
-  private def fromConfigValue(cv: ConfigValue): model.Type = {
+  private def getTypeFromConfigValue(namespace: Namespace, cv: ConfigValue, valueString: String): model.Type = {
     import ConfigValueType._
     cv.valueType() match {
       case STRING  => model.STRING
       case BOOLEAN => model.BOOLEAN
       case NUMBER  => numberType(cv.unwrapped().toString)
-      case LIST    => listType(cv.asInstanceOf[ConfigList])
-      case OBJECT  => objType(cv.asInstanceOf[ConfigObject])
+      case LIST    => listType(namespace, cv.asInstanceOf[ConfigList])
+      case OBJECT  => objType(namespace, cv.asInstanceOf[ConfigObject])
       case NULL    => throw new AssertionError("null unexpected")
     }
   }
@@ -200,7 +252,7 @@ class ModelBuilder(assumeAllRequired: Boolean = false) {
     }
   }
 
-  private def listType(cv: ConfigList): model.ListType = {
+  private def listType(namespace: Namespace, cv: ConfigList): model.ListType = {
     if (cv.isEmpty) throw new IllegalArgumentException("list with one element expected")
 
     if (cv.size() > 1) {
@@ -211,24 +263,31 @@ class ModelBuilder(assumeAllRequired: Boolean = false) {
     }
 
     val cv0: ConfigValue = cv.get(0)
-    val typ = fromConfigValue(cv0)
+    val valueString = util.escapeValue(cv0.unwrapped().toString)
+    val typ = getTypeFromConfigValue(namespace, cv0, valueString)
 
     val elemType = {
-      val valueString = util.escapeValue(cv0.unwrapped().toString)
       if (typ == model.STRING) {
-        // see possible type from the string literal:
-        toAnnBasicType(valueString) match {
-          case Some((basicType, isOpt, defaultValue)) ⇒
-            if (isOpt)
-              warns += OptListElemWarning(cv0.origin().lineNumber(), valueString)
-
-            if (defaultValue.isDefined)
-              warns += DefaultListElemWarning(cv0.origin().lineNumber(), defaultValue.get, valueString)
 
-            basicType
+        namespace.resolveDefine(valueString) match {
+          case Some(ort) ⇒
+            ort
 
           case None ⇒
-            typ
+            // see possible type from the string literal:
+            toAnnBasicType(valueString) match {
+              case Some((basicType, isOpt, defaultValue)) ⇒
+                if (isOpt)
+                  warns += OptListElemWarning(cv0.origin().lineNumber(), valueString)
+
+                if (defaultValue.isDefined)
+                  warns += DefaultListElemWarning(cv0.origin().lineNumber(), defaultValue.get, valueString)
+
+                basicType
+
+              case None ⇒
+                typ
+            }
         }
       }
       else typ
@@ -237,7 +296,8 @@ class ModelBuilder(assumeAllRequired: Boolean = false) {
     model.ListType(elemType)
   }
 
-  private def objType(cv: ConfigObject): model.ObjectType = fromConfig(cv.toConfig)
+  private def objType(namespace: Namespace, cv: ConfigObject): model.ObjectType =
+    fromConfig(namespace, cv.toConfig)
 
   private def numberType(valueString: String): model.BasicType = {
     try {
@@ -279,7 +339,7 @@ object ModelBuilder {
     val filename = args(0)
     val file = new File(filename)
     val source = io.Source.fromFile(file).mkString.trim
-    println("source:\n  |" + source.replaceAll("\n", "\n  |"))
+    //println("source:\n  |" + source.replaceAll("\n", "\n  |"))
     val result = ModelBuilder(source)
     println("objectType:")
     println(model.util.format(result.objectType))

src/main/scala/tscfg/Namespace.scala

@@ -0,0 +1,58 @@
+package tscfg
+
+import tscfg.model.{ObjectRefType, Type}
+
+object Namespace {
+  val root: Namespace = new Namespace("", None)
+
+  def getAllDefines: Map[String, Type] = {
+    allDefines.toMap
+  }
+
+  private def addToAllDefines(defineFullPath: String, t: Type): Unit = {
+    allDefines.update(defineFullPath, t)
+  }
+
+  private val allDefines = collection.mutable.HashMap[String, Type]()
+}
+
+class Namespace private(simpleName: String, parent: Option[Namespace]) {
+  import Namespace.addToAllDefines
+
+  def getPath: Seq[String] = parent match {
+    case None ⇒ Seq.empty
+    case Some(ns) ⇒ ns.getPath ++ Seq(simpleName)
+  }
+
+  def getPathString: String = getPath.mkString(".")
+
+  def extend(simpleName: String): Namespace = new Namespace(simpleName, Some(this))
+
+  private val defineNames = collection.mutable.HashSet[String]()
+
+  def addDefine(simpleName: String, t: Type): Unit = {
+    assert(!simpleName.contains("."))
+    assert(simpleName.nonEmpty)
+
+    if (defineNames.contains(simpleName)) {
+      println(s"WARN: duplicate @define '$simpleName' in namespace $getPathString. Ignoring previous entry")
+      // TODO include in build warnings
+    }
+
+    defineNames.add(simpleName)
+
+    addToAllDefines(resolvedFullPath(simpleName), t)
+  }
+
+  private def resolvedFullPath(simpleName: String): String = parent match {
+    case None ⇒ simpleName
+    case Some(_) ⇒ s"$getPathString.$simpleName"
+  }
+
+  def resolveDefine(name: String): Option[ObjectRefType] = {
+    if (defineNames.contains(name))
+      Some(ObjectRefType(this, name))
+    else
+      parent.flatMap(_.resolveDefine(name))
+  }
+}

src/main/scala/tscfg/gen4tests.scala

@@ -57,7 +57,7 @@ object gen4tests {
       // $COVERAGE-OFF$
       if (true||confFile.lastModified >= targetFile.lastModified) {
         val genOpts = baseGenOpts.copy(className = className)
-        println(s"generating for $name -> $fileName")
+        //println(s"generating for $name -> $fileName")
         val generator: Generator = lang match {
           case "Scala" ⇒ new ScalaGen(genOpts)
           case "Java" ⇒  new JavaGen(genOpts)

src/main/scala/tscfg/generators/Generator.scala

@@ -14,6 +14,10 @@ abstract class Generator(genOpts: GenOpts) {
   protected val className: String = genOpts.className
   protected val hasPath: String = if (genOpts.j7) "hasPath" else "hasPathOrNull"
   protected var genResults = GenResult()
+
+  protected def dbg(s: String, in: Boolean = true): String =
+    ""
+    //if (in) s" /*$s*/ " else s" // $s"
 }
 
 /**

src/main/scala/tscfg/generators/TemplateGenerator.scala

@@ -67,6 +67,9 @@ class TemplateGenerator(opts: TemplateOpts) {
     case o:ObjectType ⇒
       (genObjectType(o), abbrevObject)
 
+    case ort:ObjectRefType ⇒
+      (ort.toString, abbrevObjectRef)
+
     case b:BasicType  ⇒
       val lc = b.toString.toLowerCase
       (lc, lc)
@@ -80,6 +83,7 @@ class TemplateGenerator(opts: TemplateOpts) {
     abbrev != abbrevObject && !abbrev.startsWith(abbrevListOf)
 
   private val abbrevObject = "object"
+  private val abbrevObjectRef = "ref to object"
   private val abbrevListOf = "list of"
 
   private val envVarAnn  = "@envvar"