Rework plugin to use core dynamic library

Author: tomwyr

build.gradle.kts

@@ -11,6 +11,7 @@ description = "A type-safe Godot node tree representation in Kotlin"
 
 plugins {
     kotlin("jvm") version "1.9.20"
+    kotlin("plugin.serialization") version "1.9.25"
     id("com.gradle.plugin-publish") version "1.2.1"
     id("com.adarshr.test-logger") version "4.0.0"
 }
@@ -21,6 +22,8 @@ repositories {
 
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.0")
+    implementation("net.java.dev.jna:jna:5.17.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
     testImplementation(kotlin("test"))
 }
 

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

@@ -1,5 +1,6 @@
 package com.tomwyr
 
+import com.tomwyr.command.GenerateTreeCommand
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
@@ -11,10 +12,10 @@ class GodotNodeTree : Plugin<Project> {
     }
 
     private fun registerTask(project: Project) {
-        val config = project.extensions.create("godotNodeTree", GodotNodeTreeConfig::class.java)
+        val params = project.extensions.create("godotNodeTree", GodotNodeTreeInput::class.java)
         project.tasks.register("generateNodeTree") { task ->
             task.doLast {
-                GenerateTreeCommand().run(project, config)
+                GenerateTreeCommand.from(project, params).run()
             }
         }
     }
@@ -26,7 +27,7 @@ class GodotNodeTree : Plugin<Project> {
     }
 }
 
