diff --git a/build.gradle.kts b/build.gradle.kts index f686431..664fc0f 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1 +1 @@ -version = "1.5-SNAPSHOT" \ No newline at end of file +version = "1.6-SNAPSHOT" \ No newline at end of file diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts index 0fb85cf..889276f 100644 --- a/buildSrc/build.gradle.kts +++ b/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) } diff --git a/buildSrc/settings.gradle.kts b/buildSrc/settings.gradle.kts new file mode 100644 index 0000000..b5a0fab --- /dev/null +++ b/buildSrc/settings.gradle.kts @@ -0,0 +1,7 @@ +dependencyResolutionManagement { + versionCatalogs { + create("libs") { + from(files("../gradle/libs.versions.toml")) + } + } +} diff --git a/buildSrc/src/main/kotlin/commons.library.gradle.kts b/buildSrc/src/main/kotlin/commons.library.gradle.kts index 9a52c2f..cec79d7 100644 --- a/buildSrc/src/main/kotlin/commons.library.gradle.kts +++ b/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().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}") } \ No newline at end of file diff --git a/commons-http-client/build.gradle.kts b/commons-http-client/build.gradle.kts index a569791..4637eb7 100644 --- a/commons-http-client/build.gradle.kts +++ b/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) +} diff --git a/commons-http-server/build.gradle.kts b/commons-http-server/build.gradle.kts index 65c72b8..49e1041 100644 --- a/commons-http-server/build.gradle.kts +++ b/commons-http-server/build.gradle.kts @@ -1,7 +1,7 @@ import io.gitlab.jfronny.scripts.* plugins { - id("commons.library") + commons.library } dependencies { diff --git a/commons-io/build.gradle.kts b/commons-io/build.gradle.kts index 57f2230..bafcee8 100644 --- a/commons-io/build.gradle.kts +++ b/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) +} diff --git a/commons-logger/build.gradle.kts b/commons-logger/build.gradle.kts new file mode 100644 index 0000000..486fd8e --- /dev/null +++ b/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("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") +} diff --git a/commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/CommonsLogger.java b/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/CommonsLogger.java similarity index 99% rename from commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/CommonsLogger.java rename to commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/CommonsLogger.java index d720ea3..4ac5f49 100644 --- a/commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/CommonsLogger.java +++ b/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; diff --git a/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/CompactLogger.java b/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/CompactLogger.java new file mode 100644 index 0000000..34389bf --- /dev/null +++ b/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); + } +} diff --git a/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/CompoundLogger.java b/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/CompoundLogger.java new file mode 100644 index 0000000..4e8a2d5 --- /dev/null +++ b/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); + } + } +} diff --git a/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/DelegateLogger.java b/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/DelegateLogger.java new file mode 100644 index 0000000..3d73bbd --- /dev/null +++ b/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); + } +} diff --git a/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/HotswapLoggerFactory.java b/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/HotswapLoggerFactory.java new file mode 100644 index 0000000..74c7f4d --- /dev/null +++ b/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; + } + } +} diff --git a/commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/CommonsServiceProvider.java b/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/HotswapServiceProvider.java similarity index 84% rename from commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/CommonsServiceProvider.java rename to commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/HotswapServiceProvider.java index ac52025..87b6b2d 100644 --- a/commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/CommonsServiceProvider.java +++ b/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(); } diff --git a/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/LeveledLoggerFactory.java b/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/LeveledLoggerFactory.java new file mode 100644 index 0000000..f26a38a --- /dev/null +++ b/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); +} diff --git a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/MemoryLogger.java b/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/MemoryLogger.java similarity index 68% rename from commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/MemoryLogger.java rename to commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/MemoryLogger.java index 20915c1..45ecacb 100644 --- a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/MemoryLogger.java +++ b/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 { +public class MemoryLogger implements CompactLogger, Iterable { private final String name; private final List 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 { @Override public void trace(String msg) { - add("[T] " + msg); + add("[Ŧ] " + msg); } @Override public void debug(String msg) { - add("[D] " + msg); + add("[Đ] " + msg); } @Override diff --git a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/OutputColors.java b/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/OutputColors.java similarity index 93% rename from commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/OutputColors.java rename to commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/OutputColors.java index 80320a6..ab31c02 100644 --- a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/OutputColors.java +++ b/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; + }; + } } diff --git a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/PrintStreamLogger.java b/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/PrintStreamLogger.java similarity index 84% rename from commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/PrintStreamLogger.java rename to commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/PrintStreamLogger.java index 9daeee3..fffe201 100644 --- a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/PrintStreamLogger.java +++ b/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(' '); } diff --git a/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/StdoutLogger.java b/commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/StdoutLogger.java new file mode 100644 index 0000000..31218f8 --- /dev/null +++ b/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); + } +} diff --git a/commons-logger/src/main/java/module-info.java b/commons-logger/src/main/java/module-info.java new file mode 100644 index 0000000..5d8dc24 --- /dev/null +++ b/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; +} \ No newline at end of file diff --git a/commons-logger/src/main/resources/META-INF/services/org.slf4j.spi.SLF4JServiceProvider b/commons-logger/src/main/resources/META-INF/services/org.slf4j.spi.SLF4JServiceProvider new file mode 100644 index 0000000..6a8649d --- /dev/null +++ b/commons-logger/src/main/resources/META-INF/services/org.slf4j.spi.SLF4JServiceProvider @@ -0,0 +1 @@ +io.gitlab.jfronny.commons.logger.HotswapServiceProvider \ No newline at end of file diff --git a/commons-logging-slf4j/build.gradle.kts b/commons-logging-slf4j/build.gradle.kts deleted file mode 100644 index 4525ee6..0000000 --- a/commons-logging-slf4j/build.gradle.kts +++ /dev/null @@ -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("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") -} diff --git a/commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/CommonsLoggerFactory.java b/commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/CommonsLoggerFactory.java deleted file mode 100644 index f02bf8c..0000000 --- a/commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/CommonsLoggerFactory.java +++ /dev/null @@ -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 loggerMap = new HashMap<>(); - - @Override - public synchronized Logger getLogger(String name) { - return loggerMap.computeIfAbsent(name, CommonsLogger::new); - } -} diff --git a/commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/SLF4JLogger.java b/commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/SLF4JLogger.java deleted file mode 100644 index ed9d1e6..0000000 --- a/commons-logging-slf4j/src/main/java/io/gitlab/jfronny/commons/logging/slf4j/SLF4JLogger.java +++ /dev/null @@ -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); - } -} diff --git a/commons-logging-slf4j/src/main/java/module-info.java b/commons-logging-slf4j/src/main/java/module-info.java deleted file mode 100644 index ed5fd6a..0000000 --- a/commons-logging-slf4j/src/main/java/module-info.java +++ /dev/null @@ -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; -} \ No newline at end of file diff --git a/commons-logging-slf4j/src/test/java/io/gitlab/jfronny/commons/test/SLFLogStrategyTest.java b/commons-logging-slf4j/src/test/java/io/gitlab/jfronny/commons/test/SLFLogStrategyTest.java deleted file mode 100644 index 5baf5bf..0000000 --- a/commons-logging-slf4j/src/test/java/io/gitlab/jfronny/commons/test/SLFLogStrategyTest.java +++ /dev/null @@ -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()); - } -} diff --git a/commons-logging/build.gradle.kts b/commons-logging/build.gradle.kts deleted file mode 100644 index 97539fb..0000000 --- a/commons-logging/build.gradle.kts +++ /dev/null @@ -1,20 +0,0 @@ -import io.gitlab.jfronny.scripts.* - -plugins { - id("commons.library") -} - -dependencies { - implementation(project(":commons")) -} - -publishing { - publications { - create("maven") { - groupId = "io.gitlab.jfronny" - artifactId = "commons-logging" - - from(components["java"]) - } - } -} diff --git a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/CompoundLogger.java b/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/CompoundLogger.java deleted file mode 100644 index b1bbdb9..0000000 --- a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/CompoundLogger.java +++ /dev/null @@ -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); - } -} diff --git a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/DelegateLogger.java b/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/DelegateLogger.java deleted file mode 100644 index ae6bb4d..0000000 --- a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/DelegateLogger.java +++ /dev/null @@ -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; - } -} diff --git a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/HotSwappingDelegateLogger.java b/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/HotSwappingDelegateLogger.java deleted file mode 100644 index 3638d3d..0000000 --- a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/HotSwappingDelegateLogger.java +++ /dev/null @@ -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 LOGGER_BUILDER; - private static Level MINIMUM_LEVEL = Level.INFO; - private static final Set KNOWN_LOGGERS = new WeakSet<>(); - protected boolean minimumLevelChanged = false; - - static { - resetStrategy(); - } - - public static void resetStrategy() { - LOGGER_BUILDER = StdoutLogger::fancy; - } - - public static void updateStrategy(@NotNull Function 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; - } -} diff --git a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/JavaUtilLogger.java b/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/JavaUtilLogger.java deleted file mode 100644 index 584e1ef..0000000 --- a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/JavaUtilLogger.java +++ /dev/null @@ -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); - } -} diff --git a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/Level.java b/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/Level.java deleted file mode 100644 index 1c3dcf8..0000000 --- a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/Level.java +++ /dev/null @@ -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; - } -} diff --git a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/Logger.java b/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/Logger.java deleted file mode 100644 index 5adb488..0000000 --- a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/Logger.java +++ /dev/null @@ -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 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); - } -} diff --git a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/NopLogger.java b/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/NopLogger.java deleted file mode 100644 index dc44422..0000000 --- a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/NopLogger.java +++ /dev/null @@ -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) { - } -} diff --git a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/StdoutLogger.java b/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/StdoutLogger.java deleted file mode 100644 index 5348c5c..0000000 --- a/commons-logging/src/main/java/io/gitlab/jfronny/commons/logging/StdoutLogger.java +++ /dev/null @@ -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); - } -} diff --git a/commons-logging/src/main/java/module-info.java b/commons-logging/src/main/java/module-info.java deleted file mode 100644 index 0b3195c..0000000 --- a/commons-logging/src/main/java/module-info.java +++ /dev/null @@ -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; -} \ No newline at end of file diff --git a/commons-logging/src/test/java/io/gitlab/jfronny/commons/logging/test/LoggerTest.java b/commons-logging/src/test/java/io/gitlab/jfronny/commons/logging/test/LoggerTest.java deleted file mode 100644 index 76e8aa5..0000000 --- a/commons-logging/src/test/java/io/gitlab/jfronny/commons/logging/test/LoggerTest.java +++ /dev/null @@ -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()); - } -} diff --git a/commons-manifold/build.gradle.kts b/commons-manifold/build.gradle.kts index b15b22f..ecc6f31 100644 --- a/commons-manifold/build.gradle.kts +++ b/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) } diff --git a/commons-serialize-gson-dsl/build.gradle.kts b/commons-serialize-gson-dsl/build.gradle.kts index 7228e7a..e39a194 100644 --- a/commons-serialize-gson-dsl/build.gradle.kts +++ b/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) } diff --git a/commons-serialize-gson/build.gradle.kts b/commons-serialize-gson/build.gradle.kts index ee30b06..36d7ae8 100644 --- a/commons-serialize-gson/build.gradle.kts +++ b/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) } diff --git a/commons-serialize/build.gradle.kts b/commons-serialize/build.gradle.kts index 8c1dadb..6852703 100644 --- a/commons-serialize/build.gradle.kts +++ b/commons-serialize/build.gradle.kts @@ -1,7 +1,7 @@ import io.gitlab.jfronny.scripts.* plugins { - id("commons.library") + commons.library } publishing { diff --git a/commons-unsafe/build.gradle.kts b/commons-unsafe/build.gradle.kts index 60e9511..bc475d7 100644 --- a/commons-unsafe/build.gradle.kts +++ b/commons-unsafe/build.gradle.kts @@ -1,9 +1,9 @@ plugins { - id("commons.library") + commons.library } dependencies { - implementation(project(":commons")) + implementation(projects.commons) } publishing { diff --git a/commons/build.gradle.kts b/commons/build.gradle.kts index 1b0f7bf..19a5a01 100644 --- a/commons/build.gradle.kts +++ b/commons/build.gradle.kts @@ -1,7 +1,7 @@ import io.gitlab.jfronny.scripts.* plugins { - id("commons.library") + commons.library } publishing { diff --git a/commons/src/main/java/io/gitlab/jfronny/commons/StringFormatter.java b/commons/src/main/java/io/gitlab/jfronny/commons/StringFormatter.java index 79dc437..58ca30c 100644 --- a/commons/src/main/java/io/gitlab/jfronny/commons/StringFormatter.java +++ b/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 + } } diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml new file mode 100644 index 0000000..2c9dcc5 --- /dev/null +++ b/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" } \ No newline at end of file diff --git a/muscript-gson/build.gradle.kts b/muscript-gson/build.gradle.kts index 0578e59..129a7e3 100644 --- a/muscript-gson/build.gradle.kts +++ b/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) } diff --git a/muscript/build.gradle.kts b/muscript/build.gradle.kts index 8407d9b..d12e22f 100644 --- a/muscript/build.gradle.kts +++ b/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) } diff --git a/settings.gradle.kts b/settings.gradle.kts index 8f2d632..68dbb5b 100644 --- a/settings.gradle.kts +++ b/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")