Actually make a sane message board

```java
plugin.queueMessage(ForgeGradleMessages.WELCOME);
```

Author: Jonathing

src/main/java/net/minecraftforge/gradle/internal/Constants.java

@@ -55,11 +55,12 @@ If you are on an older version (1.20.4 and older), you will need the
               'net.minecraftforge.obfuscation' plugin. Many of these come with our provided
               MDK, so this should not be an issue for you.
             
+            For more details on this release, see https://docs.minecraftforge.net/en/fg-7.0/""";
+
+        static final String WELCOME_CONDITION = """
             This message will not display again until the next major beta update, ForgeGradle
             7.1, or the below file is deleted:
-            {}
-            
-            For more details on this release, see https://docs.minecraftforge.net/en/fg-7.0/""";
+            {}""";
 
         static final String MAGIC = """
             This build is using ForgeGradle Magic. ForgeGradle Magic employs automatic
@@ -70,9 +71,6 @@ If you are on an older version (1.20.4 and older), you will need the
             Gradle property:
             net.minecraftforge.gradle.magic=false
             
-            This message will not display again unless the below file is deleted:
-            {}
-            
             For more information, see https://docs.minecraftforge.net/en/fg-7.0/magic/""";
     }
 }

src/main/java/net/minecraftforge/gradle/internal/ForgeGradleFlowAction.java

@@ -5,14 +5,18 @@
 package net.minecraftforge.gradle.internal;
 
 import net.minecraftforge.gradleutils.shared.EnhancedFlowAction;
+import org.gradle.api.Project;
 import org.gradle.api.file.DirectoryProperty;
 import org.gradle.api.provider.Property;
-import org.gradle.api.provider.ProviderFactory;
+import org.gradle.api.provider.SetProperty;
+import org.jetbrains.annotations.Nullable;
 
 import javax.inject.Inject;
+import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
-import java.util.Locale;
+import java.text.MessageFormat;
+import java.util.ArrayList;
 
 import static net.minecraftforge.gradle.internal.ForgeGradlePlugin.LOGGER;
 
@@ -23,83 +27,74 @@ protected Parameters() {
         }
     }
 
