Refactor: LoadedConfiguration API

Rothes · Rothes · commit 1c15fd15f817 · 2025-11-20T16:56:59.000+08:00
diff --git a/bukkit/src/main/kotlin/io/github/rothes/esu/bukkit/module/SocialFilterModule.kt b/bukkit/src/main/kotlin/io/github/rothes/esu/bukkit/module/SocialFilterModule.kt
@@ -44,7 +44,7 @@ object SocialFilterModule: BukkitModule<BaseModuleConfiguration, SocialFilterMod
         super.onReload()
         filters = ConfigLoader.loadMulti(
             moduleFolder.resolve("filters"),
-            ConfigLoader.LoaderSettingsMulti<Filter>(
+            ConfigLoader.LoaderSettingsMulti(
                 initializeConfigs = listOf("example")
             )
         )
diff --git a/core/src/main/kotlin/io/github/rothes/esu/core/configuration/ConfigLoader.kt b/core/src/main/kotlin/io/github/rothes/esu/core/configuration/ConfigLoader.kt
diff --git a/core/src/main/kotlin/io/github/rothes/esu/core/configuration/LoadedConfiguration.kt b/core/src/main/kotlin/io/github/rothes/esu/core/configuration/LoadedConfiguration.kt
@@ -0,0 +1,49 @@
+package io.github.rothes.esu.core.configuration
+
+import io.github.rothes.esu.core.module.configuration.EmptyConfiguration
+import io.github.rothes.esu.lib.configurate.ConfigurationNode
+import io.github.rothes.esu.lib.configurate.yaml.YamlConfigurationLoader
+import java.nio.file.Path
+
+data class LoadedConfiguration(
+    val context: LoaderContext,
+    val path: Path,
+    val node: ConfigurationNode,
+    val resourceNode: ConfigurationNode?,
+) {
+
+    fun save() {
+        var root = node
+        while (node.parent() != null) {
+            root = root.parent()!!
+        }
+        context.loader.save(root)
+    }
+
+    fun <T> getAs(clazz: Class<T>): T {
+        if (context.mergeResources && resourceNode != null) {
+            node.mergeFrom(resourceNode)
+        }
+        if (clazz.isInstance(EmptyConfiguration)) return clazz.cast(EmptyConfiguration)
+        else if (clazz.isInstance(Unit)) return clazz.cast(Unit)
+
+        val instance = node.require(clazz)
+        node.set(instance)
+        return instance
+    }
+
+    fun node(vararg path: Any): LoadedConfiguration {
+        return LoadedConfiguration(
+            this.context,
+            this.path,
+            this.node.node(*path),
+            this.resourceNode?.node(*path),
+        )
+    }
+
+    data class LoaderContext(
+        val loader: YamlConfigurationLoader,
+        val mergeResources: Boolean,
+    )
+
+}
diff --git a/core/src/main/kotlin/io/github/rothes/esu/core/module/CommonFeature.kt b/core/src/main/kotlin/io/github/rothes/esu/core/module/CommonFeature.kt
@@ -23,9 +23,9 @@ abstract class CommonFeature<C, L> : Feature<C, L> {
         private set
     final override var parent: Feature<*, *>? = null
         private set
-    protected var internalModule: Module<*, *>? = null
+    private var _module: Module<*, *>? = null
     override val module: Module<*, *>
-        get() = internalModule ?: error("Feature $name is not attached to a module")
+        get() = _module ?: error("Feature $name is not attached to a module")
 
     final override val configClass: Class<C>
     final override val langClass: Class<L>
@@ -55,11 +55,13 @@ abstract class CommonFeature<C, L> : Feature<C, L> {
         langClass = actualTypeArguments[1].actualClass() as Class<L>
     }
 
-    private var configValue: C? = null
+    private var _config: C? = null
+    private var _lang: MultiLangConfiguration<L>? = null
 
     final override val config: C
-        get() = configValue ?: error("Config is not loaded for feature $name")
-    final override val lang: MultiLangConfiguration<L> = MultiLangConfiguration(mutableMapOf())
+        get() = _config ?: error("Config is not loaded for feature $name")
+    final override val lang: MultiLangConfiguration<L>
+        get() = _lang ?: error("Lang is not loaded for feature $name")
 
     override val permissionNode: String by lazy { (parent?.permissionNode ?: EsuCore.instance.basePermissionNode) + "." + name.lowercase() }
 
@@ -68,7 +70,11 @@ abstract class CommonFeature<C, L> : Feature<C, L> {
     }
 
     final override fun setConfigInstance(instance: C) {
-        configValue = instance
+        _config = instance
+    }
+
+    override fun setLangInstance(instance: MultiLangConfiguration<L>) {
+        _lang = instance
     }
 
     final override fun setEnabled(value: Boolean) {
@@ -85,7 +91,7 @@ abstract class CommonFeature<C, L> : Feature<C, L> {
         if (temp !is Module<*, *>) {
             temp = null
         }
-        internalModule = temp
+        _module = temp
     }
 
     protected val children = linkedMapOf<String, Feature<*, *>>()
diff --git a/core/src/main/kotlin/io/github/rothes/esu/core/module/CommonModule.kt b/core/src/main/kotlin/io/github/rothes/esu/core/module/CommonModule.kt
@@ -2,9 +2,11 @@ package io.github.rothes.esu.core.module
 
 import io.github.rothes.esu.core.EsuCore
 import io.github.rothes.esu.core.configuration.ConfigLoader
+import io.github.rothes.esu.core.configuration.ConfigLoader.forEachValue
+import io.github.rothes.esu.core.configuration.ConfigLoader.map
+import io.github.rothes.esu.core.configuration.LoadedConfiguration
+import io.github.rothes.esu.core.configuration.MultiConfiguration
 import io.github.rothes.esu.core.configuration.MultiLangConfiguration
-import io.github.rothes.esu.core.module.configuration.FeatureNodeMapper
-import io.github.rothes.esu.core.module.configuration.FeatureNodeMapper.Companion.nodeMapper
 import io.github.rothes.esu.core.module.configuration.FeatureToggle
 import io.github.rothes.esu.core.user.User
 import io.github.rothes.esu.lib.configurate.yaml.YamlConfigurationLoader
@@ -25,31 +27,7 @@ abstract class CommonModule<C, L> : CommonFeature<C, L>(), Module<C, L> {
     }
 
     override fun doReload() {
-        ConfigLoader.load(
-            configPath,
-            configClass,
-            ConfigLoader.LoaderSettings(
-                yamlLoader = { buildConfigLoader(it); it },
-                nodeMapper = nodeMapper(FeatureNodeMapper.TargetClass.CONFIG)
-            )
-        )
-        fun clearLang(feature: Feature<*, *>) {
-            val map = feature.lang.configs as MutableMap
-            map.clear()
-            for (feature in feature.getFeatures()) {
-                clearLang(feature)
-            }
-        }
-        clearLang(this)
-        ConfigLoader.loadMulti<MultiLangConfiguration<L>, L>(
-            langPath,
-            langClass,
-            ConfigLoader.LoaderSettingsMulti(
-                "en_us",
-                yamlLoader = { buildLangLoader(it); it },
-                nodeMapper = nodeMapper(FeatureNodeMapper.TargetClass.LANG)
-            )
-        )
+        ModuleConfigurationsLoader.load(this)
         super.doReload()
     }
 
@@ -67,4 +45,68 @@ abstract class CommonModule<C, L> : CommonFeature<C, L>(), Module<C, L> {
         return hasPermission(perm(shortPerm))
     }
 
+    private object ModuleConfigurationsLoader {
+
+        fun load(root: CommonModule<*, *>) {
+            with(root) {
+                val configNode = ConfigLoader.loadConfiguration(
+                    configPath,
+                    ConfigLoader.LoaderSettings(
+                        yamlLoader = { buildConfigLoader(it); it },
+                    ),
+                    configClass,
+                )
+                val langNodes = ConfigLoader.loadConfigurationMulti(
+                    langPath,
+                    MultiLangConfiguration::class.java,
+                    langClass,
+                    ConfigLoader.LoaderSettingsMulti(
+                        "en_us",
+                        yamlLoader = { buildLangLoader(it); it },
+                    )
+                )
+                loadConfig(root, configNode)
+                loadLang(root, langNodes)
+                configNode.save()
+                langNodes.forEachValue { it.save() }
+            }
+        }
+
+        fun <C, L> loadConfig(feature: Feature<C, L>, node: LoadedConfiguration) {
+            feature.setConfigInstance(node.getAs(feature.configClass))
+
+            feature.forEachChild { child, configPath ->
+                loadConfig(child, node.node(configPath))
+            }
+        }
+
+        fun <C, L> loadLang(feature: Feature<C, L>, nodes: MultiConfiguration<LoadedConfiguration>) {
+            feature.setLangInstance(nodes.map { node -> node.getAs(feature.langClass) })
+
+            feature.forEachChild { child, configPath ->
+                loadLang(child, nodes.map { node -> node.node(configPath) })
+            }
+        }
+
+        private fun Feature<*, *>.forEachChild(scope: (child: Feature<*, *>, configPath: String) -> Unit) {
+            for (child in getFeatures()) {
+                val name = child.name
+                val path = buildString(name.length + 4) {
+                    append(name.firstOrNull()?.lowercaseChar() ?: return@buildString)
+                    var i = 1
+                    while (i < name.length) {
+                        if (name[i].isUpperCase()) {
+                            append('-')
+                            append(name[i].lowercaseChar())
+                        } else {
+                            append(name[i])
+                        }
+                        i++
+                    }
+                }
+                scope(child, path)
+            }
+        }
+    }
+
 }
diff --git a/core/src/main/kotlin/io/github/rothes/esu/core/module/Feature.kt b/core/src/main/kotlin/io/github/rothes/esu/core/module/Feature.kt
@@ -23,6 +23,7 @@ interface Feature<C, L> {
     val permissionNode: String
 
     fun setConfigInstance(instance: C) {}
+    fun setLangInstance(instance: MultiLangConfiguration<L>) {}
     fun setEnabled(value: Boolean) {
         // Notify children
         for (feature in getFeatures().let { if (enabled) it else it.reversed() }) {
diff --git a/core/src/main/kotlin/io/github/rothes/esu/core/module/configuration/FeatureNodeMapper.kt b/core/src/main/kotlin/io/github/rothes/esu/core/module/configuration/FeatureNodeMapper.kt

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ object SocialFilterModule: BukkitModule<BaseModuleConfiguration, SocialFilterMod`
`44`	`44`	`super.onReload()`
`45`	`45`	`filters = ConfigLoader.loadMulti(`
`46`	`46`	`moduleFolder.resolve("filters"),`
`47`		`- ConfigLoader.LoaderSettingsMulti<Filter>(`
	`47`	`+ ConfigLoader.LoaderSettingsMulti(`
`48`	`48`	`initializeConfigs = listOf("example")`
`49`	`49`	`)`
`50`	`50`	`)`