Fix multiple nested subclasses with same names

Author: Yannick Gladow

src/main/scala/io/yannick_cw/sjq/jsonToCaseClass.scala

@@ -9,8 +9,6 @@ object jsonToCaseClass {
     val (_, allCCs) = buildCC(j, "CC", List.empty)
     val ccs =
       allCCs
-        // todo this is just a hack to get around duplicated nested objects
-        .distinctBy(_.name)
         .map(cc => cc.copy(content = cc.content.filter { case (key, value) => key.nonEmpty && value.nonEmpty }))
 
     ccs.map(cc => (cc.name, renderCC(cc)))
@@ -19,52 +17,60 @@ object jsonToCaseClass {
   private def renderCC(cc: CC): String =
     s"case class ${cc.name}(${cc.content.map { case (key, value) => s"$key: $value" }.mkString(", ")})"
 
-  private def buildCC(j: Json, nextLevelName: String, doneCCs: List[CC]): (Option[String], List[CC]) = {
+  private def buildCC(j: Json, nextLevelName: String, doneCCs: List[CC]): (String, List[CC]) = {
     j.fold(
-      Some("Option[Any]") -> doneCCs,
-      _ => Some("Boolean") -> doneCCs,
-      _ => Some("Double")  -> doneCCs,
-      _ => Some("String")  -> doneCCs,
-      array => {
-        val innerType = array.flatMap { ele =>
-          val (x, y) = buildCC(ele, nextLevelName, List.empty)
-          x.map(_ -> y)
-        }
-        innerType
-          .foldLeft[Option[(String, List[CC])]](None)((left, right) =>
-            left.map { case (valueName, ccs) => (valueName, right._2 ++ ccs) }.orElse(Some(right)))
-          .map {
-            case (valueName, Nil)        => valueName -> doneCCs
-            case (valueName, ele :: Nil) => valueName -> (ele :: doneCCs)
-            case (valueName, ele :: more) =>
-              val (nextLevelCCs, deeperCCs) = (ele :: more)
-                .partition(_.name == valueName)
+      // todo decode not at all if null
+      "Option[String]" -> doneCCs,
+      _ => "Boolean" -> doneCCs,
+      _ => "Double"  -> doneCCs,
+      _ => "String"  -> doneCCs,
+      array =>
+        array.toList match {
+          case all @ ele :: rest if all.forall(_.isObject) =>
+            val innerType =
+              rest.foldLeft(buildCC(ele, nextLevelName, doneCCs)) {
+                case ((newValueName, aggCCs), nextJson) =>
+                  newValueName -> buildCC(nextJson, nextLevelName, aggCCs)._2
+              }
+
+            val (valueName, ccs) = innerType match {
+              case (valueName, Nil)        => valueName -> doneCCs
+              case (valueName, ele :: Nil) => valueName -> (ele :: Nil)
+              case (valueName, ele :: more) =>
+                val (nextLevelCCs, otherCCs) = (ele :: more)
+                  .partition(_.name.startsWith(valueName))
 
-              val allContent = nextLevelCCs.map(_.content).fold(Map.empty)(_ ++ _)
-              val keyCountPerContent =
-                nextLevelCCs.map(cc => cc.content.map[String, Int] { case (key, _) => (key, 1) }).combineAll
+                val allContent = nextLevelCCs.map(_.content).fold(Map.empty)(_ ++ _)
+                val keyCountPerContent =
+                  nextLevelCCs.map(cc => cc.content.map[String, Int] { case (key, _) => (key, 1) }).combineAll
 
-              val keyCount = keyCountPerContent.size
+                val keyCount = nextLevelCCs.size
 
-              val newCC = ele.copy(content = keyCountPerContent.map({
-                case (key, count) if count == keyCount => key -> allContent(key)
-                case (key, _)                          => key -> s"Option[${allContent(key)}]"
-              }))
+                val newCC = ele.copy(content = keyCountPerContent.map({
+                  case (key, count) if count == keyCount => key -> allContent(key)
+                  case (key, _)                          => key -> s"Option[${allContent(key)}]"
+                }))
+                valueName -> (newCC :: otherCCs)
+            }
 
-              valueName -> (newCC :: deeperCCs ::: doneCCs)
-          }
-          .map { case (valueName, ccs) => Some(s"List[$valueName]") -> ccs }
-          .getOrElse(Some("List[String]") -> doneCCs)
+            s"List[$valueName]" -> ccs
+          case ele :: rest if rest.forall(_ == ele) =>
+            val (newValue, allCCs) = buildCC(ele, nextLevelName, doneCCs)
+            s"List[$newValue]" -> allCCs
+          case _ => "List[String]" -> doneCCs
       },
       jObj => {
-        val (allNewCCs, newCC) = jObj.toMap.foldLeft(List.empty[CC] -> CC(nextLevelName, Map.empty)) {
-          case ((allCss, currCC), (key, value)) =>
-            val (newValue, allNewCCs) = buildCC(value, key, List.empty)
-            (allCss ++ allNewCCs,
-             newValue.map(newV => currCC.copy(content = currCC.content.updated(key, newV))).getOrElse(currCC))
+        val (allNewCCs, newCC) = jObj.toMap.foldLeft(doneCCs -> CC(nextLevelName, Map.empty)) {
+          case ((allCCs, currCC), (key, value)) =>
+            val safeNextLevelName     = findFreeName(currCC :: allCCs, key)
+            val (newValue, allNewCCs) = buildCC(value, safeNextLevelName, allCCs)
+            (allNewCCs, currCC.copy(content = currCC.content.updated(key, newValue)))
         }
-        (Some(nextLevelName), newCC :: allNewCCs)
+        (nextLevelName, newCC :: allNewCCs)
       }
     )
   }
+
+  private def findFreeName(ccs: List[CC], name: String): String =
+    if (ccs.exists(_.name == name)) findFreeName(ccs, name + "1") else name
 }

src/test/scala/io/yannick_cw/sjq/jsonToCaseClassTest.scala

@@ -55,7 +55,7 @@ class jsonToCaseClassTest extends FlatSpec with Matchers {
                        | }
                      """.stripMargin).fold(throw _, x => x)
 
-    jsonToCaseClass(json) shouldBe List(("CC", "case class CC(name: Option[Any])"))
+    jsonToCaseClass(json) shouldBe List(("CC", "case class CC(name: Option[String])"))
   }
 
   it should "parse json empty lists" in {
@@ -118,9 +118,27 @@ class jsonToCaseClassTest extends FlatSpec with Matchers {
 
     jsonToCaseClass(json) shouldBe List(
       ("CC", "case class CC(sub: sub, another: another)"),
+      ("another", "case class another(double: double1)"),
+      ("double1", "case class double1(xx: String)"),
       ("sub", "case class sub(double: double)"),
       ("double", "case class double(xx: String)"),
-      ("another", "case class another(double: double)"),
+    )
+  }
+
+  it should "parse json with the same name but different structures" in {
+    val json = parse("""
+                       | {
+                       |   "sub": { "double": { "xx": 22 } },
+                       |   "another": { "double": { "xx": "sds" } }
+                       | }
+                     """.stripMargin).fold(throw _, x => x)
+
+    jsonToCaseClass(json) shouldBe List(
+      ("CC", "case class CC(sub: sub, another: another)"),
+      ("another", "case class another(double: double1)"),
+      ("double1", "case class double1(xx: String)"),
+      ("sub", "case class sub(double: double)"),
+      ("double", "case class double(xx: Double)"),
     )
   }
 }