Render nested classes below node fields

tomwyr · tomwyr · commit 950a08b858df · 2024-09-12T23:44:00.000+02:00
diff --git a/src/main/kotlin/com/tomwyr/generator/Renderer.kt b/src/main/kotlin/com/tomwyr/generator/Renderer.kt
@@ -10,8 +10,8 @@ class NodeTreeRenderer {
         val sceneNodes = scenes.map { renderScene(it) }.joinLines(spacing = 2)
         val types = renderTypes()
 
-        return listOfNotNull(header, nodeTree, sceneNodes, types)
-            .joinLines(spacing = 2).plus("\n")
+        return listOf(header, nodeTree, sceneNodes, types)
+            .joinLines(spacing = 2).trimBlankLines().plus("\n")
     }
 
     private fun renderHeader(packageName: String?): String {
@@ -39,35 +39,25 @@ class NodeTreeRenderer {
     private fun renderScene(scene: Scene): String {
         val nodePath = "\$path/${scene.root.name}"
 
-        val renderNodeHeader = { type: String ->
-            """
-            |class ${scene.name}Scene(private val path: String) : NodeRef<${type}>("$nodePath", "$type")
+        return when (val root = scene.root) {
+            is ParentNode -> renderParentNode(
+                node = root,
+                nodePath = nodePath,
+                className = "${scene.name}Scene",
+                nestedClass = false,
+            )
+
+            is LeafNode -> """
+            |class ${scene.name}Scene(private val path: String) : NodeRef<${root.type}>("$nodePath", "${root.type}")
             """.trimMargin()
-        }
 
-        return when (val root = scene.root) {
-            is ParentNode -> {
-                val header = renderNodeHeader(root.type)
-                val children = root.children.map { renderNode(it, nodePath) }.joinLines().indentLine()
-
-                """
-                |$header {
-                |    $children
-                |}
-                """.trimMargin()
-            }
-
-            is LeafNode -> renderNodeHeader(root.type)
-
-            is NestedScene -> {
-                """
-                |class ${scene.name}Scene(private val path: String) : ${root.scene}Scene(path)
-                """.trimMargin()
-            }
+            is NestedScene -> """
+            |class ${scene.name}Scene(private val path: String) : ${root.scene}Scene(path)
+            """.trimMargin()
         }
     }
 
-    private fun renderNode(node: Node, parentPath: String): String {
+    private fun renderNode(node: Node, parentPath: String): RenderNodeResult {
         val nodePath = "$parentPath/${node.name}"
         val symbolName = node.name
             .split("\\s+".toRegex())
@@ -76,37 +66,70 @@ class NodeTreeRenderer {
 
         Log.renderingNode(node, nodePath)
 
-        return when (node) {
-            is ParentNode -> {
-                val children = node.children.map { renderNode(it, nodePath) }.joinLines().indentLine()
-
-                """
-                |val $symbolName = ${symbolName}Tree()
-                |inner class ${symbolName}Tree : NodeRef<${node.type}>("$nodePath", "${node.type}") {
-                |    $children
-                |}
-                """.trimMargin()
-            }
-
-            is LeafNode -> {
-                """
-                |val $symbolName = NodeRef<${node.type}>("$nodePath", "${node.type}")
-                """.trimMargin()
-            }
-
-            is NestedScene -> {
-                """
-                |val $symbolName = ${node.scene}Scene("$nodePath")
-                """.trimMargin()
-            }
+        val field = when (node) {
+            is ParentNode -> """
+            |val $symbolName = ${symbolName}Tree()
+            """.trimMargin()
+
+            is LeafNode -> """
+            |val $symbolName = NodeRef<${node.type}>("$nodePath", "${node.type}")
+            """.trimMargin()
+
+            is NestedScene -> """
+            |val $symbolName = ${node.scene}Scene("$nodePath")
+            """.trimMargin()
+        }
+
+        val nestedClass = when (node) {
+            is ParentNode -> renderParentNode(
+                node = node,
+                nodePath = "$parentPath/${node.name}",
+                className = "${symbolName}Tree",
+                nestedClass = true,
+            )
+
+            else -> null
+        }
+
+        return RenderNodeResult(field, nestedClass)
+    }
+
+    private fun renderParentNode(
+        node: ParentNode,
+        nodePath: String,
+        className: String,
+        nestedClass: Boolean,
+    ): String {
+        val (classType, constructor) = when (nestedClass) {
+            true -> "inner class" to ""
+            false -> "class" to "(private val path: String)"
         }
+        val header = """
+        |$classType $className$constructor : NodeRef<${node.type}>("$nodePath", "${node.type}")
+        """.trimMargin()
+
+        val children = node.children.map { child -> renderNode(child, nodePath) }
+        val fields = children.map { it.field }.joinLines().indentLine()
+        val nestedClasses = children.mapNotNull { it.nestedClass }.joinLines(spacing = 2).indentLine()
+
+        val body = """
+        |    $fields
+        |
+        |    $nestedClasses
+        """.trimMargin().trimEnd()
+
+        return """
+        |$header {
+        |$body
+        |}
+        """.trimMargin()
     }
 
     private fun renderTypes(): String {
         return """
         |open class NodeRef<T : Node>(
-        |        private val path: String,
-        |        private val type: String,
+        |    private val path: String,
+        |    private val type: String,
         |) {
         |    operator fun getValue(thisRef: Node, property: KProperty<*>): T {
         |        val node = thisRef.getNode(NodePath(path)) ?: throw NodeNotFoundException(path)
@@ -126,3 +149,7 @@ class NodeTreeRenderer {
 private fun Iterable<String>.joinLines(spacing: Int = 1): String = joinToString("\n".repeat(spacing))
 
 private fun String.indentLine(times: Int = 1): String = lineSequence().joinToString("\n" + "    ".repeat(times))
+
+private fun String.trimBlankLines(): String = lineSequence().joinToString("\n") { it.ifBlank { "" } }
+
+private data class RenderNodeResult(val field: String, val nestedClass: String?)
diff --git a/src/test/resources/dodge-the-creeps/Expected b/src/test/resources/dodge-the-creeps/Expected
@@ -26,12 +26,13 @@ class MainScene(private val path: String) : NodeRef<Node>("$path/Main", "Node")
     val StartTimer = NodeRef<Timer>("$path/Main/StartTimer", "Timer")
     val StartPosition = NodeRef<Marker2D>("$path/Main/StartPosition", "Marker2D")
     val MobPath = MobPathTree()
-    inner class MobPathTree : NodeRef<Path2D>("$path/Main/MobPath", "Path2D") {
-        val MobSpawnLocation = NodeRef<PathFollow2D>("$path/Main/MobPath/MobSpawnLocation", "PathFollow2D")
-    }
     val HUD = HUDScene("$path/Main/HUD")
     val Music = NodeRef<AudioStreamPlayer>("$path/Main/Music", "AudioStreamPlayer")
     val DeathSound = NodeRef<AudioStreamPlayer>("$path/Main/DeathSound", "AudioStreamPlayer")
+
+    inner class MobPathTree : NodeRef<Path2D>("$path/Main/MobPath", "Path2D") {
+        val MobSpawnLocation = NodeRef<PathFollow2D>("$path/Main/MobPath/MobSpawnLocation", "PathFollow2D")
+    }
 }
 
 class MobScene(private val path: String) : NodeRef<RigidBody2D>("$path/Mob", "RigidBody2D") {
@@ -47,8 +48,8 @@ class PlayerScene(private val path: String) : NodeRef<Area2D>("$path/Player", "A
 }
 
 open class NodeRef<T : Node>(
-        private val path: String,
-        private val type: String,
+    private val path: String,
+    private val type: String,
 ) {
     operator fun getValue(thisRef: Node, property: KProperty<*>): T {
         val node = thisRef.getNode(NodePath(path)) ?: throw NodeNotFoundException(path)
diff --git a/src/test/resources/physics-test/Expected b/src/test/resources/physics-test/Expected
@@ -17,12 +17,15 @@ class MainScene(private val path: String) : NodeRef<Control>("$path/Main", "Cont
     val LabelTest = NodeRef<Label>("$path/Main/LabelTest", "Label")
     val LabelPause = NodeRef<Label>("$path/Main/LabelPause", "Label")
     val PanelLog = PanelLogTree()
+
     inner class PanelLogTree : NodeRef<Panel>("$path/Main/PanelLog", "Panel") {
         val ButtonClear = NodeRef<Button>("$path/Main/PanelLog/ButtonClear", "Button")
         val CheckBoxScroll = NodeRef<CheckButton>("$path/Main/PanelLog/CheckBoxScroll", "CheckButton")
         val ScrollLog = ScrollLogTree()
+
         inner class ScrollLogTree : NodeRef<ScrollContainer>("$path/Main/PanelLog/ScrollLog", "ScrollContainer") {
             val VBoxLog = VBoxLogTree()
+
             inner class VBoxLogTree : NodeRef<VBoxContainer>("$path/Main/PanelLog/ScrollLog/VBoxLog", "VBoxContainer") {
                 val LabelLog = NodeRef<Label>("$path/Main/PanelLog/ScrollLog/VBoxLog/LabelLog", "Label")
             }
@@ -31,8 +34,8 @@ class MainScene(private val path: String) : NodeRef<Control>("$path/Main", "Cont
 }
 
 open class NodeRef<T : Node>(
-        private val path: String,
-        private val type: String,
+    private val path: String,
+    private val type: String,
 ) {
     operator fun getValue(thisRef: Node, property: KProperty<*>): T {
         val node = thisRef.getNode(NodePath(path)) ?: throw NodeNotFoundException(path)
diff --git a/src/test/resources/scene-changer/Expected b/src/test/resources/scene-changer/Expected
@@ -20,8 +20,8 @@ class SceneBScene(private val path: String) : NodeRef<Panel>("$path/SceneB", "Pa
 }
 
 open class NodeRef<T : Node>(
-        private val path: String,
-        private val type: String,
+    private val path: String,
+    private val type: String,
 ) {
     operator fun getValue(thisRef: Node, property: KProperty<*>): T {
         val node = thisRef.getNode(NodePath(path)) ?: throw NodeNotFoundException(path)
diff --git a/src/test/resources/simple/Expected b/src/test/resources/simple/Expected
@@ -16,8 +16,8 @@ class MainScene(private val path: String) : NodeRef<GridContainer>("$path/Root",
 }
 
 open class NodeRef<T : Node>(
-        private val path: String,
-        private val type: String,
+    private val path: String,
+    private val type: String,
 ) {
     operator fun getValue(thisRef: Node, property: KProperty<*>): T {
         val node = thisRef.getNode(NodePath(path)) ?: throw NodeNotFoundException(path)
diff --git a/src/test/resources/waypoints/Expected b/src/test/resources/waypoints/Expected
@@ -11,38 +11,47 @@ object GDTree {
 
 class MainScene(private val path: String) : NodeRef<Node3D>("$path/Main", "Node3D") {
     val BlueCube = BlueCubeTree()
+    val GreenCube = GreenCubeTree()
+    val YellowCube = YellowCubeTree()
+    val RedCube = RedCubeTree()
+    val Camera3D = NodeRef<Camera3D>("$path/Main/Camera3D", "Camera3D")
+    val Label = NodeRef<Label>("$path/Main/Label", "Label")
+    val Ground = NodeRef<MeshInstance3D>("$path/Main/Ground", "MeshInstance3D")
+    val WhiteCube = NodeRef<MeshInstance3D>("$path/Main/WhiteCube", "MeshInstance3D")
+    val Environment = EnvironmentTree()
+
     inner class BlueCubeTree : NodeRef<MeshInstance3D>("$path/Main/BlueCube", "MeshInstance3D") {
         val WaypointAnchor = WaypointAnchorTree()
+
         inner class WaypointAnchorTree : NodeRef<Marker3D>("$path/Main/BlueCube/WaypointAnchor", "Marker3D") {
             val Waypoint = WaypointScene("$path/Main/BlueCube/WaypointAnchor/Waypoint")
         }
     }
-    val GreenCube = GreenCubeTree()
+
     inner class GreenCubeTree : NodeRef<MeshInstance3D>("$path/Main/GreenCube", "MeshInstance3D") {
         val WaypointAnchor = WaypointAnchorTree()
+
         inner class WaypointAnchorTree : NodeRef<Marker3D>("$path/Main/GreenCube/WaypointAnchor", "Marker3D") {
             val Waypoint = WaypointScene("$path/Main/GreenCube/WaypointAnchor/Waypoint")
         }
     }
-    val YellowCube = YellowCubeTree()
+
     inner class YellowCubeTree : NodeRef<MeshInstance3D>("$path/Main/YellowCube", "MeshInstance3D") {
         val WaypointAnchor = WaypointAnchorTree()
+
         inner class WaypointAnchorTree : NodeRef<Marker3D>("$path/Main/YellowCube/WaypointAnchor", "Marker3D") {
             val Waypoint = WaypointScene("$path/Main/YellowCube/WaypointAnchor/Waypoint")
         }
     }
-    val RedCube = RedCubeTree()
+
     inner class RedCubeTree : NodeRef<MeshInstance3D>("$path/Main/RedCube", "MeshInstance3D") {
         val WaypointAnchor = WaypointAnchorTree()
+
         inner class WaypointAnchorTree : NodeRef<Marker3D>("$path/Main/RedCube/WaypointAnchor", "Marker3D") {
             val Waypoint = WaypointScene("$path/Main/RedCube/WaypointAnchor/Waypoint")
         }
     }
-    val Camera3D = NodeRef<Camera3D>("$path/Main/Camera3D", "Camera3D")
-    val Label = NodeRef<Label>("$path/Main/Label", "Label")
-    val Ground = NodeRef<MeshInstance3D>("$path/Main/Ground", "MeshInstance3D")
-    val WhiteCube = NodeRef<MeshInstance3D>("$path/Main/WhiteCube", "MeshInstance3D")
-    val Environment = EnvironmentTree()
+
     inner class EnvironmentTree : NodeRef<WorldEnvironment>("$path/Main/Environment", "WorldEnvironment") {
         val Sun = NodeRef<DirectionalLight3D>("$path/Main/Environment/Sun", "DirectionalLight3D")
     }
@@ -54,8 +63,8 @@ class WaypointScene(private val path: String) : NodeRef<Control>("$path/Waypoint
 }
 
 open class NodeRef<T : Node>(
-        private val path: String,
-        private val type: String,
+    private val path: String,
+    private val type: String,
 ) {
     operator fun getValue(thisRef: Node, property: KProperty<*>): T {
         val node = thisRef.getNode(NodePath(path)) ?: throw NodeNotFoundException(path)
