Johannes/java-commons
Johannes
/
java-commons
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

BREAKING(logger): use System.Logger instead of SLF4J
ci/woodpecker/push/woodpecker Pipeline was successful Details

This commit is contained in:
Johannes Frohnmeyer 2024-03-14 13:57:12 +01:00
parent 2935b9af7c
commit af6252522d
Signed by: Johannes
GPG Key ID: E76429612C2929F4
22 changed files with 285 additions and 1235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
README.md
View File

@ -5,7 +5,14 @@ Common code for my java projects. Uses my common [build scripts](https://git.fro
## Modules ## Modules
- commons: Common java code without a major theme or external dependencies - commons: Common java code without a major theme or external dependencies
- commons-http-client: A simple http client
- commons-http-server: A simple http server based on JLHTTP
- commons-io: Utility classes for caching, hashing, reading json, opening archives, etc.
- commons-logger: A simple logging framework for System.Logger supporting hot reloading and slightly improved APIs
- commons-manifold: Some common code using the features of manifold-ext. Mainly extension classes.
- commons-serialize: Provides some utility classes for serialization
- commons-serialize-gson: Provides some utility classes around my fork of gson and an implementation of the `Serializer` interface
- commons-serialize-gson-dsl: Provides a Kotlin DSL for json generation
- commons-unsafe: Provides wrappers around sun.misc.Unsafe and the LambdaMetaFactory
- [muscript](https://git.frohnmeyer-wds.de/Johannes/java-commons/src/branch/master/muscript): A simple scripting language - [muscript](https://git.frohnmeyer-wds.de/Johannes/java-commons/src/branch/master/muscript): A simple scripting language
- commons-slf4j: SLF4J bindings for the logging abstraction in commons. Supports using commons as a backend for slf and slf as a commons backend. - [muscript-gson](https://git.frohnmeyer-wds.de/Johannes/java-commons/src/branch/master/muscript-gson): Glue code for manipulating gson with muscript
- commons-gson: Provides some utility classes around my fork of gson
- commons-manifold: Some common code using the features of manifold-ext. Mainly extension classes.

2
commons-logger/build.gradle.kts
View File

@ -5,7 +5,6 @@ plugins {
} }
dependencies { dependencies {
implementation(libs.slf4j.api)
implementation(projects.commons) implementation(projects.commons)
testImplementation(libs.junit.jupiter.api) testImplementation(libs.junit.jupiter.api)
@ -25,5 +24,4 @@ publishing {
tasks.javadoc { 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/$version/raw", projects.commons)
opts.links("https://www.slf4j.org/apidocs")
} }

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

@ -1,363 +1,57 @@
package io.gitlab.jfronny.commons.logger; package io.gitlab.jfronny.commons.logger;
import io.gitlab.jfronny.commons.StringFormatter; import io.gitlab.jfronny.commons.StringFormatter;
import org.slf4j.Logger;
import org.slf4j.Marker;
import org.slf4j.event.Level;
import org.slf4j.helpers.MessageFormatter;
/** import java.text.MessageFormat;
* Abstract logger that implements formatting and redirects calls to methods taking strings. import java.util.MissingResourceException;
* Simplifies the implementation of custom loggers. import java.util.ResourceBundle;
*/
public interface CompactLogger extends Logger { public interface CompactLogger extends SystemLoggerPlus {
/**
* Set the logging level
* @return the current logging level
*/
Level getLevel(); Level getLevel();
void log(Level level, String message);
@Override default void log(Level level, String message, Throwable throwable) {
default boolean isTraceEnabled() { if (!isLoggable(level)) return;
return getLevel().compareTo(Level.TRACE) >= 0; log(level, message + System.lineSeparator() + StringFormatter.toString(throwable));
} }
@Override @Override
default void trace(String msg) { default boolean isLoggable(Level level) {
if (isTraceEnabled()) { if (level == Level.ALL) return true;
if (isDebugEnabled()) { if (level == Level.OFF) return false;
debug(msg); return level.getSeverity() >= getLevel().getSeverity();
} else { }
info(msg);
@Override
default void log(Level level, ResourceBundle resourceBundle, String s, Throwable throwable) {
if (!isLoggable(level)) return;
s = getResourceStringOrMessage(resourceBundle, s);
log(level, s, throwable);
}
@Override
default void log(Level level, ResourceBundle resourceBundle, String s, Object... objects) {
if (!isLoggable(level)) return;
s = getResourceStringOrMessage(resourceBundle, s);
if (objects != null && objects.length > 0) {
String[] strings = new String[objects.length];
for (int i = 0; i < objects.length; i++) {
strings[i] = StringFormatter.toString(objects[i]);
} }
log(level, new MessageFormat(s).format(strings));
} else {
log(level, s);
} }
} }
@Override private static String getResourceStringOrMessage(ResourceBundle bundle, String msg) {
default void trace(String format, Object arg) { // This method was taken from SLF4J and modified slightly
trace(format(format, arg)); if (bundle == null || msg == null) return msg;
} try {
return bundle.getString(msg);
@Override } catch (MissingResourceException ex) {
default void trace(String format, Object arg1, Object arg2) { return msg;
trace(format(format, arg1, arg2)); } catch (ClassCastException ex) {
} return bundle.getObject(msg).toString();
@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);
}
} }

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

@ -1,16 +1,16 @@
package io.gitlab.jfronny.commons.logger; package io.gitlab.jfronny.commons.logger;
import org.slf4j.Logger;
import org.slf4j.Marker; import java.util.ResourceBundle;
/** /**
* Logger implementation that logs to multiple loggers at once. * Logger implementation that logs to multiple loggers at once.
*/ */
public class CompoundLogger implements Logger { public class CompoundLogger implements SystemLoggerPlus {
private final String name; private final String name;
private final Logger[] loggers; private final System.Logger[] loggers;
public CompoundLogger(String name, Logger[] loggers) { public CompoundLogger(String name, System.Logger[] loggers) {
this.name = name; this.name = name;
this.loggers = loggers; this.loggers = loggers;
} }
@ -21,432 +21,24 @@ public class CompoundLogger implements Logger {
} }
@Override @Override
public boolean isTraceEnabled() { public boolean isLoggable(Level level) {
for (Logger logger : loggers) { for (System.Logger logger : loggers) {
if (logger.isTraceEnabled()) return true; if (logger.isLoggable(level)) return true;
} }
return false; return false;
} }
@Override @Override
public void trace(String msg) { public void log(Level level, ResourceBundle resourceBundle, String s, Throwable throwable) {
for (Logger logger : loggers) { for (System.Logger logger : loggers) {
logger.trace(msg); if (logger.isLoggable(level)) logger.log(level, resourceBundle, s, throwable);
} }
} }
@Override @Override
public void trace(String format, Object arg) { public void log(Level level, ResourceBundle resourceBundle, String s, Object... objects) {
for (Logger logger : loggers) { for (System.Logger logger : loggers) {
logger.trace(format, arg); if (logger.isLoggable(level)) logger.log(level, resourceBundle, s, objects);
}
}
@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);
} }
} }
} }

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

