Align project with swift implementation

Author: tomwyr

src/main/kotlin/com/tomwyr/Command.kt

@@ -0,0 +1,15 @@
+package com.tomwyr
+
+import com.tomwyr.common.Log
+import com.tomwyr.generator.NodeTreeGenerator
+import com.tomwyr.utils.GodotKotlinProject
+import org.gradle.api.Project
+
+class GenerateTreeCommand {
+    fun run(project: Project, config: GodotNodeTreeConfig) {
+        val projectPath = project.projectDir.absolutePath
+        val godotProject = GodotKotlinProject.create(projectPath, config)
+        val treeInfo = NodeTreeGenerator().generate(godotProject)
+        Log.nodeTreeGenerated(treeInfo)
+    }
+}

src/main/kotlin/com/tomwyr/Generate.kt

@@ -1,44 +1,39 @@
 package com.tomwyr
 
-import com.tomwyr.core.Log
-import com.tomwyr.core.Logger
+import com.tomwyr.common.Log
+import com.tomwyr.common.Logger
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
 
 class GodotNodeTree : Plugin<Project> {
     override fun apply(project: Project) {
         initLog(project)
-        configure(project)
+        registerTask(project)
         addSourceSet(project)
     }
-}
 
-open class GodotNodeTreeConfig(
-        var projectPath: String? = null,
-        var packageName: String? = null,
-)
-
-private fun initLog(project: Project) {
-    val logger = project.logger
-    Log.logger = object : Logger {
-        override fun debug(message: String) = logger.debug(message)
-        override fun info(message: String) = logger.info(message)
-        override fun warn(message: String) = logger.warn(message)
+    private fun initLog(project: Project) {
+        Log.logger = Logger.stdOut(project)
     }
-}
 
-private fun configure(project: Project) {
-    val config = project.extensions.create("godotNodeTree", GodotNodeTreeConfig::class.java)
-    project.tasks.register("generateNodeTree") { task ->
-        task.doLast {
-            generate(project, config)
+    private fun registerTask(project: Project) {
+        val config = project.extensions.create("godotNodeTree", GodotNodeTreeConfig::class.java)
+        project.tasks.register("generateNodeTree") { task ->
+            task.doLast {
+                GenerateTreeCommand().run(project, config)
+            }
         }
     }
-}
 
-private fun addSourceSet(project: Project) {
-    val pluginExt = project.extensions.findByType(KotlinJvmProjectExtension::class.java)
-    val sourceSet = pluginExt?.sourceSets?.getByName("main")?.kotlin
-    sourceSet?.srcDirs("build/generated/godotNodeTree/kotlin")
+    private fun addSourceSet(project: Project) {
+        val pluginExt = project.extensions.findByType(KotlinJvmProjectExtension::class.java)
+        val sourceSet = pluginExt?.sourceSets?.getByName("main")?.kotlin
+        sourceSet?.srcDirs("build/generated/godotNodeTree/kotlin")
+    }
 }
+
+open class GodotNodeTreeConfig(
+        var projectPath: String? = null,
+        var packageName: String? = null,
+)

src/main/kotlin/com/tomwyr/Plugin.kt

@@ -0,0 +1,17 @@
+package com.tomwyr.common
+
+import com.tomwyr.generator.NodeParams
+
+sealed class GeneratorException(message: String) : Exception(message)
+
+class InvalidGodotProject :
+    GeneratorException("The project in which GodotNodeTree annotation was used isn't a valid Godot project directory")
+
+class UnexpectedNodeParameters(nodeParams: NodeParams) :
+    GeneratorException("A node with unexpected set of parameters encountered: $nodeParams")
+
+class UnexpectedSceneResource(instance: String) :
+    GeneratorException("A node pointing to an unknown scene resource encountered with id: $instance")
+
+class ParentNodeNotFound(sceneName: String) :
+    GeneratorException("None of the parsed nodes was identified as the parent node of scene $sceneName")

src/main/kotlin/com/tomwyr/common/Exceptions.kt

@@ -1,15 +1,9 @@
-package com.tomwyr.core
+package com.tomwyr.common
 
-import com.tomwyr.utils.SceneData
-
-interface Logger {
-    fun debug(message: String)
-    fun info(message: String)
-    fun warn(message: String)
-}
+import org.gradle.api.Project
 
 object Log : ProcessorLog, ParserLog, RendererLog, GeneratorLog, Logger {
-    lateinit var logger: Logger
+    var logger: Logger = Logger.noop()
 
     override fun debug(message: String) = logger.debug(message)
     override fun info(message: String) = logger.info(message)
@@ -121,3 +115,23 @@ interface GeneratorLog : Logger {
         info("Output file saved")
     }
 }
+
+interface Logger {
+    fun debug(message: String)
+    fun info(message: String)
+    fun warn(message: String)
+
+    companion object {
+        fun noop() = object : Logger {
+            override fun debug(message: String) {}
+            override fun info(message: String) {}
+            override fun warn(message: String) {}
+        }
+
+        fun stdOut(project: Project) = object : Logger {
+            override fun debug(message: String) = project.logger.debug(message)
+            override fun info(message: String) = project.logger.info(message)
+            override fun warn(message: String) = project.logger.warn(message)
+        }
+    }
+}

src/main/kotlin/com/tomwyr/core/Log.kt renamed to src/main/kotlin/com/tomwyr/common/Log.kt

@@ -1,11 +1,10 @@
-package com.tomwyr.core
+package com.tomwyr.common
 
 import kotlin.math.max
 
-data class Scene(
-    val name: String,
-    val root: Node,
-) {
+class SceneData(val name: String, val content: String)
+
+data class Scene(val name: String, val root: Node) {
     val nodesCount: Int = root.flatten().size
     val nodesDepth: Int = root.longestPath().size
 }

src/main/kotlin/com/tomwyr/core/Models.kt renamed to src/main/kotlin/com/tomwyr/common/Models.kt

@@ -1,9 +1,9 @@
 package com.tomwyr.generator
 
+import com.tomwyr.common.Log
+import com.tomwyr.common.NodeTreeInfo
+import com.tomwyr.common.Scene
 import com.tomwyr.utils.GodotKotlinProject
-import com.tomwyr.core.Log
-import com.tomwyr.core.NodeTreeInfo
-import com.tomwyr.core.Scene
 
 class NodeTreeGenerator(
     private val parser: SceneNodesParser = SceneNodesParser(),
@@ -16,7 +16,7 @@ class NodeTreeGenerator(
 
         val scenes = scenesData.map { data ->
             Log.parsingScene(data)
-            val root = parser.parse(data.content)
+            val root = parser.parse(data)
             Scene(data.name, root)
         }.toList()
 

src/main/kotlin/com/tomwyr/core/Exceptions.kt

@@ -1,19 +1,19 @@
 package com.tomwyr.generator
 
-import com.tomwyr.core.*
+import com.tomwyr.common.*
 import com.tomwyr.utils.capitalize
 
 class SceneNodesParser {
-    fun parse(sceneFileContent: String): Node {
-        val scenePathsById = ScenesParser().parse(sceneFileContent)
-        return NodesParser(scenePathsById).parse(sceneFileContent)
+    fun parse(sceneData: SceneData): Node {
+        val scenePathsById = ScenesParser().parse(sceneData)
+        return NodesParser(scenePathsById).parse(sceneData)
     }
 }
 
 private class ScenesParser {
-    fun parse(sceneFileContent: String): Map<String, String> {
+    fun parse(sceneData: SceneData): Map<String, String> {
         Log.parsingScenePaths()
-        return splitToEntries(sceneFileContent, "ext_resource")
+        return splitToEntries(sceneData.content, "ext_resource")
             .map(::parseEntryParams)
             .mapNotNull(::extractSceneIdToPath)
             .let(::getScenePathsById)
@@ -45,12 +45,12 @@ private class ScenesParser {
 }
 
 private class NodesParser(val scenePathsById: Map<String, String>) {
-    fun parse(sceneFileContent: String): Node {
+    fun parse(sceneData: SceneData): Node {
         Log.parsingSceneNodes()
-        return splitToEntries(sceneFileContent, "node")
+        return splitToEntries(sceneData.content, "node")
             .map(::parseEntryParams)
             .mapNotNull(::extractNodeParams)
-            .let(::createRootNode)
+            .let { createRootNode(sceneData.name, it) }
     }
 
 
@@ -68,10 +68,10 @@ private class NodesParser(val scenePathsById: Map<String, String>) {
         return NodeParams(name = name, type = type, instance = instance, parent = parent)
     }
 
-    private fun createRootNode(params: List<NodeParams>): Node {
+    private fun createRootNode(sceneName: String, params: List<NodeParams>): Node {
         Log.creatingRootNode()
         val childrenByParent = params.groupBy { it.parent }
-        val rootParams = params.single { it.parent == null }
+        val rootParams = params.firstOrNull { it.parent == null } ?: throw ParentNodeNotFound(sceneName)
         return rootParams.toNode(childrenByParent, scenePathsById)
     }
 }

src/main/kotlin/com/tomwyr/generator/Generator.kt

@@ -1,27 +1,29 @@
 package com.tomwyr.generator
 
-import com.tomwyr.core.*
+import com.tomwyr.common.*
 import com.tomwyr.utils.capitalize
 
-
 class NodeTreeRenderer {
     fun render(packageName: String?, scenes: List<Scene>): String {
-        val `package` = packageName?.let { "package $it" }
-        val imports = renderImports()
+        val header = renderHeader(packageName)
         val nodeTree = renderNodeTree(scenes)
         val sceneNodes = scenes.map { renderScene(it) }.joinLines(spacing = 2)
-        val nodeRef = renderNodeRef()
+        val types = renderTypes()
 
-        return listOfNotNull(`package`, imports, nodeTree, sceneNodes, nodeRef)
+        return listOfNotNull(header, nodeTree, sceneNodes, types)
             .joinLines(spacing = 2).plus("\n")
     }
 
-    private fun renderImports(): String {
+    private fun renderHeader(packageName: String?): String {
+        val packageOrEmpty = packageName?.let { "package $it" } ?: ""
+
         return """
+        |$packageOrEmpty
+        |
         |import godot.*
         |import godot.core.NodePath
         |import kotlin.reflect.KProperty
-        """.trimMargin()
+        """.trimMargin().trim()
     }
 
     private fun renderNodeTree(scenes: List<Scene>): String {
@@ -100,7 +102,7 @@ class NodeTreeRenderer {
         }
     }
 
-    private fun renderNodeRef(): String {
+    private fun renderTypes(): String {
         return """
         |open class NodeRef<T : Node>(
         |        private val path: String,
@@ -123,4 +125,4 @@ class NodeTreeRenderer {
 
 private fun Iterable<String>.joinLines(spacing: Int = 1): String = joinToString("\n".repeat(spacing))
 
-private fun String.indentLine(times: Int = 1) = lineSequence().joinToString("\n" + "    ".repeat(times))
+private fun String.indentLine(times: Int = 1): String = lineSequence().joinToString("\n" + "    ".repeat(times))