From a9fbf6c0bd62bb5bb8424f6938e4751843f49e79 Mon Sep 17 00:00:00 2001 From: TheBjoRedCraft Date: Sat, 6 Dec 2025 21:20:32 +0100 Subject: [PATCH 01/12] feat: add YmlConfigWrapper for managing YAML configuration files --- .../core/api/config/YmlConfigWrapper.kt | 93 +++++++++++++++++++ surf-api-gradle-plugin/build.gradle.kts | 2 +- 2 files changed, 94 insertions(+), 1 deletion(-) create mode 100644 surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt new file mode 100644 index 000000000..258f8f8a3 --- /dev/null +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt @@ -0,0 +1,93 @@ +package dev.slne.surf.surfapi.core.api.config + +import dev.slne.surf.surfapi.core.api.config.manager.SpongeConfigManager +import java.nio.file.Path +import kotlin.reflect.KClass + +/** + * Wraps a configuration file in YAML format to provide convenient access and modifications via a configuration class. + * Automatically manages the creation, loading, and saving of the configuration through a `SpongeConfigManager`. + * + * @param T The type of the configuration class. + * @param clazz The class of the configuration. + * @param configFolder The folder where the configuration file is located. + * @param fileName The name of the configuration file in YAML format. + * + * Use in your main: val myConfig = surfConfigApi.createYmlConfig(configFolderPath) + */ +class YmlConfigWrapper( + private val clazz: KClass, + private val configFolder: Path, + private val fileName: String +) { + /** + * Manages the configuration of type [T] through a Sponge-based configuration manager. + * Handles loading, saving, and reloading of the configuration using the specified file and folder structure. + * The configuration manager ensures that operations such as edits or reloads are applied to the configuration instance. + * + * @see SpongeConfigManager + */ + private val configManager: SpongeConfigManager + + init { + surfConfigApi.createSpongeYmlConfig(clazz.java, configFolder, fileName) + configManager = surfConfigApi.getSpongeConfigManagerForConfig(clazz.java) + reload() + } + + /** + * Reloads the configuration by delegating the operation to the underlying configuration manager. + * + * This method ensures that the configuration is reloaded from the associated file, + * updating the current in-memory representation of the configuration. If a critical error + * occurs during the reload process, it propagates the exception thrown by the configuration manager. + * + * Recommended to be used when changes to the underlying configuration file have been made and + * need to be reflected within the application. + * + * @throws RuntimeException if a critical error occurs during the reload operation. + */ + fun reload() { + configManager.reloadFromFile() + } + + /** + * Edits the configuration by applying the given block of modifications. + * Optionally saves the changes to the configuration file. + * + * @param save Indicates whether the updated configuration should be saved to the file. + * Defaults to `true`, meaning the changes will be persisted. + * @param block A lambda function defining the modifications to be applied to the configuration object. + */ + fun edit(save: Boolean = true, block: T.() -> Unit) { + val config = config + config.block() + + if (save) { + configManager.save() + } + } + + /** + * Provides access to the configuration object managed by the `SpongeConfigManager`. + * This property retrieves the current state of the configuration. + * + * @return The configuration data of type [T]. + */ + val config: T get() = configManager.config +} + +/** + * Creates a YAML configuration wrapper for a specified configuration class. + * + * @param C The type of the configuration class. + * @param configFolder The folder where the configuration file will be stored. + * @param fileName The name of the configuration file, defaulting to "config.yml". + * @return A `YmlConfigWrapper` instance for managing the YAML configuration of type [C]. + */ +inline fun SurfConfigApi.createYmlConfig( + configFolder: Path, + fileName: String = "config.yml" +): YmlConfigWrapper { + return YmlConfigWrapper(C::class, configFolder, fileName) +} \ No newline at end of file diff --git a/surf-api-gradle-plugin/build.gradle.kts b/surf-api-gradle-plugin/build.gradle.kts index 038a684ee..d01c64ea6 100644 --- a/surf-api-gradle-plugin/build.gradle.kts +++ b/surf-api-gradle-plugin/build.gradle.kts @@ -20,7 +20,7 @@ plugins { group = groupId version = buildString { append(mcVersion) - append("-1.6.4") + append("-1.6.5") if (snapshot) append("-SNAPSHOT") } From a2c60247866f0898f834be9cad6464d678f19281 Mon Sep 17 00:00:00 2001 From: TheBjoRedCraft <143264463+TheBjoRedCraft@users.noreply.github.com> Date: Sat, 6 Dec 2025 21:26:52 +0100 Subject: [PATCH 02/12] Update surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .../dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt | 1 - 1 file changed, 1 deletion(-) diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt index 258f8f8a3..7022ce216 100644 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt @@ -60,7 +60,6 @@ class YmlConfigWrapper( * @param block A lambda function defining the modifications to be applied to the configuration object. */ fun edit(save: Boolean = true, block: T.() -> Unit) { - val config = config config.block() if (save) { From 19911ab36394e2431dbe52cebfc04c3b10585918 Mon Sep 17 00:00:00 2001 From: TheBjoRedCraft <143264463+TheBjoRedCraft@users.noreply.github.com> Date: Sat, 6 Dec 2025 21:27:57 +0100 Subject: [PATCH 03/12] Update surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .../slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt index 7022ce216..8f650cd3a 100644 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt @@ -13,7 +13,12 @@ import kotlin.reflect.KClass * @param configFolder The folder where the configuration file is located. * @param fileName The name of the configuration file in YAML format. * - * Use in your main: val myConfig = surfConfigApi.createYmlConfig(configFolderPath) + * Example usage: + * ``` + * import dev.slne.surf.surfapi.core.api.config.surfConfigApi + * + * val myConfig = surfConfigApi.createYmlConfig(configFolderPath) + * ``` */ class YmlConfigWrapper( private val clazz: KClass, From 0ec350355785983a4f0575d521d4f6e35c975853 Mon Sep 17 00:00:00 2001 From: TheBjoRedCraft Date: Sat, 6 Dec 2025 21:28:42 +0100 Subject: [PATCH 04/12] feat: enforce YAML file name pattern in YmlConfigWrapper --- .../dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt index 258f8f8a3..451eda9a7 100644 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt @@ -18,7 +18,7 @@ import kotlin.reflect.KClass class YmlConfigWrapper( private val clazz: KClass, private val configFolder: Path, - private val fileName: String + private val fileName: @YamlConfigFileNamePattern String ) { /** * Manages the configuration of type [T] through a Sponge-based configuration manager. @@ -87,7 +87,7 @@ class YmlConfigWrapper( */ inline fun SurfConfigApi.createYmlConfig( configFolder: Path, - fileName: String = "config.yml" + fileName: @YamlConfigFileNamePattern String = "config.yml" ): YmlConfigWrapper { return YmlConfigWrapper(C::class, configFolder, fileName) } \ No newline at end of file From 679b6f1255b0e3d2db4012e5d4457d1da4d07fba Mon Sep 17 00:00:00 2001 From: TheBjoRedCraft Date: Sat, 6 Dec 2025 21:37:45 +0100 Subject: [PATCH 05/12] fix: update code block syntax in YmlConfigWrapper documentation --- .../dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt index 2cf7847c0..0962d741d 100644 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt @@ -14,7 +14,7 @@ import kotlin.reflect.KClass * @param fileName The name of the configuration file in YAML format. * * Example usage: - * ``` + * ```kotlin * import dev.slne.surf.surfapi.core.api.config.surfConfigApi * * val myConfig = surfConfigApi.createYmlConfig(configFolderPath) From 9078904e754e478f5bef1315df7d9854a6167c0d Mon Sep 17 00:00:00 2001 From: twisti Date: Wed, 10 Dec 2025 12:02:59 +0100 Subject: [PATCH 06/12] fix: downgrade version to 1.6.4 in build.gradle.kts --- surf-api-gradle-plugin/build.gradle.kts | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/surf-api-gradle-plugin/build.gradle.kts b/surf-api-gradle-plugin/build.gradle.kts index d01c64ea6..a014a3f19 100644 --- a/surf-api-gradle-plugin/build.gradle.kts +++ b/surf-api-gradle-plugin/build.gradle.kts @@ -1,3 +1,6 @@ +import gradle.kotlin.dsl.accessors._243eb5039d4da502111cc46640837e78.compileOnly +import gradle.kotlin.dsl.accessors._243eb5039d4da502111cc46640837e78.implementation +import gradle.kotlin.dsl.accessors._243eb5039d4da502111cc46640837e78.sourceSets import java.nio.file.Files // region properties @@ -20,7 +23,7 @@ plugins { group = groupId version = buildString { append(mcVersion) - append("-1.6.5") + append("-1.6.4") if (snapshot) append("-SNAPSHOT") } From d092db0ccd6c8900f550a85e41405c3fd568a35f Mon Sep 17 00:00:00 2001 From: twisti Date: Wed, 10 Dec 2025 15:00:16 +0100 Subject: [PATCH 07/12] feat: add Sponge YAML and JSON configuration manager creation methods --- .../surfapi/core/api/config/SurfConfigApi.kt | 56 +++++++++++++++++++ .../api/config/manager/SpongeConfigManager.kt | 16 +++++- .../core/server/config/SpongeConfigTracker.kt | 9 ++- .../core/server/config/SurfConfigApiImpl.kt | 28 ++++++++-- 4 files changed, 97 insertions(+), 12 deletions(-) diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SurfConfigApi.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SurfConfigApi.kt index f7de1edbb..18300e47a 100644 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SurfConfigApi.kt +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SurfConfigApi.kt @@ -62,6 +62,21 @@ interface SurfConfigApi { configFileName: @YamlConfigFileNamePattern String, ): C + /** + * Creates a Sponge YAML configuration manager. + * + * @param C The type of the configuration class. + * @param configClass The class of the configuration. + * @param configFolder The folder where the configuration file is stored. + * @param configFileName The name of the configuration file. Must follow the YAML file name pattern. + * @return An instance of [SpongeConfigManager] for the configuration class [C]. + */ + fun createSpongeYmlConfigManager( + configClass: Class, + configFolder: Path, + configFileName: @YamlConfigFileNamePattern String, + ): SpongeConfigManager + /** * Creates a Sponge JSON configuration file. * @@ -77,6 +92,21 @@ interface SurfConfigApi { configFileName: @JsonConfigFileNamePattern String, ): C + /** + * Creates a Sponge JSON configuration manager. + * + * @param C The type of the configuration class. + * @param configClass The class of the configuration. + * @param configFolder The folder where the configuration file is stored. + * @param configFileName The name of the configuration file. Must follow the JSON file name pattern. + * @return An instance of [SpongeConfigManager] for the configuration class [C]. + */ + fun createSpongeJsonConfigManager( + configClass: Class, + configFolder: Path, + configFileName: @JsonConfigFileNamePattern String, + ): SpongeConfigManager + /** * Retrieves a Sponge configuration. * @@ -162,6 +192,19 @@ inline fun SurfConfigApi.createSpongeYmlConfig( configFileName: @YamlConfigFileNamePattern String, ) = createSpongeYmlConfig(C::class.java, configFolder, configFileName) +/** + * Creates a Sponge YAML configuration manager using a reified type. + * + * @param C The type of the configuration class. + * @param configFolder The folder where the configuration file is stored. + * @param configFileName The name of the configuration file. Must follow the YAML file name pattern. + * @return An instance of [SpongeConfigManager] for the configuration class [C]. + */ +inline fun SurfConfigApi.createSpongeYmlConfigManager( + configFolder: Path, + configFileName: @YamlConfigFileNamePattern String, +) = createSpongeYmlConfigManager(C::class.java, configFolder, configFileName) + /** * Creates a Sponge JSON configuration using a reified type. * @@ -175,6 +218,19 @@ inline fun SurfConfigApi.createSpongeJsonConfig( configFileName: @JsonConfigFileNamePattern String, ) = createSpongeJsonConfig(C::class.java, configFolder, configFileName) +/** + * Creates a Sponge JSON configuration manager using a reified type. + * + * @param C The type of the configuration class. + * @param configFolder The folder where the configuration file is stored. + * @param configFileName The name of the configuration file. Must follow the JSON file name pattern. + * @return An instance of [SpongeConfigManager] for the configuration class [C]. + */ +inline fun SurfConfigApi.createSpongeJsonConfigManager( + configFolder: Path, + configFileName: @JsonConfigFileNamePattern String, +) = createSpongeJsonConfigManager(C::class.java, configFolder, configFileName) + /** * Retrieves a Sponge configuration using a reified type. * diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager.kt index a9fd123f2..f384fd2ec 100644 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager.kt +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager.kt @@ -78,6 +78,19 @@ class SpongeConfigManager @Contract(pure = true) private constructor( } } + /** + * Allows editing the configuration by applying changes within the provided block. + * Optionally saves the changes to the configuration file after applying the modifications. + * + * @param save Indicates whether the configuration should be saved after applying changes. Defaults to `true`. + * @param block A lambda with receiver scope of the configuration type to apply modifications. + */ + inline fun edit(save: Boolean = true, block: C.() -> Unit) { + config.block() + if (save) { + save() + } + } companion object { @@ -141,7 +154,8 @@ class SpongeConfigManager @Contract(pure = true) private constructor( try { val node: ScopedConfigurationNode<*> = loader.load() - val config = node.get(configClass) ?: throw LoadConfigException("Config is null after load") + val config = + node.get(configClass) ?: throw LoadConfigException("Config is null after load") loader.save(node) node.set(configClass, config) diff --git a/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SpongeConfigTracker.kt b/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SpongeConfigTracker.kt index a195aed6c..b81777ad3 100644 --- a/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SpongeConfigTracker.kt +++ b/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SpongeConfigTracker.kt @@ -1,12 +1,10 @@ package dev.slne.surf.surfapi.core.server.config import dev.slne.surf.surfapi.core.api.config.manager.SpongeConfigManager -import dev.slne.surf.surfapi.core.api.util.mutableObject2ObjectMapOf -import dev.slne.surf.surfapi.core.api.util.synchronize +import java.util.concurrent.ConcurrentHashMap object SpongeConfigTracker { - private val configManagers = - mutableObject2ObjectMapOf, SpongeConfigManager<*>>().synchronize() + private val configManagers = ConcurrentHashMap, SpongeConfigManager<*>>() fun getConfig(configClass: Class): C? { return configManagers[configClass]?.config as? C @@ -24,5 +22,6 @@ object SpongeConfigTracker { } @Suppress("UNCHECKED_CAST") - fun getConfigManager(configClass: Class) = configManagers[configClass] as? SpongeConfigManager + fun getConfigManager(configClass: Class) = + configManagers[configClass] as? SpongeConfigManager } \ No newline at end of file diff --git a/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SurfConfigApiImpl.kt b/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SurfConfigApiImpl.kt index b063c93a5..deec1cf57 100644 --- a/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SurfConfigApiImpl.kt +++ b/surf-api-core/surf-api-core-server/src/main/kotlin/dev/slne/surf/surfapi/core/server/config/SurfConfigApiImpl.kt @@ -34,26 +34,42 @@ class SurfConfigApiImpl : SurfConfigApi { override fun reloadDazzlConfig(configClass: Class): C = DazzlConfConfigTracker.reloadConfig(configClass) - override fun createSpongeYmlConfig( + override fun createSpongeYmlConfigManager( configClass: Class, configFolder: Path, configFileName: @YamlConfigFileNamePattern String - ): C { + ): SpongeConfigManager { val manager = SpongeConfigManager.yaml(configClass, configFolder, configFileName) SpongeConfigTracker.registerConfig(configClass, manager) - return manager.config + return manager } - override fun createSpongeJsonConfig( + override fun createSpongeJsonConfigManager( configClass: Class, configFolder: Path, configFileName: @JsonConfigFileNamePattern String - ): C { + ): SpongeConfigManager { val manager = SpongeConfigManager.json(configClass, configFolder, configFileName) SpongeConfigTracker.registerConfig(configClass, manager) - return manager.config + return manager + } + + override fun createSpongeYmlConfig( + configClass: Class, + configFolder: Path, + configFileName: @YamlConfigFileNamePattern String + ): C { + return createSpongeYmlConfigManager(configClass, configFolder, configFileName).config + } + + override fun createSpongeJsonConfig( + configClass: Class, + configFolder: Path, + configFileName: @JsonConfigFileNamePattern String + ): C { + return createSpongeJsonConfigManager(configClass, configFolder, configFileName).config } override fun getSpongeConfig(configClass: Class): C = From 8c1506f6b9325c6ff63a7b757ef417bca739b07b Mon Sep 17 00:00:00 2001 From: twisti Date: Wed, 10 Dec 2025 15:17:42 +0100 Subject: [PATCH 08/12] feat: add base classes for YAML and JSON Sponge configuration management --- .../core/api/config/SpongeConfigClass.kt | 95 +++++++++++++++++++ .../core/api/config/SpongeJsonConfigClass.kt | 35 +++++++ .../core/api/config/SpongeYmlConfigClass.kt | 35 +++++++ surf-api-gradle-plugin/build.gradle.kts | 3 - 4 files changed, 165 insertions(+), 3 deletions(-) create mode 100644 surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeConfigClass.kt create mode 100644 surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass.kt create mode 100644 surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass.kt diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeConfigClass.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeConfigClass.kt new file mode 100644 index 000000000..02db138ab --- /dev/null +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeConfigClass.kt @@ -0,0 +1,95 @@ +package dev.slne.surf.surfapi.core.api.config + +import dev.slne.surf.surfapi.core.api.config.manager.SpongeConfigManager +import java.nio.file.Path + +/** + * Base convenience wrapper around a [SpongeConfigManager] for a specific config type [C]. + * + * This class is intended to be extended by companion objects of config data classes. + * It provides a simple, type-safe API to: + * - access the current config instance via [getConfig] + * - persist changes via [save] + * - reload the config from disk via [reloadFromFile] + * - perform in-place mutations via [edit] + * + * The actual manager instance is provided by subclasses and typically created by + * a central configuration API (e.g. [surfConfigApi]). + * + * @param C the type of the configuration data object. + * @param configClass the Java class of [C], used by underlying config frameworks + * to create and map configuration instances. + */ +sealed class SpongeConfigClass(configClass: Class) { + /** + * Folder where the configuration file is stored. + * + * Implementations should point this to a plugin- or module-specific config directory. + */ + protected abstract val configFolder: Path + + /** + * The name of the configuration file, including its extension + * (for example `settings.yml` or `settings.json`). + */ + protected abstract val fileName: String + + /** + * The underlying configuration manager responsible for loading, saving, + * and tracking the config instance of type [C]. + */ + abstract val manager: SpongeConfigManager + + /** + * Persists the current configuration to disk. + * + * Delegates to [SpongeConfigManager.save]. + */ + fun save() = manager.save() + + /** + * Reloads the configuration from disk and replaces the current in-memory instance. + * + * Delegates to [SpongeConfigManager.reloadFromFile]. + * Use this when external changes to the config file should be picked up at runtime. + */ + fun reloadFromFile() = manager.reloadFromFile() + + /** + * Applies mutations to the current config instance in a safe way. + * + * The [block] receives the current config instance as receiver and can freely + * modify its properties. After the block completes, the config will be saved + * automatically if [save] is `true`. + * + * Example: + * ```kotlin + * MyConfig.edit { + * someField = "new value" + * } + * ``` + * + * @param save whether to persist the config to disk after applying [block]. Defaults to `true`. + * @param block mutation block executed on the current config instance. + */ + inline fun edit(save: Boolean = true, block: C.() -> Unit) = manager.edit(save, block) + + /** + * Returns the current in-memory configuration instance. + * + * The returned object is managed by the underlying [SpongeConfigManager] and + * will be replaced when [reloadFromFile] is called. + */ + fun getConfig(): C = manager.config + + /** + * Dummy initializer to force class loading and companion object initialization. + * + * This is useful in plugin entry points (e.g. `onLoad`) to ensure that: + * - the config manager is constructed + * - the configuration is loaded before first access via [getConfig] + * + * This method is a no-op and can be safely called multiple times. + */ + fun init() = Unit +} \ No newline at end of file diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass.kt new file mode 100644 index 000000000..b5cff1892 --- /dev/null +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass.kt @@ -0,0 +1,35 @@ +package dev.slne.surf.surfapi.core.api.config + +/** + * Convenience base class for JSON-backed Sponge configuration classes. + * + * This class wires the common configuration metadata ([configFolder], [fileName]) + * to a JSON-based [dev.slne.surf.surfapi.core.api.config.manager.SpongeConfigManager] instance created by [surfConfigApi]. + * + * Typical usage is via a companion object on a `@ConfigSerializable` data class: + * ```kotlin + * @ConfigSerializable + * data class MyJsonConfig( + * var someField: String = "value" + * ) { + * companion object : SpongeJsonConfigClass(MyJsonConfig::class.java) { + * override val configFolder = Path("config/my-plugin") + * override val fileName = "my-config.json" + * } + * } + * ``` + * + * @param C the type of the configuration data object. + * @param configClass the Java class of [C], used by the underlying config framework. + */ +abstract class SpongeJsonConfigClass(configClass: Class) : SpongeConfigClass(configClass) { + + /** + * JSON-backed configuration manager for this config type. + * + * The manager is created using [SurfConfigApi.createSpongeJsonConfigManager] + * with [configClass], [configFolder] and [fileName]. + */ + override val manager = + surfConfigApi.createSpongeJsonConfigManager(configClass, configFolder, fileName) +} \ No newline at end of file diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass.kt new file mode 100644 index 000000000..658b55823 --- /dev/null +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass.kt @@ -0,0 +1,35 @@ +package dev.slne.surf.surfapi.core.api.config + +/** + * Convenience base class for YAML-backed Sponge configuration classes. + * + * This class wires the common configuration metadata ([configFolder], [fileName]) + * to a YAML-based [dev.slne.surf.surfapi.core.api.config.manager.SpongeConfigManager] instance created by [surfConfigApi]. + * + * Typical usage is via a companion object on a `@ConfigSerializable` data class: + * ```kotlin + * @ConfigSerializable + * data class MyConfig( + * var someField: String = "value" + * ) { + * companion object : SpongeYmlConfigClass(MyConfig::class.java) { + * override val configFolder = Path("config/my-plugin") + * override val fileName = "my-config.yml" + * } + * } + * ``` + * + * @param C the type of the configuration data object. + * @param configClass the Java class of [C], used by the underlying config framework. + */ +abstract class SpongeYmlConfigClass(configClass: Class) : SpongeConfigClass(configClass) { + + /** + * YAML-backed configuration manager for this config type. + * + * The manager is created using [SurfConfigApi.createSpongeYmlConfigManager] + * with [configClass], [configFolder] and [fileName]. + */ + override val manager = + surfConfigApi.createSpongeYmlConfigManager(configClass, configFolder, fileName) +} \ No newline at end of file diff --git a/surf-api-gradle-plugin/build.gradle.kts b/surf-api-gradle-plugin/build.gradle.kts index a014a3f19..038a684ee 100644 --- a/surf-api-gradle-plugin/build.gradle.kts +++ b/surf-api-gradle-plugin/build.gradle.kts @@ -1,6 +1,3 @@ -import gradle.kotlin.dsl.accessors._243eb5039d4da502111cc46640837e78.compileOnly -import gradle.kotlin.dsl.accessors._243eb5039d4da502111cc46640837e78.implementation -import gradle.kotlin.dsl.accessors._243eb5039d4da502111cc46640837e78.sourceSets import java.nio.file.Files // region properties From e099e7784ebd209482c94ce30f535cd7dce5768d Mon Sep 17 00:00:00 2001 From: twisti Date: Wed, 10 Dec 2025 15:18:15 +0100 Subject: [PATCH 09/12] refactor: remove `YmlConfigWrapper` and associated creation method - Removed `YmlConfigWrapper` class, including its constructor and methods for YAML configuration handling. - Deleted `createYmlConfig` extension function from `SurfConfigApi`. --- .../core/api/config/YmlConfigWrapper.kt | 97 ------------------- 1 file changed, 97 deletions(-) delete mode 100644 surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt deleted file mode 100644 index 0962d741d..000000000 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/YmlConfigWrapper.kt +++ /dev/null @@ -1,97 +0,0 @@ -package dev.slne.surf.surfapi.core.api.config - -import dev.slne.surf.surfapi.core.api.config.manager.SpongeConfigManager -import java.nio.file.Path -import kotlin.reflect.KClass - -/** - * Wraps a configuration file in YAML format to provide convenient access and modifications via a configuration class. - * Automatically manages the creation, loading, and saving of the configuration through a `SpongeConfigManager`. - * - * @param T The type of the configuration class. - * @param clazz The class of the configuration. - * @param configFolder The folder where the configuration file is located. - * @param fileName The name of the configuration file in YAML format. - * - * Example usage: - * ```kotlin - * import dev.slne.surf.surfapi.core.api.config.surfConfigApi - * - * val myConfig = surfConfigApi.createYmlConfig(configFolderPath) - * ``` - */ -class YmlConfigWrapper( - private val clazz: KClass, - private val configFolder: Path, - private val fileName: @YamlConfigFileNamePattern String -) { - /** - * Manages the configuration of type [T] through a Sponge-based configuration manager. - * Handles loading, saving, and reloading of the configuration using the specified file and folder structure. - * The configuration manager ensures that operations such as edits or reloads are applied to the configuration instance. - * - * @see SpongeConfigManager - */ - private val configManager: SpongeConfigManager - - init { - surfConfigApi.createSpongeYmlConfig(clazz.java, configFolder, fileName) - configManager = surfConfigApi.getSpongeConfigManagerForConfig(clazz.java) - reload() - } - - /** - * Reloads the configuration by delegating the operation to the underlying configuration manager. - * - * This method ensures that the configuration is reloaded from the associated file, - * updating the current in-memory representation of the configuration. If a critical error - * occurs during the reload process, it propagates the exception thrown by the configuration manager. - * - * Recommended to be used when changes to the underlying configuration file have been made and - * need to be reflected within the application. - * - * @throws RuntimeException if a critical error occurs during the reload operation. - */ - fun reload() { - configManager.reloadFromFile() - } - - /** - * Edits the configuration by applying the given block of modifications. - * Optionally saves the changes to the configuration file. - * - * @param save Indicates whether the updated configuration should be saved to the file. - * Defaults to `true`, meaning the changes will be persisted. - * @param block A lambda function defining the modifications to be applied to the configuration object. - */ - fun edit(save: Boolean = true, block: T.() -> Unit) { - config.block() - - if (save) { - configManager.save() - } - } - - /** - * Provides access to the configuration object managed by the `SpongeConfigManager`. - * This property retrieves the current state of the configuration. - * - * @return The configuration data of type [T]. - */ - val config: T get() = configManager.config -} - -/** - * Creates a YAML configuration wrapper for a specified configuration class. - * - * @param C The type of the configuration class. - * @param configFolder The folder where the configuration file will be stored. - * @param fileName The name of the configuration file, defaulting to "config.yml". - * @return A `YmlConfigWrapper` instance for managing the YAML configuration of type [C]. - */ -inline fun SurfConfigApi.createYmlConfig( - configFolder: Path, - fileName: @YamlConfigFileNamePattern String = "config.yml" -): YmlConfigWrapper { - return YmlConfigWrapper(C::class, configFolder, fileName) -} \ No newline at end of file From c7f04d8a95385f4faaaf9bd907b2244f6dec5605 Mon Sep 17 00:00:00 2001 From: twisti Date: Wed, 10 Dec 2025 15:19:08 +0100 Subject: [PATCH 10/12] fix: bump version to 1.21.10-2.43.0 in gradle.properties --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index acfa0f5bc..4dc5bdf62 100644 --- a/gradle.properties +++ b/gradle.properties @@ -7,6 +7,6 @@ org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled javaVersion=21 mcVersion=1.21.10 group=dev.slne.surf -version=1.21.10-2.42.4 +version=1.21.10-2.43.0 relocationPrefix=dev.slne.surf.surfapi.libs snapshot=false \ No newline at end of file From 83b47b139f1931db2ce180e4510959dc59580e72 Mon Sep 17 00:00:00 2001 From: twisti Date: Wed, 10 Dec 2025 15:20:05 +0100 Subject: [PATCH 11/12] chore: dump api --- .../api/surf-api-bukkit-api.api | 27 +++++++++++++++++++ .../api/surf-api-core-api.api | 27 +++++++++++++++++++ .../api/surf-api-velocity-api.api | 27 +++++++++++++++++++ 3 files changed, 81 insertions(+) diff --git a/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api b/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api index fdb8a7e71..2fa440a87 100644 --- a/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api +++ b/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api @@ -5974,11 +5974,36 @@ public final class dev/slne/surf/surfapi/core/api/command/exception/WrapperComma public abstract interface annotation class dev/slne/surf/surfapi/core/api/config/JsonConfigFileNamePattern : java/lang/annotation/Annotation { } +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public synthetic fun (Ljava/lang/Class;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/SpongeConfigClass;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V + public final fun getConfig ()Ljava/lang/Object; + protected abstract fun getConfigFolder ()Ljava/nio/file/Path; + protected abstract fun getFileName ()Ljava/lang/String; + public abstract fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; + public final fun init ()V + public final fun reloadFromFile ()Ljava/lang/Object; + public final fun save ()V +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + public abstract interface class dev/slne/surf/surfapi/core/api/config/SurfConfigApi { public static final field Companion Ldev/slne/surf/surfapi/core/api/config/SurfConfigApi$Companion; public abstract fun createDazzlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; public abstract fun createSpongeJsonConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeJsonConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun createSpongeYmlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeYmlConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun getDazzlConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfigManagerForConfig (Ljava/lang/Class;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; @@ -6034,6 +6059,8 @@ public final class dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigMan public static final field Companion Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager$Companion; public field config Ljava/lang/Object; public synthetic fun (Ljava/lang/Class;Ljava/lang/Object;Lorg/spongepowered/configurate/loader/ConfigurationLoader;Lorg/spongepowered/configurate/ConfigurationNode;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public final fun reloadFromFile ()Ljava/lang/Object; public final fun save ()V } diff --git a/surf-api-core/surf-api-core-api/api/surf-api-core-api.api b/surf-api-core/surf-api-core-api/api/surf-api-core-api.api index f1450ef07..066ef3729 100644 --- a/surf-api-core/surf-api-core-api/api/surf-api-core-api.api +++ b/surf-api-core/surf-api-core-api/api/surf-api-core-api.api @@ -601,11 +601,36 @@ public final class dev/slne/surf/surfapi/core/api/command/exception/WrapperComma public abstract interface annotation class dev/slne/surf/surfapi/core/api/config/JsonConfigFileNamePattern : java/lang/annotation/Annotation { } +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public synthetic fun (Ljava/lang/Class;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/SpongeConfigClass;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V + public final fun getConfig ()Ljava/lang/Object; + protected abstract fun getConfigFolder ()Ljava/nio/file/Path; + protected abstract fun getFileName ()Ljava/lang/String; + public abstract fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; + public final fun init ()V + public final fun reloadFromFile ()Ljava/lang/Object; + public final fun save ()V +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + public abstract interface class dev/slne/surf/surfapi/core/api/config/SurfConfigApi { public static final field Companion Ldev/slne/surf/surfapi/core/api/config/SurfConfigApi$Companion; public abstract fun createDazzlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; public abstract fun createSpongeJsonConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeJsonConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun createSpongeYmlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeYmlConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun getDazzlConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfigManagerForConfig (Ljava/lang/Class;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; @@ -661,6 +686,8 @@ public final class dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigMan public static final field Companion Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager$Companion; public field config Ljava/lang/Object; public synthetic fun (Ljava/lang/Class;Ljava/lang/Object;Lorg/spongepowered/configurate/loader/ConfigurationLoader;Lorg/spongepowered/configurate/ConfigurationNode;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public final fun reloadFromFile ()Ljava/lang/Object; public final fun save ()V } diff --git a/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api b/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api index d630db1d7..a65f3e724 100644 --- a/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api +++ b/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api @@ -3907,11 +3907,36 @@ public final class dev/slne/surf/surfapi/core/api/command/exception/WrapperComma public abstract interface annotation class dev/slne/surf/surfapi/core/api/config/JsonConfigFileNamePattern : java/lang/annotation/Annotation { } +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public synthetic fun (Ljava/lang/Class;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/SpongeConfigClass;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V + public final fun getConfig ()Ljava/lang/Object; + protected abstract fun getConfigFolder ()Ljava/nio/file/Path; + protected abstract fun getFileName ()Ljava/lang/String; + public abstract fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; + public final fun init ()V + public final fun reloadFromFile ()Ljava/lang/Object; + public final fun save ()V +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + +public abstract class dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { + public fun (Ljava/lang/Class;)V + public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; +} + public abstract interface class dev/slne/surf/surfapi/core/api/config/SurfConfigApi { public static final field Companion Ldev/slne/surf/surfapi/core/api/config/SurfConfigApi$Companion; public abstract fun createDazzlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; public abstract fun createSpongeJsonConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeJsonConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun createSpongeYmlConfig (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ljava/lang/Object; + public abstract fun createSpongeYmlConfigManager (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public abstract fun getDazzlConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfig (Ljava/lang/Class;)Ljava/lang/Object; public abstract fun getSpongeConfigManagerForConfig (Ljava/lang/Class;)Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; @@ -3967,6 +3992,8 @@ public final class dev/slne/surf/surfapi/core/api/config/manager/SpongeConfigMan public static final field Companion Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager$Companion; public field config Ljava/lang/Object; public synthetic fun (Ljava/lang/Class;Ljava/lang/Object;Lorg/spongepowered/configurate/loader/ConfigurationLoader;Lorg/spongepowered/configurate/ConfigurationNode;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun edit (ZLkotlin/jvm/functions/Function1;)V + public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public final fun reloadFromFile ()Ljava/lang/Object; public final fun save ()V } From 65d54d1bf6e1676c31ec9e15ae4836be03979b88 Mon Sep 17 00:00:00 2001 From: twisti Date: Wed, 10 Dec 2025 15:31:22 +0100 Subject: [PATCH 12/12] feat: refactor Sponge configuration classes and add ModernTestConfig example - Updated `SpongeYmlConfigClass` and `SpongeJsonConfigClass` constructors to accept `configFolder` and `fileName` as parameters. - Adjusted `SpongeConfigClass` to make `configFolder` and `fileName` non-abstract. - Added new `ModernTestConfig` class with example usage and randomization functionality. --- .../api/surf-api-bukkit-api.api | 10 ++++---- .../surfapi/bukkit/test/BukkitPluginMain.java | 4 ++++ .../bukkit/test/config/ModernTestConfig.kt | 24 +++++++++++++++++++ .../api/surf-api-core-api.api | 10 ++++---- .../core/api/config/SpongeConfigClass.kt | 9 +++---- .../core/api/config/SpongeJsonConfigClass.kt | 14 +++++++---- .../core/api/config/SpongeYmlConfigClass.kt | 14 +++++++---- .../api/surf-api-velocity-api.api | 10 ++++---- 8 files changed, 68 insertions(+), 27 deletions(-) create mode 100644 surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/kotlin/dev/slne/surf/surfapi/bukkit/test/config/ModernTestConfig.kt diff --git a/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api b/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api index 2fa440a87..981d4ce1a 100644 --- a/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api +++ b/surf-api-bukkit/surf-api-bukkit-api/api/surf-api-bukkit-api.api @@ -5975,12 +5975,12 @@ public abstract interface annotation class dev/slne/surf/surfapi/core/api/config } public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { - public synthetic fun (Ljava/lang/Class;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V public final fun edit (ZLkotlin/jvm/functions/Function1;)V public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/SpongeConfigClass;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public final fun getConfig ()Ljava/lang/Object; - protected abstract fun getConfigFolder ()Ljava/nio/file/Path; - protected abstract fun getFileName ()Ljava/lang/String; + protected final fun getConfigFolder ()Ljava/nio/file/Path; + protected final fun getFileName ()Ljava/lang/String; public abstract fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public final fun init ()V public final fun reloadFromFile ()Ljava/lang/Object; @@ -5988,12 +5988,12 @@ public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { } public abstract class dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { - public fun (Ljava/lang/Class;)V + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; } public abstract class dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { - public fun (Ljava/lang/Class;)V + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; } diff --git a/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/java/dev/slne/surf/surfapi/bukkit/test/BukkitPluginMain.java b/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/java/dev/slne/surf/surfapi/bukkit/test/BukkitPluginMain.java index 0cab53384..0dce23646 100644 --- a/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/java/dev/slne/surf/surfapi/bukkit/test/BukkitPluginMain.java +++ b/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/java/dev/slne/surf/surfapi/bukkit/test/BukkitPluginMain.java @@ -6,6 +6,7 @@ import dev.slne.surf.surfapi.bukkit.test.command.SurfApiTestCommand; import dev.slne.surf.surfapi.bukkit.test.command.subcommands.inventory.TestInventoryView; import dev.slne.surf.surfapi.bukkit.test.command.subcommands.reflection.Reflection; +import dev.slne.surf.surfapi.bukkit.test.config.ModernTestConfig; import dev.slne.surf.surfapi.bukkit.test.listener.ChatListener; import org.bukkit.plugin.java.JavaPlugin; import org.jetbrains.annotations.NotNull; @@ -19,6 +20,9 @@ public class BukkitPluginMain extends JavaPlugin { @Override public void onLoad() { + ModernTestConfig.Companion.init(); + ModernTestConfig.Companion.randomise(); + SurfBukkitPacketListenerApi.Companion.getInstance().registerListeners(new ChatListener()); InventoryFrameworkExtensions.register(TestInventoryView.INSTANCE); // TestConfig config = SurfCore#Api.getCore() diff --git a/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/kotlin/dev/slne/surf/surfapi/bukkit/test/config/ModernTestConfig.kt b/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/kotlin/dev/slne/surf/surfapi/bukkit/test/config/ModernTestConfig.kt new file mode 100644 index 000000000..5c129154e --- /dev/null +++ b/surf-api-bukkit/surf-api-bukkit-plugin-test/src/main/kotlin/dev/slne/surf/surfapi/bukkit/test/config/ModernTestConfig.kt @@ -0,0 +1,24 @@ +package dev.slne.surf.surfapi.bukkit.test.config + +import dev.slne.surf.surfapi.bukkit.test.BukkitPluginMain +import dev.slne.surf.surfapi.core.api.config.SpongeYmlConfigClass +import org.spongepowered.configurate.objectmapping.ConfigSerializable + +@ConfigSerializable +data class ModernTestConfig( + var message: String = "Hello from Modern Config!", + var number: Int = 42, + var enabled: Boolean = true +) { + companion object : SpongeYmlConfigClass( + ModernTestConfig::class.java, + BukkitPluginMain.getInstance().dataPath, + "modern-test-config.yml" + ) { + fun randomise() = edit { + message = "Random Message ${Math.random()}" + number = (Math.random() * 100).toInt() + enabled = Math.random() > 0.5 + } + } +} \ No newline at end of file diff --git a/surf-api-core/surf-api-core-api/api/surf-api-core-api.api b/surf-api-core/surf-api-core-api/api/surf-api-core-api.api index 066ef3729..a35b6503f 100644 --- a/surf-api-core/surf-api-core-api/api/surf-api-core-api.api +++ b/surf-api-core/surf-api-core-api/api/surf-api-core-api.api @@ -602,12 +602,12 @@ public abstract interface annotation class dev/slne/surf/surfapi/core/api/config } public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { - public synthetic fun (Ljava/lang/Class;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V public final fun edit (ZLkotlin/jvm/functions/Function1;)V public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/SpongeConfigClass;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public final fun getConfig ()Ljava/lang/Object; - protected abstract fun getConfigFolder ()Ljava/nio/file/Path; - protected abstract fun getFileName ()Ljava/lang/String; + protected final fun getConfigFolder ()Ljava/nio/file/Path; + protected final fun getFileName ()Ljava/lang/String; public abstract fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public final fun init ()V public final fun reloadFromFile ()Ljava/lang/Object; @@ -615,12 +615,12 @@ public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { } public abstract class dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { - public fun (Ljava/lang/Class;)V + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; } public abstract class dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { - public fun (Ljava/lang/Class;)V + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; } diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeConfigClass.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeConfigClass.kt index 02db138ab..4b749949a 100644 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeConfigClass.kt +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeConfigClass.kt @@ -20,19 +20,20 @@ import java.nio.file.Path * @param configClass the Java class of [C], used by underlying config frameworks * to create and map configuration instances. */ -sealed class SpongeConfigClass(configClass: Class) { +sealed class SpongeConfigClass( + configClass: Class, /** * Folder where the configuration file is stored. * * Implementations should point this to a plugin- or module-specific config directory. */ - protected abstract val configFolder: Path - + protected val configFolder: Path, /** * The name of the configuration file, including its extension * (for example `settings.yml` or `settings.json`). */ - protected abstract val fileName: String + protected val fileName: String +) { /** * The underlying configuration manager responsible for loading, saving, diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass.kt index b5cff1892..5813a91e8 100644 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass.kt +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass.kt @@ -1,5 +1,7 @@ package dev.slne.surf.surfapi.core.api.config +import java.nio.file.Path + /** * Convenience base class for JSON-backed Sponge configuration classes. * @@ -12,9 +14,11 @@ package dev.slne.surf.surfapi.core.api.config * data class MyJsonConfig( * var someField: String = "value" * ) { - * companion object : SpongeJsonConfigClass(MyJsonConfig::class.java) { - * override val configFolder = Path("config/my-plugin") - * override val fileName = "my-config.json" + * companion object : SpongeJsonConfigClass( + * MyJsonConfig::class.java, + * Path("config/my-plugin"), + * "my-config.json" + * ) { * } * } * ``` @@ -22,7 +26,9 @@ package dev.slne.surf.surfapi.core.api.config * @param C the type of the configuration data object. * @param configClass the Java class of [C], used by the underlying config framework. */ -abstract class SpongeJsonConfigClass(configClass: Class) : SpongeConfigClass(configClass) { +abstract class SpongeJsonConfigClass( + configClass: Class, configFolder: Path, fileName: String +) : SpongeConfigClass(configClass, configFolder, fileName) { /** * JSON-backed configuration manager for this config type. diff --git a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass.kt b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass.kt index 658b55823..466880a70 100644 --- a/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass.kt +++ b/surf-api-core/surf-api-core-api/src/main/kotlin/dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass.kt @@ -1,5 +1,7 @@ package dev.slne.surf.surfapi.core.api.config +import java.nio.file.Path + /** * Convenience base class for YAML-backed Sponge configuration classes. * @@ -12,9 +14,11 @@ package dev.slne.surf.surfapi.core.api.config * data class MyConfig( * var someField: String = "value" * ) { - * companion object : SpongeYmlConfigClass(MyConfig::class.java) { - * override val configFolder = Path("config/my-plugin") - * override val fileName = "my-config.yml" + * companion object : SpongeYmlConfigClass( + * MyConfig::class.java, + * Path("config/my-plugin"), + * "my-config.yml" + * ) { * } * } * ``` @@ -22,7 +26,9 @@ package dev.slne.surf.surfapi.core.api.config * @param C the type of the configuration data object. * @param configClass the Java class of [C], used by the underlying config framework. */ -abstract class SpongeYmlConfigClass(configClass: Class) : SpongeConfigClass(configClass) { +abstract class SpongeYmlConfigClass( + configClass: Class, configFolder: Path, fileName: String +) : SpongeConfigClass(configClass, configFolder, fileName) { /** * YAML-backed configuration manager for this config type. diff --git a/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api b/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api index a65f3e724..da145dbd0 100644 --- a/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api +++ b/surf-api-velocity/surf-api-velocity-api/api/surf-api-velocity-api.api @@ -3908,12 +3908,12 @@ public abstract interface annotation class dev/slne/surf/surfapi/core/api/config } public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { - public synthetic fun (Ljava/lang/Class;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V public final fun edit (ZLkotlin/jvm/functions/Function1;)V public static synthetic fun edit$default (Ldev/slne/surf/surfapi/core/api/config/SpongeConfigClass;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public final fun getConfig ()Ljava/lang/Object; - protected abstract fun getConfigFolder ()Ljava/nio/file/Path; - protected abstract fun getFileName ()Ljava/lang/String; + protected final fun getConfigFolder ()Ljava/nio/file/Path; + protected final fun getFileName ()Ljava/lang/String; public abstract fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; public final fun init ()V public final fun reloadFromFile ()Ljava/lang/Object; @@ -3921,12 +3921,12 @@ public abstract class dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { } public abstract class dev/slne/surf/surfapi/core/api/config/SpongeJsonConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { - public fun (Ljava/lang/Class;)V + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; } public abstract class dev/slne/surf/surfapi/core/api/config/SpongeYmlConfigClass : dev/slne/surf/surfapi/core/api/config/SpongeConfigClass { - public fun (Ljava/lang/Class;)V + public fun (Ljava/lang/Class;Ljava/nio/file/Path;Ljava/lang/String;)V public fun getManager ()Ldev/slne/surf/surfapi/core/api/config/manager/SpongeConfigManager; }