Global logger that wraps a consumer for common logging

The default global logger is effectively just System.out/err wrapped.
This logger uses the same implementation that was made in
MinecraftMaven, with indentations and some standard levels. The wrap is
in case other projects want to use something other than sysout, like a
Gradle project or task's own logger.

Also, Logging Utils now targets Java 8 so that it can be used in Java
Version if necessary. There's not a lot of code in this though so who
cares.

Author: Jonathing

file-utils/src/main/java/net/minecraftforge/util/file/FileUtils.java

@@ -5,6 +5,7 @@
 package net.minecraftforge.util.file;
 
 import net.minecraftforge.srgutils.IMappingFile;
+import net.minecraftforge.util.logging.SimpleLogger;
 import org.apache.commons.io.IOUtils;
 
 import java.io.ByteArrayOutputStream;

file-utils/src/main/java/net/minecraftforge/util/file/Task.java

@@ -4,7 +4,7 @@
  */
 package net.minecraftforge.util.file;
 
-import net.minecraftforge.util.logging.Log;
+import net.minecraftforge.util.logging.SimpleLogger;
 
 import java.io.File;
 import java.util.Collections;
@@ -52,13 +52,15 @@ private Simple(String name, Set<Task> deps, Supplier<File> supplier) {
         @Override
         public File execute() {
             if (this.file == null) {
+                var log = SimpleLogger.getGlobal();
+
                 for (var dep : deps)
                     dep.execute();
-                Log.log(name);
-                Log.push();
+                log.info(name);
+                log.push();
                 this.file = supplier.get();
-                Log.debug("-> " + this.file.toString());
-                Log.pop();
+                log.debug("-> " + this.file.toString());
+                log.pop();
             }
             return this.file;
         }

log-utils/build.gradle

@@ -14,12 +14,13 @@ dependencies {
 }
 
 java {
-    toolchain.languageVersion = JavaLanguageVersion.of(17)
+    toolchain.languageVersion = JavaLanguageVersion.of(8)
     withSourcesJar()
 }
 
 jar {
     manifest {
+        attributes('Automatic-Module-Name': 'net.minecraftforge.utils.logging')
         attributes([
             'Specification-Title':   'Logging Utils',
             'Specification-Vendor':  'Forge Development LLC',

log-utils/src/main/java/module-info.java

@@ -0,0 +1,124 @@
+package net.minecraftforge.util.logging;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Consumer;
+
+/**
+ * A simple logger. Used to wrap loggers or output streams to make logging less of a pain in the ass. Each program that
+ * uses Logging Utils should have their own instance of a simple logger.
+ *
+ * @see SysOut
+ */
+public interface SimpleLogger {
+    /* GLOBAL */
+
+    static SimpleLogger getGlobal() {
+        return Util.global;
+    }
+
+    static void setGlobal(SimpleLogger logger) {
+        Util.global = logger;
+    }
+
+
+    /* INDENTATION */
+
+    void push();
+
+    void pop();
+
+    int getIndent();
+
+
+    /* LOGGING */
+
+    void log(Level level, String message);
+
+    enum Level {
+        TRACE, DEBUG, INFO, WARN, ERROR, FATAL
+    }
+
+    default void trace(String message) {
+        log(Level.TRACE, message);
+    }
+
+    default void debug(String message) {
+        log(Level.DEBUG, message);
+    }
+
+    default void info(String message) {
+        log(Level.INFO, message);
+    }
+
+    default void warn(String message) {
+        log(Level.WARN, message);
+    }
+
+    default void error(String message) {
+        log(Level.ERROR, message);
+    }
+
+    default void fatal(String message) {
+        log(Level.FATAL, message);
+    }
+
+    abstract class Consuming implements SimpleLogger {
+        private byte indent;
+
+        @Override
+        public void push() {
+            this.indent++;
+        }
+
+        @Override
+        public void pop() {
+            if (--this.indent < 0)
+                throw new IllegalArgumentException("Cannot pop logger below 0");
+        }
+
+        @Override
+        public int getIndent() {
+            return this.indent;
+        }
+
+        protected abstract @Nullable Consumer<String> getOut(Level level);
+
+        @Override
+        public void log(Level level, String message) {
+            Consumer<String> out = this.getOut(level);
+            if (out == null) return;
+
+            if (this.indent != 0) {
+                StringBuilder builder = new StringBuilder(message);
+                for (int i = 0; i < this.indent; i++)
+                    builder.insert(0, "  ");
+                message = builder.toString();
+            }
+
+            out.accept(message);
+        }
+    }
+
+    final class SysOut extends Consuming {
+        private final boolean debug;
+
+        public SysOut() {
+            this(false);
+        }
+
+        public SysOut(boolean debug) {
+            this.debug = debug;
+        }
+
+        @Override
+        protected @Nullable Consumer<String> getOut(Level level) {
+            if (!this.debug && (level == Level.TRACE || level == Level.DEBUG))
+                return null;
+            else if (level == Level.INFO)
+                return System.out::println;
+            else
+                return System.err::println;
+        }
+    }
+}

log-utils/src/main/java/net/minecraftforge/util/logging/Log.java

@@ -0,0 +1,5 @@
+package net.minecraftforge.util.logging;
+
+class Util {
+    static SimpleLogger global = new SimpleLogger.SysOut();
+}