refactor: Config system rework

feat: scopedConfig helper in features

Author: 0ffz

CHANGELOG.md

@@ -17,6 +17,7 @@ try to keep MAJOR changes in sync with Minecraft updates.
 ### Changed
 
 - **Feature system** has been reworked as a DSL built around Koin for dependency injection
+- **Config system** has been reworked to use a builder class that can then pick whether to decode a single file, directory, or multi-entry format which has been moved here from Geary
 - **SerializableItemStack** uses a new service for letting other plugins register custom item types instead of manually adding support for them
 - Brigadier **command api** internals reworked with much cleaner inside logic and fixes to expected behaviour from Brigadier 
 

idofront-config/src/main/kotlin/com/mineinabyss/idofront/config/Config.kt

@@ -1,85 +1,70 @@
 package com.mineinabyss.idofront.config
 
+import com.charleskorn.kaml.Yaml
 import kotlinx.serialization.KSerializer
+import kotlinx.serialization.StringFormat
+import kotlinx.serialization.json.Json
 import java.nio.file.Path
-import kotlin.io.path.*
-import kotlin.properties.ReadWriteProperty
-import kotlin.reflect.KProperty
+import kotlin.io.path.createFile
+import kotlin.io.path.createParentDirectories
+import kotlin.io.path.inputStream
+import kotlin.io.path.notExists
+import kotlin.io.path.outputStream
 