-open class GodotNodeTreeConfig(
-        var projectPath: String? = null,
-        var packageName: String? = null,
+open class GodotNodeTreeInput(
+    var projectPath: String? = null,
+    var packageName: String? = null,
 )

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

@@ -0,0 +1,51 @@
+package com.tomwyr.command
+
+import com.tomwyr.GodotNodeTreeInput
+import com.tomwyr.common.InvalidGodotProject
+import com.tomwyr.ffi.generateNodeTree
+import org.gradle.api.Project
+import java.io.File
+import java.nio.file.Paths
+
+class GenerateTreeCommand(
+    val libPath: String,
+    val projectPath: String,
+    val outputPath: String,
+    val packageName: String?,
+) {
+    fun run() {
+        val tree = generateNodeTree(libPath = libPath, projectPath = projectPath)
+        val content = NodeTreeRenderer().render(packageName, tree)
+        NodeTreeWriter().write(content, outputPath)
+    }
+
+    companion object Factory {
+        fun from(project: Project, input: GodotNodeTreeInput): GenerateTreeCommand {
+            val rootPath = project.projectDir.absolutePath
+            val libPath = "NodeTreeGenerator.dylib"
+            val projectPath = getProjectPath(rootPath = rootPath, relativePath = input.projectPath)
+            val outputPath = getOutputPath(rootPath = rootPath, packageName = input.packageName)
+
+            return GenerateTreeCommand(
+                libPath = libPath,
+                projectPath = projectPath,
+                outputPath = outputPath,
+                packageName = input.packageName
+            )
+        }
+
+        private fun getProjectPath(rootPath: String, relativePath: String?): String {
+            val fileName = "project.godot"
+            val path = Paths.get(rootPath, relativePath ?: "", fileName).toString()
+            if (!File(path).exists()) throw InvalidGodotProject()
+            return path
+        }
+
+        private fun getOutputPath(rootPath: String, packageName: String?): String {
+            val buildPath = listOf("build", "generated", "godotNodeTree", "kotlin").toTypedArray()
+            val packagePath = packageName?.split(".")?.toTypedArray() ?: emptyArray()
+            val fileName = "GodotNodeTree.kt"
+            return Paths.get(rootPath, *buildPath, *packagePath, fileName).toString()
+        }
+    }
+}

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

@@ -1,13 +1,12 @@
-package com.tomwyr.generator
+package com.tomwyr.command
 
 import com.tomwyr.common.*
-import com.tomwyr.utils.capitalize
 
 class NodeTreeRenderer {
-    fun render(packageName: String?, scenes: List<Scene>): String {
+    fun render(packageName: String?, tree: NodeTree): String {
         val header = renderHeader(packageName)
-        val nodeTree = renderNodeTree(scenes)
-        val sceneNodes = scenes.map { renderScene(it) }.joinLines(spacing = 2)
+        val nodeTree = renderNodeTree(tree.scenes)
+        val sceneNodes = tree.scenes.map { renderScene(it) }.joinLines(spacing = 2)
         val types = renderTypes()
 
         return listOf(header, nodeTree, sceneNodes, types)
@@ -150,4 +149,6 @@ private fun String.indentLine(times: Int = 1): String = lineSequence().joinToStr
 
 private fun String.trimBlankLines(): String = lineSequence().joinToString("\n") { it.ifBlank { "" } }
 
+private fun String.capitalize(): String = replaceFirstChar { it.uppercase() }
+
 private data class RenderNodeResult(val field: String, val nestedClass: String?)

src/main/kotlin/com/tomwyr/generator/Renderer.kt renamed to src/main/kotlin/com/tomwyr/command/Renderer.kt

@@ -0,0 +1,16 @@
+package com.tomwyr.command
+
+import java.io.File
+
+class NodeTreeWriter {
+    fun write(content: String, path: String) {
+        val file = File(path).apply {
+            parentFile.mkdirs()
+            createNewFile()
+        }
+        file.outputStream().apply {
+            write(content.toByteArray())
+            close()
+        }
+    }
+}

src/main/kotlin/com/tomwyr/command/Writer.kt

@@ -0,0 +1,40 @@
+package com.tomwyr.common
+
+import kotlinx.serialization.Serializable
+
+sealed class GodotKotlinTreeError : Exception() {
+    override fun getLocalizedMessage(): String = when (this) {
+        is InvalidGodotProject -> "The project in which GodotNodeTree annotation was used isn't a valid Godot project directory"
+        is GeneratorError -> error.localizedMessage
+    }
+}
+
+class InvalidGodotProject : GodotKotlinTreeError()
+
+class GeneratorError(val error: GodotNodeTreeError) : GodotKotlinTreeError()
+
+@Serializable
+sealed class GodotNodeTreeError : Exception() {
+    override fun getLocalizedMessage(): String = when (this) {
+        is ScanningScenesFailed -> "Unable to scan scene files for project at `$projectPath`."
+        is ReadingSceneFailed -> "Unable to read contens of scene at `$scenePath`."
+        is UnexpectedNodeParameters -> "A node with unexpected set of parameters encountered: $nodeParams."
+        is UnexpectedSceneResource -> "A node pointing to an unknown scene resource encountered with id: $instance."
+        is ParentNodeNotFound -> "None of the parsed nodes was identified as the parent node of scene $sceneName."
+    }
+}
+
+@Serializable
+class ScanningScenesFailed(val projectPath: String) : GodotNodeTreeError()
+
+@Serializable
+class ReadingSceneFailed(val scenePath: String) : GodotNodeTreeError()
+
+@Serializable
+class UnexpectedNodeParameters(val nodeParams: NodeParams) : GodotNodeTreeError()
+
+@Serializable
+class UnexpectedSceneResource(val instance: String) : GodotNodeTreeError()
+
+@Serializable
+class ParentNodeNotFound(val sceneName: String) : GodotNodeTreeError()

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

@@ -1,72 +1,41 @@
 package com.tomwyr.common
 
-import kotlin.math.max
+import kotlinx.serialization.Serializable
 
-class SceneData(val name: String, val content: String)
+@Serializable
+class NodeParams(
+    val name: String,
+    val type: String?,
+    val instance: String?,
+    val parent: String?,
+)
 
-data class Scene(val name: String, val root: Node) {
-    val nodesCount: Int = root.flatten().size
-    val nodesDepth: Int = root.longestPath().size
-}
+@Serializable
+class NodeTree(val scenes: List<Scene>)
+
+@Serializable
+class Scene(val name: String, val root: Node)
 
+@Serializable
 sealed class Node {
     abstract val name: String
-    abstract fun flatten(): List<Node>
-    abstract fun longestPath(): List<Node>
 }
 
-data class ParentNode(
+@Serializable
+class ParentNode(
     override val name: String,
     val type: String,
     val children: List<Node>,
-) : Node() {
-    override fun flatten(): List<Node> {
-        return children.flatMap { it.flatten() } + this
-    }
-
-    override fun longestPath(): List<Node> {
-        return children.map { it.longestPath() }.maxByOrNull { it.size }.orEmpty() + this
-    }
-}
+) : Node()
 
-data class LeafNode(
+@Serializable
+class LeafNode(
     override val name: String,
     val type: String,
-) : Node() {
-    override fun flatten(): List<Node> = listOf(this)
-
-    override fun longestPath(): List<Node> = listOf(this)
-}
+) : Node()
 
-data class NestedScene(
+@Serializable
+class NestedScene(
     override val name: String,
     val scene: String,
-) : Node() {
-    override fun flatten(): List<Node> = listOf(this)
-
-    override fun longestPath(): List<Node> = listOf(this)
-}
-
-class NodeTreeInfo(
-        val nodes: Int,
-        val depth: Int,
-        val scenes: Int,
-) {
-    companion object {
-        operator fun invoke(scenes: List<Scene>): NodeTreeInfo {
-            var nodes = 0
-            var depth = 0
-
-            for (scene in scenes) {
-                nodes += scene.nodesCount
-                depth = max(depth, scene.nodesDepth)
-            }
-
-            return NodeTreeInfo(
-                    nodes = nodes,
-                    depth = depth,
-                    scenes = scenes.size,
-            )
-        }
-    }
-}
+) : Node()

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

@@ -0,0 +1,22 @@
+package com.tomwyr.ffi
+
+import com.sun.jna.Library
+import com.sun.jna.Pointer
+import com.sun.jna.Native
+import com.tomwyr.common.GeneratorError
+import com.tomwyr.common.GodotNodeTreeError
+import com.tomwyr.common.NodeTree
+
+fun generateNodeTree(libPath: String, projectPath: String): NodeTree {
+  val lib = Native.load(libPath, GodotNodeTreeLib::class.java)
+  val resultPtr = lib.generateNodeTree(projectPath)
+  val result = Result.fromJson<NodeTree, GodotNodeTreeError>(resultPtr.getString(0))
+  return when (result) {
+    is Ok -> result.value
+    is Err -> throw GeneratorError(result.value)
+  }
+}
+
+interface GodotNodeTreeLib : Library {
+  fun generateNodeTree(projectPath: String): Pointer
+}

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

@@ -0,0 +1,58 @@
+package com.tomwyr.ffi
+
+import kotlinx.serialization.*
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.descriptors.buildClassSerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.*
+
+@Serializable
+sealed class Result<T, E : Throwable> {
+    fun unwrap(): T = when (this) {
+        is Ok -> value
+        is Err -> throw value
+    }
+}
+
+@Serializable
+class Ok<T, E : Throwable>(val value: T) : Result<T, E>()
+
+@Serializable
+class Err<T, E : Throwable>(val value: E) : Result<T, E>()
+
+class ResultSerializer<T, E : Throwable>(
+    private val tSerializer: KSerializer<T>,
+    private val eSerializer: KSerializer<E>
+) : KSerializer<Result<T, E>> {
+    override val descriptor: SerialDescriptor = buildClassSerialDescriptor("Result")
+
+    override fun serialize(encoder: Encoder, value: Result<T, E>) {
+        require(encoder is JsonEncoder)
+        val json = when (value) {
+            is Ok -> buildJsonObject { put("ok", encoder.json.encodeToJsonElement(tSerializer, value.value)) }
+            is Err -> buildJsonObject { put("err", encoder.json.encodeToJsonElement(eSerializer, value.value)) }
+        }
+        encoder.encodeJsonElement(json)
+    }
+
+    override fun deserialize(decoder: Decoder): Result<T, E> {
+        require(decoder is JsonDecoder)
+        val json = decoder.decodeJsonElement().jsonObject
+        return when {
+            "ok" in json -> Ok(decoder.json.decodeFromJsonElement(tSerializer, json.getValue("ok")))
+            "err" in json -> Err(decoder.json.decodeFromJsonElement(eSerializer, json.getValue("err")))
+            else -> throw SerializationException("Invalid data format for the expected Result type")
+        }
+    }
+}
+
+inline fun <reified T, reified E : Throwable> Result.Companion.fromJson(input: String): Result<T, E> {
+    val serializer = ResultSerializer<T, E>(serializer(), serializer())
+    return Json.decodeFromString(serializer, input)
+}
+
+inline fun <reified T, reified E : Throwable> Result<T, E>.toJson(): String {
+    val serializer = ResultSerializer<T, E>(serializer(), serializer())
+    return Json.encodeToString(serializer, this)
+}