@ -1,22 +1,21 @@
package io.gitlab.jfronny.commons.logger; package io.gitlab.jfronny.commons.logger;
import org.slf4j.Logger; import java.util.ResourceBundle;
import org.slf4j.Marker;
/** /**
* A logger that delegates all calls to another logger. * A logger that delegates all calls to another logger.
*/ */
public abstract class DelegateLogger implements Logger { public abstract class DelegateLogger implements SystemLoggerPlus {
public static DelegateLogger create(Logger delegate) { public static DelegateLogger create(System.Logger delegate) {
return new DelegateLogger() { return new DelegateLogger() {
@Override @Override
protected Logger getDelegate() { protected System.Logger getDelegate() {
return delegate; return delegate;
} }
}; };
} }
protected abstract Logger getDelegate(); protected abstract System.Logger getDelegate();
@Override @Override
public String getName() { public String getName() {
@ -24,302 +23,17 @@ public abstract class DelegateLogger implements Logger {
} }
@Override @Override
public boolean isTraceEnabled() { public boolean isLoggable(Level level) {
return !getDelegate().isTraceEnabled(); return getDelegate().isLoggable(level);
} }
@Override @Override
public void trace(String msg) { public void log(Level level, ResourceBundle resourceBundle, String s, Throwable throwable) {
getDelegate().trace(msg); getDelegate().log(level, resourceBundle, s, throwable);
} }
@Override @Override
public void trace(String format, Object arg) { public void log(Level level, ResourceBundle resourceBundle, String s, Object... objects) {
getDelegate().trace(format, arg); getDelegate().log(level, resourceBundle, s, objects);
}
@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);
} }
} }