-@Deprecated("Use new config api instead")
-class Config<T>(
-    val name: String,
-    val path: Path,
-    val default: T,
+/**
+ * Config decoding definition, built via [ConfigBuilder].
+ *
+ * Can be used to read/write a config from a single path, or configs from a directory.
+ */
+data class Config<T>(
     val serializer: KSerializer<T>,
-    val preferredFormat: Format,
-    val formats: ConfigFormats,
-    val mergeUpdates: Boolean,
-    val lazyLoad: Boolean,
-    val onFirstLoad: (T) -> Unit = {},
-    val onReload: (T) -> Unit = {},
-    val onLoad: (T) -> Unit = {},
-) : ReadWriteProperty<Any?, T> {
-    private var loaded: T? = null
-    private val fileFormat = checkFormat()
-    private val fileName = "$name.${fileFormat.ext}"
-    private val configFile = (path / fileName).createParentDirectories()
+    val format: StringFormat,
+    val default: T?,
+    val writeBack: WriteMode,
+) {
+    /**
+     * Read and write a single config file located at [path]
+     *
+     * @see SingleConfig
+     */
+    fun single(path: Path) = SingleConfig(this, path)
 
-    init {
-        if (!lazyLoad) getOrLoad()
-    }
+    /**
+     * Read and write many config files located in a directory at [path].
+     *
+     * @see DirectoryConfig
+     */
+    fun fromDirectory(
+        path: Path,
+        extension: String = inferExtensionFromFormat(),
+    ): DirectoryConfig<T> = DirectoryConfig(this, path, extension)
 
-    private fun checkFormat(): Format {
-        return formats.formats.firstOrNull {
-            val file = path / "$name.${it.ext}"
-            file.exists()
-        } ?: preferredFormat
+    /**
+     * Read and write many config files in a directory at [path], where each file contains
+     * key-value pairs of strings to this config type [T].
+     *
+     * Each entry may also reuse parts of others using an `include` key that will be parsed
+     * automatically, without the underlying serializer needing to know about it.
+     *
+     * @throws IllegalArgumentException if the [format] is not [Yaml].
+     * @see MultiEntryYamlReader
+     */
+    fun multiEntry(path: Path): MultiEntryYamlReader<T> {
+        return MultiEntryYamlReader(this, path, format as? Yaml ?: error("Format must be YAML"))
     }
 
-    fun getOrLoad(): T {
-        loaded?.let { return it }
-        return runCatching(::load).onFailure { it.printStackTrace() }.getOrDefault(loaded ?: default).also(onFirstLoad).also(onLoad)
+    internal fun decode(path: Path): Result<T> = runCatching {
+        SerializationHelpers.decode(format, serializer, path.inputStream())
     }
 
-    fun reload(): T {
-        return runCatching(::load).onFailure { it.printStackTrace() }.getOrDefault(loaded ?: default).also(onReload).also(onLoad)
+    internal fun encode(path: Path, data: T) = runCatching {
+        if (path.notExists()) path.createParentDirectories().createFile()
+        SerializationHelpers.encode(format, serializer, path.outputStream(), data)
     }
 
-    private fun load(): T {
-        val decoded = when {
-            configFile.exists() && configFile.readText().isNotEmpty() -> {
-                configFile.inputStream().use { stream ->
-                    formats.decode(
-                        preferredFormat.stringFormat,
-                        serializer,
-                        stream
-                    )
-                }
-            }
-
-            else -> {
-                configFile.toFile().createNewFile()
-                default
-            }
-        }
-
-        // Merge with any new changes
-        if (mergeUpdates) write(decoded)
-        return decoded.also { loaded = it }
+    internal fun inferExtensionFromFormat() = when (format) {
+        is Yaml -> "yml"
+        is Json -> "json"
+        else -> error("Could not infer extension from unknown format $format")
     }
-
-    fun write(data: T) {
-        configFile.outputStream().use { stream ->
-            formats.encode(
-                fileFormat.stringFormat,
-                serializer,
-                stream,
-                data
-            )
-        }
-    }
-
-    override fun getValue(thisRef: Any?, property: KProperty<*>): T = getOrLoad()
-
-    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) = write(value)
-}
+}

idofront-config/src/main/kotlin/com/mineinabyss/idofront/config/ConfigBuilder.kt

@@ -0,0 +1,51 @@
+package com.mineinabyss.idofront.config
+
+import com.charleskorn.kaml.Yaml
+import com.charleskorn.kaml.YamlConfiguration
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.StringFormat
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.modules.SerializersModule
+import kotlinx.serialization.modules.plus
+
+/**
+ * Builder for a [Config] definition.
+ *
+ * @see config
+ */
+data class ConfigBuilder<T>(
+    /** Serializer to use for decoding the config file. */
+    var serializer: KSerializer<T>,
+    /** Format to use for decoding the config file. */
+    var format: StringFormat = Yaml(
+        configuration = YamlConfiguration(
+            strictMode = false
+        )
+    ),
+) {
+    /** Defines when the decoded config file should be written back to (ex. to add new fields, or encode a default config.) */
+    var writeBack: WriteMode = WriteMode.WHEN_EMPTY
+
+    /** Provide a default config to use if decoding fails. Only applicable when using as [SingleConfig]. */
+    var default: T? = null
+
+    /**
+     * Helper to add a [SerializersModule] to the [StringFormat] being used to decode the config.
+     *
+     * Note: only supports [Yaml] and [Json] formats, for others, manually set the [format].
+     */
+    fun withSerializersModule(module: SerializersModule) {
+        format = when (val format = format) {
+            is Yaml -> Yaml(format.serializersModule + module, format.configuration)
+            is Json -> Json(format) { serializersModule += module }
+            else -> error("Could not automatically add serializers module to unknown format $format, manually add it instead.")
+        }
+    }
+
+    fun build() = Config(
+        serializer = serializer,
+        format = format,
+        writeBack = writeBack,
+        default = default,
+    )
+}

idofront-config/src/main/kotlin/com/mineinabyss/idofront/config/ConfigEntry.kt

@@ -0,0 +1,5 @@
+package com.mineinabyss.idofront.config
+
+import java.nio.file.Path
+
+data class ConfigEntry<T>(val path: Path, val data: T)

idofront-config/src/main/kotlin/com/mineinabyss/idofront/config/ConfigEntryWithKey.kt

@@ -0,0 +1,9 @@
+package com.mineinabyss.idofront.config
+
+import java.nio.file.Path
+
+data class ConfigEntryWithKey<T>(
+    val path: Path,
+    val key: String,
+    val entry: T,
+)

idofront-config/src/main/kotlin/com/mineinabyss/idofront/config/ConfigFormats.kt

@@ -1,47 +1,18 @@
 package com.mineinabyss.idofront.config
 
-import com.charleskorn.kaml.*
+import com.charleskorn.kaml.Yaml
+import com.charleskorn.kaml.decodeFromStream
+import com.charleskorn.kaml.encodeToStream
 import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.SerializationStrategy
 import kotlinx.serialization.StringFormat
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.decodeFromStream
 import kotlinx.serialization.json.encodeToStream
-import kotlinx.serialization.modules.EmptySerializersModule
-import kotlinx.serialization.modules.SerializersModule
 import java.io.InputStream
 import java.io.OutputStream
 
-@Deprecated("Use new config api instead")
-open class ConfigFormats(
-    overrides: List<Format> = listOf(),
-    val serializersModule: SerializersModule = EmptySerializersModule(),
-) {
-    private val defaultFormats = listOf(
-        Format(
-            "yml", Yaml(
-                serializersModule = serializersModule,
-                YamlConfiguration(
-                    encodeDefaults = true,
-                    strictMode = false,
-                    sequenceBlockIndent = 2,
-                    singleLineStringStyle = SingleLineStringStyle.PlainExceptAmbiguous
-                )
-            )
-        ),
-        Format("json", Json {
-            encodeDefaults = true
-            ignoreUnknownKeys = true
-            prettyPrint = true
-            serializersModule = this@ConfigFormats.serializersModule
-        })
-    )
-
-    val extToFormat = defaultFormats.associateBy { it.ext }
-        .plus(overrides.associateBy { it.ext })
-
-    val formats = extToFormat.values.toList()
-
+internal object SerializationHelpers {
     fun <T> decode(format: StringFormat, serializer: DeserializationStrategy<T>, input: InputStream): T =
         when (format) {
             is Yaml -> format.decodeFromStream(serializer, input)

idofront-config/src/main/kotlin/com/mineinabyss/idofront/config/ConfigManager.kt

@@ -1,48 +1,10 @@
 package com.mineinabyss.idofront.config
 
-import com.charleskorn.kaml.Yaml
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.StringFormat
-import kotlinx.serialization.modules.SerializersModule
-import java.nio.file.Path
+import kotlinx.serialization.serializer
 
-inline fun <reified T> config(block: ConfigBuilder<T>.() -> Unit): ConfigManager<T> {
-    return TODO() //ConfigBuilder(serializer<T>(), format)
+/**
+ * Entrypoint for Idofront's config helpers.
+ */
+inline fun <reified T> config(block: ConfigBuilder<T>.() -> Unit = {}): Config<T> {
+    return ConfigBuilder(serializer<T>()).apply(block).build()
 }
-
-data class ConfigBuilder<T>(
-    var serializer: KSerializer<T>,
-    var format: StringFormat
-) {
-    var serializersModule: SerializersModule? = null
-}
-
-class ConfigManager<T> {
-    private val defaultPath: Path? = null
-
-    fun single(path: Path) {
-
-    }
-
-    fun directory(path: Path): List<ConfigEntry<T>> {
-        TODO()
-    }
-//    fun read(path: Path = defaultPath ?: error("No default path specified")): T = TODO()
-//
-//    fun write(value: T, path: Path = defaultPath ?: error("No default path specified")) {
-//
-//    }
-
-    fun readFromDirectory(path: Path): List<ConfigEntry<T>> = TODO()
-}
-
-data class ConfigEntry<T>(val path: Path, val data: T)
-
-data class Test(
-    val a: String
-)
-fun main() {
-    config<Test> {
-        format = Yaml.default
-    }.single(Path.of("test.yml"))
-}

idofront-config/src/main/kotlin/com/mineinabyss/idofront/config/DirectoryConfig.kt

@@ -0,0 +1,32 @@
+package com.mineinabyss.idofront.config
+
+import com.mineinabyss.idofront.messaging.idofrontLogger
+import java.nio.file.Path
+import kotlin.io.path.extension
+import kotlin.io.path.isRegularFile
+import kotlin.io.path.walk
+
+class DirectoryConfig<T>(
+    val config: Config<T>,
+    val directory: Path,
+    val extension: String,
+) {
+    fun read(): List<ConfigEntry<T>> = directory.walk()
+        .filter { it.isRegularFile() && it.extension == extension }
+        .mapNotNull { path ->
+            val decoded = config.decode(path)
+                .onFailure {
+                    idofrontLogger.e { "Failed to read config file at $path" }
+                    it.printStackTrace()
+                }
+                .getOrNull()
+            if (decoded != null) ConfigEntry<T>(path, decoded) else null
+        }
+        .toList()
+
+    fun readSingle(path: Path): T {
+        return SingleConfig(config, path).read()
+    }
+
+    fun writeSingle(data: T, path: Path) = SingleConfig(config, path).write(data)
+}