Copy published data files prior to publishing.

src/main/java/net/neoforged/moddevgradle/internal/DataFileCollections.java

@@ -4,6 +4,8 @@
 import java.util.function.Consumer;
 import net.neoforged.moddevgradle.dsl.DataFileCollection;
 import net.neoforged.moddevgradle.internal.utils.ExtensionUtils;
+import net.neoforged.moddevgradle.internal.utils.StringUtils;
+import net.neoforged.moddevgradle.tasks.CopyDataFile;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.ConfigurablePublishArtifact;
 import org.gradle.api.artifacts.Configuration;
@@ -93,15 +95,32 @@ private static CollectionWrapper createCollection(Project project, String name,
             }
         });
 
+        var copyTaskName = "copy" + StringUtils.capitalize(name) + "Publications";
+        var copyTask = project.getTasks().register(copyTaskName, CopyDataFile.class);
+
         var depFactory = project.getDependencyFactory();
         Consumer<Object> publishCallback = new Consumer<>() {
             ConfigurablePublishArtifact firstArtifact;
             int artifactCount;
 
             @Override
             public void accept(Object artifactNotation) {
-                elementsConfiguration.getDependencies().add(depFactory.create(project.files(artifactNotation)));
-                project.getArtifacts().add(elementsConfiguration.getName(), artifactNotation, artifact -> {
+                // Create a temporary artifact to resolve file and task dependencies.
+                var dummyArtifact = project.getArtifacts().add(elementsConfiguration.getName(), artifactNotation);
+
+                var artifactFile = dummyArtifact.getFile();
+                var artifactDependencies = dummyArtifact.getBuildDependencies();
+                elementsConfiguration.getArtifacts().remove(dummyArtifact);
+
+                var copyOutput = project.getLayout().getBuildDirectory().file(copyTaskName + "/" + artifactCount + "-" + artifactFile.getName());
+                copyTask.configure(t -> {
+                    t.dependsOn(artifactDependencies);
+                    t.getInputFiles().add(project.getLayout().file(project.provider(() -> artifactFile)));
+                    t.getOutputFiles().add(copyOutput);
+                });
+
+                project.getArtifacts().add(elementsConfiguration.getName(), copyOutput, artifact -> {
+                    artifact.builtBy(copyTask);
                     if (firstArtifact == null) {
                         firstArtifact = artifact;
                         artifact.setClassifier(category);

src/main/java/net/neoforged/moddevgradle/tasks/CopyDataFile.java

@@ -0,0 +1,33 @@
+package net.neoforged.moddevgradle.tasks;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.file.RegularFile;
+import org.gradle.api.provider.ListProperty;
+import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.tasks.OutputFiles;
+import org.gradle.api.tasks.TaskAction;
+
+public abstract class CopyDataFile extends DefaultTask {
+    @InputFiles
+    public abstract ListProperty<RegularFile> getInputFiles();
+
+    @OutputFiles
+    public abstract ListProperty<RegularFile> getOutputFiles();
+
+    @TaskAction
+    public void doCopy() throws IOException {
+        var inputs = getInputFiles().get();
+        var outputs = getOutputFiles().get();
+        if (inputs.size() != outputs.size()) throw new RuntimeException("Lists length dont match.");
+
+        for (int i = 0; i < inputs.size(); i++) {
+            var in = inputs.get(i).getAsFile().toPath();
+            var out = outputs.get(i).getAsFile().toPath();
+            Files.createDirectories(out.getParent());
+            Files.copy(in, out, StandardCopyOption.REPLACE_EXISTING);
+        }
+    }
+}

src/test/java/net/neoforged/moddevgradle/functional/DataFileCollectionFunctionalTest.java

@@ -11,6 +11,8 @@
 import java.nio.file.Files;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import org.gradle.testkit.runner.GradleRunner;
 import org.gradle.testkit.runner.TaskOutcome;
 import org.intellij.lang.annotations.Language;
@@ -37,6 +39,50 @@ public void testPublishAccessTransformerFile() throws IOException {
                 entry("publish-at-1.0-accesstransformer.cfg", "# hello world"));
     }
 
+    @Test
+    public void testPublishSignedAccessTransformerFileDoesntProduceGarbageNextToTheFile() throws IOException {
+        var atFile = testProjectDir.toPath().resolve("accesstransformer.cfg");
+        Files.writeString(atFile, "# hello world");
+
+        publishDataFiles("test", "publish-at", "1.0", """
+                neoForge {
+                    accessTransformers {
+                        publish(project.file("accesstransformer.cfg"))
+                    }
+                }
+                signing {
+                    useInMemoryPgpKeys(
+                        ""\"
+                -----BEGIN PGP PRIVATE KEY BLOCK-----
+
+                lIYEZ50OURYJKwYBBAHaRw8BAQdAjVNqyWTfusmnT3/pNNmjmG9AfOFL8YbFUXCo
+                PZO3dCj+BwMCZ5yIZTjHa2r/WIUWn/nr1+5CLJOI1xzscxZOq6Vyvh9m3TWgPKWh
+                iW/MM/tGGvOnFt4qD+WNYNaHo3GtbG+KoK0584Ddon60yFEAPCdAUrQXTURHIDxt
+                ZGdAbmVvZm9yZ2VkLm5ldD6IkwQTFgoAOxYhBN0jxfacUTgqiXj3CnkqaxjDscQa
+                BQJnnQ5RAhsDBQsJCAcCAiICBhUKCQgLAgQWAgMBAh4HAheAAAoJEHkqaxjDscQa
+                93YA/ix1FkHrtF+VglGcSBGUvtqfiBzYPvwrazNdURxCZpaVAP4zWPYtbDJP14dP
+                s8I/jILSUfE61lVl6Y74tpiEvNm8Bg==
+                =3g5S
+                -----END PGP PRIVATE KEY BLOCK-----
+                        ""\",
+                        "123456"
+                    )
+                    sign publishing.publications.maven
+                }
+                """, "signing");
+
+        assertThat(atFile.resolveSibling(atFile.getFileName() + ".asc"))
+                .doesNotExist();
+        var copiedFile = testProjectDir.toPath()
+                .resolve("build/copyAccessTransformersPublications/0-accesstransformer.cfg");
+        assertThat(copiedFile)
+                .hasSameTextualContentAs(atFile);
+        assertThat(copiedFile.resolveSibling(copiedFile.getFileName() + ".asc"))
+                .exists();
+        assertThat(consumeDataFilePublication("accessTransformers", "test:publish-at:1.0")).containsOnly(
+                entry("publish-at-1.0-accesstransformer.cfg", "# hello world"));
+    }
+
     @Test
     public void testPublishInterfaceInjectionFile() throws IOException {
         writeProjectFile("interfaces.json", "[]");
@@ -126,7 +172,11 @@ private Map<String, String> consumeDataFilePublication(String configurationName,
     private void publishDataFiles(String groupId,
             String artifactId,
             String version,
-            @Language("groovy") String buildScriptBody) throws IOException {
+            @Language("groovy") String buildScriptBody,
+            String... extraPlugins) throws IOException {
+        String extraPluginLines = Stream.of(extraPlugins)
+                .map("id \"%s\""::formatted)
+                .collect(Collectors.joining("\n"));
         writeGroovySettingsScript("""
                 plugins {
                     id 'org.gradle.toolchains.foojay-resolver-convention' version '0.8.0'
@@ -137,6 +187,7 @@ private void publishDataFiles(String groupId,
                 plugins {
                     id "net.neoforged.moddev"
                     id "maven-publish"
+                    {4}
                 }
                 group = "{0}"
                 version = "{1}"
@@ -156,7 +207,7 @@ url file("{3}")
                     }
                 }
                 {2}
-                """, groupId, version, buildScriptBody, publicationTarget);
+                """, groupId, version, buildScriptBody, publicationTarget, extraPluginLines);
 
         var result = GradleRunner.create()
                 .withPluginClasspath()