-    static abstract class WelcomeMessage extends ForgeGradleFlowAction<WelcomeMessage.Parameters> {
-        enum DisplayOption {
-            ONCE, NEVER, ALWAYS
-        }
-
+    static abstract class MessageBoard extends ForgeGradleFlowAction<MessageBoard.Parameters> {
         static abstract class Parameters extends ForgeGradleFlowAction.Parameters {
-            final DirectoryProperty messagesDir;
-            final Property<DisplayOption> displayOption;
-
-            protected abstract @Inject ProviderFactory getProviders();
+            final SetProperty<ForgeGradleMessage.QueuedMessage> messages = this.getObjects().setProperty(ForgeGradleMessage.QueuedMessage.class);
 
             @Inject
-            public Parameters() {
-                this.messagesDir = this.getObjects().directoryProperty();
-                this.displayOption = this.getObjects().property(DisplayOption.class).convention(DisplayOption.ONCE).value(
-                    this.getProviders().gradleProperty("net.minecraftforge.gradle.messages.welcome")
-                        .orElse(this.getProviders().systemProperty("net.minecraftforge.gradle.messages.welcome"))
-                        .map(it -> DisplayOption.valueOf(it.toUpperCase(Locale.ROOT)))
-                );
+            public Parameters() { }
+
+            void queue(Project project, DirectoryProperty globalCaches, ForgeGradleMessage message) {
+                this.messages.add(message.queue(project, globalCaches));
             }
         }
 
         @Inject
-        public WelcomeMessage() { }
+        public MessageBoard() { }
 
         @Override
-        protected void run(Parameters parameters) throws IOException {
+        protected void run(Parameters parameters) {
             // if build failed, don't bother
             if (parameters.getFailure().isPresent()) return;
 
-            // check for marker file
-            var markerFile = parameters.messagesDir.file("7_0_BETA_WELCOME_1").get().getAsFile();
-            if (markerFile.exists()) return;
-            Files.createDirectories(markerFile.toPath().getParent());
-            Files.createFile(markerFile.toPath());
-
-            LOGGER.lifecycle(Constants.Messages.WELCOME, markerFile.getAbsolutePath());
-        }
-    }
-
-    static abstract class MagicMessage extends ForgeGradleFlowAction<MagicMessage.Parameters> {
-        enum DisplayOption {
-            ONCE, NEVER, ALWAYS
-        }
-
-        static abstract class Parameters extends ForgeGradleFlowAction.Parameters {
-            final DirectoryProperty messagesDir;
-            final Property<DisplayOption> displayOption;
+            var pending = parameters.messages.get();
+            var messages = new ArrayList<ForgeGradleMessage.QueuedMessage>(pending.size());
+            @Nullable File markerFile = null;
+            for (var queued : pending) {
+                switch (queued.displayOption()) {
+                    case NEVER:
+                        continue;
+
+                    case ONCE:
+                        // check for marker file
+                        markerFile = queued.markerFile().get().getAsFile();
+                        if (markerFile.exists()) continue;
+
+                        try {
+                            Files.createDirectories(markerFile.toPath().getParent());
+                            Files.createFile(markerFile.toPath());
+                        } catch (IOException e) {
+                            parameters.problems().reportMessageBoardCacheBroken(e, markerFile, queued.message().getProperty());
+                        }
+
+                    case ALWAYS:
+                        messages.add(queued);
+                        break;
+                }
+            }
 
-            protected abstract @Inject ProviderFactory getProviders();
+            if (messages.isEmpty())
+                return;
 
-            @Inject
-            public Parameters() {
-                this.messagesDir = this.getObjects().directoryProperty();
-                this.displayOption = this.getObjects().property(DisplayOption.class).convention(DisplayOption.ONCE).value(
-                    this.getProviders().gradleProperty("net.minecraftforge.gradle.messages.magic")
-                        .orElse(this.getProviders().systemProperty("net.minecraftforge.gradle.messages.magic"))
-                        .map(it -> DisplayOption.valueOf(it.toUpperCase(Locale.ROOT)))
-                );
+            if (!LOGGER.isLifecycleEnabled()) {
+                LOGGER.warn("WARNING: ForgeGradle messages cannot be displayed as the logger is not configured to display lifecycle messages.");
             }
-        }
 
-        @Inject
-        public MagicMessage() { }
+            var count = messages.size();
+            LOGGER.lifecycle("You have " + count + " new message" + (count == 1 ? "" : "s") + " from ForgeGradle.\n");
+            for (var i = 0; i < count; i++) {
+                var queued = messages.get(i);
 
-        @Override
-        protected void run(Parameters parameters) throws IOException {
-            // if build failed, don't bother
-            if (parameters.getFailure().isPresent()) return;
+                LOGGER.lifecycle("---   Message %d/%d   ---".formatted(i + 1, count));
+                LOGGER.lifecycle(MessageFormat.format(queued.message().getText(), queued));
 
-            // check for marker file
-            var markerFile = parameters.messagesDir.file("7_0_BETA_MAGIC_1").get().getAsFile();
-            if (markerFile.exists()) return;
-            Files.createDirectories(markerFile.toPath().getParent());
-            Files.createFile(markerFile.toPath());
+                if (markerFile != null && queued.displayOption() == ForgeGradleMessage.DisplayOption.ONCE)
+                    LOGGER.lifecycle('\n' + queued.message().getCondition(), markerFile.getAbsolutePath());
 
-            LOGGER.lifecycle(Constants.Messages.MAGIC, markerFile.getAbsolutePath());
+                LOGGER.lifecycle("--- End of Message ---");
+                if (i != count - 1)
+                    LOGGER.lifecycle("");
+            }
         }
     }
 

src/main/java/net/minecraftforge/gradle/internal/ForgeGradleMessage.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Forge Development LLC and contributors
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+package net.minecraftforge.gradle.internal;
+
+import org.gradle.api.Project;
+import org.gradle.api.file.Directory;
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.file.RegularFile;
+import org.gradle.api.provider.Provider;
+
+import java.util.Locale;
+
+enum ForgeGradleMessage {
+    WELCOME("7_0_BETA_WELCOME_1", Constants.Messages.WELCOME, Constants.Messages.WELCOME_CONDITION),
+    MAGIC("7_0_BETA_MAGIC_1", Constants.Messages.MAGIC);
+
+    private static final String MESSAGES_DIR = "messages";
+
+    private final String marker;
+    private final String property;
+    private final String text;
+    private final String condition;
+
+    ForgeGradleMessage(String marker, String text) {
+        this(marker, text, """
+            This message will not display again unless the below file is deleted:
+            {}""");
+    }
+
+    ForgeGradleMessage(String marker, String text, String condition) {
+        var name = this.name().toLowerCase(Locale.ENGLISH);
+        this.marker = marker;
+        this.property = "net.minecraftforge.gradle.messages." + name;
+        this.text = text;
+        this.condition = condition;
+    }
+
+    String getProperty() {
+        return this.property;
+    }
+
+    String getText() {
+        return this.text;
+    }
+
+    String getCondition() {
+        return this.condition;
+    }
+
+    QueuedMessage queue(Project project, DirectoryProperty globalCaches) {
+        return new QueuedMessage(project, globalCaches, this);
+    }
+
+    enum DisplayOption {
+        ONCE, NEVER, ALWAYS
+    }
+
+    static Provider<Directory> getMessagesDirectory(DirectoryProperty globalCaches) {
+        return globalCaches.dir(MESSAGES_DIR);
+    }
+
+    private Provider<RegularFile> getMarkerFile(DirectoryProperty globalCaches) {
+        return getMessagesDirectory(globalCaches).map(d -> d.file(this.marker));
+    }
+
+    private DisplayOption getDisplayOption(Project project) {
+        return project.getProviders().gradleProperty(this.property)
+                      .orElse(project.getProviders().systemProperty(this.property))
+                      .map(it -> DisplayOption.valueOf(it.toUpperCase(Locale.ROOT)))
+                      .getOrElse(DisplayOption.ONCE);
+    }
+
+    // NOTE: Has to be public so Gradle can reconstruct it for configuration cache.
+    //       Can't be accessed though since ForgeGradleMessage is package-private.
+    public record QueuedMessage(
+        ForgeGradleMessage message, Provider<RegularFile> markerFile, DisplayOption displayOption
+    ) implements Comparable<QueuedMessage> {
+        @SuppressWarnings("ClassEscapesDefinedScope")
+        public QueuedMessage(Project project, DirectoryProperty globalCaches, ForgeGradleMessage message) {
+            this(message, message.getMarkerFile(globalCaches), message.getDisplayOption(project));
+        }
+
+        @Override
+        public int compareTo(ForgeGradleMessage.QueuedMessage that) {
+            return this.message.compareTo(that.message);
+        }
+    }
+}

src/main/java/net/minecraftforge/gradle/internal/ForgeGradlePlugin.java

@@ -6,11 +6,16 @@
 
 import net.minecraftforge.gradleutils.shared.EnhancedPlugin;
 import org.gradle.api.Project;
+import org.gradle.api.flow.FlowProviders;
+import org.gradle.api.flow.FlowScope;
 import org.gradle.api.logging.Logger;
 import org.gradle.api.logging.Logging;
 import org.gradle.api.plugins.ExtensionAware;
+import org.jetbrains.annotations.Nullable;
 
 import javax.inject.Inject;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
 
 abstract class ForgeGradlePlugin extends EnhancedPlugin<ExtensionAware> {
     static final String NAME = "forgegradle";
@@ -24,19 +29,39 @@ abstract class ForgeGradlePlugin extends EnhancedPlugin<ExtensionAware> {
         LOGGER.lifecycle("ForgeGradle 7 is an incubating plugin.");
     }
 
+    protected abstract @Inject FlowScope getFlowScope();
+
+    protected abstract @Inject FlowProviders getFlowProviders();
+
     @Inject
     public ForgeGradlePlugin() {
         super(NAME, DISPLAY_NAME, "fgtools");
     }
 
     @Override
     public void setup(ExtensionAware target) {
-        if (target instanceof Project project && !problems.testFalse("net.minecraftforge.gradle.magic")) {
-            LOGGER.info("Applying ForgeGradle Magic to {}", project);
-            project.getPluginManager().apply(ForgeGradleMagicPlugin.class);
+        if (target instanceof Project project) {
+            this.getFlowScope().always(ForgeGradleFlowAction.MessageBoard.class, spec -> {
+                spec.parameters(parameters -> {
+                    this.messageBoard = message -> parameters.queue(project, globalCaches(), message);
+                    parameters.getFailure().set(this.getFlowProviders().getBuildWorkResult().map(p -> p.getFailure().orElse(null)));
+                });
+            });
+
+            if (!problems.testFalse("net.minecraftforge.gradle.magic")) {
+                LOGGER.info("Applying ForgeGradle Magic to {}", project);
+                project.getPluginManager().apply(ForgeGradleMagicPlugin.class);
+            }
         }
 
         ForgeGradleExtensionImpl.register(this, target);
         MinecraftExtensionImpl.register(this, target);
     }
+
+    private @Nullable Consumer<ForgeGradleMessage> messageBoard;
+
+    void queueMessage(ForgeGradleMessage message) {
+        if (messageBoard != null)
+            messageBoard.accept(message);
+    }
 }

src/main/java/net/minecraftforge/gradle/internal/ForgeGradleProblems.java

@@ -14,6 +14,8 @@
 
 import javax.inject.Inject;
 
+import java.io.File;
+
 import static net.minecraftforge.gradle.internal.ForgeGradlePlugin.LOGGER;
 
 /**
@@ -183,6 +185,7 @@ void reportForgeMavenNotDeclared() {
     //endregion
     //endregion
 
+    //region Access Transformers
     void reportAccessTransformersNotApplied(Throwable e) {
         this.report("access-transformers-not-applied", "AccessTransformers plugin not applied", spec -> spec
             .details("""
@@ -216,4 +219,18 @@ RuntimeException accessTransformersNotOnClasspath(Throwable e) {
         );
     }
     //endregion
+
+    //region Message Board
+    void reportMessageBoardCacheBroken(Throwable e, File file, String property) {
+        this.report("message-board-cache-broken", "ForgeGradle's message board cannot save data", spec -> spec
+            .details("""
+                ForgeGradle's message board cannot save data to its cache directory.
+                This will prevent ForgeGradle from remembering that a message has been displayed.""")
+            .severity(Severity.ERROR)
+            .withException(e)
+            .solution("Ensure read/write access for the following file: " + file)
+            .solution("Disable the message by setting the following property: " + property + "=never")
+            .solution(HELP_MESSAGE));
+    }
+    //endregion
 }