feat: replace commons-logging with slf4j-based commons-logger and use type-safe dependency DSLs

The only reason it needed to be separate was logging during ultra early init in Minecraft. I can figure out something else for that.

build.gradle.kts

@@ -1 +1 @@
-version = "1.5-SNAPSHOT"
+version = "1.6-SNAPSHOT"

buildSrc/build.gradle.kts

@@ -9,6 +9,6 @@ repositories {
 }
 
 dependencies {
-    implementation("org.gradle.kotlin:gradle-kotlin-dsl-plugins:4.1.2")
-    implementation("io.gitlab.jfronny:convention:1.5-SNAPSHOT")
+    implementation(libs.plugin.kotlin)
+    implementation(libs.plugin.convention)
 }

buildSrc/settings.gradle.kts

@@ -0,0 +1,7 @@
+dependencyResolutionManagement {
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}

buildSrc/src/main/kotlin/commons.library.gradle.kts

@@ -1,21 +1,25 @@
+import io.gitlab.jfronny.scripts.*
+
 plugins {
     `java-library`
     `maven-publish`
-    id("jf.umldoc")
+    jf.umldoc
 }
 
 version = rootProject.version
 
+val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+
 repositories {
     mavenCentral()
     maven("https://maven.frohnmeyer-wds.de/artifacts/")
 }
 
 dependencies {
-    compileOnly("org.jetbrains:annotations:24.0.1")
+    compileOnly(libs.findLibrary("annotations").orElseThrow())
 
-    testImplementation("org.junit.jupiter:junit-jupiter-api:5.9.3")
-    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.9.3")
+    testImplementation(libs.findLibrary("junit-jupiter-api").orElseThrow())
+    testRuntimeOnly(libs.findLibrary("junit-jupiter-engine").orElseThrow())
 }
 
 tasks.test {
@@ -45,4 +49,8 @@ publishing {
             }
         }
     }
+}
+
+tasks.javadoc {
+    opts.links("https://javadoc.io/doc/org.jetbrains/annotations/${libs.findVersion("annotations").orElseThrow().preferredVersion}")
 }

commons-http-client/build.gradle.kts

@@ -1,10 +1,12 @@
+import io.gitlab.jfronny.scripts.*
+
 plugins {
-    id("commons.library")
+    commons.library
 }
 
 dependencies {
-    implementation(project(":commons"))
-    implementation(project(":commons-serialize"))
+    implementation(projects.commons)
+    implementation(projects.commonsSerialize)
 }
 
 publishing {
@@ -17,3 +19,8 @@ publishing {
         }
     }
 }
+
+tasks.javadoc {
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", projects.commons)
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons-serialize/$version/raw", projects.commonsSerialize)
+}

commons-http-server/build.gradle.kts

@@ -1,7 +1,7 @@
 import io.gitlab.jfronny.scripts.*
 
 plugins {
-    id("commons.library")
+    commons.library
 }
 
 dependencies {

commons-io/build.gradle.kts

@@ -1,12 +1,12 @@
 import io.gitlab.jfronny.scripts.*
 
 plugins {
-    id("commons.library")
+    commons.library
 }
 
 dependencies {
-    implementation(project(":commons"))
-    implementation(project(":commons-serialize"))
+    implementation(projects.commons)
+    implementation(projects.commonsSerialize)
 }
 
 publishing {
@@ -19,3 +19,8 @@ publishing {
         }
     }
 }
+
+tasks.javadoc {
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", projects.commons)
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons-serialize/$version/raw", projects.commonsSerialize)
+}

commons-logger/build.gradle.kts

@@ -0,0 +1,29 @@
+import io.gitlab.jfronny.scripts.*
+
+plugins {
+    commons.library
+}
+
+dependencies {
+    implementation(libs.slf4j.api)
+    implementation(projects.commons)
+
+    testImplementation(libs.junit.jupiter.api)
+    testRuntimeOnly(libs.junit.jupiter.engine)
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("maven") {
+            groupId = "io.gitlab.jfronny"
+            artifactId = "commons-logger"
+
+            from(components["java"])
+        }
+    }
+}
+
+tasks.javadoc {
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", projects.commons)
+    opts.links("https://www.slf4j.org/apidocs")
+}

commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/CommonsLogger.java

@@ -1,4 +1,4 @@
-package io.gitlab.jfronny.commons.logging.slf4j;
+package io.gitlab.jfronny.commons.logger;
 
 import org.slf4j.Logger;
 import org.slf4j.Marker;

commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/CompactLogger.java

@@ -0,0 +1,355 @@
+package io.gitlab.jfronny.commons.logger;
+
+import io.gitlab.jfronny.commons.StringFormatter;
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+import org.slf4j.event.Level;
+import org.slf4j.helpers.MessageFormatter;
+
+public interface CompactLogger extends Logger {
+    Level getLevel();
+
+    @Override
+    default boolean isTraceEnabled() {
+        return getLevel().compareTo(Level.TRACE) >= 0;
+    }
+
+    @Override
+    default void trace(String msg) {
+        if (isTraceEnabled()) {
+            if (isDebugEnabled()) {
+                debug(msg);
+            } else {
+                info(msg);
+            }
+        }
+    }
+
+    @Override
+    default void trace(String format, Object arg) {
+        trace(format(format, arg));
+    }
+
+    @Override
+    default void trace(String format, Object arg1, Object arg2) {
+        trace(format(format, arg1, arg2));
+    }
+
+    @Override
+    default void trace(String format, Object... arguments) {
+        trace(format(format, arguments));
+    }
+
+    @Override
+    default void trace(String msg, Throwable t) {
+        trace(format(msg, t));
+    }
+
+    @Override
+    default boolean isTraceEnabled(Marker marker) {
+        return getLevel().compareTo(Level.TRACE) >= 0;
+    }
+
+    @Override
+    default void trace(Marker marker, String msg) {
+        trace(format(marker, msg));
+    }
+
+    @Override
+    default void trace(Marker marker, String format, Object arg) {
+        trace(marker, format(format, arg));
+    }
+
+    @Override
+    default void trace(Marker marker, String format, Object arg1, Object arg2) {
+        trace(marker, format(format, arg1, arg2));
+    }
+
+    @Override
+    default void trace(Marker marker, String format, Object... argArray) {
+        trace(marker, format(format, argArray));
+    }
+
+    @Override
+    default void trace(Marker marker, String msg, Throwable t) {
+        trace(marker, format(msg, t));
+    }
+
+    @Override
+    default boolean isDebugEnabled() {
+        return getLevel().compareTo(Level.DEBUG) >= 0;
+    }
+
+    @Override
+    default void debug(String msg) {
+        if (isDebugEnabled()) {
+            info(msg);
+        }
+    }
+
+    @Override
+    default void debug(String format, Object arg) {
+        debug(format(format, arg));
+    }
+
+    @Override
+    default void debug(String format, Object arg1, Object arg2) {
+        debug(format(format, arg1, arg2));
+    }
+
+    @Override
+    default void debug(String format, Object... arguments) {
+        debug(format(format, arguments));
+    }
+
+    @Override
+    default void debug(String msg, Throwable t) {
+        debug(format(msg, t));
+    }
+
+    @Override
+    default boolean isDebugEnabled(Marker marker) {
+        return getLevel().compareTo(Level.DEBUG) >= 0;
+    }
+
+    @Override
+    default void debug(Marker marker, String msg) {
+        debug(format(marker, msg));
+    }
+
+    @Override
+    default void debug(Marker marker, String format, Object arg) {
+        debug(marker, format(format, arg));
+    }
+
+    @Override
+    default void debug(Marker marker, String format, Object arg1, Object arg2) {
+        debug(marker, format(format, arg1, arg2));
+    }
+
+    @Override
+    default void debug(Marker marker, String format, Object... arguments) {
+        debug(marker, format(format, arguments));
+    }
+
+    @Override
+    default void debug(Marker marker, String msg, Throwable t) {
+        debug(marker, format(msg, t));
+    }
+
+    @Override
+    default boolean isInfoEnabled() {
+        return getLevel().compareTo(Level.INFO) >= 0;
+    }
+
+    @Override
+    void info(String msg);
+
+    @Override
+    default void info(String format, Object arg) {
+        info(format(format, arg));
+    }
+
+    @Override
+    default void info(String format, Object arg1, Object arg2) {
+        info(format(format, arg1, arg2));
+    }
+
+    @Override
+    default void info(String format, Object... arguments) {
+        info(format(format, arguments));
+    }
+
+    @Override
+    default void info(String msg, Throwable t) {
+        info(format(msg, t));
+    }
+
+    @Override
+    default boolean isInfoEnabled(Marker marker) {
+        return getLevel().compareTo(Level.INFO) >= 0;
+    }
+
+    @Override
+    default void info(Marker marker, String msg) {
+        info(format(marker, msg));
+    }
+
+    @Override
+    default void info(Marker marker, String format, Object arg) {
+        info(marker, format(format, arg));
+    }
+
+    @Override
+    default void info(Marker marker, String format, Object arg1, Object arg2) {
+        info(marker, format(format, arg1, arg2));
+    }
+
+    @Override
+    default void info(Marker marker, String format, Object... arguments) {
+        info(marker, format(format, arguments));
+    }
+
+    @Override
+    default void info(Marker marker, String msg, Throwable t) {
+        info(marker, format(msg, t));
+    }
+
+    @Override
+    default boolean isWarnEnabled() {
+        return getLevel().compareTo(Level.WARN) >= 0;
+    }
+
+    @Override
+    default void warn(String msg) {
+        if (isWarnEnabled()) {
+            info(msg);
+        }
+    }
+
+    @Override
+    default void warn(String format, Object arg) {
+        warn(format(format, arg));
+    }
+
+    @Override
+    default void warn(String format, Object... arguments) {
+        warn(format(format, arguments));
+    }
+
+    @Override
+    default void warn(String format, Object arg1, Object arg2) {
+        warn(format(format, arg1, arg2));
+    }
+
+    @Override
+    default void warn(String msg, Throwable t) {
+        warn(format(msg, t));
+    }
+
+    @Override
+    default boolean isWarnEnabled(Marker marker) {
+        return getLevel().compareTo(Level.WARN) >= 0;
+    }
+
+    @Override
+    default void warn(Marker marker, String msg) {
+        warn(format(marker, msg));
+    }
+
+    @Override
+    default void warn(Marker marker, String format, Object arg) {
+        warn(marker, format(format, arg));
+    }
+
+    @Override
+    default void warn(Marker marker, String format, Object arg1, Object arg2) {
+        warn(marker, format(format, arg1, arg2));
+    }
+
+    @Override
+    default void warn(Marker marker, String format, Object... arguments) {
+        warn(marker, format(format, arguments));
+    }
+
+    @Override
+    default void warn(Marker marker, String msg, Throwable t) {
+        warn(marker, format(msg, t));
+    }
+
+    @Override
+    default boolean isErrorEnabled() {
+        return getLevel().compareTo(Level.ERROR) >= 0;
+    }
+
+    @Override
+    default void error(String msg) {
+        if (isErrorEnabled()) {
+            if (isWarnEnabled()) {
+                warn(msg);
+            } else {
+                info(msg);
+            }
+        }
+    }
+
+    @Override
+    default void error(String format, Object arg) {
+        error(format(format, arg));
+    }
+
+    @Override
+    default void error(String format, Object arg1, Object arg2) {
+        error(format(format, arg1, arg2));
+    }
+
+    @Override
+    default void error(String format, Object... arguments) {
+        error(format(format, arguments));
+    }
+
+    @Override
+    default void error(String msg, Throwable t) {
+        error(format(msg, t));
+    }
+
+    @Override
+    default boolean isErrorEnabled(Marker marker) {
+        return getLevel().compareTo(Level.ERROR) >= 0;
+    }
+
+    @Override
+    default void error(Marker marker, String msg) {
+        error(format(marker, msg));
+    }
+
+    @Override
+    default void error(Marker marker, String format, Object arg) {
+        error(marker, format(format, arg));
+    }
+
+    @Override
+    default void error(Marker marker, String format, Object arg1, Object arg2) {
+        error(marker, format(format, arg1, arg2));
+    }
+
+    @Override
+    default void error(Marker marker, String format, Object... arguments) {
+        error(marker, format(format, arguments));
+    }
+
+    @Override
+    default void error(Marker marker, String msg, Throwable t) {
+        error(marker, format(msg, t));
+    }
+
+    default String format(Marker marker, String msg) {
+        return msg;
+    }
+
+    default String format(String format, Object arg) {
+        return MessageFormatter.basicArrayFormat(format, new Object[] {
+                StringFormatter.toString(arg)
+        });
+    }
+
+    default String format(String format, Object arg1, Object arg2) {
+        return MessageFormatter.basicArrayFormat(format, new Object[] {
+                StringFormatter.toString(arg1),
+                StringFormatter.toString(arg2)
+        });
+    }
+
+    default String format(String format, Object[] args) {
+        String[] strings = new String[args.length];
+        for (int i = 0; i < args.length; i++) {
+            strings[i] = StringFormatter.toString(args[i]);
+        }
+        return MessageFormatter.basicArrayFormat(format, strings);
+    }
+
+    default String format(String msg, Throwable t) {
+        if (t == null) return msg;
+        return msg + System.lineSeparator() + StringFormatter.toString(t);
+    }
+}

commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/CompoundLogger.java

@@ -0,0 +1,449 @@
+package io.gitlab.jfronny.commons.logger;
+
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+
+public class CompoundLogger implements Logger {
+    private final String name;
+    private final Logger[] loggers;
+
+    public CompoundLogger(String name, Logger[] loggers) {
+        this.name = name;
+        this.loggers = loggers;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public boolean isTraceEnabled() {
+        for (Logger logger : loggers) {
+            if (logger.isTraceEnabled()) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void trace(String msg) {
+        for (Logger logger : loggers) {
+            logger.trace(msg);
+        }
+    }
+
+    @Override
+    public void trace(String format, Object arg) {
+        for (Logger logger : loggers) {
+            logger.trace(format, arg);
+        }
+    }
+
+    @Override
+    public void trace(String format, Object arg1, Object arg2) {
+        for (Logger logger : loggers) {
+            logger.trace(format, arg1, arg2);
+        }
+    }
+
+    @Override
+    public void trace(String format, Object... arguments) {
+        for (Logger logger : loggers) {
+            logger.trace(format, arguments);
+        }
+    }
+
+    @Override
+    public void trace(String msg, Throwable t) {
+        for (Logger logger : loggers) {
+            logger.trace(msg, t);
+        }
+    }
+
+    @Override
+    public boolean isTraceEnabled(Marker marker) {
+        for (Logger logger : loggers) {
+            if (logger.isTraceEnabled(marker)) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void trace(Marker marker, String msg) {
+        for (Logger logger : loggers) {
+            logger.trace(marker, msg);
+        }
+    }
+
+    @Override
+    public void trace(Marker marker, String format, Object arg) {
+        for (Logger logger : loggers) {
+            logger.trace(marker, format, arg);
+        }
+    }
+
+    @Override
+    public void trace(Marker marker, String format, Object arg1, Object arg2) {
+        for (Logger logger : loggers) {
+            logger.trace(marker, format, arg1, arg2);
+        }
+    }
+
+    @Override
+    public void trace(Marker marker, String format, Object... argArray) {
+        for (Logger logger : loggers) {
+            logger.trace(marker, format, argArray);
+        }
+    }
+
+    @Override
+    public void trace(Marker marker, String msg, Throwable t) {
+        for (Logger logger : loggers) {
+            logger.trace(marker, msg, t);
+        }
+    }
+
+    @Override
+    public boolean isDebugEnabled() {
+        for (Logger logger : loggers) {
+            if (logger.isDebugEnabled()) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void debug(String msg) {
+        for (Logger logger : loggers) {
+            logger.debug(msg);
+        }
+    }
+
+    @Override
+    public void debug(String format, Object arg) {
+        for (Logger logger : loggers) {
+            logger.debug(format, arg);
+        }
+    }
+
+    @Override
+    public void debug(String format, Object arg1, Object arg2) {
+        for (Logger logger : loggers) {
+            logger.debug(format, arg1, arg2);
+        }
+    }
+
+    @Override
+    public void debug(String format, Object... arguments) {
+        for (Logger logger : loggers) {
+            logger.trace(format, arguments);
+        }
+    }
+
+    @Override
+    public void debug(String msg, Throwable t) {
+        for (Logger logger : loggers) {
+            logger.debug(msg, t);
+        }
+    }
+
+    @Override
+    public boolean isDebugEnabled(Marker marker) {
+        for (Logger logger : loggers) {
+            if (logger.isDebugEnabled(marker)) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void debug(Marker marker, String msg) {
+        for (Logger logger : loggers) {
+            logger.debug(marker, msg);
+        }
+    }
+
+    @Override
+    public void debug(Marker marker, String format, Object arg) {
+        for (Logger logger : loggers) {
+            logger.debug(marker, format, arg);
+        }
+    }
+
+    @Override
+    public void debug(Marker marker, String format, Object arg1, Object arg2) {
+        for (Logger logger : loggers) {
+            logger.debug(marker, format, arg1, arg2);
+        }
+    }
+
+    @Override
+    public void debug(Marker marker, String format, Object... arguments) {
+        for (Logger logger : loggers) {
+            logger.debug(marker, format, arguments);
+        }
+    }
+
+    @Override
+    public void debug(Marker marker, String msg, Throwable t) {
+        for (Logger logger : loggers) {
+            logger.debug(marker, msg, t);
+        }
+    }
+
+    @Override
+    public boolean isInfoEnabled() {
+        for (Logger logger : loggers) {
+            if (logger.isInfoEnabled()) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void info(String msg) {
+        for (Logger logger : loggers) {
+            logger.info(msg);
+        }
+    }
+
+    @Override
+    public void info(String format, Object arg) {
+        for (Logger logger : loggers) {
+            logger.info(format, arg);
+        }
+    }
+
+    @Override
+    public void info(String format, Object arg1, Object arg2) {
+        for (Logger logger : loggers) {
+            logger.info(format, arg1, arg2);
+        }
+    }
+
+    @Override
+    public void info(String format, Object... arguments) {
+        for (Logger logger : loggers) {
+            logger.info(format, arguments);
+        }
+    }
+
+    @Override
+    public void info(String msg, Throwable t) {
+        for (Logger logger : loggers) {
+            logger.info(msg, t);
+        }
+    }
+
+    @Override
+    public boolean isInfoEnabled(Marker marker) {
+        for (Logger logger : loggers) {
+            if (logger.isInfoEnabled(marker)) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void info(Marker marker, String msg) {
+        for (Logger logger : loggers) {
+            logger.info(marker, msg);
+        }
+    }
+
+    @Override
+    public void info(Marker marker, String format, Object arg) {
+        for (Logger logger : loggers) {
+            logger.info(marker, format, arg);
+        }
+    }
+
+    @Override
+    public void info(Marker marker, String format, Object arg1, Object arg2) {
+        for (Logger logger : loggers) {
+            logger.info(marker, format, arg1, arg2);
+        }
+    }
+
+    @Override
+    public void info(Marker marker, String format, Object... arguments) {
+        for (Logger logger : loggers) {
+            logger.info(marker, format, arguments);
+        }
+    }
+
+    @Override
+    public void info(Marker marker, String msg, Throwable t) {
+        for (Logger logger : loggers) {
+            logger.info(marker, msg, t);
+        }
+    }
+
+    @Override
+    public boolean isWarnEnabled() {
+        for (Logger logger : loggers) {
+            if (logger.isWarnEnabled()) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void warn(String msg) {
+        for (Logger logger : loggers) {
+            logger.warn(msg);
+        }
+    }
+
+    @Override
+    public void warn(String format, Object arg) {
+        for (Logger logger : loggers) {
+            logger.warn(format, arg);
+        }
+    }
+
+    @Override
+    public void warn(String format, Object... arguments) {
+        for (Logger logger : loggers) {
+            logger.warn(format, arguments);
+        }
+    }
+
+    @Override
+    public void warn(String format, Object arg1, Object arg2) {
+        for (Logger logger : loggers) {
+            logger.warn(format, arg1, arg2);
+        }
+    }
+
+    @Override
+    public void warn(String msg, Throwable t) {
+        for (Logger logger : loggers) {
+            logger.warn(msg, t);
+        }
+    }
+
+    @Override
+    public boolean isWarnEnabled(Marker marker) {
+        for (Logger logger : loggers) {
+            if (logger.isWarnEnabled(marker)) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void warn(Marker marker, String msg) {
+        for (Logger logger : loggers) {
+            logger.warn(marker, msg);
+        }
+    }
+
+    @Override
+    public void warn(Marker marker, String format, Object arg) {
+        for (Logger logger : loggers) {
+            logger.warn(marker, format, arg);
+        }
+    }
+
+    @Override
+    public void warn(Marker marker, String format, Object arg1, Object arg2) {
+        for (Logger logger : loggers) {
+            logger.warn(marker, format, arg1, arg2);
+        }
+    }
+
+    @Override
+    public void warn(Marker marker, String format, Object... arguments) {
+        for (Logger logger : loggers) {
+            logger.warn(marker, format, arguments);
+        }
+    }
+
+    @Override
+    public void warn(Marker marker, String msg, Throwable t) {
+        for (Logger logger : loggers) {
+            logger.warn(marker, msg, t);
+        }
+    }
+
+    @Override
+    public boolean isErrorEnabled() {
+        for (Logger logger : loggers) {
+            if (logger.isErrorEnabled()) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void error(String msg) {
+        for (Logger logger : loggers) {
+            logger.error(msg);
+        }
+    }
+
+    @Override
+    public void error(String format, Object arg) {
+        for (Logger logger : loggers) {
+            logger.error(format, arg);
+        }
+    }
+
+    @Override
+    public void error(String format, Object arg1, Object arg2) {
+        for (Logger logger : loggers) {
+            logger.error(format, arg1, arg2);
+        }
+    }
+
+    @Override
+    public void error(String format, Object... arguments) {
+        for (Logger logger : loggers) {
+            logger.error(format, arguments);
+        }
+    }
+
+    @Override
+    public void error(String msg, Throwable t) {
+        for (Logger logger : loggers) {
+            logger.error(msg, t);
+        }
+    }
+
+    @Override
+    public boolean isErrorEnabled(Marker marker) {
+        for (Logger logger : loggers) {
+            if (logger.isErrorEnabled(marker)) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void error(Marker marker, String msg) {
+        for (Logger logger : loggers) {
+            logger.error(marker, msg);
+        }
+    }
+
+    @Override
+    public void error(Marker marker, String format, Object arg) {
+        for (Logger logger : loggers) {
+            logger.error(marker, format, arg);
+        }
+    }
+
+    @Override
+    public void error(Marker marker, String format, Object arg1, Object arg2) {
+        for (Logger logger : loggers) {
+            logger.error(marker, format, arg1, arg2);
+        }
+    }
+
+    @Override
+    public void error(Marker marker, String format, Object... arguments) {
+        for (Logger logger : loggers) {
+            logger.error(marker, format, arguments);
+        }
+    }
+
+    @Override
+    public void error(Marker marker, String msg, Throwable t) {
+        for (Logger logger : loggers) {
+            logger.error(marker, msg, t);
+        }
+    }
+}

commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/DelegateLogger.java

@@ -0,0 +1,322 @@
+package io.gitlab.jfronny.commons.logger;
+
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+
+public abstract class DelegateLogger implements Logger {
+    public static DelegateLogger create(Logger delegate) {
+        return new DelegateLogger() {
+            @Override
+            protected Logger getDelegate() {
+                return delegate;
+            }
+        };
+    }
+
+    protected abstract Logger getDelegate();
+
+    @Override
+    public String getName() {
+        return getDelegate().getName();
+    }
+
+    @Override
+    public boolean isTraceEnabled() {
+        return !getDelegate().isTraceEnabled();
+    }
+
+    @Override
+    public void trace(String msg) {
+        getDelegate().trace(msg);
+    }
+
+    @Override
+    public void trace(String format, Object arg) {
+        getDelegate().trace(format, arg);
+    }
+
+    @Override
+    public void trace(String format, Object arg1, Object arg2) {
+        getDelegate().trace(format, arg1, arg2);
+    }
+
+    @Override
+    public void trace(String format, Object... arguments) {
+        getDelegate().trace(format, arguments);
+    }
+
+    @Override
+    public void trace(String msg, Throwable t) {
+        getDelegate().trace(msg, t);
+    }
+
+    @Override
+    public boolean isTraceEnabled(Marker marker) {
+        return !getDelegate().isTraceEnabled(marker);
+    }
+
+    @Override
+    public void trace(Marker marker, String msg) {
+        getDelegate().trace(marker, msg);
+    }
+
+    @Override
+    public void trace(Marker marker, String format, Object arg) {
+        getDelegate().trace(marker, format, arg);
+    }
+
+    @Override
+    public void trace(Marker marker, String format, Object arg1, Object arg2) {
+        getDelegate().trace(marker, format, arg1, arg2);
+    }
+
+    @Override
+    public void trace(Marker marker, String format, Object... argArray) {
+        getDelegate().trace(marker, format, argArray);
+    }
+
+    @Override
+    public void trace(Marker marker, String msg, Throwable t) {
+        getDelegate().trace(marker, msg, t);
+    }
+
+    @Override
+    public boolean isDebugEnabled() {
+        return !getDelegate().isDebugEnabled();
+    }
+
+    @Override
+    public void debug(String msg) {
+        getDelegate().debug(msg);
+    }
+
+    @Override
+    public void debug(String format, Object arg) {
+        getDelegate().debug(format, arg);
+    }
+
+    @Override
+    public void debug(String format, Object arg1, Object arg2) {
+        getDelegate().debug(format, arg1, arg2);
+    }
+
+    @Override
+    public void debug(String format, Object... arguments) {
+        getDelegate().debug(format, arguments);
+    }
+
+    @Override
+    public void debug(String msg, Throwable t) {
+        getDelegate().debug(msg, t);
+    }
+
+    @Override
+    public boolean isDebugEnabled(Marker marker) {
+        return !getDelegate().isDebugEnabled(marker);
+    }
+
+    @Override
+    public void debug(Marker marker, String msg) {
+        getDelegate().debug(marker, msg);
+    }
+
+    @Override
+    public void debug(Marker marker, String format, Object arg) {
+        getDelegate().debug(marker, format, arg);
+    }
+
+    @Override
+    public void debug(Marker marker, String format, Object arg1, Object arg2) {
+        getDelegate().debug(marker, format, arg1, arg2);
+    }
+
+    @Override
+    public void debug(Marker marker, String format, Object... arguments) {
+        getDelegate().debug(marker, format, arguments);
+    }
+
+    @Override
+    public void debug(Marker marker, String msg, Throwable t) {
+        getDelegate().debug(marker, msg, t);
+    }
+
+    @Override
+    public boolean isInfoEnabled() {
+        return !getDelegate().isInfoEnabled();
+    }
+
+    @Override
+    public void info(String msg) {
+        getDelegate().info(msg);
+    }
+
+    @Override
+    public void info(String format, Object arg) {
+        getDelegate().info(format, arg);
+    }
+
+    @Override
+    public void info(String format, Object arg1, Object arg2) {
+        getDelegate().info(format, arg1, arg2);
+    }
+
+    @Override
+    public void info(String format, Object... arguments) {
+        getDelegate().info(format, arguments);
+    }
+
+    @Override
+    public void info(String msg, Throwable t) {
+        getDelegate().info(msg, t);
+    }
+
+    @Override
+    public boolean isInfoEnabled(Marker marker) {
+        return !getDelegate().isInfoEnabled(marker);
+    }
+
+    @Override
+    public void info(Marker marker, String msg) {
+        getDelegate().info(marker, msg);
+    }
+
+    @Override
+    public void info(Marker marker, String format, Object arg) {
+        getDelegate().info(marker, format, arg);
+    }
+
+    @Override
+    public void info(Marker marker, String format, Object arg1, Object arg2) {
+        getDelegate().info(marker, format, arg1, arg2);
+    }
+
+    @Override
+    public void info(Marker marker, String format, Object... arguments) {
+        getDelegate().info(marker, format, arguments);
+    }
+
+    @Override
+    public void info(Marker marker, String msg, Throwable t) {
+        getDelegate().info(marker, msg, t);
+    }
+
+    @Override
+    public boolean isWarnEnabled() {
+        return !getDelegate().isWarnEnabled();
+    }
+
+    @Override
+    public void warn(String msg) {
+        getDelegate().warn(msg);
+    }
+
+    @Override
+    public void warn(String format, Object arg) {
+        getDelegate().warn(format, arg);
+    }
+
+    @Override
+    public void warn(String format, Object... arguments) {
+        getDelegate().warn(format, arguments);
+    }
+
+    @Override
+    public void warn(String format, Object arg1, Object arg2) {
+        getDelegate().warn(format, arg1, arg2);
+    }
+
+    @Override
+    public void warn(String msg, Throwable t) {
+        getDelegate().warn(msg, t);
+    }
+
+    @Override
+    public boolean isWarnEnabled(Marker marker) {
+        return !getDelegate().isWarnEnabled(marker);
+    }
+
+    @Override
+    public void warn(Marker marker, String msg) {
+        getDelegate().warn(marker, msg);
+    }
+
+    @Override
+    public void warn(Marker marker, String format, Object arg) {
+        getDelegate().warn(marker, format, arg);
+    }
+
+    @Override
+    public void warn(Marker marker, String format, Object arg1, Object arg2) {
+        getDelegate().warn(marker, format, arg1, arg2);
+    }
+
+    @Override
+    public void warn(Marker marker, String format, Object... arguments) {
+        getDelegate().warn(marker, format, arguments);
+    }
+
+    @Override
+    public void warn(Marker marker, String msg, Throwable t) {
+        getDelegate().warn(marker, msg, t);
+    }
+
+    @Override
+    public boolean isErrorEnabled() {
+        return !getDelegate().isErrorEnabled();
+    }
+
+    @Override
+    public void error(String msg) {
+        getDelegate().error(msg);
+    }
+
+    @Override
+    public void error(String format, Object arg) {
+        getDelegate().error(format, arg);
+    }
+
+    @Override
+    public void error(String format, Object arg1, Object arg2) {
+        getDelegate().error(format, arg1, arg2);
+    }
+
+    @Override
+    public void error(String format, Object... arguments) {
+        getDelegate().error(format, arguments);
+    }
+
+    @Override
+    public void error(String msg, Throwable t) {
+        getDelegate().error(msg, t);
+    }
+
+    @Override
+    public boolean isErrorEnabled(Marker marker) {
+        return !getDelegate().isErrorEnabled(marker);
+    }
+
+    @Override
+    public void error(Marker marker, String msg) {
+        getDelegate().error(marker, msg);
+    }
+
+    @Override
+    public void error(Marker marker, String format, Object arg) {
+        getDelegate().error(marker, format, arg);
+    }
+
+    @Override
+    public void error(Marker marker, String format, Object arg1, Object arg2) {
+        getDelegate().error(marker, format, arg1, arg2);
+    }
+
+    @Override
+    public void error(Marker marker, String format, Object... arguments) {
+        getDelegate().error(marker, format, arguments);
+    }
+
+    @Override
+    public void error(Marker marker, String msg, Throwable t) {
+        getDelegate().error(marker, msg, t);
+    }
+}

commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/HotswapLoggerFactory.java

@@ -0,0 +1,75 @@
+package io.gitlab.jfronny.commons.logger;
+
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.ILoggerFactory;
+import org.slf4j.Logger;
+import org.slf4j.event.Level;
+
+import java.util.Objects;
+
+public class HotswapLoggerFactory implements LeveledLoggerFactory {
+    private LeveledLoggerFactory defaultFactory = StdoutLogger::fancy;
+    private Level minimumLevel = Level.INFO;
+    private int version = 0;
+
+    public void resetStrategy() {
+        updateStrategy(StdoutLogger::fancy);
+    }
+
+    public void updateStrategy(ILoggerFactory factory) {
+        if (factory instanceof LeveledLoggerFactory f) {
+            updateStrategy(f);
+        } else {
+            updateStrategy((name, level) -> factory.getLogger(name));
+        }
+    }
+
+    public void updateStrategy(LeveledLoggerFactory factory) {
+        synchronized (this) {
+            defaultFactory = Objects.requireNonNull(factory);
+            version++;
+        }
+    }
+
+    public void updateDefaultLevel(Level minimumLevel) {
+        synchronized (this) {
+            this.minimumLevel = Objects.requireNonNull(minimumLevel);
+            version++;
+        }
+    }
+
+    @Override
+    public Logger getLogger(String name, @Nullable Level level) {
+        return new SwappableDelegateLogger(name, level);
+    }
+
+    private class SwappableDelegateLogger extends DelegateLogger {
+        private final String name;
+        private final boolean keepLevel;
+        private Level lastMinimumLevel;
+        private Logger delegate;
+        int version = -1;
+
+        private SwappableDelegateLogger(String name, @Nullable Level level) {
+            this.name = name == null ? "null" : name;
+            this.keepLevel = level != null;
+            this.lastMinimumLevel = level == null ? HotswapLoggerFactory.this.minimumLevel : level;
+            updateStrategy();
+        }
+
+        public void updateStrategy() {
+            if (this.version == HotswapLoggerFactory.this.version) return;
+            synchronized (HotswapLoggerFactory.this) {
+                this.version = HotswapLoggerFactory.this.version;
+                if (!keepLevel) this.lastMinimumLevel = HotswapLoggerFactory.this.minimumLevel;
+                this.delegate = HotswapLoggerFactory.this.defaultFactory.getLogger(this.name, this.lastMinimumLevel);
+            }
+        }
+
+        @Override
+        protected Logger getDelegate() {
+            updateStrategy();
+            return delegate;
+        }
+    }
+}

commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/HotswapServiceProvider.java

@@ -1,4 +1,4 @@
-package io.gitlab.jfronny.commons.logging.slf4j;
+package io.gitlab.jfronny.commons.logger;
 
 import org.slf4j.ILoggerFactory;
 import org.slf4j.IMarkerFactory;
@@ -7,7 +7,7 @@ import org.slf4j.helpers.NOPMDCAdapter;
 import org.slf4j.spi.MDCAdapter;
 import org.slf4j.spi.SLF4JServiceProvider;
 
-public class CommonsServiceProvider implements SLF4JServiceProvider {
+public class HotswapServiceProvider implements SLF4JServiceProvider {
     private ILoggerFactory loggerFactory;
     private IMarkerFactory markerFactory;
     private MDCAdapter mdcAdapter;
@@ -34,7 +34,7 @@ public class CommonsServiceProvider implements SLF4JServiceProvider {
 
     @Override
     public void initialize() {
-        loggerFactory = new CommonsLoggerFactory();
+        loggerFactory = new HotswapLoggerFactory();
         markerFactory = new BasicMarkerFactory();
         mdcAdapter = new NOPMDCAdapter();
     }

commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/LeveledLoggerFactory.java

@@ -0,0 +1,16 @@
+package io.gitlab.jfronny.commons.logger;
+
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.ILoggerFactory;
+import org.slf4j.Logger;
+import org.slf4j.event.Level;
+
+@FunctionalInterface
+public interface LeveledLoggerFactory extends ILoggerFactory {
+    @Override
+    default Logger getLogger(String name) {
+        return getLogger(name, null);
+    }
+
+    Logger getLogger(String name, @Nullable Level level);
+}

commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/MemoryLogger.java

@@ -1,30 +1,38 @@
-package io.gitlab.jfronny.commons.logging;
+package io.gitlab.jfronny.commons.logger;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import org.slf4j.event.Level;
 
 import java.util.*;
 import java.util.function.Consumer;
 
-public class MemoryLogger implements Logger, Iterable<String> {
+public class MemoryLogger implements CompactLogger, Iterable<String> {
     private final String name;
     private final List<String> lines;
     private final int size;
+    private final Level level;
 
-    public MemoryLogger(String name) {
-        this.name = name;
+    public MemoryLogger(String name, Level level) {
+        this.name = Objects.requireNonNull(name);
         this.lines = new LinkedList<>();
         this.size = -1;
+        this.level = Objects.requireNonNull(level);
     }
 
-    public MemoryLogger(String name, int size) {
-        this.name = name;
+    public MemoryLogger(String name, Level level, int size) {
+        this.name = Objects.requireNonNull(name);
         this.lines = new ArrayList<>(size);
         this.size = size;
+        this.level = Objects.requireNonNull(level);
     }
 
     @Override
-    public @Nullable String getName() {
+    public Level getLevel() {
+        return level;
+    }
+
+    @Override
+    public String getName() {
         return name;
     }
 
@@ -41,12 +49,12 @@ public class MemoryLogger implements Logger, Iterable<String> {
 
     @Override
     public void trace(String msg) {
-        add("[T] " + msg);
+        add("[Ŧ] " + msg);
     }
 
     @Override
     public void debug(String msg) {
-        add("[D] " + msg);
+        add("[Đ] " + msg);
     }
 
     @Override

commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/OutputColors.java

@@ -1,4 +1,6 @@
-package io.gitlab.jfronny.commons.logging;
+package io.gitlab.jfronny.commons.logger;
+
+import org.slf4j.event.Level;
 
 public class OutputColors {
     // Reset
@@ -73,4 +75,13 @@ public class OutputColors {
     public static final String PURPLE_BACKGROUND_BRIGHT = "\033[0;105m"; // PURPLE
     public static final String CYAN_BACKGROUND_BRIGHT = "\033[0;106m";  // CYAN
     public static final String WHITE_BACKGROUND_BRIGHT = "\033[0;107m";   // WHITE
+
+    public static String byLevel(Level level) {
+        return switch (level) {
+            case INFO -> BLUE;
+            case WARN -> RED;
+            case ERROR -> RED_BOLD;
+            default -> WHITE;
+        };
+    }
 }

commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/PrintStreamLogger.java

@@ -1,23 +1,26 @@
-package io.gitlab.jfronny.commons.logging;
+package io.gitlab.jfronny.commons.logger;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.slf4j.event.Level;
 
 import java.io.PrintStream;
 import java.time.LocalTime;
 import java.time.format.DateTimeFormatter;
 import java.util.Objects;
 
-public class PrintStreamLogger implements Logger {
+public class PrintStreamLogger implements CompactLogger {
     private final @Nullable String name;
     private final boolean color;
     private final boolean thread;
     private final boolean timestamp;
+    private final Level level;
     private final PrintStream target;
 
-    public PrintStreamLogger(@NotNull PrintStream target, @Nullable String name, boolean color, boolean thread, boolean timestamp) {
+    public PrintStreamLogger(@NotNull PrintStream target, @Nullable String name, Level level, boolean color, boolean thread, boolean timestamp) {
         this.target = Objects.requireNonNull(target);
         this.name = name;
+        this.level = level;
         this.color = color;
         this.thread = thread;
         this.timestamp = timestamp;
@@ -28,6 +31,11 @@ public class PrintStreamLogger implements Logger {
         return name == null ? "" : name;
     }
 
+    @Override
+    public Level getLevel() {
+        return level;
+    }
+
     @Override
     public void trace(String msg) {
         target.println(generateMessage(msg, Level.TRACE));
@@ -78,7 +86,7 @@ public class PrintStreamLogger implements Logger {
         }
         // Level
         if (this.color) {
-            sb.append(level.color).append(level.name()).append(OutputColors.RESET).append(' ');
+            sb.append(OutputColors.byLevel(level)).append(level.name()).append(OutputColors.RESET).append(' ');
         } else {
             sb.append(level.name().charAt(0)).append(' ');
         }

commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/StdoutLogger.java

@@ -0,0 +1,22 @@
+package io.gitlab.jfronny.commons.logger;
+
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.event.Level;
+
+public class StdoutLogger extends PrintStreamLogger {
+    public StdoutLogger(@Nullable String name, Level level) {
+        this(name, level, false);
+    }
+
+    public StdoutLogger(@Nullable String name, Level level, boolean color) {
+        this(name, level, color, false, false);
+    }
+
+    public StdoutLogger(@Nullable String name, Level level, boolean color, boolean thread, boolean timestamp) {
+        super(System.out, name, level, color, thread, timestamp);
+    }
+
+    public static StdoutLogger fancy(String name, Level level) {
+        return new StdoutLogger(name, level, true, true, true);
+    }
+}

commons-logger/src/main/java/module-info.java

@@ -0,0 +1,6 @@
+module io.gitlab.jfronny.commons.logger {
+    requires io.gitlab.jfronny.commons;
+    requires org.slf4j;
+    requires static org.jetbrains.annotations;
+    exports io.gitlab.jfronny.commons.logger;
+}

commons-logger/src/main/resources/META-INF/services/org.slf4j.spi.SLF4JServiceProvider

@@ -0,0 +1 @@
+io.gitlab.jfronny.commons.logger.HotswapServiceProvider

commons-logging-slf4j/build.gradle.kts

@@ -1,30 +0,0 @@
-import io.gitlab.jfronny.scripts.*
-
-plugins {
-    id("commons.library")
-}
-
-dependencies {
-    implementation("org.slf4j:slf4j-api:2.0.7")
-    implementation(project(":commons"))
-    implementation(project(":commons-logging"))
-
-    testImplementation("org.junit.jupiter:junit-jupiter-api:5.9.3")
-    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.9.3")
-}
-
-publishing {
-    publications {
-        create<MavenPublication>("maven") {
-            groupId = "io.gitlab.jfronny"
-            artifactId = "commons-logging-slf4j"
-
-            from(components["java"])
-        }
-    }
-}
-
-tasks.javadoc {
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", project(":commons"))
-    opts.links("https://www.slf4j.org/apidocs")
-}

commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/CommonsLoggerFactory.java

@@ -1,16 +0,0 @@
-package io.gitlab.jfronny.commons.logging.slf4j;
-
-import org.slf4j.ILoggerFactory;
-import org.slf4j.Logger;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public class CommonsLoggerFactory implements ILoggerFactory {
-    private final Map<String, Logger> loggerMap = new HashMap<>();
-
-    @Override
-    public synchronized Logger getLogger(String name) {
-        return loggerMap.computeIfAbsent(name, CommonsLogger::new);
-    }
-}

commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/SLF4JLogger.java

@@ -1,117 +0,0 @@
-package io.gitlab.jfronny.commons.logging.slf4j;
-
-import io.gitlab.jfronny.commons.logging.Logger;
-import org.slf4j.LoggerFactory;
-
-public class SLF4JLogger implements Logger {
-    private final org.slf4j.Logger logger;
-
-    public SLF4JLogger(String name) {
-        this.logger = LoggerFactory.getLogger(name);
-    }
-
-    @Override
-    public String getName() {
-        return logger.getName();
-    }
-
-    @Override
-    public void trace(String msg) {
-        logger.trace(msg);
-    }
-
-    @Override
-    public void trace(String format, Object arg) {
-        logger.trace(format, arg);
-    }
-
-    @Override
-    public void trace(String format, Object... args) {
-        logger.trace(format, args);
-    }
-
-    @Override
-    public void trace(String msg, Throwable t) {
-        logger.trace(msg, t);
-    }
-
-    @Override
-    public void debug(String msg) {
-        logger.debug(msg);
-    }
-
-    @Override
-    public void debug(String format, Object arg) {
-        logger.debug(format, arg);
-    }
-
-    @Override
-    public void debug(String format, Object... args) {
-        logger.debug(format, args);
-    }
-
-    @Override
-    public void debug(String msg, Throwable t) {
-        logger.debug(msg, t);
-    }
-
-    @Override
-    public void info(String msg) {
-        logger.info(msg);
-    }
-
-    @Override
-    public void info(String format, Object arg) {
-        logger.info(format, arg);
-    }
-
-    @Override
-    public void info(String format, Object... args) {
-        logger.info(format, args);
-    }
-
-    @Override
-    public void info(String msg, Throwable t) {
-        logger.info(msg, t);
-    }
-
-    @Override
-    public void warn(String msg) {
-        logger.warn(msg);
-    }
-
-    @Override
-    public void warn(String format, Object arg) {
-        logger.warn(format, arg);
-    }
-
-    @Override
-    public void warn(String format, Object... args) {
-        logger.warn(format, args);
-    }
-
-    @Override
-    public void warn(String msg, Throwable t) {
-        logger.warn(msg, t);
-    }
-
-    @Override
-    public void error(String msg) {
-        logger.error(msg);
-    }
-
-    @Override
-    public void error(String format, Object arg) {
-        logger.error(format, arg);
-    }
-
-    @Override
-    public void error(String format, Object... args) {
-        logger.error(format, args);
-    }
-
-    @Override
-    public void error(String msg, Throwable t) {
-        logger.error(msg, t);
-    }
-}

commons-logging-slf4j/src/main/java/module-info.java

@@ -1,6 +0,0 @@
-module io.gitlab.jfronny.commons.logging.slf4j {
-    requires io.gitlab.jfronny.commons;
-    requires io.gitlab.jfronny.commons.logging;
-    requires org.slf4j;
-    exports io.gitlab.jfronny.commons.logging.slf4j;
-}

commons-logging-slf4j/src/test/java/io/gitlab/jfronny/commons/test/SLFLogStrategyTest.java

@@ -1,20 +0,0 @@
-package io.gitlab.jfronny.commons.test;
-
-import io.gitlab.jfronny.commons.logging.HotSwappingDelegateLogger;
-import io.gitlab.jfronny.commons.logging.slf4j.SLF4JLogger;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-public class SLFLogStrategyTest {
-    @BeforeEach
-    void prepare() {
-        HotSwappingDelegateLogger.updateStrategy(SLF4JLogger::new);
-    }
-
-    @Test
-    void testFactory() {
-        assertEquals(SLF4JLogger.class, HotSwappingDelegateLogger.forName("Joe").getDelegate().getClass());
-    }
-}

commons-logging/build.gradle.kts

@@ -1,20 +0,0 @@
-import io.gitlab.jfronny.scripts.*
-
-plugins {
-    id("commons.library")
-}
-
-dependencies {
-    implementation(project(":commons"))
-}
-
-publishing {
-    publications {
-        create<MavenPublication>("maven") {
-            groupId = "io.gitlab.jfronny"
-            artifactId = "commons-logging"
-
-            from(components["java"])
-        }
-    }
-}

commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/CompoundLogger.java

@@ -1,176 +0,0 @@
-package io.gitlab.jfronny.commons.logging;
-
-import org.jetbrains.annotations.Nullable;
-
-public class CompoundLogger implements Logger {
-    private final String name;
-    private final Logger[] loggers;
-
-    public CompoundLogger(String name, Logger... loggers) {
-        this.name = name;
-        this.loggers = loggers;
-    }
-
-    @Override
-    public @Nullable String getName() {
-        return name;
-    }
-
-    @Override
-    public void trace(String msg) {
-        for (Logger logger : loggers) {
-            logger.trace(msg);
-        }
-    }
-
-    @Override
-    public void trace(String format, Object arg) {
-        for (Logger logger : loggers) {
-            logger.trace(format, arg);
-        }
-    }
-
-    @Override
-    public void trace(String format, Object... args) {
-        for (Logger logger : loggers) {
-            logger.trace(format, args);
-        }
-    }
-
-    @Override
-    public void trace(String msg, Throwable t) {
-        for (Logger logger : loggers) {
-            logger.trace(msg, t);
-        }
-    }
-
-    @Override
-    public void debug(String msg) {
-        for (Logger logger : loggers) {
-            logger.debug(msg);
-        }
-    }
-
-    @Override
-    public void debug(String format, Object arg) {
-        for (Logger logger : loggers) {
-            logger.debug(format, arg);
-        }
-    }
-
-    @Override
-    public void debug(String format, Object... args) {
-        for (Logger logger : loggers) {
-            logger.debug(format, args);
-        }
-    }
-
-    @Override
-    public void debug(String msg, Throwable t) {
-        for (Logger logger : loggers) {
-            logger.debug(msg, t);
-        }
-    }
-
-    @Override
-    public void info(String msg) {
-        for (Logger logger : loggers) {
-            logger.info(msg);
-        }
-    }
-
-    @Override
-    public void info(String format, Object arg) {
-        for (Logger logger : loggers) {
-            logger.info(format, arg);
-        }
-    }
-
-    @Override
-    public void info(String format, Object... args) {
-        for (Logger logger : loggers) {
-            logger.info(format, args);
-        }
-    }
-
-    @Override
-    public void info(String msg, Throwable t) {
-        for (Logger logger : loggers) {
-            logger.info(msg, t);
-        }
-    }
-
-    @Override
-    public void warn(String msg) {
-        for (Logger logger : loggers) {
-            logger.warn(msg);
-        }
-    }
-
-    @Override
-    public void warn(String format, Object arg) {
-        for (Logger logger : loggers) {
-            logger.warn(format, arg);
-        }
-    }
-
-    @Override
-    public void warn(String format, Object... args) {
-        for (Logger logger : loggers) {
-            logger.warn(format, args);
-        }
-    }
-
-    @Override
-    public void warn(String msg, Throwable t) {
-        for (Logger logger : loggers) {
-            logger.warn(msg, t);
-        }
-    }
-
-    @Override
-    public void error(String msg) {
-        for (Logger logger : loggers) {
-            logger.error(msg);
-        }
-    }
-
-    @Override
-    public void error(String format, Object arg) {
-        for (Logger logger : loggers) {
-            logger.error(format, arg);
-        }
-    }
-
-    @Override
-    public void error(String format, Object... args) {
-        for (Logger logger : loggers) {
-            logger.error(format, args);
-        }
-    }
-
-    @Override
-    public void error(String msg, Throwable t) {
-        for (Logger logger : loggers) {
-            logger.error(msg, t);
-        }
-    }
-
-    @Override
-    public String format(String format, Object arg) {
-        if (loggers.length == 0) return Logger.super.format(format, arg);
-        return loggers[0].format(format, arg);
-    }
-
-    @Override
-    public String format(String format, Object... args) {
-        if (loggers.length == 0) return Logger.super.format(format, args);
-        return loggers[0].format(format, args);
-    }
-
-    @Override
-    public String format(String msg, Throwable t) {
-        if (loggers.length == 0) return Logger.super.format(msg, t);
-        return loggers[0].format(msg, t);
-    }
-}

commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/DelegateLogger.java

@@ -1,180 +0,0 @@
-package io.gitlab.jfronny.commons.logging;
-
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Objects;
-
-public class DelegateLogger implements Logger {
-    public DelegateLogger() {
-        this(null);
-    }
-
-    public DelegateLogger(Logger delegate) {
-        this.delegate = delegate;
-    }
-
-    protected Logger delegate;
-    protected Level minimumLevel = Level.TRACE;
-
-    @Override
-    public @Nullable String getName() {
-        return delegate.getName();
-    }
-
-    @Override
-    public void trace(String msg) {
-        if (minimumLevel.shouldOmit(Level.TRACE)) return;
-        delegate.trace(msg);
-    }
-
-    @Override
-    public void trace(String format, Object arg) {
-        if (minimumLevel.shouldOmit(Level.TRACE)) return;
-        delegate.trace(format, arg);
-    }
-
-    @Override
-    public void trace(String format, Object... args) {
-        if (minimumLevel.shouldOmit(Level.TRACE)) return;
-        delegate.trace(format, args);
-    }
-
-    @Override
-    public void trace(String msg, Throwable t) {
-        if (minimumLevel.shouldOmit(Level.TRACE)) return;
-        delegate.trace(msg, t);
-    }
-
-    @Override
-    public void debug(String msg) {
-        if (minimumLevel.shouldOmit(Level.DEBUG)) return;
-        delegate.debug(msg);
-    }
-
-    @Override
-    public void debug(String format, Object arg) {
-        if (minimumLevel.shouldOmit(Level.DEBUG)) return;
-        delegate.debug(format, arg);
-    }
-
-    @Override
-    public void debug(String format, Object... args) {
-        if (minimumLevel.shouldOmit(Level.DEBUG)) return;
-        delegate.debug(format, args);
-    }
-
-    @Override
-    public void debug(String msg, Throwable t) {
-        if (minimumLevel.shouldOmit(Level.DEBUG)) return;
-        delegate.debug(msg, t);
-    }
-
-    @Override
-    public void info(String msg) {
-        if (minimumLevel.shouldOmit(Level.INFO)) return;
-        delegate.info(msg);
-    }
-
-    @Override
-    public void info(String format, Object arg) {
-        if (minimumLevel.shouldOmit(Level.INFO)) return;
-        delegate.info(format, arg);
-    }
-
-    @Override
-    public void info(String format, Object... args) {
-        if (minimumLevel.shouldOmit(Level.INFO)) return;
-        delegate.info(format, args);
-    }
-
-    @Override
-    public void info(String msg, Throwable t) {
-        if (minimumLevel.shouldOmit(Level.INFO)) return;
-        delegate.info(msg, t);
-    }
-
-    @Override
-    public void warn(String msg) {
-        if (minimumLevel.shouldOmit(Level.WARN)) return;
-        delegate.warn(msg);
-    }
-
-    @Override
-    public void warn(String format, Object arg) {
-        if (minimumLevel.shouldOmit(Level.WARN)) return;
-        delegate.warn(format, arg);
-    }
-
-    @Override
-    public void warn(String format, Object... args) {
-        if (minimumLevel.shouldOmit(Level.WARN)) return;
-        delegate.warn(format, args);
-    }
-
-    @Override
-    public void warn(String msg, Throwable t) {
-        if (minimumLevel.shouldOmit(Level.WARN)) return;
-        delegate.warn(msg, t);
-    }
-
-    @Override
-    public void error(String msg) {
-        if (minimumLevel.shouldOmit(Level.ERROR)) return;
-        delegate.error(msg);
-    }
-
-    @Override
-    public void error(String format, Object arg) {
-        if (minimumLevel.shouldOmit(Level.ERROR)) return;
-        delegate.error(format, arg);
-    }
-
-    @Override
-    public void error(String format, Object... args) {
-        if (minimumLevel.shouldOmit(Level.ERROR)) return;
-        delegate.error(format, args);
-    }
-
-    @Override
-    public void error(String msg, Throwable t) {
-        if (minimumLevel.shouldOmit(Level.ERROR)) return;
-        delegate.error(msg, t);
-    }
-
-    @Override
-    public String format(String format, Object arg) {
-        return delegate.format(format, arg);
-    }
-
-    @Override
-    public String format(String format, Object... args) {
-        return delegate.format(format, args);
-    }
-
-    @Override
-    public String format(String msg, Throwable t) {
-        return delegate.format(msg, t);
-    }
-
-    public Logger getDelegate() {
-        return delegate;
-    }
-
-    /**
-     * Set the minimum level messages must have to not be discarded
-     *
-     * @param minimumLevel The new minimum
-     */
-    public void setMinimumLevel(Level minimumLevel) {
-        this.minimumLevel = Objects.requireNonNull(minimumLevel);
-    }
-
-    /**
-     * Get the minimum level messages must have to not be discarded
-     *
-     * @return the minimum
-     */
-    public Level getMinimumLevel() {
-        return minimumLevel;
-    }
-}

commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/HotSwappingDelegateLogger.java

@@ -1,72 +0,0 @@
-package io.gitlab.jfronny.commons.logging;
-
-import io.gitlab.jfronny.commons.ref.WeakSet;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Objects;
-import java.util.Set;
-import java.util.function.Function;
-
-public class HotSwappingDelegateLogger extends DelegateLogger {
-    public static Function<String, Logger> LOGGER_BUILDER;
-    private static Level MINIMUM_LEVEL = Level.INFO;
-    private static final Set<HotSwappingDelegateLogger> KNOWN_LOGGERS = new WeakSet<>();
-    protected boolean minimumLevelChanged = false;
-
-    static {
-        resetStrategy();
-    }
-
-    public static void resetStrategy() {
-        LOGGER_BUILDER = StdoutLogger::fancy;
-    }
-
-    public static void updateStrategy(@NotNull Function<String, Logger> factory) {
-        LOGGER_BUILDER = Objects.requireNonNull(factory);
-        synchronized (KNOWN_LOGGERS) {
-            for (HotSwappingDelegateLogger ref : KNOWN_LOGGERS) {
-                ref.updateStrategy();
-            }
-        }
-    }
-
-    public static void updateMinimumLevel(Level minimumLevel) {
-        MINIMUM_LEVEL = Objects.requireNonNull(minimumLevel);
-        synchronized (KNOWN_LOGGERS) {
-            for (HotSwappingDelegateLogger ref : KNOWN_LOGGERS) {
-                ref.updateMinimumLevel();
-            }
-        }
-    }
-
-    public static HotSwappingDelegateLogger forName(@NotNull String name) {
-        return new HotSwappingDelegateLogger(name);
-    }
-
-    private final String name;
-
-    private HotSwappingDelegateLogger(String name) {
-        this.name = name;
-        synchronized (KNOWN_LOGGERS) {
-            updateStrategy();
-            updateMinimumLevel();
-            KNOWN_LOGGERS.add(this);
-        }
-    }
-
-    private void updateStrategy() {
-        delegate = LOGGER_BUILDER.apply(name);
-    }
-
-    private void updateMinimumLevel() {
-        if (!minimumLevelChanged) {
-            minimumLevel = MINIMUM_LEVEL;
-        }
-    }
-
-    @Override
-    public void setMinimumLevel(Level minLevel) {
-        super.setMinimumLevel(minLevel);
-        this.minimumLevelChanged = true;
-    }
-}

commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/JavaUtilLogger.java

@@ -1,116 +0,0 @@
-package io.gitlab.jfronny.commons.logging;
-
-import java.util.logging.Level;
-
-public class JavaUtilLogger implements Logger {
-    private final java.util.logging.Logger logger;
-
-    public JavaUtilLogger(String name) {
-        this.logger = java.util.logging.Logger.getLogger(name);
-    }
-
-    @Override
-    public String getName() {
-        return logger.getName();
-    }
-
-    @Override
-    public void trace(String msg) {
-        logger.log(Level.FINER, msg);
-    }
-
-    @Override
-    public void trace(String format, Object arg) {
-        logger.log(Level.FINER, format, arg);
-    }
-
-    @Override
-    public void trace(String format, Object... args) {
-        logger.log(Level.FINER, format, args);
-    }
-
-    @Override
-    public void trace(String msg, Throwable t) {
-        logger.log(Level.FINER, msg, t);
-    }
-
-    @Override
-    public void debug(String msg) {
-        logger.log(Level.FINE, msg);
-    }
-
-    @Override
-    public void debug(String format, Object arg) {
-        logger.log(Level.FINE, format, arg);
-    }
-
-    @Override
-    public void debug(String format, Object... args) {
-        logger.log(Level.FINE, format, args);
-    }
-
-    @Override
-    public void debug(String msg, Throwable t) {
-        logger.log(Level.FINE, msg, t);
-    }
-
-    @Override
-    public void info(String msg) {
-        logger.log(Level.INFO, msg);
-    }
-
-    @Override
-    public void info(String format, Object arg) {
-        logger.log(Level.INFO, format, arg);
-    }
-
-    @Override
-    public void info(String format, Object... args) {
-        logger.log(Level.INFO, format, args);
-    }
-
-    @Override
-    public void info(String msg, Throwable t) {
-        logger.log(Level.INFO, msg, t);
-    }
-
-    @Override
-    public void warn(String msg) {
-        logger.log(Level.WARNING, msg);
-    }
-
-    @Override
-    public void warn(String format, Object arg) {
-        logger.log(Level.WARNING, format, arg);
-    }
-
-    @Override
-    public void warn(String format, Object... args) {
-        logger.log(Level.WARNING, format, args);
-    }
-
-    @Override
-    public void warn(String msg, Throwable t) {
-        logger.log(Level.WARNING, msg, t);
-    }
-
-    @Override
-    public void error(String msg) {
-        logger.log(Level.SEVERE, msg);
-    }
-
-    @Override
-    public void error(String format, Object arg) {
-        logger.log(Level.SEVERE, format, arg);
-    }
-
-    @Override
-    public void error(String format, Object... args) {
-        logger.log(Level.SEVERE, format, args);
-    }
-
-    @Override
-    public void error(String msg, Throwable t) {
-        logger.log(Level.SEVERE, msg, t);
-    }
-}

commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/Level.java

@@ -1,25 +0,0 @@
-package io.gitlab.jfronny.commons.logging;
-
-public enum Level {
-    TRACE(OutputColors.WHITE),
-    DEBUG(OutputColors.WHITE),
-    INFO(OutputColors.BLUE),
-    WARN(OutputColors.RED),
-    ERROR(OutputColors.RED_BOLD);
-
-    public final String color;
-
-    Level(String color) {
-        this.color = color;
-    }
-
-    /**
-     * Whether a message with the provided level should be omitted if this is the minimum level
-     *
-     * @param level The level of the message
-     * @return whether it should be omitted
-     */
-    public boolean shouldOmit(Level level) {
-        return this.compareTo(level) > 0;
-    }
-}

commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/Logger.java

@@ -1,109 +0,0 @@
-package io.gitlab.jfronny.commons.logging;
-
-import io.gitlab.jfronny.commons.StringFormatter;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Objects;
-import java.util.function.Function;
-import java.util.regex.Matcher;
-
-public interface Logger {
-    static Logger forName(@NotNull String name) {
-        return HotSwappingDelegateLogger.forName(Objects.requireNonNull(name));
-    }
-
-    static void registerFactory(@NotNull Function<String, Logger> factory) {
-        HotSwappingDelegateLogger.updateStrategy(Objects.requireNonNull(factory));
-    }
-
-    static void resetFactory() {
-        HotSwappingDelegateLogger.resetStrategy();
-    }
-
-    static void setMinimumLevel(@NotNull Level level) {
-        HotSwappingDelegateLogger.updateMinimumLevel(level);
-    }
-
-    @Nullable String getName();
-
-    default void trace(String msg) {
-        debug(msg);
-    }
-    default void trace(String format, Object arg) {
-        trace(format(format, arg));
-    }
-    default void trace(String format, Object... args) {
-        trace(format(format, args));
-    }
-    default void trace(String msg, Throwable t) {
-        trace(format(msg, t));
-    }
-
-    default void debug(String msg) {
-        info(msg);
-    }
-    default void debug(String format, Object arg) {
-        debug(format(format, arg));
-    }
-    default void debug(String format, Object... args) {
-        debug(format(format, args));
-    }
-    default void debug(String msg, Throwable t) {
-        debug(format(msg, t));
-    }
-
-    void info(String msg);
-    default void info(String format, Object arg) {
-        info(format(format, arg));
-    }
-    default void info(String format, Object... args) {
-        info(format(format, args));
-    }
-    default void info(String msg, Throwable t) {
-        info(format(msg, t));
-    }
-
-    default void warn(String msg) {
-        info(msg);
-    }
-    default void warn(String format, Object arg) {
-        warn(format(format, arg));
-    }
-    default void warn(String format, Object... args) {
-        warn(format(format, args));
-    }
-    default void warn(String msg, Throwable t) {
-        warn(format(msg, t));
-    }
-
-    default void error(String msg) {
-        warn(msg);
-    }
-    default void error(String format, Object arg) {
-        error(format(format, arg));
-    }
-    default void error(String format, Object... args) {
-        error(format(format, args));
-    }
-    default void error(String msg, Throwable t) {
-        error(format(msg, t));
-    }
-
-    default String format(String format, Object arg) {
-        return format.replaceFirst("\\{}", Matcher.quoteReplacement(StringFormatter.toString(arg)));
-    }
-
-    default String format(String format, Object... args) {
-        if (args == null || format == null) return format;
-        for (Object arg : args) {
-            format = format.replaceFirst("\\{}", Matcher.quoteReplacement(StringFormatter.toString(arg)));
-        }
-        return format;
-    }
-
-    default String format(String msg, Throwable t) {
-        if (t == null) return msg;
-        return msg + System.lineSeparator() + StringFormatter.toString(t);
-    }
-}

commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/NopLogger.java

@@ -1,12 +0,0 @@
-package io.gitlab.jfronny.commons.logging;
-
-public class NopLogger implements Logger {
-    @Override
-    public String getName() {
-        return null;
-    }
-
-    @Override
-    public void info(String msg) {
-    }
-}

commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/StdoutLogger.java

@@ -1,19 +0,0 @@
-package io.gitlab.jfronny.commons.logging;
-
-public class StdoutLogger extends PrintStreamLogger {
-    public StdoutLogger(String name) {
-        this(name, false);
-    }
-
-    public StdoutLogger(String name, boolean color) {
-        this(name, color, false, false);
-    }
-
-    public StdoutLogger(String name, boolean color, boolean thread, boolean timestamp) {
-        super(System.out, name, color, thread, timestamp);
-    }
-
-    public static StdoutLogger fancy(String name) {
-        return new StdoutLogger(name, true, true, true);
-    }
-}

commons-logging/src/main/java/module-info.java

@@ -1,6 +0,0 @@
-module io.gitlab.jfronny.commons.logging {
-    exports io.gitlab.jfronny.commons.logging;
-    requires static org.jetbrains.annotations;
-    requires io.gitlab.jfronny.commons;
-    requires java.logging;
-}

commons-logging/src/test/java/io/gitlab/jfronny/commons/logging/test/LoggerTest.java

@@ -1,31 +0,0 @@
-package io.gitlab.jfronny.commons.logging.test;
-
-import io.gitlab.jfronny.commons.logging.HotSwappingDelegateLogger;
-import io.gitlab.jfronny.commons.logging.Logger;
-import io.gitlab.jfronny.commons.logging.NopLogger;
-import io.gitlab.jfronny.commons.logging.StdoutLogger;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertInstanceOf;
-
-public class LoggerTest {
-    @BeforeEach
-    void prepare() {
-        Logger.resetFactory();
-    }
-
-    @Test
-    void testFactory() {
-        assertEquals(StdoutLogger.class, assertInstanceOf(HotSwappingDelegateLogger.class, Logger.forName("Joe")).getDelegate().getClass());
-    }
-
-    @Test
-    void testRegisterFactory() {
-        HotSwappingDelegateLogger logger = assertInstanceOf(HotSwappingDelegateLogger.class, Logger.forName("Joe"));
-        assertEquals(StdoutLogger.class, logger.getDelegate().getClass());
-        Logger.registerFactory(s -> new NopLogger());
-        assertEquals(NopLogger.class, logger.getDelegate().getClass());
-    }
-}

commons-manifold/build.gradle.kts

@@ -1,12 +1,12 @@
 import io.gitlab.jfronny.scripts.*
 
 plugins {
-    id("commons.library")
-    id("jf.manifold")
+    commons.library
+    jf.manifold
 }
 
 dependencies {
-    implementation(project(":commons"))
+    implementation(projects.commons)
 }
 
 publishing {
@@ -27,5 +27,5 @@ tasks.jar {
 }
 
 tasks.javadoc {
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", project(":commons"))
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", projects.commons)
 }

commons-serialize-gson-dsl/build.gradle.kts

@@ -1,12 +1,12 @@
 import io.gitlab.jfronny.scripts.*
 
 plugins {
-    id("commons.library")
+    commons.library
     kotlin("jvm")
 }
 
 dependencies {
-    implementation(project(":commons-serialize-gson"))
+    implementation(projects.commonsSerializeGson)
 
     testImplementation(kotlin("test"))
 }
@@ -28,8 +28,8 @@ tasks.compileKotlin {
 
 tasks.javadoc {
     enabled = false
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", project(":commons"))
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons-gson/$version/raw", project(":commons-serialize"))
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons-gson/$version/raw", project(":commons-serialize-gson"))
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", projects.commons)
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons-serialize/$version/raw", projects.commonsSerialize)
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons-serialize-gson/$version/raw", projects.commonsSerializeGson)
     //TODO link gson javadoc (harder to generate than expected)
 }

commons-serialize-gson/build.gradle.kts

@@ -1,16 +1,16 @@
 import io.gitlab.jfronny.scripts.*
 
 plugins {
-    id("commons.library")
+    commons.library
 }
 
 dependencies {
-    api("io.gitlab.jfronny:gson:2.10.3-SNAPSHOT")
-    implementation(project(":commons"))
-    implementation(project(":commons-serialize"))
+    api(libs.gson)
+    implementation(projects.commons)
+    implementation(projects.commonsSerialize)
 
-    testImplementation("org.junit.jupiter:junit-jupiter-api:5.9.3")
-    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.9.3")
+    testImplementation(libs.junit.jupiter.api)
+    testRuntimeOnly(libs.junit.jupiter.engine)
 }
 
 publishing {
@@ -25,7 +25,7 @@ publishing {
 }
 
 tasks.javadoc {
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", project(":commons"))
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", project(":commons-serialize"))
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", projects.commons)
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons-serialize/$version/raw", projects.commonsSerialize)
     //TODO link gson javadoc (harder to generate than expected)
 }

commons-serialize/build.gradle.kts

@@ -1,7 +1,7 @@
 import io.gitlab.jfronny.scripts.*
 
 plugins {
-    id("commons.library")
+    commons.library
 }
 
 publishing {

commons-unsafe/build.gradle.kts

@@ -1,9 +1,9 @@
 plugins {
-    id("commons.library")
+    commons.library
 }
 
 dependencies {
-    implementation(project(":commons"))
+    implementation(projects.commons)
 }
 
 publishing {

commons/build.gradle.kts

@@ -1,7 +1,7 @@
 import io.gitlab.jfronny.scripts.*
 
 plugins {
-    id("commons.library")
+    commons.library
 }
 
 publishing {

commons/src/main/java/io/gitlab/jfronny/commons/StringFormatter.java

@@ -9,6 +9,7 @@ public class StringFormatter {
         else if (o instanceof Double d) return toString((double) d);
         else if (o instanceof Float f) return toString((float) f);
         else if (o instanceof Throwable t) return toString(t, Objects::toString);
+        else if (o.getClass().isArray()) return arrayToString(o);
         else return o.toString();
     }
 
@@ -75,4 +76,17 @@ public class StringFormatter {
         Throwable cause = t.getCause();
         if (cause != null) getStackTrace(sb, cause, trace, "Caused by: ", prefix, stringify, dejaVu, false);
     }
+
+    private static String arrayToString(Object array) {
+        if (array instanceof boolean[] o) return Arrays.toString(o);
+        else if (array instanceof byte[] o) return Arrays.toString(o);
+        else if (array instanceof char[] o) return Arrays.toString(o);
+        else if (array instanceof short[] o) return Arrays.toString(o);
+        else if (array instanceof int[] o) return Arrays.toString(o);
+        else if (array instanceof long[] o) return Arrays.toString(o);
+        else if (array instanceof float[] o) return Arrays.toString(o);
+        else if (array instanceof double[] o) return Arrays.toString(o);
+        else if (array instanceof Object[] o) return Arrays.toString(o);
+        else return array.toString(); // unknown array type
+    }
 }

gradle/libs.versions.toml

@@ -0,0 +1,17 @@
+[versions]
+slf4j = "2.0.12"
+junit = "5.10.2"
+annotations = "24.1.0"
+gradle-kotlin-dsl = "4.1.2"
+jf-scripts = "1.5-SNAPSHOT"
+gson = "2.10.3-SNAPSHOT"
+
+[libraries]
+slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
+junit-jupiter-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit" }
+junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit" }
+annotations = { module = "org.jetbrains:annotations", version.ref = "annotations" }
+gson = { module = "io.gitlab.jfronny:gson", version.ref = "gson" }
+
+plugin-kotlin = { module = "org.gradle.kotlin:gradle-kotlin-dsl-plugins", version.ref = "gradle-kotlin-dsl"}
+plugin-convention = { module = "io.gitlab.jfronny:convention", version.ref="jf-scripts" }

muscript-gson/build.gradle.kts

@@ -1,15 +1,15 @@
 import io.gitlab.jfronny.scripts.*
 
 plugins {
-    id("commons.library")
+    commons.library
 }
 
 dependencies {
-    implementation(project(":muscript"))
-    implementation(project(":commons-serialize-gson"))
+    implementation(projects.muscript)
+    implementation(projects.commonsSerializeGson)
 
-    testImplementation("org.junit.jupiter:junit-jupiter-api:5.9.3")
-    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.9.3")
+    testImplementation(libs.junit.jupiter.api)
+    testRuntimeOnly(libs.junit.jupiter.engine)
 }
 
 publishing {
@@ -24,8 +24,8 @@ publishing {
 }
 
 tasks.javadoc {
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", project(":commons"))
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons-gson/$version/raw", project(":commons-serialize"))
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons-gson/$version/raw", project(":commons-serialize-gson"))
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/muscript-gson/$version/raw", project(":muscript"))
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", projects.commons)
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons-serialize/$version/raw", projects.commonsSerialize)
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons-serialize-gson/$version/raw", projects.commonsSerializeGson)
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/muscript/$version/raw", projects.muscript)
 }

muscript/build.gradle.kts

@@ -1,15 +1,15 @@
 import io.gitlab.jfronny.scripts.*
 
 plugins {
-    id("commons.library")
+    commons.library
 }
 
 dependencies {
-    implementation(project(":commons"))
-    implementation(project(":commons-logging"))
+    implementation(projects.commons)
+    implementation(libs.slf4j.api)
 
-    testImplementation("org.junit.jupiter:junit-jupiter-api:5.9.3")
-    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.9.3")
+    testImplementation(libs.junit.jupiter.api)
+    testRuntimeOnly(libs.junit.jupiter.engine)
 }
 
 publishing {
@@ -24,5 +24,5 @@ publishing {
 }
 
 tasks.javadoc {
-    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", project(":commons"))
+    linksOffline("https://maven.frohnmeyer-wds.de/javadoc/artifacts/io/gitlab/jfronny/commons/$version/raw", projects.commons)
 }

settings.gradle.kts

@@ -1,15 +1,16 @@
-rootProject.name = "Commons"
+rootProject.name = "JfCommons"
 
 include("commons")
 include("commons-serialize")
 include("commons-serialize-gson")
 include("commons-serialize-gson-dsl")
 include("commons-io")
-include("commons-logging")
-include("commons-logging-slf4j")
+include("commons-logger")
 include("commons-http-client")
 include("commons-http-server")
 include("commons-manifold")
 include("commons-unsafe")
 include("muscript")
 include("muscript-gson")
+
+enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")