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
- 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
- commons-slf4j: SLF4J bindings for the logging abstraction in commons. Supports using commons as a backend for slf and slf as a commons backend.
- 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.
- [muscript-gson](https://git.frohnmeyer-wds.de/Johannes/java-commons/src/branch/master/muscript-gson): Glue code for manipulating gson with muscript

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

@ -5,7 +5,6 @@ plugins {
}
dependencies {
implementation(libs.slf4j.api)
implementation(projects.commons)
testImplementation(libs.junit.jupiter.api)
@ -25,5 +24,4 @@ publishing {
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")
}

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

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

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 org.jetbrains.annotations.Nullable;
import org.slf4j.ILoggerFactory;
import org.slf4j.Logger;
import org.slf4j.event.Level;
import java.util.Objects;
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.
*/
public class HotswapLoggerFactory implements LeveledLoggerFactory {
private static final Set<HotswapLoggerFactory> KNOWN_INSTANCES = new WeakSet<>();
public class HotswapLoggerFinder extends LeveledLoggerFinder {
private static final Set<HotswapLoggerFinder> KNOWN_INSTANCES = new WeakSet<>();
/**
* Resets all known instances to use the default logger factory.
*/
public static void resetAllStrategies() {
for (HotswapLoggerFactory factory : KNOWN_INSTANCES) {
for (HotswapLoggerFinder factory : KNOWN_INSTANCES) {
factory.resetStrategy();
}
}
@ -28,18 +25,20 @@ public class HotswapLoggerFactory implements LeveledLoggerFactory {
* Updates all known instances to use the new logger factory.
* @param factory the new logger factory to use for all known instances
*/
public static void updateAllStrategies(ILoggerFactory factory) {
for (HotswapLoggerFactory f : KNOWN_INSTANCES) {
f.updateStrategy(factory);
}
public static void updateAllStrategies(System.LoggerFinder factory) {
updateAllStrategies(LeveledLoggerFinder.get(factory));
}
public static void updateAllStrategies(LeveledLoggerFinder.Simple factory) {
updateAllStrategies(LeveledLoggerFinder.get(factory));
}
/**
* Updates all known instances to use the new logger factory.
* @param factory the new logger factory to use for all known instances
*/
public static void updateAllStrategies(LeveledLoggerFactory factory) {
for (HotswapLoggerFactory f : KNOWN_INSTANCES) {
public static void updateAllStrategies(LeveledLoggerFinder factory) {
for (HotswapLoggerFinder f : KNOWN_INSTANCES) {
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.
* @param minimumLevel the new minimum level to use for all known instances
*/
public static void updateAllDefaultLevels(Level minimumLevel) {
for (HotswapLoggerFactory f : KNOWN_INSTANCES) {
public static void updateAllDefaultLevels(System.Logger.Level minimumLevel) {
for (HotswapLoggerFinder f : KNOWN_INSTANCES) {
f.updateDefaultLevel(minimumLevel);
}
}
public HotswapLoggerFactory() {
public HotswapLoggerFinder() {
KNOWN_INSTANCES.add(this);
}
private LeveledLoggerFactory defaultFactory = StdoutLogger::fancy;
private Level minimumLevel = Level.INFO;
private LeveledLoggerFinder defaultFactory = LeveledLoggerFinder.get(StdoutLogger::fancy);
private System.Logger.Level minimumLevel = System.Logger.Level.INFO;
private int version = 0;
/**
@ -73,19 +72,23 @@ public class HotswapLoggerFactory implements LeveledLoggerFactory {
* Updates the strategy to use the new logger factory.
* @param factory the new logger factory to use
*/
public void updateStrategy(ILoggerFactory factory) {
if (factory instanceof LeveledLoggerFactory f) {
public void updateStrategy(System.LoggerFinder factory) {
if (factory instanceof LeveledLoggerFinder f) {
updateStrategy(f);
} 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.
* @param factory the new logger factory to use
*/
public void updateStrategy(LeveledLoggerFactory factory) {
public void updateStrategy(LeveledLoggerFinder factory) {
synchronized (this) {
defaultFactory = Objects.requireNonNull(factory);
version++;
@ -96,7 +99,7 @@ public class HotswapLoggerFactory implements LeveledLoggerFactory {
* Updates the minimum log 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) {
this.minimumLevel = Objects.requireNonNull(minimumLevel);
version++;
@ -104,35 +107,37 @@ public class HotswapLoggerFactory implements LeveledLoggerFactory {
}
@Override
public Logger getLogger(String name, @Nullable Level level) {
return new SwappableDelegateLogger(name, level);
public SystemLoggerPlus getLogger(String name, Module module, @Nullable System.Logger.Level level) {
return new SwappableDelegateLogger(name, module, level);
}
private class SwappableDelegateLogger extends DelegateLogger {
private final String name;
private final Module module;
private final boolean keepLevel;
private Level lastMinimumLevel;
private Logger delegate;
private System.Logger delegate;
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.module = module;
this.keepLevel = level != null;
this.lastMinimumLevel = level == null ? HotswapLoggerFactory.this.minimumLevel : level;
this.lastMinimumLevel = level == null ? HotswapLoggerFinder.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);
if (this.version == HotswapLoggerFinder.this.version) return;
synchronized (HotswapLoggerFinder.this) {
this.version = HotswapLoggerFinder.this.version;
if (!keepLevel) this.lastMinimumLevel = HotswapLoggerFinder.this.minimumLevel;
this.delegate = HotswapLoggerFinder.this.defaultFactory.getLogger(this.name, module, this.lastMinimumLevel);
}
}
@Override
protected Logger getDelegate() {
protected System.Logger getDelegate() {
updateStrategy();
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;
import org.jetbrains.annotations.NotNull;
import org.slf4j.event.Level;
import java.util.*;
import java.util.function.Consumer;
@ -34,6 +33,19 @@ public class MemoryLogger implements CompactLogger, Iterable<String> {
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
public String getName() {
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
@Override
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;
import org.slf4j.event.Level;
/**
* 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
* @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) {
case INFO -> BLUE;
case WARN -> RED;
case WARNING -> RED;
case ERROR -> RED_BOLD;
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.Nullable;
import org.slf4j.event.Level;
import java.io.PrintStream;
import java.time.LocalTime;
@ -17,7 +16,7 @@ public class PrintStreamLogger implements CompactLogger {
private final boolean color;
private final boolean thread;
private final boolean timestamp;
private final Level level;
private final System.Logger.Level level;
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 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.name = name;
this.level = level;
@ -44,33 +43,23 @@ public class PrintStreamLogger implements CompactLogger {
}
@Override
public Level getLevel() {
public System.Logger.Level getLevel() {
return level;
}
@Override
public void trace(String msg) {
target.println(generateMessage(msg, Level.TRACE));
public void log(Level level, String message) {
if (!isLoggable(level)) return;
else if (level == Level.ALL) level = Level.TRACE;
target.println(generateMessage(message, level));
}
@Override
public void debug(String msg) {
target.println(generateMessage(msg, Level.DEBUG));
}
@Override
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));
public void log(Level level, String message, Throwable throwable) {
if (!isLoggable(level)) return;
else if (level == Level.ALL) level = Level.TRACE;
target.println(generateMessage(message, level));
throwable.printStackTrace(target);
}
/**
@ -79,7 +68,7 @@ public class PrintStreamLogger implements CompactLogger {
* @param level the level of the 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();
// 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;
import org.jetbrains.annotations.Nullable;
import org.slf4j.event.Level;
/**
* A simple logger that writes to stdout.
@ -47,4 +46,15 @@ public class StdoutLogger extends PrintStreamLogger {
public static StdoutLogger fancy(String name, Level level) {
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 {
requires io.gitlab.jfronny.commons;
requires org.slf4j;
requires static org.jetbrains.annotations;
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]
slf4j = "2.0.12"
junit = "5.10.2"
annotations = "24.1.0"
gradle-kotlin-dsl = "4.3.0"
@ -7,7 +6,6 @@ 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" }

1
muscript/build.gradle.kts
View File

@ -6,7 +6,6 @@ plugins {
dependencies {
implementation(projects.commons)
implementation(libs.slf4j.api)
testImplementation(libs.junit.jupiter.api)
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;
import io.gitlab.jfronny.muscript.compiler.Decompilable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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
@ -63,15 +61,15 @@ public class StarScriptIngester {
if (!currbuf.isEmpty()) result.append(Decompilable.enquote(currbuf.toString()));
}
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(")");
}
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("')");
}
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("\")");
}
}

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

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