feat: support yaml

build.gradle

@@ -1,42 +1,37 @@
 plugins {
-    id 'org.jetbrains.kotlin.jvm' version '1.9.23'
-    id 'kr.entree.spigradle' version '2.4.3'
-    id 'org.jetbrains.kotlin.plugin.serialization' version '1.9.23'
+    id 'org.jetbrains.kotlin.jvm' version '2.2.0'
+    id 'io.typst.spigradle' version '3.0.4'
+    id 'org.jetbrains.kotlin.plugin.serialization' version '2.2.0'
     id 'com.github.johnrengelman.shadow' version '8.1.1'
     id 'maven-publish'
     id 'signing'
 }
 
 group = 'io.typst'
-version = '3.0.2'
+version = '3.1.0'
 
 repositories {
     mavenCentral()
+    spigotmc()
 }
 
 dependencies {
     compileOnly spigot('1.16.5')
-    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3'
-    testImplementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3'
+    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0'
+    implementation 'com.charleskorn.kaml:kaml-jvm:0.96.0'
+    testImplementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0'
     testImplementation 'org.jetbrains.kotlin:kotlin-test'
 }
 
 test {
     useJUnitPlatform()
 }
 
-compileKotlin {
-    kotlinOptions.jvmTarget = '1.8'
-}
-
-compileTestKotlin {
-    kotlinOptions.jvmTarget = '1.8'
+kotlin {
+    jvmToolchain(17)
 }
 
 spigot {
-    debug {
-        buildVersion '1.16.5'
-    }
     apiVersion '1.16'
 }
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/kotlin/io/typst/bukkit/kotlin/serialization/BukkitConfigSerializableSerializer.kt

@@ -0,0 +1,124 @@
+package io.typst.bukkit.kotlin.serialization
+
+import com.charleskorn.kaml.*
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.descriptors.buildClassSerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.*
+import org.bukkit.configuration.serialization.ConfigurationSerializable
+import org.bukkit.configuration.serialization.ConfigurationSerialization
+
+private val ROOT = YamlPath.root
+
+object BukkitConfigSerializableSerializer : KSerializer<ConfigurationSerializable> {
+    override val descriptor: SerialDescriptor =
+        buildClassSerialDescriptor("BukkitConfigurationSerializable")
+
+    fun serialize(value: ConfigurationSerializable): Map<String, Any?> {
+        val map: MutableMap<String, Any?> = value.serialize()
+        val alias = ConfigurationSerialization.getAlias(value.javaClass)
+        return map + (ConfigurationSerialization.SERIALIZED_TYPE_KEY to alias)
+    }
+
+    override fun serialize(encoder: Encoder, value: ConfigurationSerializable) {
+        val bukkitMap = serialize(value)
+        when (encoder) {
+            is JsonEncoder -> encoder.encodeJsonElement(mapToJson(bukkitMap))
+            else -> {
+                val node: YamlNode = mapToYaml(bukkitMap)
+                encoder.encodeSerializableValue(YamlNode.serializer(), node)
+            }
+        }
+    }
+
+    override fun deserialize(decoder: Decoder): ConfigurationSerializable {
+        val map: Map<String, Any?> = when (decoder) {
+            is JsonDecoder -> {
+                val elem = decoder.decodeJsonElement()
+                (jsonToAny(elem) as Map<String, Any?>)
+            }
+
+            else -> {
+                val node: YamlNode = decoder.decodeSerializableValue(YamlNode.serializer())
+                (yamlToAny(node) as Map<String, Any?>)
+            }
+        }
+        return ConfigurationSerialization.deserializeObject(map)
+            ?: error("Failed to deserialize ConfigurationSerializable (missing '==' alias?)")
+    }
+
+    // -------------------- JSON <-> Any --------------------
+    private fun mapToJson(map: Map<String, *>): JsonObject = buildJsonObject {
+        for ((k, v) in map) put(k, anyToJson(v))
+    }
+
+    private fun listToJson(list: List<*>): JsonArray = JsonArray(list.map { anyToJson(it) })
+
+    private fun anyToJson(v: Any?): JsonElement = when (v) {
+        null -> JsonNull
+        is JsonElement -> v
+        is String -> JsonPrimitive(v)
+        is Boolean -> JsonPrimitive(v)
+        is Number -> JsonPrimitive(v)
+        is Map<*, *> -> mapToJson(v as Map<String, *>)
+        is List<*> -> listToJson(v)
+        is ConfigurationSerializable -> mapToJson(serialize(v))
+        else -> JsonPrimitive(v.toString())
+    }
+
+    private fun jsonToAny(elem: JsonElement): Any? = when (elem) {
+        is JsonNull -> null
+        is JsonPrimitive -> when {
+            elem.isString -> elem.content
+            elem.booleanOrNull != null -> elem.boolean
+            elem.longOrNull != null -> if (elem.content.contains('.')) elem.double else elem.long
+            else -> elem.content
+        }
+
+        is JsonObject -> elem.mapValues { jsonToAny(it.value) }
+        is JsonArray -> elem.map { jsonToAny(it) }
+    }
+
+    // -------------------- YAML(KAML 0.96) <-> Any --------------------
+    private fun mapToYaml(map: Map<String, *>): YamlMap =
+        YamlMap(map.map { (k, v) -> YamlScalar(k, ROOT) to anyToYaml(v) }.toMap(), ROOT)
+
+    private fun listToYaml(list: List<*>): YamlList =
+        YamlList(list.map { anyToYaml(it) }, ROOT)
+
+    private fun anyToYaml(v: Any?): YamlNode = when (v) {
+        null -> YamlNull(ROOT)
+        is YamlNode -> v
+        is String -> YamlScalar(v, ROOT)
+        is Boolean -> YamlScalar(v.toString(), ROOT) // 스칼라는 문자열 컨텐트
+        is Number -> YamlScalar(v.toString(), ROOT)
+        is Map<*, *> -> mapToYaml(v as Map<String, *>)
+        is List<*> -> listToYaml(v)
+        is ConfigurationSerializable -> mapToYaml(serialize(v))
+        else -> YamlScalar(v.toString(), ROOT)
+    }
+
+    private fun yamlToAny(node: YamlNode): Any? = when (node) {
+        is YamlNull -> null
+        is YamlScalar -> parseYamlScalar(node.content)
+        is YamlList -> node.items.map { yamlToAny(it) }
+        is YamlMap -> node.entries
+            .mapKeys { (k, _) -> (yamlToAny(k) ?: "").toString() }
+            .mapValues { (_, v) -> yamlToAny(v) }
+
+        is YamlTaggedNode -> {
+            yamlToAny(node.innerNode)
+        }
+    }
+
+    private fun parseYamlScalar(s: String): Any {
+        val lower = s.lowercase()
+        if (lower == "true" || lower == "false") return lower == "true"
+        val num = s.replace("_", "")
+        num.toLongOrNull()?.let { return it }
+        num.toDoubleOrNull()?.let { return it }
+        return s
+    }
+}

src/main/kotlin/io/typst/bukkit/kotlin/serialization/ItemStackSerializer.kt

@@ -1,4 +1,3 @@
-
 package io.typst.bukkit.kotlin.serialization
 
 import kotlinx.serialization.KSerializer
@@ -10,15 +9,14 @@ import org.bukkit.inventory.ItemStack
 
 typealias ItemStackSerializable = @Serializable(ItemStackSerializer::class) ItemStack
 
-class ItemStackSerializer : KSerializer<ItemStack> {
-    override val descriptor: SerialDescriptor
-        get() = ConfigSerializableSerializer.descriptor
+object ItemStackSerializer : KSerializer<ItemStack> {
+    override val descriptor: SerialDescriptor = BukkitConfigSerializableSerializer.descriptor
 
-    override fun serialize(encoder: Encoder, value: ItemStack) =
-        encoder.encodeSerializableValue(ConfigSerializableSerializer, value)
+    override fun serialize(encoder: Encoder, value: ItemStack) {
+        BukkitConfigSerializableSerializer.serialize(encoder, value)
+    }
 
     override fun deserialize(decoder: Decoder): ItemStack {
-        val serializable = decoder.decodeSerializableValue(ConfigSerializableSerializer)
-        return serializable as ItemStack
+        return BukkitConfigSerializableSerializer.deserialize(decoder) as ItemStack
     }
 }