71
commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/HotswapLoggerFactory.java → commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/HotswapLoggerFinder.java
View File

@ -2,9 +2,6 @@ package io.gitlab.jfronny.commons.logger;
import io.gitlab.jfronny.commons.ref.WeakSet; import io.gitlab.jfronny.commons.ref.WeakSet;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.slf4j.ILoggerFactory;
import org.slf4j.Logger;
import org.slf4j.event.Level;
import java.util.Objects; import java.util.Objects;
import java.util.Set; import java.util.Set;
@ -12,14 +9,14 @@ import java.util.Set;
/** /**
* A logger factory that allows apps to swap the backing factory at runtime, automatically updating all created loggers. * A logger factory that allows apps to swap the backing factory at runtime, automatically updating all created loggers.
*/ */
public class HotswapLoggerFactory implements LeveledLoggerFactory { public class HotswapLoggerFinder extends LeveledLoggerFinder {
private static final Set<HotswapLoggerFactory> KNOWN_INSTANCES = new WeakSet<>(); private static final Set<HotswapLoggerFinder> KNOWN_INSTANCES = new WeakSet<>();
/** /**
* Resets all known instances to use the default logger factory. * Resets all known instances to use the default logger factory.
*/ */
public static void resetAllStrategies() { public static void resetAllStrategies() {
for (HotswapLoggerFactory factory : KNOWN_INSTANCES) { for (HotswapLoggerFinder factory : KNOWN_INSTANCES) {
factory.resetStrategy(); factory.resetStrategy();
} }
} }
@ -28,18 +25,20 @@ public class HotswapLoggerFactory implements LeveledLoggerFactory {
* Updates all known instances to use the new logger factory. * Updates all known instances to use the new logger factory.
* @param factory the new logger factory to use for all known instances * @param factory the new logger factory to use for all known instances
*/ */
public static void updateAllStrategies(ILoggerFactory factory) { public static void updateAllStrategies(System.LoggerFinder factory) {
for (HotswapLoggerFactory f : KNOWN_INSTANCES) { updateAllStrategies(LeveledLoggerFinder.get(factory));
f.updateStrategy(factory); }
}
public static void updateAllStrategies(LeveledLoggerFinder.Simple factory) {
updateAllStrategies(LeveledLoggerFinder.get(factory));
} }
/** /**
* Updates all known instances to use the new logger factory. * Updates all known instances to use the new logger factory.
* @param factory the new logger factory to use for all known instances * @param factory the new logger factory to use for all known instances
*/ */
public static void updateAllStrategies(LeveledLoggerFactory factory) { public static void updateAllStrategies(LeveledLoggerFinder factory) {
for (HotswapLoggerFactory f : KNOWN_INSTANCES) { for (HotswapLoggerFinder f : KNOWN_INSTANCES) {
f.updateStrategy(factory); f.updateStrategy(factory);
} }
} }
@ -48,18 +47,18 @@ public class HotswapLoggerFactory implements LeveledLoggerFactory {
* Updates all known instances to use the new minimum log level if supported. * Updates all known instances to use the new minimum log level if supported.
* @param minimumLevel the new minimum level to use for all known instances * @param minimumLevel the new minimum level to use for all known instances
*/ */
public static void updateAllDefaultLevels(Level minimumLevel) { public static void updateAllDefaultLevels(System.Logger.Level minimumLevel) {
for (HotswapLoggerFactory f : KNOWN_INSTANCES) { for (HotswapLoggerFinder f : KNOWN_INSTANCES) {
f.updateDefaultLevel(minimumLevel); f.updateDefaultLevel(minimumLevel);
} }
} }
public HotswapLoggerFactory() { public HotswapLoggerFinder() {
KNOWN_INSTANCES.add(this); KNOWN_INSTANCES.add(this);
} }
private LeveledLoggerFactory defaultFactory = StdoutLogger::fancy; private LeveledLoggerFinder defaultFactory = LeveledLoggerFinder.get(StdoutLogger::fancy);
private Level minimumLevel = Level.INFO; private System.Logger.Level minimumLevel = System.Logger.Level.INFO;
private int version = 0; private int version = 0;
/** /**
@ -73,19 +72,23 @@ public class HotswapLoggerFactory implements LeveledLoggerFactory {
* Updates the strategy to use the new logger factory. * Updates the strategy to use the new logger factory.
* @param factory the new logger factory to use * @param factory the new logger factory to use
*/ */
public void updateStrategy(ILoggerFactory factory) { public void updateStrategy(System.LoggerFinder factory) {
if (factory instanceof LeveledLoggerFactory f) { if (factory instanceof LeveledLoggerFinder f) {
updateStrategy(f); updateStrategy(f);
} else { } else {
updateStrategy((name, level) -> factory.getLogger(name)); updateStrategy(LeveledLoggerFinder.get(factory));
} }
} }
public void updateStrategy(LeveledLoggerFinder.Simple factory) {
updateStrategy(LeveledLoggerFinder.get(factory));
}
/** /**
* Updates the strategy to use the new logger factory. * Updates the strategy to use the new logger factory.
* @param factory the new logger factory to use * @param factory the new logger factory to use
*/ */
public void updateStrategy(LeveledLoggerFactory factory) { public void updateStrategy(LeveledLoggerFinder factory) {
synchronized (this) { synchronized (this) {
defaultFactory = Objects.requireNonNull(factory); defaultFactory = Objects.requireNonNull(factory);
version++; version++;
@ -96,7 +99,7 @@ public class HotswapLoggerFactory implements LeveledLoggerFactory {
* Updates the minimum log level to use if supported. * Updates the minimum log level to use if supported.
* @param minimumLevel the new minimum level to use if supported * @param minimumLevel the new minimum level to use if supported
*/ */
public void updateDefaultLevel(Level minimumLevel) { public void updateDefaultLevel(System.Logger.Level minimumLevel) {
synchronized (this) { synchronized (this) {
this.minimumLevel = Objects.requireNonNull(minimumLevel); this.minimumLevel = Objects.requireNonNull(minimumLevel);
version++; version++;
@ -104,35 +107,37 @@ public class HotswapLoggerFactory implements LeveledLoggerFactory {
} }
@Override @Override
public Logger getLogger(String name, @Nullable Level level) { public SystemLoggerPlus getLogger(String name, Module module, @Nullable System.Logger.Level level) {
return new SwappableDelegateLogger(name, level); return new SwappableDelegateLogger(name, module, level);
} }
private class SwappableDelegateLogger extends DelegateLogger { private class SwappableDelegateLogger extends DelegateLogger {
private final String name; private final String name;
private final Module module;
private final boolean keepLevel; private final boolean keepLevel;
private Level lastMinimumLevel; private Level lastMinimumLevel;
private Logger delegate; private System.Logger delegate;
int version = -1; int version = -1;
private SwappableDelegateLogger(String name, @Nullable Level level) { private SwappableDelegateLogger(String name, Module module, @Nullable Level level) {
this.name = name == null ? "null" : name; this.name = name == null ? "null" : name;
this.module = module;
this.keepLevel = level != null; this.keepLevel = level != null;
this.lastMinimumLevel = level == null ? HotswapLoggerFactory.this.minimumLevel : level; this.lastMinimumLevel = level == null ? HotswapLoggerFinder.this.minimumLevel : level;
updateStrategy(); updateStrategy();
} }
public void updateStrategy() { public void updateStrategy() {
if (this.version == HotswapLoggerFactory.this.version) return; if (this.version == HotswapLoggerFinder.this.version) return;
synchronized (HotswapLoggerFactory.this) { synchronized (HotswapLoggerFinder.this) {
this.version = HotswapLoggerFactory.this.version; this.version = HotswapLoggerFinder.this.version;
if (!keepLevel) this.lastMinimumLevel = HotswapLoggerFactory.this.minimumLevel; if (!keepLevel) this.lastMinimumLevel = HotswapLoggerFinder.this.minimumLevel;
this.delegate = HotswapLoggerFactory.this.defaultFactory.getLogger(this.name, this.lastMinimumLevel); this.delegate = HotswapLoggerFinder.this.defaultFactory.getLogger(this.name, module, this.lastMinimumLevel);
} }
} }
@Override @Override
protected Logger getDelegate() { protected System.Logger getDelegate() {
updateStrategy(); updateStrategy();
return delegate; return delegate;
} }

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

@ -1,44 +0,0 @@
package io.gitlab.jfronny.commons.logger;
import org.slf4j.ILoggerFactory;
import org.slf4j.IMarkerFactory;
import org.slf4j.helpers.BasicMarkerFactory;
import org.slf4j.helpers.NOPMDCAdapter;
import org.slf4j.spi.MDCAdapter;
import org.slf4j.spi.SLF4JServiceProvider;
/**
* A ServiceProvider creating HotswapLoggerFactories.
*/
public class HotswapServiceProvider implements SLF4JServiceProvider {
private ILoggerFactory loggerFactory;
private IMarkerFactory markerFactory;
private MDCAdapter mdcAdapter;
@Override
public ILoggerFactory getLoggerFactory() {
return loggerFactory;
}
@Override
public IMarkerFactory getMarkerFactory() {
return markerFactory;
}
@Override
public MDCAdapter getMDCAdapter() {
return mdcAdapter;
}
@Override
public String getRequestedApiVersion() {
return "2.0.0";
}
@Override
public void initialize() {
loggerFactory = new HotswapLoggerFactory();
markerFactory = new BasicMarkerFactory();
mdcAdapter = new NOPMDCAdapter();
}
}

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

@ -1,19 +0,0 @@
package io.gitlab.jfronny.commons.logger;
import org.jetbrains.annotations.Nullable;
import org.slf4j.ILoggerFactory;
import org.slf4j.Logger;
import org.slf4j.event.Level;
/**
* Abstract logger factory that optionally takes a log level.
*/
@FunctionalInterface
public interface LeveledLoggerFactory extends ILoggerFactory {
@Override
default Logger getLogger(String name) {
return getLogger(name, null);
}
Logger getLogger(String name, @Nullable Level level);
}

37
commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/LeveledLoggerFinder.java Normal file
View File

@ -0,0 +1,37 @@
package io.gitlab.jfronny.commons.logger;
import org.jetbrains.annotations.Nullable;
/**
* Abstract logger factory that optionally takes a log level.
*/
public abstract class LeveledLoggerFinder extends System.LoggerFinder {
public static LeveledLoggerFinder get(Simple simple) {
return new LeveledLoggerFinder() {
@Override
public SystemLoggerPlus getLogger(String name, Module module, @Nullable System.Logger.Level level) {
return simple.getLogger(name, module, level);
}
};
}
public static LeveledLoggerFinder get(System.LoggerFinder factory) {
return factory instanceof LeveledLoggerFinder fac ? fac : get((name, module, level) -> SystemLoggerPlus.get(factory.getLogger(name, module)));
}
public static LeveledLoggerFinder getLoggerFinder() {
return get(System.LoggerFinder.getLoggerFinder());
}
@Override
public SystemLoggerPlus getLogger(String s, Module module) {
return getLogger(s, module, null);
}
public abstract SystemLoggerPlus getLogger(String name, Module module, @Nullable System.Logger.Level level);
@FunctionalInterface
public interface Simple {
SystemLoggerPlus getLogger(String name, Module module, @Nullable System.Logger.Level level);
}
}

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

@ -1,7 +1,6 @@
package io.gitlab.jfronny.commons.logger; package io.gitlab.jfronny.commons.logger;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.slf4j.event.Level;
import java.util.*; import java.util.*;
import java.util.function.Consumer; import java.util.function.Consumer;
@ -34,6 +33,19 @@ public class MemoryLogger implements CompactLogger, Iterable<String> {
return level; return level;
} }
@Override
public void log(Level level, String message) {
if (!isLoggable(level)) return;
add("[" + switch (level) {
case TRACE -> "T";
case DEBUG -> "D";
case INFO -> "I";
case WARNING -> "W";
case ERROR -> "E";
default -> "I";
} + "] " + message);
}
@Override @Override
public String getName() { public String getName() {
return name; return name;
@ -50,31 +62,6 @@ public class MemoryLogger implements CompactLogger, Iterable<String> {
} }
} }
@Override
public void trace(String msg) {
add("[Ŧ] " + msg);
}
@Override
public void debug(String msg) {
add("[Đ] " + msg);
}
@Override
public void info(String msg) {
add("[I] " + msg);
}
@Override
public void warn(String msg) {
add("[W] " + msg);
}
@Override
public void error(String msg) {
add("[E] " + msg);
}
@NotNull @NotNull
@Override @Override
public Iterator<String> iterator() { public Iterator<String> iterator() {

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

@ -1,7 +1,5 @@
package io.gitlab.jfronny.commons.logger; package io.gitlab.jfronny.commons.logger;
import org.slf4j.event.Level;
/** /**
* A class that provides ANSI escape codes for colored console output. * A class that provides ANSI escape codes for colored console output.
*/ */
@ -85,10 +83,10 @@ public class OutputColors {
* @param level the level to get the color for * @param level the level to get the color for
* @return the ANSI escape code for the given level * @return the ANSI escape code for the given level
*/ */
public static String byLevel(Level level) { public static String byLevel(System.Logger.Level level) {
return switch (level) { return switch (level) {
case INFO -> BLUE; case INFO -> BLUE;
case WARN -> RED; case WARNING -> RED;
case ERROR -> RED_BOLD; case ERROR -> RED_BOLD;
default -> WHITE; default -> WHITE;
}; };

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

@ -2,7 +2,6 @@ package io.gitlab.jfronny.commons.logger;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.slf4j.event.Level;
import java.io.PrintStream; import java.io.PrintStream;
import java.time.LocalTime; import java.time.LocalTime;
@ -17,7 +16,7 @@ public class PrintStreamLogger implements CompactLogger {
private final boolean color; private final boolean color;
private final boolean thread; private final boolean thread;
private final boolean timestamp; private final boolean timestamp;
private final Level level; private final System.Logger.Level level;
private final PrintStream target; private final PrintStream target;
/** /**
@ -29,7 +28,7 @@ public class PrintStreamLogger implements CompactLogger {
* @param thread whether to include the thread name in the output * @param thread whether to include the thread name in the output
* @param timestamp whether to include a timestamp in the output * @param timestamp whether to include a timestamp in the output
*/ */
public PrintStreamLogger(@NotNull PrintStream target, @Nullable String name, Level level, boolean color, boolean thread, boolean timestamp) { public PrintStreamLogger(@NotNull PrintStream target, @Nullable String name, System.Logger.Level level, boolean color, boolean thread, boolean timestamp) {
this.target = Objects.requireNonNull(target); this.target = Objects.requireNonNull(target);
this.name = name; this.name = name;
this.level = level; this.level = level;
@ -44,33 +43,23 @@ public class PrintStreamLogger implements CompactLogger {
} }
@Override @Override
public Level getLevel() { public System.Logger.Level getLevel() {
return level; return level;
} }
@Override @Override
public void trace(String msg) { public void log(Level level, String message) {
target.println(generateMessage(msg, Level.TRACE)); if (!isLoggable(level)) return;
else if (level == Level.ALL) level = Level.TRACE;
target.println(generateMessage(message, level));
} }
@Override @Override
public void debug(String msg) { public void log(Level level, String message, Throwable throwable) {
target.println(generateMessage(msg, Level.DEBUG)); if (!isLoggable(level)) return;
} else if (level == Level.ALL) level = Level.TRACE;
target.println(generateMessage(message, level));
@Override throwable.printStackTrace(target);
public void info(String msg) {
target.println(generateMessage(msg, Level.INFO));
}
@Override
public void warn(String msg) {
target.println(generateMessage(msg, Level.WARN));
}
@Override
public void error(String msg) {
target.println(generateMessage(msg, Level.ERROR));
} }
/** /**
@ -79,7 +68,7 @@ public class PrintStreamLogger implements CompactLogger {
* @param level the level of the message * @param level the level of the message
* @return the formatted message * @return the formatted message
*/ */
protected String generateMessage(String msg, Level level) { protected String generateMessage(String msg, System.Logger.Level level) {
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
// Timestamp // Timestamp
if (this.timestamp) { if (this.timestamp) {

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

@ -1,7 +1,6 @@
package io.gitlab.jfronny.commons.logger; package io.gitlab.jfronny.commons.logger;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.slf4j.event.Level;
/** /**
* A simple logger that writes to stdout. * A simple logger that writes to stdout.
@ -47,4 +46,15 @@ public class StdoutLogger extends PrintStreamLogger {
public static StdoutLogger fancy(String name, Level level) { public static StdoutLogger fancy(String name, Level level) {
return new StdoutLogger(name, level, true, true, true); return new StdoutLogger(name, level, true, true, true);
} }
/**
* Creates a new StdoutLogger configured to be fancy, ignoring the module (use with LeveledLoggerFactory.get()).
* @param name the name of the logger
* @param module ignored
* @param level the minimum log level
* @return a new StdoutLogger with the given name and level
*/
public static StdoutLogger fancy(String name, Module module, Level level) {
return fancy(name, level);
}
} }

53
commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/SystemLoggerPlus.java Normal file
View File

@ -0,0 +1,53 @@
package io.gitlab.jfronny.commons.logger;
import io.gitlab.jfronny.commons.logger.impl.DelegateLoggerPlus;
public interface SystemLoggerPlus extends System.Logger {
static SystemLoggerPlus forName(String name) {
return get(System.getLogger(name));
}
static SystemLoggerPlus get(System.Logger logger) {
return DelegateLoggerPlus.get(logger);
}
default void trace(String msg, Object... params) {
log(Level.TRACE, msg, params);
}
default void trace(String msg, Throwable t) {
log(Level.TRACE, msg, t);
}
default void debug(String msg, Object... params) {
log(Level.DEBUG, msg, params);
}
default void debug(String msg, Throwable t) {
log(Level.DEBUG, msg, t);
}
default void info(String msg, Object... params) {
log(Level.INFO, msg, params);
}
default void info(String msg, Throwable t) {
log(Level.INFO, msg, t);
}
default void warn(String msg, Object... params) {
log(Level.WARNING, msg, params);
}
default void warn(String msg, Throwable t) {
log(Level.WARNING, msg, t);
}
default void error(String msg, Object... params) {
log(Level.ERROR, msg, params);
}
default void error(String msg, Throwable t) {
log(Level.ERROR, msg, t);
}
}

36
commons-logger/src/main/java/io/gitlab/jfronny/commons/logger/impl/DelegateLoggerPlus.java Normal file
View File

@ -0,0 +1,36 @@
package io.gitlab.jfronny.commons.logger.impl;
import io.gitlab.jfronny.commons.logger.SystemLoggerPlus;
import java.util.Objects;
import java.util.ResourceBundle;
public record DelegateLoggerPlus(System.Logger delegate) implements SystemLoggerPlus {
public static SystemLoggerPlus get(System.Logger delegate) {
return delegate instanceof SystemLoggerPlus slp ? slp : new DelegateLoggerPlus(delegate);
}
public DelegateLoggerPlus {
Objects.requireNonNull(delegate);
}
@Override
public String getName() {
return delegate.getName();
}
@Override
public boolean isLoggable(Level level) {
return delegate.isLoggable(level);
}
@Override
public void log(Level level, ResourceBundle bundle, String msg, Throwable thrown) {
delegate.log(level, bundle, msg, thrown);
}
@Override
public void log(Level level, ResourceBundle bundle, String format, Object... params) {
delegate.log(level, bundle, format, params);
}
}

1
commons-logger/src/main/java/module-info.java
View File

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

1
commons-logger/src/main/resources/META-INF/services/java.lang.System$LoggerFinder Normal file
View File

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

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

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

2
gradle/libs.versions.toml
View File

@ -1,5 +1,4 @@
[versions] [versions]
slf4j = "2.0.12"
junit = "5.10.2" junit = "5.10.2"
annotations = "24.1.0" annotations = "24.1.0"
gradle-kotlin-dsl = "4.3.0" gradle-kotlin-dsl = "4.3.0"
@ -7,7 +6,6 @@ jf-scripts = "1.5-SNAPSHOT"
gson = "2.10.3-SNAPSHOT" gson = "2.10.3-SNAPSHOT"
[libraries] [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-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit" }
junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit" } junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit" }
annotations = { module = "org.jetbrains:annotations", version.ref = "annotations" } annotations = { module = "org.jetbrains:annotations", version.ref = "annotations" }

1
muscript/build.gradle.kts
View File

@ -6,7 +6,6 @@ plugins {
dependencies { dependencies {
implementation(projects.commons) implementation(projects.commons)
implementation(libs.slf4j.api)
testImplementation(libs.junit.jupiter.api) testImplementation(libs.junit.jupiter.api)
testRuntimeOnly(libs.junit.jupiter.engine) testRuntimeOnly(libs.junit.jupiter.engine)

10
muscript/src/main/java/io/gitlab/jfronny/muscript/StarScriptIngester.java
View File

@ -1,11 +1,9 @@
package io.gitlab.jfronny.muscript; package io.gitlab.jfronny.muscript;
import io.gitlab.jfronny.muscript.compiler.Decompilable; import io.gitlab.jfronny.muscript.compiler.Decompilable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class StarScriptIngester { public class StarScriptIngester {
private static final Logger LOGGER = LoggerFactory.getLogger("MuScript"); private static final System.Logger LOGGER = System.getLogger("MuScript");
/** /**
* Naive conversion of starscript syntax to muscript * Naive conversion of starscript syntax to muscript
@ -63,15 +61,15 @@ public class StarScriptIngester {
if (!currbuf.isEmpty()) result.append(Decompilable.enquote(currbuf.toString())); if (!currbuf.isEmpty()) result.append(Decompilable.enquote(currbuf.toString()));
} }
case UnquotedInner -> { case UnquotedInner -> {
LOGGER.warn("Starscript code segment improperly closed, closing automatically"); LOGGER.log(System.Logger.Level.WARNING, "Starscript code segment improperly closed, closing automatically");
if (!currbuf.isEmpty()) result.append("(").append(currbuf).append(")"); if (!currbuf.isEmpty()) result.append("(").append(currbuf).append(")");
} }
case SingleQuoteInner -> { case SingleQuoteInner -> {
LOGGER.warn("Quote in starscript swallows ending, completing with closing quote"); LOGGER.log(System.Logger.Level.WARNING, "Quote in starscript swallows ending, completing with closing quote");
if (!currbuf.isEmpty()) result.append("(").append(currbuf).append("')"); if (!currbuf.isEmpty()) result.append("(").append(currbuf).append("')");
} }
case DoubleQuoteInner -> { case DoubleQuoteInner -> {
LOGGER.warn("Quote in starscript swallows ending, completing with closing quote"); LOGGER.log(System.Logger.Level.WARNING, "Quote in starscript swallows ending, completing with closing quote");
if (!currbuf.isEmpty()) result.append("(").append(currbuf).append("\")"); if (!currbuf.isEmpty()) result.append("(").append(currbuf).append("\")");
} }
} }

1
muscript/src/main/java/module-info.java
View File

@ -1,6 +1,5 @@
module io.gitlab.jfronny.commons.muscript { module io.gitlab.jfronny.commons.muscript {
requires io.gitlab.jfronny.commons; requires io.gitlab.jfronny.commons;
requires org.slf4j;
requires static org.jetbrains.annotations; requires static org.jetbrains.annotations;
exports io.gitlab.jfronny.muscript; exports io.gitlab.jfronny.muscript;
exports io.gitlab.jfronny.muscript.compiler; exports io.gitlab.jfronny.muscript.compiler;