switch to configurate

buildSrc/src/main/kotlin/webhooklogger.platform-conventions.gradle.kts

@@ -25,11 +25,10 @@ tasks {
 			"io.github._4drian3d.jdwebhooks",
 			"com.google.gson",
 			"org.bstats",
-			"org.json",
-			"space.arim",
+			"org.spongepowered.configurate",
 			"dev.vankka.mcdiscordreserializer",
 			"org.incendo.cloud",
-			"io.leangen"
+			"io.leangen.geantyref"
 		).forEach { pkg ->
 			relocate(pkg, "fi.fabianadrian.webhooklogger.dependency.$pkg")
 		}

common/build.gradle.kts

@@ -5,11 +5,6 @@ plugins {
 dependencies {
 	// Webhook clients
 	implementation(libs.client.discord)
-
-	// External libraries
-	implementation(libs.dazzleconf) {
-		exclude("org.yaml")
-	}
 	implementation(libs.mcdiscordserializer) {
 		exclude("net.kyori")
 	}
@@ -21,7 +16,7 @@ dependencies {
 	compileOnly(libs.adventure.text.minimessage)
 	compileOnly(libs.adventure.text.serializer.ansi)
 	compileOnly(libs.slf4j)
-	compileOnly(libs.snakeyaml)
+	compileOnly(libs.configurate)
 
 	compileOnly(libs.miniplaceholders)
 }

common/src/main/java/fi/fabianadrian/webhooklogger/common/WebhookLogger.java

@@ -17,6 +17,7 @@
 import org.incendo.cloud.minecraft.extras.MinecraftExceptionHandler;
 import org.incendo.cloud.minecraft.extras.caption.TranslatableCaption;
 import org.slf4j.Logger;
+import org.spongepowered.configurate.ConfigurateException;
 
 import java.util.List;
 import java.util.concurrent.Executors;
@@ -34,27 +35,25 @@ public WebhookLogger(Platform platform) {
 		this.platform = platform;
 
 		new TranslationManager(platform.logger());
-		this.configManager = new ConfigManager(platform.configPath(), platform.logger());
+		this.configManager = new ConfigManager(platform.configPath());
 		this.webhookManager = new WebhookManager(this);
 
 		this.commandManager = platform.commandManager();
 		setupCommandManager();
 		registerCommands();
 	}
 
-	public void startup() {
+	public void startup() throws ConfigurateException {
 		this.configManager.reload();
 		this.platform.listenerManager().registerListeners();
 		this.webhookManager.reload();
 	}
 
-	public boolean reload() {
-		boolean success = this.configManager.reload();
+	public void reload() throws ConfigurateException {
+		this.configManager.reload();
 
 		this.platform.listenerManager().clearRegisteredWebhooks();
 		this.webhookManager.reload();
-
-		return success;
 	}
 
 	public void shutdown() {

common/src/main/java/fi/fabianadrian/webhooklogger/common/command/commands/ReloadCommand.java

@@ -6,6 +6,7 @@
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.incendo.cloud.context.CommandContext;
+import org.spongepowered.configurate.ConfigurateException;
 
 import static net.kyori.adventure.text.Component.translatable;
 
@@ -33,10 +34,12 @@ public void register() {
 	}
 
 	private void executeReload(CommandContext<Audience> context) {
-		if (webhookLogger.reload()) {
+		try {
+			this.webhookLogger.reload();
 			context.sender().sendMessage(COMPONENT_SUCCESS);
-		} else {
+		} catch (ConfigurateException e) {
 			context.sender().sendMessage(COMPONENT_FAILURE);
+			super.webhookLogger.logger().error("Could not load configuration", e);
 		}
 	}
 }

common/src/main/java/fi/fabianadrian/webhooklogger/common/config/ConfigLoader.java

@@ -0,0 +1,44 @@
+package fi.fabianadrian.webhooklogger.common.config;
+
+import org.spongepowered.configurate.CommentedConfigurationNode;
+import org.spongepowered.configurate.ConfigurateException;
+import org.spongepowered.configurate.ConfigurationOptions;
+import org.spongepowered.configurate.objectmapping.ObjectMapper;
+import org.spongepowered.configurate.serialize.SerializationException;
+import org.spongepowered.configurate.yaml.NodeStyle;
+import org.spongepowered.configurate.yaml.YamlConfigurationLoader;
+
+import java.nio.file.Path;
+import java.util.function.UnaryOperator;
+
+public final class ConfigLoader<C> {
+	private final YamlConfigurationLoader loader;
+	private final ObjectMapper<C> mapper;
+
+	public ConfigLoader(Class<C> configClass, Path configPath, UnaryOperator<ConfigurationOptions> options) {
+		try {
+			this.mapper = ObjectMapper.factory().get(configClass);
+		} catch (SerializationException e) {
+			throw new IllegalStateException(
+					"Failed to initialize an object mapper for type: " + configClass.getSimpleName(),
+					e
+			);
+		}
+
+		this.loader = YamlConfigurationLoader.builder()
+				.path(configPath)
+				.nodeStyle(NodeStyle.BLOCK)
+				.defaultOptions(options).build();
+	}
+
+	public C load() throws ConfigurateException {
+		CommentedConfigurationNode node = this.loader.load();
+		return this.mapper.load(node);
+	}
+
+	public void save(C config) throws ConfigurateException {
+		CommentedConfigurationNode node = this.loader.createNode();
+		this.mapper.save(config, node);
+		this.loader.save(node);
+	}
+}

common/src/main/java/fi/fabianadrian/webhooklogger/common/config/ConfigManager.java

@@ -1,60 +1,55 @@
 package fi.fabianadrian.webhooklogger.common.config;
 
-import org.slf4j.Logger;
-import space.arim.dazzleconf.helper.ConfigurationHelper;
+import fi.fabianadrian.webhooklogger.common.config.serializer.PatternSerializer;
+import fi.fabianadrian.webhooklogger.common.config.serializer.ZoneIdSerializer;
+import org.spongepowered.configurate.ConfigurateException;
 
 import java.nio.file.Path;
+import java.time.ZoneId;
+import java.util.regex.Pattern;
 
 public final class ConfigManager {
-	private final Logger logger;
-	private final ConfigurationHelper<MainConfig> mainConfigHelper;
-	private final ConfigurationHelper<EventsConfig> eventsConfigHelper;
-
-	private volatile MainConfig mainConfigData;
-	private volatile EventsConfig eventsConfigData;
+	private final ConfigLoader<MainConfig> mainConfigLoader;
+	private final ConfigLoader<EventsConfig> eventsConfigLoader;
+	private MainConfig mainConfig;
+	private EventsConfig eventsConfig;
+
+	public ConfigManager(Path configPath) {
+		this.mainConfigLoader = new ConfigLoader<>(
+				MainConfig.class,
+				configPath.resolve("config.yml"),
+				options -> options.header("WebhookLogger Main Configuration")
+						.serializers(builder -> builder
+								.register(Pattern.class, PatternSerializer.INSTANCE)
+								.register(ZoneId.class, ZoneIdSerializer.INSTANCE)
+						)
+		);
+		this.eventsConfigLoader = new ConfigLoader<>(
+				EventsConfig.class,
+				configPath.resolve("events.yml"),
+				options -> options.header("WebhookLogger Events Configuration")
+		);
+	}
 
-	public ConfigManager(Path configPath, Logger logger) {
-		this.logger = logger;
+	public void reload() throws ConfigurateException {
+		this.mainConfig = this.mainConfigLoader.load();
+		this.mainConfigLoader.save(this.mainConfig);
 
-		ConfigurationHelperFactory helperFactory = new ConfigurationHelperFactory(configPath);
-		mainConfigHelper = helperFactory.create("config.yml", MainConfig.class);
-		eventsConfigHelper = helperFactory.create("events.yml", EventsConfig.class);
+		this.eventsConfig = this.eventsConfigLoader.load();
+		this.eventsConfigLoader.save(this.eventsConfig);
 	}
 
 	public MainConfig mainConfig() {
-		MainConfig configData = mainConfigData;
-		if (configData == null) {
-			throw new IllegalStateException("Configuration has not been loaded yet");
+		if (this.mainConfig == null) {
+			throw new IllegalStateException("Main configuration isn't loaded");
 		}
-		return configData;
+		return this.mainConfig;
 	}
 
 	public EventsConfig eventsConfig() {
-		EventsConfig configData = eventsConfigData;
-		if (configData == null) {
-			throw new IllegalStateException("Configuration has not been loaded yet");
-		}
-		return configData;
-	}
-
-	public boolean reload() {
-		boolean success = true;
-		try {
-			mainConfigData = mainConfigHelper.reloadConfigData();
-		} catch (Exception e) {
-			logger.error("Could not load config.yml, falling back to default configuration", e);
-			mainConfigData = mainConfigHelper.getFactory().loadDefaults();
-			success = false;
-		}
-
-		try {
-			eventsConfigData = eventsConfigHelper.reloadConfigData();
-		} catch (Exception e) {
-			logger.error("Could not load events.yml, falling back to default configuration", e);
-			eventsConfigData = eventsConfigHelper.getFactory().loadDefaults();
-			success = false;
+		if (this.eventsConfig == null) {
+			throw new IllegalStateException("Events configuration isn't loaded");
 		}
-
-		return success;
+		return this.eventsConfig;
 	}
 }

common/src/main/java/fi/fabianadrian/webhooklogger/common/config/EventsConfig.java

@@ -1,27 +1,33 @@
 package fi.fabianadrian.webhooklogger.common.config;
 
 import fi.fabianadrian.webhooklogger.common.config.event.*;
-import space.arim.dazzleconf.annote.SubSection;
-import space.arim.dazzleconf.sorter.AnnotationBasedSorter;
+import org.spongepowered.configurate.objectmapping.ConfigSerializable;
 
-public interface EventsConfig {
-	@AnnotationBasedSorter.Order(0)
-	@SubSection
-	ChatEventConfig chat();
+@ConfigSerializable
+public class EventsConfig {
+	private ChatEventConfig chat = new ChatEventConfig();
+	private CommandEventConfig command = new CommandEventConfig();
+	private DeathEventConfig death = new DeathEventConfig();
+	private JoinEventConfig join = new JoinEventConfig();
+	private QuitEventConfig quit = new QuitEventConfig();
 
-	@AnnotationBasedSorter.Order(1)
-	@SubSection
-	CommandEventConfig command();
+	public ChatEventConfig chat() {
+		return chat;
+	}
 
-	@AnnotationBasedSorter.Order(2)
-	@SubSection
-	DeathEventConfig death();
+	public CommandEventConfig command() {
+		return command;
+	}
 
-	@AnnotationBasedSorter.Order(3)
-	@SubSection
-	JoinEventConfig join();
+	public DeathEventConfig death() {
+		return death;
+	}
 
-	@AnnotationBasedSorter.Order(4)
-	@SubSection
-	QuitEventConfig quit();
+	public JoinEventConfig join() {
+		return join;
+	}
+
+	public QuitEventConfig quit() {
+		return quit;
+	}
 }