diff --git a/README.md b/README.md index 1966294ed..e3eb5f34a 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,31 @@ dependencies { } ``` +#### Access Transformers +The userdev plugin provides a way to configure access transformers for your mod. +You need to create an access transformer configuration file in your resources directory, and then configure the userdev plugin to use it. +```groovy +userdev { + accessTransformer { + file 'src/main/resources/META-INF/accesstransformer.cfg' + } +} +``` +The path here is up to you, and does not need to be included in your final jar. + +#### Interface Injections +The userdev plugin provides a way to configure interface injections for your mod. +This allows you to have a decompiled minecraft artifact that contains the interfaces you want to inject via mixins already statically applied. +The advantage of this approach is that you can use the interfaces in your code, and the mixins will be applied to the interfaces, and not the classes that implement them. +```groovy +userdev { + interfaceInjection { + file 'src/main/resources/META-INF/interfaceinjection.json' + } +} +``` +You can find more information on the format of the file [here](https://github.com/neoforged/JavaSourceTransformer?tab=readme-ov-file#interface-injection). + #### Dependency management by the userdev plugin When this plugin detects a dependency on NeoForge, it will spring into action and create the necessary NeoForm runtime tasks to build a usable Minecraft JAR-file that contains the requested NeoForge version. It additionally (if configured to do so via conventions, which is the default) will create runs for your project, and add the necessary dependencies to the classpath of the run. diff --git a/common/src/main/java/net/neoforged/gradle/common/CommonProjectPlugin.java b/common/src/main/java/net/neoforged/gradle/common/CommonProjectPlugin.java index 6fab4c9f1..4f21ff6c7 100644 --- a/common/src/main/java/net/neoforged/gradle/common/CommonProjectPlugin.java +++ b/common/src/main/java/net/neoforged/gradle/common/CommonProjectPlugin.java @@ -5,10 +5,12 @@ import net.neoforged.gradle.common.dependency.ExtraJarDependencyManager; import net.neoforged.gradle.common.extensions.*; import net.neoforged.gradle.common.extensions.dependency.replacement.ReplacementLogic; +import net.neoforged.gradle.common.extensions.problems.ProblemReportingConfigurator; import net.neoforged.gradle.common.extensions.repository.IvyRepository; import net.neoforged.gradle.common.extensions.sourcesets.SourceSetDependencyExtensionImpl; import net.neoforged.gradle.common.extensions.sourcesets.SourceSetInheritanceExtensionImpl; import net.neoforged.gradle.common.extensions.subsystems.SubsystemsExtension; +import net.neoforged.gradle.common.interfaceinjection.InterfaceInjectionPublishing; import net.neoforged.gradle.common.rules.LaterAddedReplacedDependencyRule; import net.neoforged.gradle.common.runs.ide.IdeRunIntegrationManager; import net.neoforged.gradle.common.runs.run.RunManagerImpl; @@ -21,6 +23,7 @@ import net.neoforged.gradle.common.services.caching.CachedExecutionService; import net.neoforged.gradle.common.tasks.CleanCache; import net.neoforged.gradle.common.tasks.DisplayMappingsLicenseTask; +import net.neoforged.gradle.common.util.CommonRuntimeTaskUtils; import net.neoforged.gradle.common.util.ConfigurationUtils; import net.neoforged.gradle.common.util.run.RunsUtil; import net.neoforged.gradle.dsl.common.extensions.*; @@ -40,7 +43,9 @@ import org.gradle.api.plugins.JavaPlugin; import org.gradle.api.problems.Problems; import org.gradle.api.tasks.Delete; +import org.gradle.api.tasks.SourceSet; import org.gradle.api.tasks.SourceSetContainer; +import org.gradle.jvm.tasks.Jar; import org.gradle.plugins.ide.eclipse.EclipsePlugin; import org.gradle.plugins.ide.idea.IdeaPlugin; import org.jetbrains.gradle.ext.IdeaExtPlugin; @@ -49,8 +54,6 @@ public class CommonProjectPlugin implements Plugin { - public static final String PROBLEM_NAMESPACE = "neoforged.gradle"; - public static final String PROBLEM_REPORTER_EXTENSION_NAME = "neogradleProblems"; private final Problems problems; @@ -82,8 +85,8 @@ public void apply(Project project) { project.getExtensions().create(Repository.class, "ivyDummyRepository", IvyRepository.class, project); project.getExtensions().create(MinecraftArtifactCache.class, "minecraftArtifactCache", MinecraftArtifactCacheExtension.class, project); project.getExtensions().create(DependencyReplacement.class, "dependencyReplacements", ReplacementLogic.class, project); - project.getExtensions().create(NeoGradleProblemReporter.class, PROBLEM_REPORTER_EXTENSION_NAME, NeoGradleProblemReporter.class, problems.forNamespace(PROBLEM_NAMESPACE)); project.getExtensions().create(AccessTransformers.class, "accessTransformers", AccessTransformersExtension.class, project); + project.getExtensions().create(InterfaceInjections.class, "interfaceInjections", InterfaceInjectionsExtension.class, project); project.getExtensions().create(Minecraft.class, "minecraft", MinecraftExtension.class, project); project.getExtensions().create(Mappings.class,"mappings", MappingsExtension.class, project); @@ -91,6 +94,8 @@ public void apply(Project project) { project.getExtensions().create(ExtraJarDependencyManager.class, "clientExtraJarDependencyManager", ExtraJarDependencyManager.class, project); project.getExtensions().create(RunManager.class, "runManager", RunManagerImpl.class, project); + ProblemReportingConfigurator.configureProblemReporting(project, problems); + final ConfigurationData configurationData = project.getExtensions().create(ConfigurationData.class, "configurationData", ConfigurationDataExtension.class, project); OfficialNamingChannelConfigurator.getInstance().configure(project); @@ -131,6 +136,9 @@ public void apply(Project project) { //Set up publishing for access transformer elements AccessTransformerPublishing.setup(project); + //Set up publishing for interface injection elements + InterfaceInjectionPublishing.setup(project); + //Set up the IDE run integration manager IdeRunIntegrationManager.getInstance().setup(project); @@ -145,6 +153,10 @@ public void apply(Project project) { //Set up reporting tasks project.getTasks().register("runs", RunsReport.class); + //Configure sdk configurations + final SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class); + sourceSets.all(ConfigurationUtils::getSdkConfiguration); + //Needs to be before after evaluate ConventionConfigurator.configureConventions(project); diff --git a/common/src/main/java/net/neoforged/gradle/common/conventions/ConventionConfigurator.java b/common/src/main/java/net/neoforged/gradle/common/conventions/ConventionConfigurator.java index 996208619..e2decf863 100644 --- a/common/src/main/java/net/neoforged/gradle/common/conventions/ConventionConfigurator.java +++ b/common/src/main/java/net/neoforged/gradle/common/conventions/ConventionConfigurator.java @@ -10,6 +10,7 @@ import net.neoforged.gradle.dsl.common.extensions.subsystems.conventions.Runs; import net.neoforged.gradle.dsl.common.extensions.subsystems.conventions.SourceSets; import net.neoforged.gradle.dsl.common.extensions.subsystems.conventions.ide.IDEA; +import net.neoforged.gradle.dsl.common.runs.run.Run; import net.neoforged.gradle.dsl.common.runs.run.RunManager; import org.gradle.StartParameter; import org.gradle.TaskExecutionRequest; @@ -62,11 +63,23 @@ private static void configureRunConventions(Project project, Conventions convent final Configuration runRuntimeConfiguration = project.getConfigurations().maybeCreate(configurations.getRunRuntimeConfigurationName().get()); project.getExtensions().configure(RunManager.class, runContainer -> runContainer.configureAll(run -> { + run.getDependencies().getRuntime().add(runRuntimeConfiguration); + })); + + final RunManager runManager = project.getExtensions().getByType(RunManager.class); + project.getConfigurations().addRule("Create run specific runtime configuration", configurationName -> { + if (!configurationName.endsWith(configurations.getPerRunRuntimeConfigurationPostFix().get())) + return; + + final String runName = configurationName.substring(0, configurationName.length() - configurations.getPerRunRuntimeConfigurationPostFix().get().length()); + if (runManager.findByName(runName) == null) + return; + + final Run run = runManager.getByName(runName); final Configuration runSpecificRuntimeConfiguration = project.getConfigurations().maybeCreate(ConfigurationUtils.getRunName(run, configurations.getPerRunRuntimeConfigurationPostFix().get())); - run.getDependencies().getRuntime().add(runRuntimeConfiguration); run.getDependencies().getRuntime().add(runSpecificRuntimeConfiguration); - })); + }); } private static void configureIDEConventions(Project project, Conventions conventions) { diff --git a/common/src/main/java/net/neoforged/gradle/common/dependency/ExtraJarDependencyManager.java b/common/src/main/java/net/neoforged/gradle/common/dependency/ExtraJarDependencyManager.java index 784383e8d..463bd8579 100644 --- a/common/src/main/java/net/neoforged/gradle/common/dependency/ExtraJarDependencyManager.java +++ b/common/src/main/java/net/neoforged/gradle/common/dependency/ExtraJarDependencyManager.java @@ -1,7 +1,7 @@ package net.neoforged.gradle.common.dependency; import com.google.common.collect.Maps; -import net.neoforged.gradle.common.extensions.NeoGradleProblemReporter; +import net.neoforged.gradle.common.extensions.problems.IProblemReporter; import net.neoforged.gradle.common.runtime.tasks.GenerateExtraJar; import net.neoforged.gradle.dsl.common.extensions.MinecraftArtifactCache; import net.neoforged.gradle.dsl.common.extensions.dependency.replacement.DependencyReplacement; @@ -77,7 +77,7 @@ private boolean hasMatchingArtifact(ExternalModuleDependency externalModuleDepen private ReplacementResult generateReplacement(final Project project, final Dependency dependency) { final String minecraftVersion = dependency.getVersion(); if (minecraftVersion == null) { - final NeoGradleProblemReporter problemReporter = project.getExtensions().getByType(NeoGradleProblemReporter.class); + final IProblemReporter problemReporter = project.getExtensions().getByType(IProblemReporter.class); throw problemReporter.throwing(spec -> { spec.id("dependencies.extra-jar", "missingVersion") .contextualLabel("Client-Extra Jar: Missing Version") diff --git a/common/src/main/java/net/neoforged/gradle/common/dependency/JarJarArtifacts.java b/common/src/main/java/net/neoforged/gradle/common/dependency/JarJarArtifacts.java index e1ef593a1..55e6529aa 100644 --- a/common/src/main/java/net/neoforged/gradle/common/dependency/JarJarArtifacts.java +++ b/common/src/main/java/net/neoforged/gradle/common/dependency/JarJarArtifacts.java @@ -1,7 +1,7 @@ package net.neoforged.gradle.common.dependency; import net.neoforged.gradle.common.extensions.JarJarExtension; -import net.neoforged.gradle.common.extensions.NeoGradleProblemReporter; +import net.neoforged.gradle.common.extensions.problems.IProblemReporter; import net.neoforged.gradle.dsl.common.dependency.DependencyFilter; import net.neoforged.gradle.dsl.common.dependency.DependencyManagementObject; import net.neoforged.gradle.dsl.common.dependency.DependencyVersionInformationHandler; @@ -42,7 +42,7 @@ public abstract class JarJarArtifacts { private transient final SetProperty includedRootComponents; private transient final SetProperty includedArtifacts; - private final NeoGradleProblemReporter reporter; + private final IProblemReporter reporter; private final DependencyFilter dependencyFilter; private final DependencyVersionInformationHandler dependencyVersionInformationHandler; @@ -74,7 +74,7 @@ public DependencyVersionInformationHandler getDependencyVersionInformationHandle } @Inject - public JarJarArtifacts(NeoGradleProblemReporter reporter) { + public JarJarArtifacts(IProblemReporter reporter) { this.reporter = reporter; dependencyFilter = getObjectFactory().newInstance(DefaultDependencyFilter.class); dependencyVersionInformationHandler = getObjectFactory().newInstance(DefaultDependencyVersionInformationHandler.class); diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/AccessTransformersExtension.java b/common/src/main/java/net/neoforged/gradle/common/extensions/AccessTransformersExtension.java index 61dcf4637..46ee07b70 100644 --- a/common/src/main/java/net/neoforged/gradle/common/extensions/AccessTransformersExtension.java +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/AccessTransformersExtension.java @@ -1,8 +1,6 @@ package net.neoforged.gradle.common.extensions; -import net.neoforged.gradle.common.CommonProjectPlugin; import net.neoforged.gradle.common.accesstransformers.AccessTransformerPublishing; -import net.neoforged.gradle.common.extensions.base.BaseFilesWithEntriesExtension; import net.neoforged.gradle.dsl.common.extensions.AccessTransformers; import org.gradle.api.Action; import org.gradle.api.Project; @@ -13,14 +11,16 @@ import javax.inject.Inject; -public abstract class AccessTransformersExtension extends BaseFilesWithEntriesExtension implements AccessTransformers { +public abstract class AccessTransformersExtension implements AccessTransformers { private transient final DependencyHandler projectDependencies; private transient final ArtifactHandler projectArtifacts; + private final Project project; + @SuppressWarnings("UnstableApiUsage") @Inject public AccessTransformersExtension(Project project) { - super(project); + this.project = project; this.projectDependencies = project.getDependencies(); this.projectArtifacts = project.getArtifacts(); @@ -32,9 +32,14 @@ public AccessTransformersExtension(Project project) { }); } + @Override + public Project getProject() { + return project; + } + @Override public void expose(Object path, Action action) { - file(path); + getFiles().from(path); projectArtifacts.add(AccessTransformerPublishing.ACCESS_TRANSFORMER_ELEMENTS_CONFIGURATION, path, action); } diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/IExtensionCreator.java b/common/src/main/java/net/neoforged/gradle/common/extensions/IExtensionCreator.java deleted file mode 100644 index 0412df880..000000000 --- a/common/src/main/java/net/neoforged/gradle/common/extensions/IExtensionCreator.java +++ /dev/null @@ -1,13 +0,0 @@ -package net.neoforged.gradle.common.extensions; - -import org.gradle.api.Project; - -import java.util.function.Function; - -/** - * Custom function definition for creating an extension. - * - * @param The type of the extension - */ -public interface IExtensionCreator extends Function { -} diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/IdeManagementExtension.java b/common/src/main/java/net/neoforged/gradle/common/extensions/IdeManagementExtension.java index 04edda606..28e1b066d 100644 --- a/common/src/main/java/net/neoforged/gradle/common/extensions/IdeManagementExtension.java +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/IdeManagementExtension.java @@ -13,6 +13,7 @@ import org.gradle.plugins.ide.eclipse.model.EclipseModel; import org.gradle.plugins.ide.idea.model.IdeaModel; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.gradle.ext.IdeaExtPlugin; import org.jetbrains.gradle.ext.ProjectSettings; import org.jetbrains.gradle.ext.TaskTriggersConfig; @@ -261,22 +262,30 @@ private void onCommonEclipse(final BiConsumer toPerform) if (!isEclipseImport()) { return; } - - //Grab the eclipse model so we can extend it. -> Done on the root project so that the model is available to all subprojects. - //And so that post sync tasks are only ran once for all subprojects. - EclipseModel model = project.getExtensions().findByType(EclipseModel.class); - if (model == null) { - model = rootProject.getExtensions().findByType(EclipseModel.class); - if (model == null) { - return; - } - } - + + EclipseModel model = getEclipseModel(); + if (model == null) return; + //Configure the project, passing the model and the relevant project. Which does not need to be the root, but can be. toPerform.accept(project, model); }); } - + + /** + * Get the eclipse model from the extensions project. + * + * @return the eclipse model, or {@code null} if not found + */ + public @Nullable EclipseModel getEclipseModel() { + //Grab the eclipse model so we can extend it. -> Done on the root project so that the model is available to all subprojects. + //And so that post sync tasks are only ran once for all subprojects. + EclipseModel model = project.getExtensions().findByType(EclipseModel.class); + if (model == null) { + model = project.getRootProject().getExtensions().findByType(EclipseModel.class); + } + return model; + } + /** * Applies the specified configuration action to configure gradle run projects only. * diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/InterfaceInjectionsExtension.java b/common/src/main/java/net/neoforged/gradle/common/extensions/InterfaceInjectionsExtension.java new file mode 100644 index 000000000..72dfcc2d5 --- /dev/null +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/InterfaceInjectionsExtension.java @@ -0,0 +1,56 @@ +package net.neoforged.gradle.common.extensions; + +import net.neoforged.gradle.common.interfaceinjection.InterfaceInjectionPublishing; +import net.neoforged.gradle.dsl.common.extensions.InterfaceInjections; +import org.gradle.api.Action; +import org.gradle.api.Project; +import org.gradle.api.artifacts.ConfigurablePublishArtifact; +import org.gradle.api.artifacts.Dependency; +import org.gradle.api.artifacts.dsl.ArtifactHandler; +import org.gradle.api.artifacts.dsl.DependencyHandler; + +import javax.inject.Inject; + +public abstract class InterfaceInjectionsExtension implements InterfaceInjections { + private transient final DependencyHandler projectDependencies; + private transient final ArtifactHandler projectArtifacts; + + private final Project project; + + @SuppressWarnings("UnstableApiUsage") + @Inject + public InterfaceInjectionsExtension(Project project) { + this.project = project; + + this.projectDependencies = project.getDependencies(); + this.projectArtifacts = project.getArtifacts(); + + // We have to add these after project evaluation because of dependency replacement making configurations non-lazy; adding them earlier would prevent further addition of dependencies + project.afterEvaluate(p -> { + p.getConfigurations().maybeCreate(InterfaceInjectionPublishing.INTERFACE_INJECTION_CONFIGURATION).fromDependencyCollector(getConsume()); + p.getConfigurations().maybeCreate(InterfaceInjectionPublishing.INTERFACE_INJECTION_API_CONFIGURATION).fromDependencyCollector(getConsumeApi()); + }); + } + + @Override + public Project getProject() { + return project; + } + + @Override + public void expose(Object path, Action action) { + getFiles().from(path); + projectArtifacts.add(InterfaceInjectionPublishing.INTERFACE_INJECTION_ELEMENTS_CONFIGURATION, path, action); + } + + @Override + public void expose(Object path) { + expose(path, artifacts -> { + }); + } + + @Override + public void expose(Dependency dependency) { + projectDependencies.add(InterfaceInjectionPublishing.INTERFACE_INJECTION_API_CONFIGURATION, dependency); + } +} diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/MinecraftExtension.java b/common/src/main/java/net/neoforged/gradle/common/extensions/MinecraftExtension.java index a770fbfca..1e4ed4cdd 100644 --- a/common/src/main/java/net/neoforged/gradle/common/extensions/MinecraftExtension.java +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/MinecraftExtension.java @@ -23,11 +23,13 @@ import net.minecraftforge.gdi.ConfigurableDSLElement; import net.neoforged.gradle.common.runtime.naming.NamingChannelProvider; import net.neoforged.gradle.dsl.common.extensions.AccessTransformers; +import net.neoforged.gradle.dsl.common.extensions.InterfaceInjections; import net.neoforged.gradle.dsl.common.extensions.Mappings; import net.neoforged.gradle.dsl.common.extensions.Minecraft; import net.neoforged.gradle.dsl.common.runtime.naming.NamingChannel; import org.gradle.api.NamedDomainObjectContainer; import org.gradle.api.Project; +import org.jetbrains.annotations.NotNull; import javax.inject.Inject; @@ -35,12 +37,14 @@ public abstract class MinecraftExtension implements ConfigurableDSLElement namingChannelProviders; @Inject public MinecraftExtension(final Project project) { this.project = project; this.accessTransformers = project.getExtensions().getByType(AccessTransformers.class); + this.interfaceInjections = project.getExtensions().getByType(InterfaceInjections.class); this.namingChannelProviders = project.getObjects().domainObjectContainer(NamingChannel.class, name -> project.getObjects().newInstance(NamingChannelProvider.class, project, name)); final String baseName = project.getName().replace(":", "_"); @@ -52,23 +56,33 @@ public MinecraftExtension(final Project project) { })); } + @NotNull @Override public Project getProject() { return project; } + @NotNull @Override public NamedDomainObjectContainer getNamingChannels() { return namingChannelProviders; } + @NotNull @Override public Mappings getMappings() { return project.getExtensions().getByType(Mappings.class); } + @NotNull @Override public AccessTransformers getAccessTransformers() { return this.accessTransformers; } + + @NotNull + @Override + public InterfaceInjections getInterfaceInjections() { + return interfaceInjections; + } } diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/NeoGradleProblemReporter.java b/common/src/main/java/net/neoforged/gradle/common/extensions/NeoGradleProblemReporter.java deleted file mode 100644 index 2879fe5c4..000000000 --- a/common/src/main/java/net/neoforged/gradle/common/extensions/NeoGradleProblemReporter.java +++ /dev/null @@ -1,114 +0,0 @@ -package net.neoforged.gradle.common.extensions; - - -import net.neoforged.gradle.common.util.NeoGradleUtils; -import org.gradle.api.Action; -import org.gradle.api.InvalidUserDataException; -import org.gradle.api.logging.Logger; -import org.gradle.api.problems.ProblemReporter; -import org.gradle.api.problems.ProblemSpec; -import org.gradle.api.problems.Severity; - -public class NeoGradleProblemReporter { - - private final ProblemReporter delegate; - - public NeoGradleProblemReporter(ProblemReporter delegate) { - this.delegate = delegate; - } - - public void reporting(Action spec, Logger logger) { - delegate.reporting(problemSpec -> { - final NeoGradleProblemSpec neoGradleProblemSpec = new NeoGradleProblemSpec(); - spec.execute(neoGradleProblemSpec); - - final String url = readMeUrl(neoGradleProblemSpec.section); - - problemSpec.id(neoGradleProblemSpec.category, neoGradleProblemSpec.id) - .contextualLabel(neoGradleProblemSpec.contextualLabel) - .solution(neoGradleProblemSpec.solution) - .details(neoGradleProblemSpec.details) - .severity(Severity.WARNING) - .documentedAt(url); - - neoGradleProblemSpec.log(logger); - }); - - - } - - public RuntimeException throwing(Action spec) { - return delegate.throwing(problemSpec -> { - final NeoGradleProblemSpec neoGradleProblemSpec = new NeoGradleProblemSpec(); - spec.execute(neoGradleProblemSpec); - - final String url = readMeUrl(neoGradleProblemSpec.section); - - problemSpec.id(neoGradleProblemSpec.category, neoGradleProblemSpec.id) - .contextualLabel(neoGradleProblemSpec.contextualLabel) - .solution(neoGradleProblemSpec.solution) - .details(neoGradleProblemSpec.details) - .severity(Severity.ERROR) - .withException(new InvalidUserDataException( "(%s) %s.\nPotential Solution: %s.\nMore information: %s".formatted( - neoGradleProblemSpec.contextualLabel, - neoGradleProblemSpec.details, - neoGradleProblemSpec.solution, - url - ))) - .documentedAt(url); - }); - } - - private static String readMeUrl(String section) { - final String neogradleVersion = NeoGradleUtils.getNeogradleVersion(); - final String branchMajorVersion = neogradleVersion.split("\\.")[0]; - final String branchMinorVersion = neogradleVersion.split("\\.")[1]; - final String branch = "NG_%s.%s".formatted(branchMajorVersion, branchMinorVersion); - - return "https://github.com/neoforged/NeoGradle/blob/%s/README.md#%s".formatted(branch, section); - } - - public static final class NeoGradleProblemSpec { - private String category; - private String id; - private String contextualLabel; - private String solution; - private String details; - private String section; - - public NeoGradleProblemSpec id(String category, String id) { - this.category = category; - this.id = id; - return this; - } - - public NeoGradleProblemSpec contextualLabel(String contextualLabel) { - this.contextualLabel = contextualLabel; - return this; - } - - public NeoGradleProblemSpec solution(String solution) { - this.solution = solution; - return this; - } - - public NeoGradleProblemSpec details(String details) { - this.details = details; - return this; - } - - public NeoGradleProblemSpec section(String section) { - this.section = section; - return this; - } - - private void log(Logger logger) { - logger.warn("-------------------------------------"); - logger.warn("NeoGradle detected a problem with your project: %s".formatted(contextualLabel)); - logger.warn("Details: %s".formatted(details)); - logger.warn("Potential Solution: %s".formatted(solution)); - logger.warn("More information: %s".formatted(readMeUrl(section))); - logger.warn("-------------------------------------"); - } - } -} diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/base/BaseFilesWithEntriesExtension.java b/common/src/main/java/net/neoforged/gradle/common/extensions/base/BaseFilesWithEntriesExtension.java deleted file mode 100644 index 47ff86626..000000000 --- a/common/src/main/java/net/neoforged/gradle/common/extensions/base/BaseFilesWithEntriesExtension.java +++ /dev/null @@ -1,30 +0,0 @@ -package net.neoforged.gradle.common.extensions.base; - -import net.minecraftforge.gdi.BaseDSLElementWithFilesAndEntries; -import org.gradle.api.Project; - -import javax.inject.Inject; -import java.util.Collections; - -/** - * Represents part of an extension which combines a set of files with entries as well as raw addable entries. - */ -public abstract class BaseFilesWithEntriesExtension> implements BaseDSLElementWithFilesAndEntries { - - private final Project project; - - @Inject - public BaseFilesWithEntriesExtension(Project project) { - this.project = project; - } - - @Override - public Project getProject() { - return project; - } - - @Override - public boolean isEmpty() { - return getFiles().isEmpty() && getEntries().getOrElse(Collections.emptyList()).isEmpty(); - } -} diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/dependency/replacement/ReplacementLogic.java b/common/src/main/java/net/neoforged/gradle/common/extensions/dependency/replacement/ReplacementLogic.java index 2d14ce9de..23be5b835 100644 --- a/common/src/main/java/net/neoforged/gradle/common/extensions/dependency/replacement/ReplacementLogic.java +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/dependency/replacement/ReplacementLogic.java @@ -5,6 +5,7 @@ import net.minecraftforge.gdi.ConfigurableDSLElement; import net.neoforged.gradle.common.extensions.IdeManagementExtension; import net.neoforged.gradle.common.tasks.ArtifactFromOutput; +import net.neoforged.gradle.common.util.ConfigurationUtils; import net.neoforged.gradle.dsl.common.extensions.dependency.replacement.DependencyReplacement; import net.neoforged.gradle.dsl.common.extensions.dependency.replacement.DependencyReplacementHandler; import net.neoforged.gradle.dsl.common.extensions.dependency.replacement.ReplacementAware; @@ -13,7 +14,6 @@ import net.neoforged.gradle.dsl.common.extensions.repository.Repository; import net.neoforged.gradle.dsl.common.tasks.WithOutput; import net.neoforged.gradle.dsl.common.util.CommonRuntimeUtils; -import net.neoforged.gradle.common.util.ConfigurationUtils; import org.gradle.api.GradleException; import org.gradle.api.NamedDomainObjectContainer; import org.gradle.api.Project; @@ -27,6 +27,7 @@ import javax.inject.Inject; import java.util.*; +import java.util.concurrent.ConcurrentHashMap; /** * Defines the implementation of the @{link DependencyReplacement} extension. @@ -39,7 +40,7 @@ public abstract class ReplacementLogic implements ConfigurableDSLElement> dependencyReplacementInformation = HashBasedTable.create(); private final Table repositoryEntries = HashBasedTable.create(); - private final Table originalDependencyLookup = HashBasedTable.create(); + private final Map originalDependencyLookup = new ConcurrentHashMap<>(); private final NamedDomainObjectContainer dependencyReplacementHandlers; private final List whenDependencyReplaced = new ArrayList<>(); @@ -59,9 +60,7 @@ public ReplacementLogic(Project project) { public void whenDependencyReplaced(DependencyReplacedCallback dependencyAction) { this.whenDependencyReplaced.add(dependencyAction); - for (Table.Cell dependencyConfigurationDependencyCell : this.originalDependencyLookup.cellSet()) { - dependencyAction.apply(dependencyConfigurationDependencyCell.getRowKey(), dependencyConfigurationDependencyCell.getColumnKey(), dependencyConfigurationDependencyCell.getValue()); - } + this.originalDependencyLookup.forEach(dependencyAction::apply); } @Override @@ -113,18 +112,9 @@ public NamedDomainObjectContainer getReplacementHa @NotNull @Override - public Dependency optionallyConvertBackToOriginal(@NotNull final Dependency dependency, Configuration configuration) { - final Dependency originalDependency = originalDependencyLookup.get(dependency, configuration); - if (originalDependency == null && !configuration.getExtendsFrom().isEmpty()) { - //Check if we have a parent configuration that might have the original dependency. - for (Configuration parentConfiguration : configuration.getExtendsFrom()) { - return optionallyConvertBackToOriginal(dependency, parentConfiguration); - } - } else if (originalDependency != null) { - return originalDependency; - } - - return dependency; + public Dependency optionallyConvertBackToOriginal(@NotNull final Dependency dependency) { + final Dependency originalDependency = originalDependencyLookup.get(dependency); + return Objects.requireNonNullElse(originalDependency, dependency); } /** @@ -273,36 +263,34 @@ private void handleDependencyReplacement(Configuration configuration, Dependency //Find the configurations that the dependency should be replaced in. final List targetConfigurations = ConfigurationUtils.findReplacementConfigurations(project, configuration); + //Create a dependency from the tasks that copies the raw jar to the repository. + //The sources jar is not needed here. + final ConfigurableFileCollection replacedFiles = createDependencyFromTask(rawTask); + final Dependency replacedDependency = project.getDependencies().create(replacedFiles); + final Dependency localRepoDependency = newRepoEntry.getDependency(); + //For each configuration that we target we now need to add the new dependencies to. for (Configuration targetConfiguration : targetConfigurations) { try { - //Create a dependency from the tasks that copies the raw jar to the repository. - //The sources jar is not needed here. - final Provider replacedFiles = createDependencyFromTask(rawTask); - //Add the new dependency to the target configuration. final DependencySet targetDependencies = targetConfiguration == configuration ? configuredSet : targetConfiguration.getDependencies(); - final Provider replacedDependencies = replacedFiles - .map(files -> project.getDependencies().create(files)); - final Provider newRepoDependency = project.provider(newRepoEntry::getDependency); - //Add the new dependency to the target configuration. - targetDependencies.addLater(replacedDependencies); - targetDependencies.addLater(newRepoDependency); - - //Keep track of the original dependency, so we can convert back if needed. - originalDependencyLookup.put(newRepoEntry.getDependency(), targetConfiguration, dependency); - - for (DependencyReplacedCallback dependencyReplacedCallback : this.whenDependencyReplaced) { - dependencyReplacedCallback.apply(newRepoEntry.getDependency(), targetConfiguration, dependency); - } + targetDependencies.add(replacedDependency); + targetDependencies.add(localRepoDependency); } catch (Exception exception) { throw new GradleException("Failed to add the replaced dependency to the configuration " + targetConfiguration.getName() + ": " + exception.getMessage(), exception); } } + + //Keep track of the original dependency, so we can convert back if needed. + originalDependencyLookup.put(localRepoDependency, dependency); + + for (DependencyReplacedCallback dependencyReplacedCallback : this.whenDependencyReplaced) { + dependencyReplacedCallback.apply(localRepoDependency, dependency); + } } /** @@ -475,7 +463,7 @@ Entry createDummyDependency(final Dependency dependency, final ReplacementResult return entry; } - public Provider createDependencyFromTask(TaskProvider task) { - return task.map(taskWithOutput -> project.files(taskWithOutput.getOutput())); + public ConfigurableFileCollection createDependencyFromTask(TaskProvider task) { + return project.files(task.flatMap(WithOutput::getOutput)); } } diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/problems/IProblemReporter.java b/common/src/main/java/net/neoforged/gradle/common/extensions/problems/IProblemReporter.java new file mode 100644 index 000000000..c8b40861a --- /dev/null +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/problems/IProblemReporter.java @@ -0,0 +1,26 @@ +package net.neoforged.gradle.common.extensions.problems; + +import org.gradle.api.Action; +import org.gradle.api.logging.Logger; + +/** + * NeoGradle problems reporter API + */ +public interface IProblemReporter { + + /** + * Reports a problem to the user without stopping the build. + * + * @param spec An action that configures the problem spec + * @param logger A logger to log the problem to + */ + void reporting(Action spec, Logger logger); + + /** + * Reports a problem to the user and stops the build. + * + * @param spec An action that configures the problem spec + * @return A runtime exception to throw + */ + RuntimeException throwing(Action spec); +} diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/problems/IntegratedProblemReporter.java b/common/src/main/java/net/neoforged/gradle/common/extensions/problems/IntegratedProblemReporter.java new file mode 100644 index 000000000..6548de055 --- /dev/null +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/problems/IntegratedProblemReporter.java @@ -0,0 +1,61 @@ +package net.neoforged.gradle.common.extensions.problems; + +import org.gradle.api.Action; +import org.gradle.api.InvalidUserDataException; +import org.gradle.api.logging.Logger; +import org.gradle.api.problems.Severity; +import org.gradle.api.problems.ProblemReporter; + +import javax.inject.Inject; + +/** + * Implements a problem reporter that integrates with the Gradles own problem reporter, while + * also logging directly to the user where needed + */ +public class IntegratedProblemReporter implements IProblemReporter { + + private final ProblemReporter delegate; + + @Inject + public IntegratedProblemReporter(ProblemReporter delegate) { + this.delegate = delegate; + } + + @Override + public void reporting(Action spec, Logger logger) { + delegate.reporting(problemSpec -> { + final NeoGradleProblemSpec neoGradleProblemSpec = new NeoGradleProblemSpec(); + spec.execute(neoGradleProblemSpec); + + problemSpec.id(neoGradleProblemSpec.category(), neoGradleProblemSpec.id()) + .contextualLabel(neoGradleProblemSpec.contextualLabel()) + .solution(neoGradleProblemSpec.solution()) + .details(neoGradleProblemSpec.details()) + .severity(Severity.WARNING) + .documentedAt(neoGradleProblemSpec.documentedAt()); + + neoGradleProblemSpec.log(logger); + }); + } + + @Override + public RuntimeException throwing(Action spec) { + return delegate.throwing(problemSpec -> { + final NeoGradleProblemSpec neoGradleProblemSpec = new NeoGradleProblemSpec(); + spec.execute(neoGradleProblemSpec); + + problemSpec.id(neoGradleProblemSpec.category(), neoGradleProblemSpec.id()) + .contextualLabel(neoGradleProblemSpec.contextualLabel()) + .solution(neoGradleProblemSpec.solution()) + .details(neoGradleProblemSpec.details()) + .severity(Severity.ERROR) + .withException(new InvalidUserDataException( "(%s) %s.\nPotential Solution: %s.\nMore information: %s".formatted( + neoGradleProblemSpec.contextualLabel(), + neoGradleProblemSpec.details(), + neoGradleProblemSpec.solution(), + neoGradleProblemSpec.documentedAt() + ))) + .documentedAt(neoGradleProblemSpec.documentedAt()); + }); + } +} diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/problems/IsolatedProblemReporter.java b/common/src/main/java/net/neoforged/gradle/common/extensions/problems/IsolatedProblemReporter.java new file mode 100644 index 000000000..e05187265 --- /dev/null +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/problems/IsolatedProblemReporter.java @@ -0,0 +1,28 @@ +package net.neoforged.gradle.common.extensions.problems; + +import org.gradle.api.Action; +import org.gradle.api.InvalidUserDataException; +import org.gradle.api.logging.Logger; + +public class IsolatedProblemReporter implements IProblemReporter { + + @Override + public void reporting(Action spec, Logger logger) { + final NeoGradleProblemSpec neoGradleProblemSpec = new NeoGradleProblemSpec(); + spec.execute(neoGradleProblemSpec); + neoGradleProblemSpec.log(logger); + } + + @Override + public RuntimeException throwing(Action spec) { + final NeoGradleProblemSpec neoGradleProblemSpec = new NeoGradleProblemSpec(); + spec.execute(neoGradleProblemSpec); + + throw new InvalidUserDataException( "(%s) %s.\nPotential Solution: %s.\nMore information: %s".formatted( + neoGradleProblemSpec.contextualLabel(), + neoGradleProblemSpec.details(), + neoGradleProblemSpec.solution(), + neoGradleProblemSpec.documentedAt() + )); + } +} diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/problems/NeoGradleProblemSpec.java b/common/src/main/java/net/neoforged/gradle/common/extensions/problems/NeoGradleProblemSpec.java new file mode 100644 index 000000000..639a5e12f --- /dev/null +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/problems/NeoGradleProblemSpec.java @@ -0,0 +1,85 @@ +package net.neoforged.gradle.common.extensions.problems; + +import net.neoforged.gradle.common.util.NeoGradleUtils; +import org.gradle.api.logging.Logger; + +public final class NeoGradleProblemSpec { + private String category; + private String id; + private String contextualLabel; + private String solution; + private String details; + private String section; + + public NeoGradleProblemSpec id(String category, String id) { + this.category = category; + this.id = id; + return this; + } + + public NeoGradleProblemSpec contextualLabel(String contextualLabel) { + this.contextualLabel = contextualLabel; + return this; + } + + public NeoGradleProblemSpec solution(String solution) { + this.solution = solution; + return this; + } + + public NeoGradleProblemSpec details(String details) { + this.details = details; + return this; + } + + public NeoGradleProblemSpec section(String section) { + this.section = section; + return this; + } + + String category() { + return category; + } + + String id() { + return id; + } + + String contextualLabel() { + return contextualLabel; + } + + String solution() { + return solution; + } + + String details() { + return details; + } + + String getSection() { + return section; + } + + String documentedAt() { + return readMeUrl(section); + } + + void log(Logger logger) { + logger.warn("-------------------------------------"); + logger.warn("NeoGradle detected a problem with your project: %s".formatted(contextualLabel)); + logger.warn("Details: %s".formatted(details)); + logger.warn("Potential Solution: %s".formatted(solution)); + logger.warn("More information: %s".formatted(documentedAt())); + logger.warn("-------------------------------------"); + } + + private static String readMeUrl(String section) { + final String neogradleVersion = NeoGradleUtils.getNeogradleVersion(); + final String branchMajorVersion = neogradleVersion.split("\\.")[0]; + final String branchMinorVersion = neogradleVersion.split("\\.")[1]; + final String branch = "NG_%s.%s".formatted(branchMajorVersion, branchMinorVersion); + + return "https://github.com/neoforged/NeoGradle/blob/%s/README.md#%s".formatted(branch, section); + } +} diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/problems/ProblemReportingConfigurator.java b/common/src/main/java/net/neoforged/gradle/common/extensions/problems/ProblemReportingConfigurator.java new file mode 100644 index 000000000..537200e45 --- /dev/null +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/problems/ProblemReportingConfigurator.java @@ -0,0 +1,20 @@ +package net.neoforged.gradle.common.extensions.problems; + +import net.neoforged.gradle.dsl.common.extensions.subsystems.Subsystems; +import org.gradle.api.Project; +import org.gradle.api.problems.Problems; + +public class ProblemReportingConfigurator { + + public static final String PROBLEM_NAMESPACE = "neoforged.gradle"; + public static final String PROBLEM_REPORTER_EXTENSION_NAME = "neogradleProblems"; + + public static void configureProblemReporting(Project project, Problems problems) { + final boolean enableGradleProblemReporting = project.getExtensions().getByType(Subsystems.class).getIntegration().getUseGradleProblemReporting().get(); + if (enableGradleProblemReporting) { + project.getExtensions().create(IProblemReporter.class, PROBLEM_REPORTER_EXTENSION_NAME, IntegratedProblemReporter.class, problems.forNamespace(PROBLEM_NAMESPACE)); + } else { + project.getExtensions().create(IProblemReporter.class, PROBLEM_REPORTER_EXTENSION_NAME, IsolatedProblemReporter.class); + } + } +} diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/sourcesets/SourceSetDependencyExtensionImpl.java b/common/src/main/java/net/neoforged/gradle/common/extensions/sourcesets/SourceSetDependencyExtensionImpl.java index 56e40cbd5..68211c19f 100644 --- a/common/src/main/java/net/neoforged/gradle/common/extensions/sourcesets/SourceSetDependencyExtensionImpl.java +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/sourcesets/SourceSetDependencyExtensionImpl.java @@ -1,6 +1,6 @@ package net.neoforged.gradle.common.extensions.sourcesets; -import net.neoforged.gradle.common.extensions.NeoGradleProblemReporter; +import net.neoforged.gradle.common.extensions.problems.IProblemReporter; import net.neoforged.gradle.common.util.SourceSetUtils; import net.neoforged.gradle.dsl.common.extensions.sourceset.SourceSetDependencyExtension; import net.neoforged.gradle.dsl.common.extensions.sourceset.SourceSetInheritanceExtension; @@ -30,7 +30,7 @@ public void on(SourceSet sourceSet) { final Project sourceSetProject = SourceSetUtils.getProject(sourceSet); if (sourceSetProject != project) { - final NeoGradleProblemReporter reporter = project.getExtensions().getByType(NeoGradleProblemReporter.class); + final IProblemReporter reporter = project.getExtensions().getByType(IProblemReporter.class); throw reporter.throwing(spec -> spec .id("source-set-dependencies", "wrong-project") .contextualLabel("on(SourceSet)") diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/sourcesets/SourceSetInheritanceExtensionImpl.java b/common/src/main/java/net/neoforged/gradle/common/extensions/sourcesets/SourceSetInheritanceExtensionImpl.java index 39ed390ac..02e3b5556 100644 --- a/common/src/main/java/net/neoforged/gradle/common/extensions/sourcesets/SourceSetInheritanceExtensionImpl.java +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/sourcesets/SourceSetInheritanceExtensionImpl.java @@ -1,6 +1,6 @@ package net.neoforged.gradle.common.extensions.sourcesets; -import net.neoforged.gradle.common.extensions.NeoGradleProblemReporter; +import net.neoforged.gradle.common.extensions.problems.IProblemReporter; import net.neoforged.gradle.common.util.SourceSetUtils; import net.neoforged.gradle.dsl.common.extensions.sourceset.SourceSetInheritanceExtension; import org.gradle.api.Project; @@ -29,7 +29,7 @@ public void from(SourceSet sourceSet) { final Project sourceSetProject = SourceSetUtils.getProject(sourceSet); if (sourceSetProject != project) { - final NeoGradleProblemReporter reporter = project.getExtensions().getByType(NeoGradleProblemReporter.class); + final IProblemReporter reporter = project.getExtensions().getByType(IProblemReporter.class); throw reporter.throwing(spec -> spec .id("source-set-inheritance", "wrong-project") .contextualLabel("from(SourceSet)") diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/IntegrationExtensions.java b/common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/IntegrationExtensions.java new file mode 100644 index 000000000..622403dcf --- /dev/null +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/IntegrationExtensions.java @@ -0,0 +1,19 @@ +package net.neoforged.gradle.common.extensions.subsystems; + +import net.neoforged.gradle.common.extensions.base.WithEnabledProperty; +import net.neoforged.gradle.dsl.common.extensions.subsystems.Integration; +import org.gradle.api.Project; + +import javax.inject.Inject; + +public abstract class IntegrationExtensions extends WithEnabledProperty implements Integration { + + @Inject + public IntegrationExtensions(Project project) { + super(project, "integrations"); + + getUseGradleProblemReporting().set( + getBooleanProperty("gradle-problem-reporting", false, false) + ); + } +} diff --git a/common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/SubsystemsExtension.java b/common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/SubsystemsExtension.java index c5dbd2525..80cf153b9 100644 --- a/common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/SubsystemsExtension.java +++ b/common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/SubsystemsExtension.java @@ -22,12 +22,14 @@ public abstract class SubsystemsExtension extends WithPropertyLookup implements private final Conventions conventions; private final Parchment parchment; private final Tools tools; + private final Integration integration; @Inject public SubsystemsExtension(Project project) { super(project); + this.integration = project.getObjects().newInstance(IntegrationExtensions.class, project); this.conventions = project.getObjects().newInstance(ConventionsExtension.class, project); this.parchment = project.getObjects().newInstance(ParchmentExtensions.class, project); this.tools = project.getObjects().newInstance(ToolsExtension.class, project); @@ -118,6 +120,11 @@ private void configureParchmentDefaults() { }); } + @Override + public Integration getIntegration() { + return integration; + } + @Override public Conventions getConventions() { return conventions; diff --git a/common/src/main/java/net/neoforged/gradle/common/interfaceinjection/InterfaceInjectionPublishing.java b/common/src/main/java/net/neoforged/gradle/common/interfaceinjection/InterfaceInjectionPublishing.java new file mode 100644 index 000000000..4f3f52973 --- /dev/null +++ b/common/src/main/java/net/neoforged/gradle/common/interfaceinjection/InterfaceInjectionPublishing.java @@ -0,0 +1,56 @@ +package net.neoforged.gradle.common.interfaceinjection; + +import net.neoforged.gradle.dsl.common.extensions.InterfaceInjections; +import org.gradle.api.Action; +import org.gradle.api.Project; +import org.gradle.api.artifacts.Configuration; +import org.gradle.api.attributes.AttributeContainer; +import org.gradle.api.attributes.Category; +import org.gradle.api.component.AdhocComponentWithVariants; + +public class InterfaceInjectionPublishing { + + public static final String INTERFACE_INJECTION_ELEMENTS_CONFIGURATION = "InterfaceInjectionElements"; + public static final String INTERFACE_INJECTION_API_CONFIGURATION = "InterfaceInjectionApi"; + public static final String INTERFACE_INJECTION_CONFIGURATION = "InterfaceInjection"; + public static final String INTERFACE_INJECTION_CATEGORY = "interfaceinjection"; + + public static void setup(Project project) { + InterfaceInjections InterfaceInjectionsExtension = project.getExtensions().getByType(InterfaceInjections.class); + + Configuration InterfaceInjectionElements = project.getConfigurations().maybeCreate(INTERFACE_INJECTION_ELEMENTS_CONFIGURATION); + Configuration InterfaceInjectionApi = project.getConfigurations().maybeCreate(INTERFACE_INJECTION_API_CONFIGURATION); + Configuration InterfaceInjection = project.getConfigurations().maybeCreate(INTERFACE_INJECTION_CONFIGURATION); + + InterfaceInjectionApi.setCanBeConsumed(false); + InterfaceInjectionApi.setCanBeResolved(false); + + InterfaceInjection.setCanBeConsumed(false); + InterfaceInjection.setCanBeResolved(true); + + InterfaceInjectionElements.setCanBeConsumed(true); + InterfaceInjectionElements.setCanBeResolved(false); + InterfaceInjectionElements.setCanBeDeclared(false); + + Action action = attributes -> { + attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.getObjects().named(Category.class, INTERFACE_INJECTION_CATEGORY)); + }; + + InterfaceInjectionElements.attributes(action); + InterfaceInjection.attributes(action); + + InterfaceInjection.extendsFrom(InterfaceInjectionApi); + InterfaceInjectionElements.extendsFrom(InterfaceInjectionApi); + + // Now we set up the component, conditionally + AdhocComponentWithVariants java = (AdhocComponentWithVariants) project.getComponents().getByName("java"); + Runnable enable = () -> java.addVariantsFromConfiguration(InterfaceInjectionElements, variant -> { + }); + + InterfaceInjectionElements.getAllDependencies().configureEach(dep -> enable.run()); + InterfaceInjectionElements.getArtifacts().configureEach(artifact -> enable.run()); + + // And add resolved ATs to the extension + InterfaceInjectionsExtension.getFiles().from(InterfaceInjection); + } +} diff --git a/common/src/main/java/net/neoforged/gradle/common/runs/ide/IdeRunIntegrationManager.java b/common/src/main/java/net/neoforged/gradle/common/runs/ide/IdeRunIntegrationManager.java index a973d8129..b49798d65 100644 --- a/common/src/main/java/net/neoforged/gradle/common/runs/ide/IdeRunIntegrationManager.java +++ b/common/src/main/java/net/neoforged/gradle/common/runs/ide/IdeRunIntegrationManager.java @@ -267,7 +267,7 @@ public void eclipse(Project project, EclipseModel eclipse) { return; final TaskProvider ideBeforeRunTask = getOrCreateIdeBeforeRunTask(project, runImpl); - final List> copyProcessResourcesTasks = createEclipseCopyResourcesTasks(eclipse, run); + final List> copyProcessResourcesTasks = createEclipseCopyResourcesTasks(run); ideBeforeRunTask.configure(task -> copyProcessResourcesTasks.forEach(task::dependsOn)); try { @@ -327,7 +327,7 @@ public void vscode(Project project, EclipseModel eclipse) final RunImpl runImpl = (RunImpl) run; final TaskProvider ideBeforeRunTask = getOrCreateIdeBeforeRunTask(project, runImpl); - final List> copyProcessResourcesTasks = createEclipseCopyResourcesTasks(eclipse, run); + final List> copyProcessResourcesTasks = createEclipseCopyResourcesTasks(run); ideBeforeRunTask.configure(task -> copyProcessResourcesTasks.forEach(task::dependsOn)); final LaunchConfiguration cfg = launchWriter.createGroup("NG - " + project.getName(), WritingMode.REMOVE_EXISTING) @@ -410,7 +410,7 @@ private List> createIntelliJCopyResourcesTasks(Run run) { return intelliJResourcesTask; } - private List> createEclipseCopyResourcesTasks(EclipseModel eclipse, Run run) { + private List> createEclipseCopyResourcesTasks(Run run) { final List> copyProcessResources = new ArrayList<>(); for (SourceSet sourceSet : run.getModSources().all().get().values()) { final Project sourceSetProject = SourceSetUtils.getProject(sourceSet); @@ -425,7 +425,7 @@ private List> createEclipseCopyResourcesTasks(EclipseModel eclip eclipseResourcesTask = sourceSetProject.getTasks().register(taskName, Copy.class, task -> { final TaskProvider defaultProcessResources = sourceSetProject.getTasks().named(sourceSet.getProcessResourcesTaskName(), ProcessResources.class); task.from(defaultProcessResources.map(ProcessResources::getDestinationDir)); - Path outputDir = eclipse.getClasspath().getDefaultOutputDir().toPath(); + Path outputDir = sourceSetProject.getExtensions().getByType(IdeManagementExtension.class).getEclipseModel().getClasspath().getDefaultOutputDir().toPath(); if (outputDir.endsWith("default")) { // sometimes it has default value from org.gradle.plugins.ide.eclipse.internal.EclipsePluginConstants#DEFAULT_PROJECT_OUTPUT_PATH // which has /default on end that is not present in the final outputDir in eclipse/buildship diff --git a/common/src/main/java/net/neoforged/gradle/common/runs/run/RunImpl.java b/common/src/main/java/net/neoforged/gradle/common/runs/run/RunImpl.java index 0363637c5..c542ce32f 100644 --- a/common/src/main/java/net/neoforged/gradle/common/runs/run/RunImpl.java +++ b/common/src/main/java/net/neoforged/gradle/common/runs/run/RunImpl.java @@ -2,7 +2,7 @@ import com.google.common.collect.Multimap; import net.minecraftforge.gdi.ConfigurableDSLElement; -import net.neoforged.gradle.common.extensions.NeoGradleProblemReporter; +import net.neoforged.gradle.common.extensions.problems.IProblemReporter; import net.neoforged.gradle.common.runtime.definition.CommonRuntimeDefinition; import net.neoforged.gradle.common.util.ConfigurationUtils; import net.neoforged.gradle.common.util.SourceSetUtils; @@ -202,7 +202,7 @@ public void overrideArguments(ListProperty arguments) { @Deprecated public ListProperty getProgramArguments() { - getProject().getExtensions().getByType(NeoGradleProblemReporter.class) + getProject().getExtensions().getByType(IProblemReporter.class) .reporting(problem -> problem .id("deprecated-method", "Deprecated method") .contextualLabel("Run.getProgramArguments()") @@ -471,7 +471,7 @@ private void configureFromSDKs() { } }, () -> unconfiguredSourceSets.add(sourceSet)); } catch (MultipleDefinitionsFoundException e) { - final NeoGradleProblemReporter reporter = project.getExtensions().getByType(NeoGradleProblemReporter.class); + final IProblemReporter reporter = project.getExtensions().getByType(IProblemReporter.class); throw reporter.throwing(problem -> problem .id("multiple-definitions-found", "Multiple runtime definitions found") .contextualLabel("Run: " + this.getName()) @@ -483,7 +483,7 @@ private void configureFromSDKs() { }); final DependencyReplacement replacementLogic = project.getExtensions().getByType(DependencyReplacement.class); - replacementLogic.whenDependencyReplaced((virtualDependency, targetConfiguration, originalDependency) -> { + replacementLogic.whenDependencyReplaced((virtualDependency, originalDependency) -> { if (unconfiguredSourceSets.isEmpty()) { return; } @@ -584,7 +584,7 @@ private void configureRunSpecification() { @Deprecated @Override public final void configure(final @NotNull String name) { - getProject().getExtensions().getByType(NeoGradleProblemReporter.class) + getProject().getExtensions().getByType(IProblemReporter.class) .reporting(problem -> problem .id("deprecated-method", "Deprecated method") .contextualLabel("Run.configure(String)") @@ -647,7 +647,7 @@ private Provider> getRunTypesByName(String name) { .toList() ))).map(types -> { if (types.isEmpty()) { - final NeoGradleProblemReporter reporter = project.getExtensions().getByType(NeoGradleProblemReporter.class); + final IProblemReporter reporter = project.getExtensions().getByType(IProblemReporter.class); throw reporter.throwing(problem -> problem .id("run-type-not-found", "Run type not found") .contextualLabel("The run type '%s' was not found".formatted(name)) diff --git a/common/src/main/java/net/neoforged/gradle/common/runtime/definition/CommonRuntimeDefinition.java b/common/src/main/java/net/neoforged/gradle/common/runtime/definition/CommonRuntimeDefinition.java index e88fce31c..379bc4ce7 100644 --- a/common/src/main/java/net/neoforged/gradle/common/runtime/definition/CommonRuntimeDefinition.java +++ b/common/src/main/java/net/neoforged/gradle/common/runtime/definition/CommonRuntimeDefinition.java @@ -17,6 +17,7 @@ import org.gradle.api.artifacts.Configuration; import org.gradle.api.file.ConfigurableFileCollection; import org.gradle.api.file.Directory; +import org.gradle.api.file.FileCollection; import org.gradle.api.file.RegularFile; import org.gradle.api.provider.ListProperty; import org.gradle.api.provider.MapProperty; @@ -61,6 +62,12 @@ public abstract class CommonRuntimeDefinition versionJson; + @NotNull + private FileCollection additionalRecompileDependencies; + + @NotNull + private FileCollection additionalSources; + protected CommonRuntimeDefinition( @NotNull final S specification, @NotNull final LinkedHashMap> taskOutputs, @@ -79,8 +86,12 @@ protected CommonRuntimeDefinition( this.associatedTaskConsumer = associatedTaskConsumer; this.versionJson = versionJson; + this.additionalRecompileDependencies = specification.getProject().files(); + this.additionalSources = specification.getProject().files(); + this.allDependencies = specification.getProject().files(); this.allDependencies.from(getMinecraftDependenciesConfiguration()); + this.allDependencies.from(this.additionalRecompileDependencies); } @Override @@ -163,6 +174,40 @@ public final ConfigurableFileCollection getAllDependencies() { return allDependencies; } + @NotNull + @Override + public FileCollection getAdditionalRecompileDependencies() { + return additionalRecompileDependencies; + } + + @Override + public void additionalRecompileDependency(Provider dependency) { + final FileCollection files = specification.getProject().files(dependency); + this.additionalRecompileDependencies = this.additionalRecompileDependencies.plus(files); + } + + @Override + public void additionalRecompileDependencies(FileCollection dependencies) { + this.additionalRecompileDependencies = this.additionalRecompileDependencies.plus(dependencies); + } + + @NotNull + @Override + public FileCollection getAdditionalCompileSources() { + return additionalSources; + } + + @Override + public void additionalCompileSource(Provider source) { + final FileCollection files = specification.getProject().files(source); + this.additionalSources = this.additionalSources.plus(files); + } + + @Override + public void additionalCompileSources(FileCollection sources) { + this.additionalSources = this.additionalSources.plus(sources); + } + public void configureRun(RunImpl run) { final MapProperty runtimeInterpolationData = getSpecification().getProject().getObjects().mapProperty(String.class, String.class); buildRunInterpolationData(run, runtimeInterpolationData); diff --git a/common/src/main/java/net/neoforged/gradle/common/runtime/tasks/AccessTransformerFileGenerator.java b/common/src/main/java/net/neoforged/gradle/common/runtime/tasks/AccessTransformerFileGenerator.java deleted file mode 100644 index 1a5a8f30a..000000000 --- a/common/src/main/java/net/neoforged/gradle/common/runtime/tasks/AccessTransformerFileGenerator.java +++ /dev/null @@ -1,44 +0,0 @@ -package net.neoforged.gradle.common.runtime.tasks; - -import net.neoforged.gradle.dsl.common.extensions.AccessTransformers; -import org.gradle.api.provider.ListProperty; -import org.gradle.api.tasks.CacheableTask; -import org.gradle.api.tasks.Input; -import org.gradle.api.tasks.Optional; -import org.gradle.api.tasks.TaskAction; - -import java.io.File; -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.StandardOpenOption; - -@CacheableTask -public abstract class AccessTransformerFileGenerator extends DefaultRuntime { - - public AccessTransformerFileGenerator() { - super(); - - getAdditionalTransformers().convention( - getProject().getExtensions().getByType(AccessTransformers.class) - .getEntries() - ); - - getOutputFileName().set(String.format("_script_%s.cfg", getProject().getName())); - } - - @TaskAction - void doCreateAccessTransformerFiles() throws IOException { - final File outputFile = ensureFileWorkspaceReady(getOutput()); - Files.deleteIfExists(outputFile.toPath()); - Files.write(outputFile.toPath(), getAdditionalTransformers().get(), StandardOpenOption.CREATE_NEW); - - if (!Files.exists(outputFile.toPath())) { - Files.createFile(outputFile.toPath()); - } - } - - @Input - @Optional - public abstract ListProperty getAdditionalTransformers(); - -} diff --git a/common/src/main/java/net/neoforged/gradle/common/runtime/tasks/SourceAccessTransformer.java b/common/src/main/java/net/neoforged/gradle/common/runtime/tasks/SourceAccessTransformer.java index 0b2545fd4..ed98feb9c 100644 --- a/common/src/main/java/net/neoforged/gradle/common/runtime/tasks/SourceAccessTransformer.java +++ b/common/src/main/java/net/neoforged/gradle/common/runtime/tasks/SourceAccessTransformer.java @@ -41,7 +41,7 @@ public SourceAccessTransformer() { } builder.append(f.getAbsolutePath()); }); - args.add("--classpath=" + builder.toString()); + args.add("--classpath=" + builder); args.add(inputFile.getAsFile().getAbsolutePath()); args.add(outputFile.getAbsolutePath()); diff --git a/common/src/main/java/net/neoforged/gradle/common/runtime/tasks/SourceInterfaceInjection.java b/common/src/main/java/net/neoforged/gradle/common/runtime/tasks/SourceInterfaceInjection.java new file mode 100644 index 000000000..0ceb28d4b --- /dev/null +++ b/common/src/main/java/net/neoforged/gradle/common/runtime/tasks/SourceInterfaceInjection.java @@ -0,0 +1,95 @@ +package net.neoforged.gradle.common.runtime.tasks; + +import com.google.common.collect.Lists; +import net.neoforged.gradle.common.util.ToolUtilities; +import net.neoforged.gradle.dsl.common.extensions.subsystems.Subsystems; +import org.apache.commons.io.FileUtils; +import org.gradle.api.file.ConfigurableFileCollection; +import org.gradle.api.file.RegularFileProperty; +import org.gradle.api.plugins.JavaPluginExtension; +import org.gradle.api.tasks.*; + +import java.io.File; +import java.util.List; + +@CacheableTask +public abstract class SourceInterfaceInjection extends DefaultExecute { + + public SourceInterfaceInjection() { + super(); + + setDescription("Runs the interface injection on the decompiled sources."); + + getStubs().convention(getOutputDirectory().map(dir -> dir.file("stubs.jar"))); + + getExecutingJar().set(ToolUtilities.resolveTool(getProject(), getProject().getExtensions().getByType(Subsystems.class).getTools().getJST().get())); + getRuntimeProgramArguments().convention( + getInputFile().map(inputFile -> { + final List args = Lists.newArrayList(); + final File outputFile = ensureFileWorkspaceReady(getOutput()); + final File stubsFile = ensureFileWorkspaceReady(getStubs()); + + args.add("--enable-interface-injection"); + getTransformers().forEach(f -> { + args.add("--interface-injection-data"); + args.add(f.getAbsolutePath()); + }); + + args.add("--interface-injection-stubs"); + args.add(stubsFile.getAbsolutePath()); + + args.add("--libraries-list=" + getLibraries().get().getAsFile().getAbsolutePath()); + + final StringBuilder builder = new StringBuilder(); + getClasspath().forEach(f -> { + if (!builder.isEmpty()) { + builder.append(File.pathSeparator); + } + builder.append(f.getAbsolutePath()); + }); + args.add("--classpath=" + builder); + + args.add(inputFile.getAsFile().getAbsolutePath()); + args.add(outputFile.getAbsolutePath()); + + return args; + } + ) + ); + + getJavaVersion().convention(getProject().getExtensions().getByType(JavaPluginExtension.class).getToolchain().getLanguageVersion()); + getTransformers().finalizeValueOnRead(); + getLogLevel().set(LogLevel.DISABLED); + } + + @Override + public void doExecute() throws Exception { + //We need a separate check here that skips the execute call if there are no transformers. + if (getTransformers().isEmpty()) { + final File output = ensureFileWorkspaceReady(getOutput()); + FileUtils.copyFile(getInputFile().get().getAsFile(), output); + } + + super.doExecute(); + } + + @InputFile + @PathSensitive(PathSensitivity.NONE) + public abstract RegularFileProperty getInputFile(); + + @InputFile + @PathSensitive(PathSensitivity.NONE) + public abstract RegularFileProperty getLibraries(); + + @InputFiles + @Optional + @PathSensitive(PathSensitivity.NONE) + public abstract ConfigurableFileCollection getClasspath(); + + @InputFiles + @PathSensitive(PathSensitivity.NONE) + public abstract ConfigurableFileCollection getTransformers(); + + @OutputFile + public abstract RegularFileProperty getStubs(); +} diff --git a/common/src/main/java/net/neoforged/gradle/common/tasks/JarJar.java b/common/src/main/java/net/neoforged/gradle/common/tasks/JarJar.java index 557b85bc3..a34a97024 100644 --- a/common/src/main/java/net/neoforged/gradle/common/tasks/JarJar.java +++ b/common/src/main/java/net/neoforged/gradle/common/tasks/JarJar.java @@ -2,7 +2,7 @@ import net.neoforged.gradle.common.dependency.JarJarArtifacts; import net.neoforged.gradle.common.dependency.ResolvedJarJarArtifact; -import net.neoforged.gradle.common.extensions.NeoGradleProblemReporter; +import net.neoforged.gradle.common.extensions.problems.IProblemReporter; import net.neoforged.gradle.common.manifest.DefaultInheritManifest; import net.neoforged.gradle.common.manifest.InheritManifest; import net.neoforged.gradle.dsl.common.dependency.DependencyFilter; @@ -34,7 +34,7 @@ public abstract class JarJar extends Jar { public JarJar() { this.artifacts = getProject().getObjects().newInstance(JarJarArtifacts.class, - getProject().getExtensions().getByType(NeoGradleProblemReporter.class) + getProject().getExtensions().getByType(IProblemReporter.class) ); this.jarJarCopySpec = this.getMainSpec().addChild(); this.jarJarCopySpec.into("META-INF/jarjar"); diff --git a/common/src/main/java/net/neoforged/gradle/common/util/CommonRuntimeTaskUtils.java b/common/src/main/java/net/neoforged/gradle/common/util/CommonRuntimeTaskUtils.java index 078d43639..050f7a2c8 100644 --- a/common/src/main/java/net/neoforged/gradle/common/util/CommonRuntimeTaskUtils.java +++ b/common/src/main/java/net/neoforged/gradle/common/util/CommonRuntimeTaskUtils.java @@ -1,10 +1,7 @@ package net.neoforged.gradle.common.util; -import net.neoforged.gradle.common.runtime.tasks.BinaryAccessTransformer; -import net.neoforged.gradle.common.runtime.tasks.SourceAccessTransformer; -import net.neoforged.gradle.common.runtime.tasks.AccessTransformerFileGenerator; +import net.neoforged.gradle.common.runtime.tasks.*; import net.neoforged.gradle.dsl.common.runtime.definition.Definition; -import net.neoforged.gradle.dsl.common.runtime.tasks.Runtime; import net.neoforged.gradle.dsl.common.tasks.WithOutput; import net.neoforged.gradle.dsl.common.util.CommonRuntimeUtils; import net.neoforged.gradle.util.StringCapitalizationUtils; @@ -12,58 +9,33 @@ import org.gradle.api.file.FileTree; import org.gradle.api.tasks.TaskProvider; -import java.io.File; -import java.util.Collection; -import java.util.function.Consumer; - public final class CommonRuntimeTaskUtils { private CommonRuntimeTaskUtils() { throw new IllegalStateException("Can not instantiate an instance of: CommonRuntimeTaskUtils. This is a utility class"); } - public static TaskProvider createSourceAccessTransformer(Definition definition, String namePreFix, File workspaceDirectory, Consumer> dependentTaskConfigurationHandler, FileTree files, Collection data, TaskProvider listLibs, FileCollection additionalClasspathElements) { - final TaskProvider generator; - if (!data.isEmpty()) { - generator = definition.getSpecification().getProject().getTasks().register(CommonRuntimeUtils.buildTaskName(definition.getSpecification(), namePreFix + "AccessTransformerGenerator"), AccessTransformerFileGenerator.class, task -> { - task.getOutput().set(new File(workspaceDirectory, "accesstransformers/" + namePreFix + "/_script-access-transformer.cfg")); - task.getAdditionalTransformers().set(data); - }); - dependentTaskConfigurationHandler.accept(generator); - } else { - generator = null; - } - + public static TaskProvider createSourceAccessTransformer(Definition definition, String namePreFix, FileTree files, TaskProvider listLibs, FileCollection additionalClasspathElements) { return definition.getSpecification().getProject().getTasks().register(CommonRuntimeUtils.buildTaskName(definition.getSpecification(), String.format("apply%sAccessTransformer", StringCapitalizationUtils.capitalize(namePreFix))), SourceAccessTransformer.class, task -> { task.getTransformers().from(files); - if (generator != null) { - task.getTransformers().from(generator.flatMap(WithOutput::getOutput)); - task.dependsOn(generator); - } task.dependsOn(listLibs); task.getLibraries().set(listLibs.flatMap(WithOutput::getOutput)); task.getClasspath().from(additionalClasspathElements); }); } - public static TaskProvider createBinaryAccessTransformer(Definition definition, String namePreFix, File workspaceDirectory, Consumer> dependentTaskConfigurationHandler, FileTree files, Collection data) { - final TaskProvider generator; - if (!data.isEmpty()) { - generator = definition.getSpecification().getProject().getTasks().register(CommonRuntimeUtils.buildTaskName(definition.getSpecification(), namePreFix + "AccessTransformerGenerator"), AccessTransformerFileGenerator.class, task -> { - task.getOutput().set(new File(workspaceDirectory, "accesstransformers/" + namePreFix + "/_script-access-transformer.cfg")); - task.getAdditionalTransformers().set(data); - }); - dependentTaskConfigurationHandler.accept(generator); - } else { - generator = null; - } + public static TaskProvider createSourceInterfaceInjection(Definition definition, String namePreFix, FileTree files, TaskProvider listLibs, FileCollection additionalClasspathElements) { + return definition.getSpecification().getProject().getTasks().register(CommonRuntimeUtils.buildTaskName(definition.getSpecification(), String.format("apply%sInterfaceInjection", StringCapitalizationUtils.capitalize(namePreFix))), SourceInterfaceInjection.class, task -> { + task.getTransformers().from(files); + task.dependsOn(listLibs); + task.getLibraries().set(listLibs.flatMap(WithOutput::getOutput)); + task.getClasspath().from(additionalClasspathElements); + }); + } + public static TaskProvider createBinaryAccessTransformer(Definition definition, String namePreFix, FileTree files) { return definition.getSpecification().getProject().getTasks().register(CommonRuntimeUtils.buildTaskName(definition.getSpecification(), String.format("apply%sAccessTransformer", StringCapitalizationUtils.capitalize(namePreFix))), BinaryAccessTransformer.class, task -> { task.getTransformers().from(files); - if (generator != null) { - task.getTransformers().from(generator.flatMap(WithOutput::getOutput)); - task.dependsOn(generator); - } }); } } diff --git a/common/src/main/java/net/neoforged/gradle/common/util/ConfigurationUtils.java b/common/src/main/java/net/neoforged/gradle/common/util/ConfigurationUtils.java index 1bfd25927..14cd9f7d2 100644 --- a/common/src/main/java/net/neoforged/gradle/common/util/ConfigurationUtils.java +++ b/common/src/main/java/net/neoforged/gradle/common/util/ConfigurationUtils.java @@ -1,10 +1,8 @@ package net.neoforged.gradle.common.util; import net.neoforged.gradle.dsl.common.extensions.dependency.replacement.DependencyReplacement; -import net.neoforged.gradle.dsl.common.extensions.subsystems.Subsystems; import net.neoforged.gradle.dsl.common.runs.run.Run; import org.apache.commons.lang3.StringUtils; -import org.codehaus.groovy.runtime.DefaultGroovyMethods; import org.codehaus.groovy.runtime.StringGroovyMethods; import org.gradle.api.Action; import org.gradle.api.Project; @@ -17,7 +15,10 @@ import org.gradle.util.internal.GUtil; import java.io.File; -import java.util.*; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; import java.util.function.Function; public class ConfigurationUtils { @@ -28,6 +29,21 @@ private ConfigurationUtils() { throw new IllegalStateException("Can not instantiate an instance of: ConfigurationUtils. This is a utility class"); } + /** + * Extends the dependencies and dependency constraints of the target configuration with the dependencies and dependency constraints of the given configurations. + * + * @param project The project to create the configuration for + * @param target The configuration to extend + * @param configurations The configurations to extend from + */ + public static void extendsFrom(final Project project, final Configuration target, final Configuration... configurations) { + for (Configuration configuration : configurations) { + //We treat each configuration as a dependency collector in and of it-self, and copy the dependencies and dependency constraints to the target configuration. + target.getDependencies().addAllLater(project.provider(configuration::getDependencies)); + target.getDependencyConstraints().addAllLater(project.provider(configuration::getDependencyConstraints)); + } + } + /** * Creates a configuration that can be resolved, but not consumed. * @@ -37,18 +53,10 @@ private ConfigurationUtils() { * @return The detached configuration */ public static Configuration temporaryConfiguration(final Project project, final String context, final Dependency... dependencies) { - final Configuration configuration = project.getConfigurations().maybeCreate("neoGradleInternal" + StringGroovyMethods.capitalize(context)); - - if (configuration.getDependencies().isEmpty()) { - DefaultGroovyMethods.addAll(configuration.getDependencies(), dependencies); - - configuration.setCanBeConsumed(false); - configuration.setCanBeResolved(true); - - final DependencyReplacement dependencyReplacement = project.getExtensions().getByType(DependencyReplacement.class); - dependencyReplacement.handleConfiguration(configuration); - } + final Configuration configuration = project.getConfigurations().detachedConfiguration(dependencies); + final DependencyReplacement dependencyReplacement = project.getExtensions().getByType(DependencyReplacement.class); + dependencyReplacement.handleConfiguration(configuration); return configuration; } @@ -62,23 +70,13 @@ public static Configuration temporaryConfiguration(final Project project, final * @return The detached configuration */ public static Configuration temporaryConfiguration(final Project project, final String context, final Action processor) { - final String name = "neoGradleInternal" + StringGroovyMethods.capitalize(context); - final boolean exists = project.getConfigurations().getNames().contains(name); + final Configuration config = project.getConfigurations().detachedConfiguration(); + processor.execute(config); - final Configuration configuration = project.getConfigurations().maybeCreate("neoGradleInternal" + StringGroovyMethods.capitalize(context)); + final DependencyReplacement dependencyReplacement = project.getExtensions().getByType(DependencyReplacement.class); + dependencyReplacement.handleConfiguration(config); - if (!exists) { - processor.execute(configuration); - - configuration.setCanBeConsumed(false); - configuration.setCanBeResolved(true); - - final DependencyReplacement dependencyReplacement = project.getExtensions().getByType(DependencyReplacement.class); - dependencyReplacement.handleConfiguration(configuration); - } - - - return configuration; + return config; } /** @@ -100,17 +98,9 @@ public static boolean isUnhandledConfiguration(Configuration configuration) { * @return The detached configuration */ public static Configuration temporaryUnhandledConfiguration(final ConfigurationContainer configurations, final String context, final Dependency... dependencies) { - final Configuration configuration = configurations.maybeCreate("neoGradleInternalUnhandled" + StringGroovyMethods.capitalize(context)); - UNHANDLED_CONFIGURATIONS.add(configuration); - - if (configuration.getDependencies().isEmpty()) { - configuration.getDependencies().addAll(Arrays.asList(dependencies)); - configuration.setCanBeConsumed(false); - configuration.setCanBeResolved(true); - } - - - return configuration; + final Configuration config = configurations.detachedConfiguration(dependencies); + UNHANDLED_CONFIGURATIONS.add(config); + return config; } /** @@ -122,23 +112,10 @@ public static Configuration temporaryUnhandledConfiguration(final ConfigurationC * @return The detached configuration */ public static Configuration temporaryUnhandledConfiguration(final ConfigurationContainer configurations, final String context, final Provider> dependencies) { - final String name = "neoGradleInternalUnhandled" + StringGroovyMethods.capitalize(context); - if (configurations.findByName(name) != null) { - return configurations.getByName(name); - } - - final Configuration configuration = configurations.create(name); - UNHANDLED_CONFIGURATIONS.add(configuration); - - if (configuration.getDependencies().isEmpty()) { - configuration.getDependencies().addAllLater(dependencies); - - configuration.setCanBeConsumed(false); - configuration.setCanBeResolved(true); - } - - - return configuration; + final Configuration config = configurations.detachedConfiguration(); + config.getDependencies().addAllLater(dependencies); + UNHANDLED_CONFIGURATIONS.add(config); + return config; } /** @@ -150,25 +127,16 @@ public static Configuration temporaryUnhandledConfiguration(final ConfigurationC * @return The detached configuration */ public static Configuration temporaryUnhandledNotTransitiveConfiguration(final ConfigurationContainer configurations, final String context, final Dependency... dependencies) { - final Configuration configuration = configurations.maybeCreate("neoGradleInternalUnhandled" + StringGroovyMethods.capitalize(context)); - UNHANDLED_CONFIGURATIONS.add(configuration); - - if (configuration.getDependencies().isEmpty()) { - DefaultGroovyMethods.addAll(configuration.getDependencies(), dependencies); - - configuration.setCanBeConsumed(false); - configuration.setCanBeResolved(true); - configuration.setTransitive(false); - } - - - return configuration; + final Configuration config = configurations.detachedConfiguration(dependencies); + config.setTransitive(false); + UNHANDLED_CONFIGURATIONS.add(config); + return config; } /** * Creates a provider that will resolve a temporary configuration containing the given dependency. */ - public static Provider getArtifactProvider(Project project, String context, Provider dependencyNotationProvider) { + public static Provider getArtifactProvider(Project project, String context, Provider dependencyNotationProvider) { return dependencyNotationProvider.flatMap(dependencyNotation -> { Configuration configuration = temporaryUnhandledNotTransitiveConfiguration(project.getConfigurations(), context, project.getDependencies().create(dependencyNotation)); return configuration.getElements().map(files -> files.iterator().next().getAsFile()); @@ -186,7 +154,6 @@ public static List findReplacementConfigurations(final Project pr resultContainer.add(configuration); } - return new ArrayList<>(resultContainer); } @@ -237,9 +204,11 @@ public static List findRuntimeOnlyConfigurationFromSourceSetRepla final Set supers = getAllSuperConfigurations(runtimeClasspath); if (supers.contains(runtimeOnly) && supers.contains(configuration)) { - final Configuration reallyRuntimeOnly = project.getConfigurations().maybeCreate(getSourceSetName(sourceSet, "%s%s".formatted(NEOGRADLE_RUNTIME_REPLACEMENT, StringUtils.capitalize(sourceSet.getName())))); - runtimeClasspath.extendsFrom(reallyRuntimeOnly); - targets.add(reallyRuntimeOnly); + final Configuration detachedRuntimeOnly = project.getConfigurations().detachedConfiguration(); + + extendsFrom(project, runtimeClasspath, detachedRuntimeOnly); + + targets.add(detachedRuntimeOnly); } }); @@ -314,6 +283,5 @@ public static String getTaskBaseName(final SourceSet sourceSet) { return sourceSet.getName().equals(SourceSet.MAIN_SOURCE_SET_NAME) ? "" : GUtil.toCamelCase(sourceSet.getName()); } - private static Set UNHANDLED_CONFIGURATIONS = new HashSet(); - + private static final Set UNHANDLED_CONFIGURATIONS = new HashSet(); } diff --git a/common/src/main/java/net/neoforged/gradle/common/util/NeoGradleUtils.java b/common/src/main/java/net/neoforged/gradle/common/util/NeoGradleUtils.java index 0036a40bb..694e83a96 100644 --- a/common/src/main/java/net/neoforged/gradle/common/util/NeoGradleUtils.java +++ b/common/src/main/java/net/neoforged/gradle/common/util/NeoGradleUtils.java @@ -1,6 +1,5 @@ package net.neoforged.gradle.common.util; -import net.neoforged.gradle.common.extensions.NeoGradleProblemReporter; import org.jetbrains.annotations.NotNull; import java.io.IOException; diff --git a/common/src/main/java/net/neoforged/gradle/common/util/TaskDependencyUtils.java b/common/src/main/java/net/neoforged/gradle/common/util/TaskDependencyUtils.java index 70430297e..588e060f0 100644 --- a/common/src/main/java/net/neoforged/gradle/common/util/TaskDependencyUtils.java +++ b/common/src/main/java/net/neoforged/gradle/common/util/TaskDependencyUtils.java @@ -237,7 +237,7 @@ private void processConfiguration(Configuration configuration) { //Grab the original dependencies if we have a replacement extension final DependencyReplacement replacement = project.getExtensions().findByType(DependencyReplacement.class); final Set operatingSet = replacement == null ? dependencies : dependencies.stream() - .map(dependency -> replacement.optionallyConvertBackToOriginal(dependency, configuration)) + .map(replacement::optionallyConvertBackToOriginal) .collect(Collectors.toSet()); this.runtimes.stream() diff --git a/common/src/main/java/net/neoforged/gradle/common/util/ZipFileUpdater.java b/common/src/main/java/net/neoforged/gradle/common/util/ZipFileUpdater.java new file mode 100644 index 000000000..2a7c55bd7 --- /dev/null +++ b/common/src/main/java/net/neoforged/gradle/common/util/ZipFileUpdater.java @@ -0,0 +1,49 @@ +package net.neoforged.gradle.common.util; + +import java.io.*; +import java.nio.file.*; +import java.util.zip.*; + +public class ZipFileUpdater { + + public static void addFileToZip(File zipFile, File fileToAdd, String entryName) throws IOException { + // Temporary zip file + File tempFile = File.createTempFile(zipFile.getName(), null); + tempFile.delete(); + + try (ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFile)); + ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(tempFile))) { + + // Copy existing entries to the new zip file + ZipEntry entry; + while ((entry = zis.getNextEntry()) != null) { + if (entry.getName().equals(entryName)) { + continue; + } + zos.putNextEntry(new ZipEntry(entry.getName())); + byte[] buffer = new byte[1024]; + int len; + while ((len = zis.read(buffer)) > 0) { + zos.write(buffer, 0, len); + } + zos.closeEntry(); + zis.closeEntry(); + } + + // Add the new file to the zip file + try (InputStream fis = new FileInputStream(fileToAdd)) { + zos.putNextEntry(new ZipEntry(entryName)); + byte[] buffer = new byte[1024]; + int len; + while ((len = fis.read(buffer)) > 0) { + zos.write(buffer, 0, len); + } + zos.closeEntry(); + } + } + + // Replace the old zip file with the new zip file + Files.delete(zipFile.toPath()); + Files.move(tempFile.toPath(), zipFile.toPath(), StandardCopyOption.REPLACE_EXISTING); + } +} \ No newline at end of file diff --git a/common/src/main/java/net/neoforged/gradle/common/util/run/RunsUtil.java b/common/src/main/java/net/neoforged/gradle/common/util/run/RunsUtil.java index 142c7a376..061b1809b 100644 --- a/common/src/main/java/net/neoforged/gradle/common/util/run/RunsUtil.java +++ b/common/src/main/java/net/neoforged/gradle/common/util/run/RunsUtil.java @@ -3,7 +3,7 @@ import com.google.common.collect.HashMultimap; import com.google.common.collect.Multimap; import net.neoforged.gradle.common.extensions.IdeManagementExtension; -import net.neoforged.gradle.common.extensions.NeoGradleProblemReporter; +import net.neoforged.gradle.common.extensions.problems.IProblemReporter; import net.neoforged.gradle.common.runs.run.RunImpl; import net.neoforged.gradle.common.tasks.RenderDocDownloaderTask; import net.neoforged.gradle.common.util.ClasspathUtils; @@ -160,7 +160,7 @@ public static void setupModSources(Project project, Run run, boolean isInternal) //Warn the user if no source sets are configured if (run.getModSources().all().get().isEmpty()) { - final NeoGradleProblemReporter reporter = project.getExtensions().getByType(NeoGradleProblemReporter.class); + final IProblemReporter reporter = project.getExtensions().getByType(IProblemReporter.class); throw reporter.throwing(problemSpec -> problemSpec.id("runs", "noSourceSetsConfigured") .contextualLabel("Run: " + run.getName()) @@ -201,7 +201,7 @@ public static void setupDevLoginSupport(Project project, Run run) { //Set the main class to the dev login tool run.getMainClass().set(devLogin.getMainClass()); } else if (!run.getIsClient().get() && runsDevLogin.getIsEnabled().get()) { - final NeoGradleProblemReporter reporter = project.getExtensions().getByType(NeoGradleProblemReporter.class); + final IProblemReporter reporter = project.getExtensions().getByType(IProblemReporter.class); throw reporter.throwing(spec -> spec .id("runs", "dev-login-not-supported") .contextualLabel("Run: " + run.getName()) diff --git a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/AccessTransformers.groovy b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/AccessTransformers.groovy index 33bfe32bd..685e34824 100644 --- a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/AccessTransformers.groovy +++ b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/AccessTransformers.groovy @@ -2,17 +2,27 @@ package net.neoforged.gradle.dsl.common.extensions import groovy.transform.CompileStatic import net.minecraftforge.gdi.BaseDSLElementWithFilesAndEntries +import net.minecraftforge.gdi.annotations.DSLProperty import org.gradle.api.Action import org.gradle.api.artifacts.ConfigurablePublishArtifact import org.gradle.api.artifacts.Dependency import org.gradle.api.artifacts.dsl.Dependencies import org.gradle.api.artifacts.dsl.DependencyCollector +import org.gradle.api.file.ConfigurableFileCollection +import org.gradle.api.tasks.InputFiles /** * Defines a DSL extension which allows for the specification of access transformers. */ @CompileStatic -interface AccessTransformers extends BaseDSLElementWithFilesAndEntries, Dependencies { +interface AccessTransformers extends Dependencies { + + /** + * {@return access transformer files} + */ + @DSLProperty + ConfigurableFileCollection getFiles(); + /** * {@return access transformers to add as dependencies} */ diff --git a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/InjectedInterfaceData.groovy b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/InjectedInterfaceData.groovy new file mode 100644 index 000000000..4f6772502 --- /dev/null +++ b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/InjectedInterfaceData.groovy @@ -0,0 +1,37 @@ +package net.neoforged.gradle.dsl.common.extensions + +import groovy.transform.CompileStatic +import net.minecraftforge.gdi.ConfigurableDSLElement +import net.minecraftforge.gdi.annotations.DSLProperty +import org.gradle.api.provider.ListProperty +import org.gradle.api.provider.Property +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.Nested + +/** + * Represents the data for injecting interfaces into a target class. + */ +@CompileStatic +abstract class InjectedInterfaceData implements ConfigurableDSLElement { + + /** + * The binary representation of the target class to inject the interfaces into. + * + * @return The target class to inject the interfaces into. + */ + @Input + @DSLProperty + abstract Property getTarget(); + + /** + * The binary representation of the interfaces to inject. + *

+ * Generics are copied verbatim. If you need the generics to reference a class, please use its fully qualified name (e.g. java/util/function/Supplier). + *

+ * + * @return The interfaces to inject. + */ + @Input + @DSLProperty + abstract ListProperty getInterfaces(); +} diff --git a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/InterfaceInjections.groovy b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/InterfaceInjections.groovy new file mode 100644 index 000000000..52bcbbc1b --- /dev/null +++ b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/InterfaceInjections.groovy @@ -0,0 +1,55 @@ +package net.neoforged.gradle.dsl.common.extensions + +import groovy.transform.CompileStatic +import net.minecraftforge.gdi.BaseDSLElementWithFilesAndEntries +import net.minecraftforge.gdi.annotations.DSLProperty +import org.gradle.api.Action +import org.gradle.api.artifacts.ConfigurablePublishArtifact +import org.gradle.api.artifacts.Dependency +import org.gradle.api.artifacts.dsl.Dependencies +import org.gradle.api.artifacts.dsl.DependencyCollector +import org.gradle.api.file.ConfigurableFileCollection + +/** + * Defines a DSL extension which allows for the specification of interface injections. + */ +@CompileStatic +interface InterfaceInjections extends Dependencies { + + /** + * {@return interface injection files} + */ + @DSLProperty + ConfigurableFileCollection getFiles() + + /** + * {@return interface injections to add as dependencies} + */ + DependencyCollector getConsume() + + /** + * {@return interface injections to add as dependencies and also expose to consumers} + */ + DependencyCollector getConsumeApi() + + /** + * Publishes a transitive dependency on the given access transformer in the published interface injections of this component. + * + * @param dependency to expose to consumers + */ + void expose(Dependency dependency) + + /** + * Publishes the provided access transformer as an artifact. + * + * @param path access transformer file to publish + */ + void expose(Object path) + + /** + * Publishes the provided access transformer as an artifact and configures it with the provided action. + * @param path access transformer file to publish + * @param action configures the published artifact + */ + void expose(Object path, Action action) +} \ No newline at end of file diff --git a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/Minecraft.groovy b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/Minecraft.groovy index 7d69592e9..dfb7e0fd4 100644 --- a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/Minecraft.groovy +++ b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/Minecraft.groovy @@ -47,4 +47,13 @@ interface Minecraft extends BaseDSLElement { @NotNull @DSLProperty AccessTransformers getAccessTransformers(); + + /** + * Gives access to the interface injections configuration extension. + * + * @return The interface injections configuration extension. + */ + @NotNull + @DSLProperty + InterfaceInjections getInterfaceInjections(); } diff --git a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/dependency/replacement/DependencyReplacement.groovy b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/dependency/replacement/DependencyReplacement.groovy index 97ed9e006..68f27e6ca 100644 --- a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/dependency/replacement/DependencyReplacement.groovy +++ b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/dependency/replacement/DependencyReplacement.groovy @@ -3,7 +3,6 @@ package net.neoforged.gradle.dsl.common.extensions.dependency.replacement import groovy.transform.CompileStatic import net.minecraftforge.gdi.BaseDSLElement import net.minecraftforge.gdi.annotations.DSLProperty -import org.gradle.api.Action import org.gradle.api.NamedDomainObjectContainer import org.gradle.api.artifacts.Configuration import org.gradle.api.artifacts.Dependency @@ -34,12 +33,11 @@ interface DependencyReplacement extends BaseDSLElement { /** * Optionally converts the given dependency back to the original dependency it replaced. * - * @param dependency The dependency to optionally convert back. * @param configuration The configuration the given dependency can be found it resides in. * @return The original dependency if it can be converted back, otherwise the given dependency. */ @NotNull - Dependency optionallyConvertBackToOriginal(Dependency dependency, Configuration configuration) + Dependency optionallyConvertBackToOriginal(Dependency dependency) /** * Invoked when a dependency is replaced. @@ -57,9 +55,8 @@ interface DependencyReplacement extends BaseDSLElement { * Invoked when a dependency is replaced. * * @param virtualDependency The virtual dependency. - * @param targetConfiguration The target configuration in which the virtual dependency resides. * @param originalDependency The original dependency. */ - void apply(Dependency virtualDependency, Configuration targetConfiguration, Dependency originalDependency); + void apply(Dependency virtualDependency, Dependency originalDependency); } } diff --git a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/subsystems/Integration.groovy b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/subsystems/Integration.groovy new file mode 100644 index 000000000..193b210c4 --- /dev/null +++ b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/subsystems/Integration.groovy @@ -0,0 +1,20 @@ +package net.neoforged.gradle.dsl.common.extensions.subsystems + +import net.minecraftforge.gdi.BaseDSLElement +import org.gradle.api.provider.Property + +/** + * Defines the integration settings for NeoGradle. + */ +interface Integration extends BaseDSLElement { + + /** + * @return whether the integration is enabled + */ + Property getIsEnabled(); + + /** + * @return whether to use Gradle problem reporting + */ + Property getUseGradleProblemReporting(); +} \ No newline at end of file diff --git a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/subsystems/Subsystems.groovy b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/subsystems/Subsystems.groovy index c1966251f..1005930f8 100644 --- a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/subsystems/Subsystems.groovy +++ b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/subsystems/Subsystems.groovy @@ -12,6 +12,11 @@ import org.gradle.api.tasks.Nested @CompileStatic interface Subsystems extends BaseDSLElement { + /** + * @return settings for the integration subsystem + */ + Integration getIntegration(); + /** * @return settings for the decompiler subsystem */ diff --git a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/runtime/definition/Definition.groovy b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/runtime/definition/Definition.groovy index aba4c5f88..83d5682e2 100644 --- a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/runtime/definition/Definition.groovy +++ b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/runtime/definition/Definition.groovy @@ -10,6 +10,8 @@ import org.gradle.api.artifacts.Configuration import org.gradle.api.artifacts.Dependency import org.gradle.api.file.ConfigurableFileCollection import org.gradle.api.file.FileCollection +import org.gradle.api.file.RegularFile +import org.gradle.api.provider.Provider import org.gradle.api.tasks.TaskProvider import org.jetbrains.annotations.NotNull @@ -98,4 +100,50 @@ interface Definition { */ @NotNull ConfigurableFileCollection getAllDependencies() + + /** + * A collection of files which need to be added to the recompile classpath, + * for the recompile phase to succeed. + * + * @return The file collection with the additional jars which need to be added + */ + @NotNull + FileCollection getAdditionalRecompileDependencies(); + + /** + * Adds a dependency to the recompile classpath. + * + * @param dependency The dependency to add. + */ + void additionalRecompileDependency(Provider dependency); + + /** + * Adds dependencies to the recompile classpath. + * + * @param dependencies The dependencies to add. + */ + void additionalRecompileDependencies(FileCollection dependencies); + + /** + * A collection of source files which need to be added to the compile sources. + * These sources are removed again from the compiled jar. + * + * @return The file collection with the additional sources which need to be added + */ + @NotNull + FileCollection getAdditionalCompileSources(); + + /** + * Adds a source to the compile sources. + * + * @param source The source to add. + */ + void additionalCompileSource(Provider source); + + /** + * Adds sources to the compile sources. + * + * @param sources The sources to add. + */ + void additionalCompileSources(FileCollection sources); } diff --git a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/tasks/ArtifactProvider.groovy b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/tasks/ArtifactProvider.groovy index 3cd866e85..a4bd93213 100644 --- a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/tasks/ArtifactProvider.groovy +++ b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/tasks/ArtifactProvider.groovy @@ -2,12 +2,14 @@ package net.neoforged.gradle.dsl.common.tasks import groovy.transform.CompileStatic import net.minecraftforge.gdi.annotations.DSLProperty +import org.gradle.api.InvalidUserDataException import org.gradle.api.file.ConfigurableFileCollection import org.gradle.api.provider.Property import org.gradle.api.tasks.* import java.nio.file.Files import java.nio.file.Path +import java.util.stream.Collectors @CacheableTask @CompileStatic @@ -20,7 +22,16 @@ abstract class ArtifactProvider extends NeoGradleBase implements WithOutput { @TaskAction void doProvide() throws Exception { final Path output = ensureFileWorkspaceReady(getOutput()).toPath(); - final Path source = getInputFiles().getSingleFile().toPath(); + + final File inputFile; + try { + inputFile = getInputFiles().getSingleFile() + } catch (final IllegalStateException e) { + throw new InvalidUserDataException("There where either none or multiple input files provided. " + getInputFiles().files + .stream().map { file -> file.absolutePath }.collect(Collectors.joining()), e) + } + + final Path source = inputFile.toPath(); if (!Files.exists(source)) { throw new IllegalStateException("Source file does not exist: " + source); diff --git a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/tasks/specifications/OutputSpecification.groovy b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/tasks/specifications/OutputSpecification.groovy index 4e518c877..0791fb963 100644 --- a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/tasks/specifications/OutputSpecification.groovy +++ b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/tasks/specifications/OutputSpecification.groovy @@ -1,9 +1,11 @@ package net.neoforged.gradle.dsl.common.tasks.specifications import net.minecraftforge.gdi.annotations.DSLProperty +import org.gradle.api.file.DirectoryProperty import org.gradle.api.file.RegularFileProperty import org.gradle.api.provider.Property import org.gradle.api.tasks.Input +import org.gradle.api.tasks.Internal import org.gradle.api.tasks.Optional import org.gradle.api.tasks.OutputFile @@ -12,7 +14,6 @@ import org.gradle.api.tasks.OutputFile */ trait OutputSpecification implements ProjectSpecification { - /** * The output file of this task as configured. * If not set, then it is derived from the output file name and the working directory of the task. @@ -25,7 +26,7 @@ trait OutputSpecification implements ProjectSpecification { abstract RegularFileProperty getOutput(); /** - * The name of the output file name for this step. + * The name of the output file name for this task. * Can be left out, if and only if the output is set directly. * * @return The name of the output file. @@ -34,4 +35,15 @@ trait OutputSpecification implements ProjectSpecification { @Optional @DSLProperty abstract Property getOutputFileName(); + + /** + * The output directory for this step, also doubles as working directory for this task. + * Can be left out, if and only if the output is set directly. + * + * @return The output and working directory for this task. + */ + @Internal + @Optional + @DSLProperty + abstract DirectoryProperty getOutputDirectory(); } \ No newline at end of file diff --git a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/util/Constants.groovy b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/util/Constants.groovy index 5a61a5c3d..a511811e2 100644 --- a/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/util/Constants.groovy +++ b/dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/util/Constants.groovy @@ -27,7 +27,7 @@ class Constants { public static final String DEFAULT_PARCHMENT_GROUP = "org.parchmentmc.data" public static final String DEFAULT_PARCHMENT_ARTIFACT_PREFIX = "parchment-" public static final String DEFAULT_PARCHMENT_MAVEN_URL = "https://maven.parchmentmc.org/" - public static final String JST_TOOL_ARTIFACT = "net.neoforged.jst:jst-cli-bundle:1.0.55" + public static final String JST_TOOL_ARTIFACT = "net.neoforged.jst:jst-cli-bundle:1.0.67" public static final String DEVLOGIN_TOOL_ARTIFACT = "net.covers1624:DevLogin:0.1.0.4" public static final String RENDERNURSE_TOOL_ARTIFACT = "net.neoforged:render-nurse:0.0.12"; public static final String DEVLOGIN_MAIN_CLASS = "net.covers1624.devlogin.DevLogin" diff --git a/examples/multi_neoforge_root/api/build.gradle b/examples/multi_neoforge_root/api/build.gradle new file mode 100644 index 000000000..eaa539247 --- /dev/null +++ b/examples/multi_neoforge_root/api/build.gradle @@ -0,0 +1,16 @@ +plugins { + id 'net.neoforged.gradle.userdev' + id 'java-library' +} + + + java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } + } + + dependencies { + api(libs.neoforge) + } + \ No newline at end of file diff --git a/examples/multi_neoforge_root/api/gradle.properties b/examples/multi_neoforge_root/api/gradle.properties new file mode 100644 index 000000000..5adc99987 --- /dev/null +++ b/examples/multi_neoforge_root/api/gradle.properties @@ -0,0 +1,3 @@ +net.neoforged.gradle.caching.cacheDirectory=/tmp/spock_multiple_projects_w_0_tempDir7138874024286350570/.ng-cache +org.gradle.console=rich +org.gradle.jvmargs=-Xmx8000m \ No newline at end of file diff --git a/examples/multi_neoforge_root/api/runs/junit/junit_jvm_args.txt b/examples/multi_neoforge_root/api/runs/junit/junit_jvm_args.txt new file mode 100644 index 000000000..c688e6ee5 --- /dev/null +++ b/examples/multi_neoforge_root/api/runs/junit/junit_jvm_args.txt @@ -0,0 +1,24 @@ +-p +/var/home/marchermans/.gradle/caches/modules-2/files-2.1/cpw.mods/bootstraplauncher/2.0.2/1a2d076cbc33b0520cbacd591224427b2a20047d/bootstraplauncher-2.0.2.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/cpw.mods/securejarhandler/3.0.8/c0ef95cecd8699a0449053ac7d9c160748d902cd/securejarhandler-3.0.8.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/org.ow2.asm/asm-commons/9.7/e86dda4696d3c185fcc95d8d311904e7ce38a53f/asm-commons-9.7.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/org.ow2.asm/asm-util/9.7/c0655519f24d92af2202cb681cd7c1569df6ead6/asm-util-9.7.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/org.ow2.asm/asm-analysis/9.7/e4a258b7eb96107106c0599f0061cfc1832fe07a/asm-analysis-9.7.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/org.ow2.asm/asm-tree/9.7/e446a17b175bfb733b87c5c2560ccb4e57d69f1a/asm-tree-9.7.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/org.ow2.asm/asm/9.7/73d7b3086e14beb604ced229c302feff6449723/asm-9.7.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/net.neoforged/JarJarFileSystems/0.4.1/78f59f89defcd032ed788b151ca6a0d40ace796a/JarJarFileSystems-0.4.1.jar +--add-modules +ALL-MODULE-PATH +--add-opens +java.base/java.util.jar=cpw.mods.securejarhandler +--add-opens +java.base/java.lang.invoke=cpw.mods.securejarhandler +--add-exports +java.base/sun.security.util=cpw.mods.securejarhandler +--add-exports +jdk.naming.dns/com.sun.jndi.dns=java.naming +-p +/var/home/marchermans/.gradle/caches/modules-2/files-2.1/cpw.mods/bootstraplauncher/2.0.2/1a2d076cbc33b0520cbacd591224427b2a20047d/bootstraplauncher-2.0.2.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/cpw.mods/securejarhandler/3.0.8/c0ef95cecd8699a0449053ac7d9c160748d902cd/securejarhandler-3.0.8.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/org.ow2.asm/asm-commons/9.7/e86dda4696d3c185fcc95d8d311904e7ce38a53f/asm-commons-9.7.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/org.ow2.asm/asm-util/9.7/c0655519f24d92af2202cb681cd7c1569df6ead6/asm-util-9.7.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/org.ow2.asm/asm-analysis/9.7/e4a258b7eb96107106c0599f0061cfc1832fe07a/asm-analysis-9.7.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/org.ow2.asm/asm-tree/9.7/e446a17b175bfb733b87c5c2560ccb4e57d69f1a/asm-tree-9.7.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/org.ow2.asm/asm/9.7/73d7b3086e14beb604ced229c302feff6449723/asm-9.7.jar:/var/home/marchermans/.gradle/caches/modules-2/files-2.1/net.neoforged/JarJarFileSystems/0.4.1/78f59f89defcd032ed788b151ca6a0d40ace796a/JarJarFileSystems-0.4.1.jar +--add-modules +ALL-MODULE-PATH +--add-opens +java.base/java.util.jar=cpw.mods.securejarhandler +--add-opens +java.base/java.lang.invoke=cpw.mods.securejarhandler +--add-exports +java.base/sun.security.util=cpw.mods.securejarhandler +--add-exports +jdk.naming.dns/com.sun.jndi.dns=java.naming diff --git a/examples/multi_neoforge_root/api/runs/junit/junit_test_args.txt b/examples/multi_neoforge_root/api/runs/junit/junit_test_args.txt new file mode 100644 index 000000000..b38c35c7b --- /dev/null +++ b/examples/multi_neoforge_root/api/runs/junit/junit_test_args.txt @@ -0,0 +1,36 @@ +--launchTarget +forgejunituserdev +--version +21.3.6-beta +--assetIndex +asset-index +--assetsDir +/var/home/marchermans/.gradle/caches/minecraft/assets +--gameDir +. +--fml.neoForgeVersion +21.3.6-beta +--fml.fmlVersion +4.0.31 +--fml.mcVersion +1.21.3 +--fml.neoFormVersion +20241023.131943 +--launchTarget +forgejunituserdev +--version +21.3.6-beta +--assetIndex +asset-index +--assetsDir +/var/home/marchermans/.gradle/caches/minecraft/assets +--gameDir +. +--fml.neoForgeVersion +21.3.6-beta +--fml.fmlVersion +4.0.31 +--fml.mcVersion +1.21.3 +--fml.neoFormVersion +20241023.131943 diff --git a/examples/multi_neoforge_root/api/src/main/java/net/neoforged/gradle/apitest/FunctionalTests.java b/examples/multi_neoforge_root/api/src/main/java/net/neoforged/gradle/apitest/FunctionalTests.java new file mode 100644 index 000000000..8a21ee205 --- /dev/null +++ b/examples/multi_neoforge_root/api/src/main/java/net/neoforged/gradle/apitest/FunctionalTests.java @@ -0,0 +1,11 @@ + + package net.neoforged.gradle.apitest; + + import net.minecraft.client.Minecraft; + + public class FunctionalTests { + public static void main(String[] args) { + System.out.println(Minecraft.getInstance().getClass().toString()); + } + } + \ No newline at end of file diff --git a/examples/multi_neoforge_root/build.gradle b/examples/multi_neoforge_root/build.gradle new file mode 100644 index 000000000..939da3986 --- /dev/null +++ b/examples/multi_neoforge_root/build.gradle @@ -0,0 +1,11 @@ +plugins { + id 'net.neoforged.gradle.userdev' +} + + + java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } + } + \ No newline at end of file diff --git a/examples/multi_neoforge_root/gradle.properties b/examples/multi_neoforge_root/gradle.properties new file mode 100644 index 000000000..5adc99987 --- /dev/null +++ b/examples/multi_neoforge_root/gradle.properties @@ -0,0 +1,3 @@ +net.neoforged.gradle.caching.cacheDirectory=/tmp/spock_multiple_projects_w_0_tempDir7138874024286350570/.ng-cache +org.gradle.console=rich +org.gradle.jvmargs=-Xmx8000m \ No newline at end of file diff --git a/examples/multi_neoforge_root/gradle/libs.versions.toml b/examples/multi_neoforge_root/gradle/libs.versions.toml new file mode 100644 index 000000000..336928333 --- /dev/null +++ b/examples/multi_neoforge_root/gradle/libs.versions.toml @@ -0,0 +1,6 @@ +[versions] + # Neoforge Settings + neoforge = "+" + + [libraries] + neoforge = { group = "net.neoforged", name = "neoforge", version.ref = "neoforge" } \ No newline at end of file diff --git a/examples/multi_neoforge_root/gradle/wrapper/gradle-wrapper.jar b/examples/multi_neoforge_root/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 000000000..e6441136f Binary files /dev/null and b/examples/multi_neoforge_root/gradle/wrapper/gradle-wrapper.jar differ diff --git a/examples/multi_neoforge_root/gradle/wrapper/gradle-wrapper.properties b/examples/multi_neoforge_root/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 000000000..66cd5a0e4 --- /dev/null +++ b/examples/multi_neoforge_root/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,7 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-all.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/examples/multi_neoforge_root/main/build.gradle b/examples/multi_neoforge_root/main/build.gradle new file mode 100644 index 000000000..82b8061bf --- /dev/null +++ b/examples/multi_neoforge_root/main/build.gradle @@ -0,0 +1,15 @@ +plugins { + id 'net.neoforged.gradle.userdev' +} + + + java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } + } + + dependencies { + implementation project(':api') + } + \ No newline at end of file diff --git a/examples/multi_neoforge_root/main/gradle.properties b/examples/multi_neoforge_root/main/gradle.properties new file mode 100644 index 000000000..5adc99987 --- /dev/null +++ b/examples/multi_neoforge_root/main/gradle.properties @@ -0,0 +1,3 @@ +net.neoforged.gradle.caching.cacheDirectory=/tmp/spock_multiple_projects_w_0_tempDir7138874024286350570/.ng-cache +org.gradle.console=rich +org.gradle.jvmargs=-Xmx8000m \ No newline at end of file diff --git a/examples/multi_neoforge_root/main/src/main/java/net/neoforged/gradle/main/ApiTests.java b/examples/multi_neoforge_root/main/src/main/java/net/neoforged/gradle/main/ApiTests.java new file mode 100644 index 000000000..d78521200 --- /dev/null +++ b/examples/multi_neoforge_root/main/src/main/java/net/neoforged/gradle/main/ApiTests.java @@ -0,0 +1,13 @@ + + package net.neoforged.gradle.main; + + import net.minecraft.client.Minecraft; + import net.neoforged.gradle.apitest.FunctionalTests; + + public class ApiTests { + public static void main(String[] args) { + System.out.println(Minecraft.getInstance().getClass().toString()); + FunctionalTests.main(args); + } + } + \ No newline at end of file diff --git a/examples/multi_neoforge_root/settings.gradle b/examples/multi_neoforge_root/settings.gradle new file mode 100644 index 000000000..92bbc41c1 --- /dev/null +++ b/examples/multi_neoforge_root/settings.gradle @@ -0,0 +1,18 @@ +pluginManagement { + repositories { + gradlePluginPortal() + mavenLocal() + maven { url = 'https://maven.neoforged.net/' } + } + + includeBuild '../../' +} + +plugins { + id 'org.gradle.toolchains.foojay-resolver-convention' version '0.8.0' +} + +rootProject.name = 'multi_neoforge_root' + +include 'api' +include 'main' diff --git a/examples/runs/build.gradle b/examples/runs/build.gradle index 59e95bbe4..a3285d87a 100644 --- a/examples/runs/build.gradle +++ b/examples/runs/build.gradle @@ -1,5 +1,5 @@ plugins { - id 'net.neoforged.gradle.userdev' +// id 'net.neoforged.gradle.userdev' } java { @@ -9,11 +9,13 @@ java { } dependencies { - implementation 'net.neoforged:neoforge:+' + //implementation 'net.neoforged:neoforge:+' } +/* runs { client { // no modsource } -} \ No newline at end of file +} +*/ diff --git a/gradle.properties b/gradle.properties index 93c152c13..c63c272fd 100644 --- a/gradle.properties +++ b/gradle.properties @@ -10,7 +10,7 @@ group=net.neoforged.gradle java_version=17 #Dependency versions -groovy_version=3.0.21 +groovy_version=3.0.22 commons_io_version=2.11.0 commons_codec_version=1.15 gson_version=2.9.0 @@ -26,7 +26,7 @@ diffpatch_version=2.0.0.35 jarjar_version=0.4.1 jetbrains_annotations_version=23.0.0 gradle_idea_extension_version=1.1.6 -groovy_dsl_improver_version=1.0.15 +groovy_dsl_improver_version=1.0.16 eclipse_launch_configs_version=0.1.3 vscode_launch_configs_version=1.0.8 diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 6f7a6eb33..66cd5a0e4 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-all.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-all.zip networkTimeout=10000 validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME diff --git a/neoform/src/functionalTest/groovy/net/neoforged/gradle/neoform/FunctionalTests.groovy b/neoform/src/functionalTest/groovy/net/neoforged/gradle/neoform/FunctionalTests.groovy index 566c0c706..329758c91 100644 --- a/neoform/src/functionalTest/groovy/net/neoforged/gradle/neoform/FunctionalTests.groovy +++ b/neoform/src/functionalTest/groovy/net/neoforged/gradle/neoform/FunctionalTests.groovy @@ -79,16 +79,13 @@ class FunctionalTests extends BuilderBasedTestSpecification { } } - minecraft { - accessTransformers { - entry "public net.minecraft.client.Minecraft LOGGER # searchRegistry" - } - } + minecraft.accessTransformers.file rootProject.file('src/main/resources/META-INF/accesstransformer.cfg') dependencies { implementation 'net.minecraft:neoform_client:${NEOFORM_VERSION}' } """) + it.file("src/main/resources/META-INF/accesstransformer.cfg", """public-f net.minecraft.client.Minecraft LOGGER""") it.file("src/main/java/net/neoforged/gradle/neoform/FunctionalTests.java", """ package net.neoforged.gradle.neoform; diff --git a/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/definition/NeoFormRuntimeDefinition.java b/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/definition/NeoFormRuntimeDefinition.java index 85c869176..468a655c0 100644 --- a/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/definition/NeoFormRuntimeDefinition.java +++ b/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/definition/NeoFormRuntimeDefinition.java @@ -47,7 +47,7 @@ public NeoFormRuntimeDefinition(@NotNull NeoFormRuntimeSpecification specificati this.assetsTaskProvider = assetsTaskProvider; this.nativesTaskProvider = nativesTaskProvider; - this.getAllDependencies().from(getSpecification().getAdditionalRecompileDependencies()); + this.additionalRecompileDependencies(specification.getAdditionalRecompileDependencies()); } @Override diff --git a/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/extensions/NeoFormRuntimeExtension.java b/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/extensions/NeoFormRuntimeExtension.java index 10702831e..2b79b0b5c 100644 --- a/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/extensions/NeoFormRuntimeExtension.java +++ b/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/extensions/NeoFormRuntimeExtension.java @@ -23,7 +23,10 @@ import net.neoforged.gradle.dsl.common.tasks.ArtifactProvider; import net.neoforged.gradle.dsl.common.tasks.WithOutput; import net.neoforged.gradle.dsl.common.tasks.specifications.OutputSpecification; -import net.neoforged.gradle.dsl.common.util.*; +import net.neoforged.gradle.dsl.common.util.CommonRuntimeUtils; +import net.neoforged.gradle.dsl.common.util.DistributionType; +import net.neoforged.gradle.dsl.common.util.GameArtifact; +import net.neoforged.gradle.dsl.common.util.NamingConstants; import net.neoforged.gradle.dsl.neoform.configuration.NeoFormConfigConfigurationSpecV1; import net.neoforged.gradle.dsl.neoform.configuration.NeoFormConfigConfigurationSpecV2; import net.neoforged.gradle.neoform.runtime.definition.NeoFormRuntimeDefinition; @@ -43,6 +46,7 @@ import org.gradle.api.tasks.compile.AbstractCompile; import org.gradle.api.tasks.compile.ForkOptions; import org.gradle.jvm.toolchain.JavaLanguageVersion; +import org.gradle.process.CommandLineArgumentProvider; import org.jetbrains.annotations.NotNull; import javax.annotation.Nullable; @@ -191,18 +195,13 @@ private static TaskProvider createDecompile(NeoFormRuntimeSpe } private static String getDecompilerLogLevelArg(DecompilerLogLevel logLevel, String version) { - switch (logLevel) { - case TRACE: - return "trace"; - case INFO: - return "info"; - case WARN: - return "warn"; - case ERROR: - return "error"; - default: - throw new GradleException("LogLevel " + logLevel + " not supported by " + version); - } + return switch (logLevel) { + case TRACE -> "trace"; + case INFO -> "info"; + case WARN -> "warn"; + case ERROR -> "error"; + default -> throw new GradleException("LogLevel " + logLevel + " not supported by " + version); + }; } private TaskProvider createExecute(final NeoFormRuntimeSpecification spec, final NeoFormConfigConfigurationSpecV1.Step step, final NeoFormConfigConfigurationSpecV1.Function function) { @@ -217,7 +216,7 @@ private static void buildArguments(final RuntimeArguments arguments, final NeoFo step.getValues().forEach((key, value) -> { if (value.startsWith("{") && value.endsWith("}")) { Optional> dependentTask; - if (!Objects.equals(key, "input") || !alternativeInputProvider.isPresent()) { + if (!Objects.equals(key, "input") || alternativeInputProvider.isEmpty()) { dependentTask = NeoFormRuntimeUtils.getInputTaskForTaskFrom(spec, value, tasks); } else { dependentTask = alternativeInputProvider; @@ -354,24 +353,7 @@ protected void bakeDefinition(NeoFormRuntimeDefinition definition) { Optional> adaptedInput = Optional.empty(); if (spec.getPreTaskTypeAdapters().containsKey(step.getName())) { - final String inputArgumentMarker = step.getValue("input"); - if (inputArgumentMarker == null) { - throw new IllegalStateException("Can not change input chain on: " + step.getName() + " it has no input to transform!"); - } - - Optional> inputTask = NeoFormRuntimeUtils.getInputTaskForTaskFrom(spec, inputArgumentMarker, taskOutputs); - - if (!spec.getPreTaskTypeAdapters().get(step.getName()).isEmpty() && inputTask.isPresent()) { - for (TaskTreeAdapter taskTreeAdapter : spec.getPreTaskTypeAdapters().get(step.getName())) { - final TaskProvider modifiedTree = taskTreeAdapter.adapt(definition, inputTask.get(), neoFormDirectory, definition.getGameArtifactProvidingTasks(), definition.getMappingVersionData(), taskProvider -> taskProvider.configure(task -> configureMcpRuntimeTaskWithDefaults(spec, neoFormDirectory, symbolicDataSources, task))); - if (modifiedTree != null) { - modifiedTree.configure(task -> configureMcpRuntimeTaskWithDefaults(spec, neoFormDirectory, symbolicDataSources, task)); - inputTask = Optional.of(modifiedTree); - } - } - - adaptedInput = inputTask; - } + adaptedInput = adaptPreTaskInput(definition, step, spec, taskOutputs, neoFormDirectory, symbolicDataSources, adaptedInput); } TaskProvider neoFormRuntimeTaskProvider = createBuiltIn( @@ -399,8 +381,7 @@ protected void bakeDefinition(NeoFormRuntimeDefinition definition) { Optional> finalAdaptedInput = adaptedInput; neoFormRuntimeTaskProvider.configure((WithOutput neoFormRuntimeTask) -> { - if (neoFormRuntimeTask instanceof Runtime) { - final Runtime runtimeTask = (Runtime) neoFormRuntimeTask; + if (neoFormRuntimeTask instanceof Runtime runtimeTask) { configureMcpRuntimeTaskWithDefaults(spec, neoFormDirectory, symbolicDataSources, taskOutputs, step, runtimeTask, finalAdaptedInput); } }); @@ -438,22 +419,36 @@ protected void bakeDefinition(NeoFormRuntimeDefinition definition) { remapTask, symbolicDataSources, neoFormDirectory, - context.getLibrariesTask().flatMap(WithOutput::getOutput) + Objects.requireNonNull(context.getLibrariesTask()).flatMap(WithOutput::getOutput) ); - final FileCollection recompileDependencies = spec.getAdditionalRecompileDependencies().plus(spec.getProject().files(definition.getMinecraftDependenciesConfiguration())); + recompileInput = adaptPreTaskInput( + definition, + "recompile", + spec, + neoFormDirectory, + symbolicDataSources, + Optional.of(recompileInput), + Optional.of(recompileInput) + ).orElseThrow(() -> new IllegalStateException("No input for recompile task due to pre-task adapters")); + final FileCollection recompileDependencies = definition.getAdditionalRecompileDependencies().plus(spec.getProject().files(definition.getMinecraftDependenciesConfiguration())); + final TaskProvider extractionSource = recompileInput; final TaskProvider unpackSources = spec.getProject().getTasks().register(CommonRuntimeUtils.buildTaskName(spec, "unzipSources"), UnpackZip.class, task -> { task.getInput().from( - recompileInput.flatMap(WithOutput::getOutput) + extractionSource.flatMap(WithOutput::getOutput) .map(sourceJar -> task.getArchiveOperations().zipTree(sourceJar).matching(sp -> sp.include("**/*.java")).getAsFileTree()) ); + task.getInput().from( + definition.getAdditionalCompileSources() + ); }); unpackSources.configure(neoFormRuntimeTask -> configureMcpRuntimeTaskWithDefaults(spec, neoFormDirectory, symbolicDataSources, neoFormRuntimeTask)); final TaskProvider recompileTask = spec.getProject() .getTasks().register(CommonRuntimeUtils.buildTaskName(spec, "recompile"), RecompileSourceJar.class, task -> { task.setSource(unpackSources.flatMap(UnpackZip::getUnpackingTarget)); + task.getAdditionalInputFiles().from(definition.getAdditionalCompileSources()); task.getCompileClasspath().setFrom(recompileDependencies); task.getStepName().set("recompile"); @@ -464,7 +459,7 @@ protected void bakeDefinition(NeoFormRuntimeDefinition definition) { ForkOptions forkOptions = task.getOptions().getForkOptions(); forkOptions.setMemoryMaximumSize(maxMemory); forkOptions.setJvmArgs(settings.getJvmArgs().get()); - task.getOptions().getCompilerArgumentProviders().add(settings.getArgs()::get); + task.getOptions().getCompilerArgumentProviders().add(new CustomCompilerArgsProvider(settings.getArgs())); task.getJavaVersion().set( definition.getVersionJson() @@ -478,7 +473,7 @@ protected void bakeDefinition(NeoFormRuntimeDefinition definition) { final TaskProvider packTask = spec.getProject() .getTasks().register(CommonRuntimeUtils.buildTaskName(spec, "packRecomp"), PackJar.class, task -> { - task.getInputFiles().from(recompileInput.flatMap(WithOutput::getOutput).map(task.getArchiveOperations()::zipTree).map(zipTree -> zipTree.matching(sp -> sp.exclude("**/*.java")))); + task.getInputFiles().from(extractionSource.flatMap(WithOutput::getOutput).map(task.getArchiveOperations()::zipTree).map(zipTree -> zipTree.matching(sp -> sp.exclude("**/*.java")))); task.getInputFiles().from(recompileTask.flatMap(AbstractCompile::getDestinationDirectory)); }); packTask.configure(neoFormRuntimeTask -> configureMcpRuntimeTaskWithDefaults(spec, neoFormDirectory, symbolicDataSources, neoFormRuntimeTask)); @@ -486,7 +481,7 @@ protected void bakeDefinition(NeoFormRuntimeDefinition definition) { taskOutputs.put(recompileTask.getName(), packTask); definition.getSourceJarTask().configure(task -> { - task.getInputFiles().from(recompileInput); + task.getInputFiles().from(extractionSource.flatMap(WithOutput::getOutput)); task.dependsOn(remapTask); }); definition.getRawJarTask().configure(task -> { @@ -495,6 +490,32 @@ protected void bakeDefinition(NeoFormRuntimeDefinition definition) { }); } + private static Optional> adaptPreTaskInput(NeoFormRuntimeDefinition definition, NeoFormConfigConfigurationSpecV1.Step step, NeoFormRuntimeSpecification spec, LinkedHashMap> taskOutputs, File neoFormDirectory, Map symbolicDataSources, Optional> adaptedInput) { + final String inputArgumentMarker = step.getValue("input"); + if (inputArgumentMarker == null) { + throw new IllegalStateException("Can not change input chain on: " + step.getName() + " it has no input to transform!"); + } + + Optional> inputTask = NeoFormRuntimeUtils.getInputTaskForTaskFrom(spec, inputArgumentMarker, taskOutputs); + + return adaptPreTaskInput(definition, step.getName(), spec, neoFormDirectory, symbolicDataSources, adaptedInput, inputTask); + } + + private static Optional> adaptPreTaskInput(NeoFormRuntimeDefinition definition, String stepName, NeoFormRuntimeSpecification spec, File neoFormDirectory, Map symbolicDataSources, Optional> adaptedInput, Optional> inputTask) { + if (!spec.getPreTaskTypeAdapters().get(stepName).isEmpty() && inputTask.isPresent()) { + for (TaskTreeAdapter taskTreeAdapter : spec.getPreTaskTypeAdapters().get(stepName)) { + final TaskProvider modifiedTree = taskTreeAdapter.adapt(definition, inputTask.get(), neoFormDirectory, definition.getGameArtifactProvidingTasks(), definition.getMappingVersionData(), taskProvider -> taskProvider.configure(task -> configureMcpRuntimeTaskWithDefaults(spec, neoFormDirectory, symbolicDataSources, task))); + if (modifiedTree != null) { + modifiedTree.configure(task -> configureMcpRuntimeTaskWithDefaults(spec, neoFormDirectory, symbolicDataSources, task)); + inputTask = Optional.of(modifiedTree); + } + } + + adaptedInput = inputTask; + } + return adaptedInput; + } + private static TaskProvider maybeApplyParchment(NeoFormRuntimeDefinition runtimeDefinition, TaskProvider recompileInput, Map symbolicDataSources, @@ -507,7 +528,7 @@ private static TaskProvider maybeApplyParchment(NeoFormRun return recompileInput; } - TaskProvider applyParchmentTask = project.getTasks().register(CommonRuntimeUtils.buildTaskName(runtimeDefinition, "applyParchment"), DefaultExecute.class, task -> { + return project.getTasks().register(CommonRuntimeUtils.buildTaskName(runtimeDefinition, "applyParchment"), DefaultExecute.class, task -> { // Provide the mappings via artifact File mappingFile = ToolUtilities.resolveTool(project, parchment.getParchmentArtifact().get()); String conflictPrefix = parchment.getConflictPrefix().get(); @@ -543,7 +564,12 @@ private static TaskProvider maybeApplyParchment(NeoFormRun configureCommonRuntimeTaskParameters(task, symbolicDataSources, "applyParchment", runtimeDefinition.getSpecification(), neoFormDirectory); }); + } - return applyParchmentTask; + public record CustomCompilerArgsProvider(Provider> args) implements CommandLineArgumentProvider { + @Override + public Iterable asArguments() { + return args.get(); + } } } diff --git a/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/tasks/RecompileSourceJar.java b/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/tasks/RecompileSourceJar.java index 9b2a5a2df..c7b760ad7 100644 --- a/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/tasks/RecompileSourceJar.java +++ b/neoform/src/main/java/net/neoforged/gradle/neoform/runtime/tasks/RecompileSourceJar.java @@ -9,16 +9,14 @@ import net.neoforged.gradle.dsl.common.runtime.tasks.RuntimeMultiArguments; import org.gradle.api.GradleException; import org.gradle.api.file.ConfigurableFileCollection; +import org.gradle.api.file.FileTree; import org.gradle.api.model.ObjectFactory; import org.gradle.api.plugins.JavaPluginExtension; import org.gradle.api.provider.Property; import org.gradle.api.provider.Provider; import org.gradle.api.provider.ProviderFactory; import org.gradle.api.services.ServiceReference; -import org.gradle.api.tasks.CacheableTask; -import org.gradle.api.tasks.Internal; -import org.gradle.api.tasks.Nested; -import org.gradle.api.tasks.Optional; +import org.gradle.api.tasks.*; import org.gradle.api.tasks.compile.JavaCompile; import org.gradle.internal.jvm.Jvm; import org.gradle.jvm.toolchain.JavaLanguageVersion; @@ -133,6 +131,10 @@ public Property getJavaVersion() { @ServiceReference(CachedExecutionService.NAME) public abstract Property getCacheService(); + @InputFiles + @PathSensitive(PathSensitivity.NONE) + public abstract ConfigurableFileCollection getAdditionalInputFiles(); + @Override protected void compile(InputChanges inputs) { try { @@ -142,7 +144,7 @@ protected void compile(InputChanges inputs) { ICacheableJob.Default.directory( getDestinationDirectory(), () -> { - super.compile(inputs); + doCachedCompile(inputs); } ) ).execute(); @@ -150,4 +152,31 @@ protected void compile(InputChanges inputs) { throw new GradleException("Failed to recompile!", e); } } + + private void doCachedCompile(InputChanges inputs) { + super.compile(inputs); + + final FileTree outputTree = getDestinationDirectory().get().getAsFileTree(); + outputTree.matching(pattern -> pattern.include(fileTreeElement -> { + final String relativePath = fileTreeElement.getRelativePath().getPathString(); + if (!relativePath.endsWith(".class")) { + return false; + } + + final String sourceFilePath; + if (!relativePath.contains("$")) { + sourceFilePath = relativePath.substring(0, relativePath.length() - ".class".length()) + ".java"; + } else { + sourceFilePath = relativePath.substring(0, relativePath.indexOf('$')) + ".java"; + } + + return !getAdditionalInputFiles() + .getAsFileTree() + .matching(sp1 -> sp1.include(sourceFilePath)) + .getFiles().isEmpty(); + })).forEach(file -> { + getLogger().debug("Removing additional source file: {}", file); + file.delete(); + }); + } } diff --git a/neoform/src/main/java/net/neoforged/gradle/neoform/util/NeoFormAccessTaskAdapterUtils.java b/neoform/src/main/java/net/neoforged/gradle/neoform/util/NeoFormAccessTaskAdapterUtils.java new file mode 100644 index 000000000..bec0ae202 --- /dev/null +++ b/neoform/src/main/java/net/neoforged/gradle/neoform/util/NeoFormAccessTaskAdapterUtils.java @@ -0,0 +1,59 @@ +package net.neoforged.gradle.neoform.util; + +import net.neoforged.gradle.common.runtime.tasks.SourceAccessTransformer; +import net.neoforged.gradle.common.runtime.tasks.SourceInterfaceInjection; +import net.neoforged.gradle.common.util.CommonRuntimeTaskUtils; +import net.neoforged.gradle.dsl.common.extensions.AccessTransformers; +import net.neoforged.gradle.dsl.common.extensions.InterfaceInjections; +import net.neoforged.gradle.dsl.common.extensions.Minecraft; +import net.neoforged.gradle.dsl.common.runtime.tasks.tree.TaskTreeAdapter; +import net.neoforged.gradle.dsl.common.tasks.WithOutput; +import org.gradle.api.Project; +import org.gradle.api.tasks.TaskProvider; + +public class NeoFormAccessTaskAdapterUtils { + + private NeoFormAccessTaskAdapterUtils() { + throw new IllegalStateException("Can not instantiate an instance of: McpAccessTransformerUtils. This is a utility class"); + } + + public static TaskTreeAdapter createAccessTransformerAdapter(final Project project) { + final Minecraft minecraftExtension = project.getExtensions().getByType(Minecraft.class); + final AccessTransformers accessTransformerFiles = minecraftExtension.getAccessTransformers(); + + return (definition, previousTasksOutput, runtimeWorkspace, gameArtifacts, mappingVersionData, dependentTaskConfigurationHandler) -> { + if (accessTransformerFiles.getFiles().isEmpty()) { + return null; + } + + final TaskProvider accessTransformerTask = CommonRuntimeTaskUtils.createSourceAccessTransformer(definition, "User", accessTransformerFiles.getFiles().getAsFileTree(), definition.getListLibrariesTaskProvider(), definition.getAllDependencies()); + accessTransformerTask.configure(task -> task.getInputFile().set(previousTasksOutput.flatMap(WithOutput::getOutput))); + accessTransformerTask.configure(task -> task.dependsOn(previousTasksOutput)); + return accessTransformerTask; + }; + } + + public static TaskTreeAdapter createInterfaceInjectionAdapter(final Project project) { + final Minecraft minecraftExtension = project.getExtensions().getByType(Minecraft.class); + final InterfaceInjections interfaceInjectionFiles = minecraftExtension.getInterfaceInjections(); + + return (definition, previousTasksOutput, runtimeWorkspace, gameArtifacts, mappingVersionData, dependentTaskConfigurationHandler) -> { + if (interfaceInjectionFiles.getFiles().isEmpty()) { + return null; + } + + final TaskProvider interfaceInjectionTask = CommonRuntimeTaskUtils.createSourceInterfaceInjection(definition, "User", interfaceInjectionFiles.getFiles().getAsFileTree(), definition.getListLibrariesTaskProvider(), definition.getAllDependencies()); + interfaceInjectionTask.configure(task -> task.getInputFile().set(previousTasksOutput.flatMap(WithOutput::getOutput))); + interfaceInjectionTask.configure(task -> task.dependsOn(previousTasksOutput)); + + //Register the stubs + definition.additionalCompileSources( + project.zipTree( + interfaceInjectionTask.flatMap(SourceInterfaceInjection::getStubs) + ) + ); + + return interfaceInjectionTask; + }; + } +} diff --git a/neoform/src/main/java/net/neoforged/gradle/neoform/util/NeoFormAccessTransformerUtils.java b/neoform/src/main/java/net/neoforged/gradle/neoform/util/NeoFormAccessTransformerUtils.java deleted file mode 100644 index b1d8af389..000000000 --- a/neoform/src/main/java/net/neoforged/gradle/neoform/util/NeoFormAccessTransformerUtils.java +++ /dev/null @@ -1,33 +0,0 @@ -package net.neoforged.gradle.neoform.util; - -import net.neoforged.gradle.common.runtime.tasks.SourceAccessTransformer; -import net.neoforged.gradle.common.util.CommonRuntimeTaskUtils; -import net.neoforged.gradle.dsl.common.extensions.AccessTransformers; -import net.neoforged.gradle.dsl.common.extensions.Minecraft; -import net.neoforged.gradle.dsl.common.runtime.tasks.tree.TaskTreeAdapter; -import net.neoforged.gradle.dsl.common.tasks.WithOutput; -import org.gradle.api.Project; -import org.gradle.api.tasks.TaskProvider; - -public class NeoFormAccessTransformerUtils { - - private NeoFormAccessTransformerUtils() { - throw new IllegalStateException("Can not instantiate an instance of: McpAccessTransformerUtils. This is a utility class"); - } - - public static TaskTreeAdapter createAccessTransformerAdapter(final Project project) { - final Minecraft minecraftExtension = project.getExtensions().getByType(Minecraft.class); - final AccessTransformers accessTransformerFiles = minecraftExtension.getAccessTransformers(); - - return (definition, previousTasksOutput, runtimeWorkspace, gameArtifacts, mappingVersionData, dependentTaskConfigurationHandler) -> { - if (accessTransformerFiles.getFiles().isEmpty() && accessTransformerFiles.getEntries().get().isEmpty()) { - return null; - } - - final TaskProvider accessTransformerTask = CommonRuntimeTaskUtils.createSourceAccessTransformer(definition, "User", runtimeWorkspace, dependentTaskConfigurationHandler, accessTransformerFiles.getFiles().getAsFileTree(), accessTransformerFiles.getEntries().get(), definition.getListLibrariesTaskProvider(), definition.getAllDependencies()); - accessTransformerTask.configure(task -> task.getInputFile().set(previousTasksOutput.flatMap(WithOutput::getOutput))); - accessTransformerTask.configure(task -> task.dependsOn(previousTasksOutput)); - return accessTransformerTask; - }; - } -} diff --git a/neoform/src/main/java/net/neoforged/gradle/neoform/util/NeoFormRuntimeUtils.java b/neoform/src/main/java/net/neoforged/gradle/neoform/util/NeoFormRuntimeUtils.java index 5162f5bd3..10d5d1fed 100644 --- a/neoform/src/main/java/net/neoforged/gradle/neoform/util/NeoFormRuntimeUtils.java +++ b/neoform/src/main/java/net/neoforged/gradle/neoform/util/NeoFormRuntimeUtils.java @@ -23,21 +23,6 @@ private NeoFormRuntimeUtils() { throw new IllegalStateException("Can not instantiate an instance of: NeoFormRuntimeUtils. This is a utility class"); } - @SuppressWarnings("OptionalUsedAsFieldOrParameterType") - public static Provider getTaskInputFor(final NeoFormRuntimeSpecification spec, final Map> tasks, NeoFormConfigConfigurationSpecV1.Step step, final String defaultInputTask, final Optional> adaptedInput, Task task) { - if (adaptedInput.isPresent()) { - task.dependsOn(adaptedInput); - return adaptedInput.get().flatMap(t -> t.getOutput().getAsFile()); - } - - final String inputValue = step.getValue("input"); - if (inputValue == null) { - return getInputForTaskFrom(spec, "{" + defaultInputTask + "Output}", tasks, task); - } - - return getInputForTaskFrom(spec, inputValue, tasks, task); - } - public static Provider getTaskInputFor(final NeoFormRuntimeSpecification spec, final Map> tasks, NeoFormConfigConfigurationSpecV1.Step step, Task task) { final String inputValue = step.getValue("input"); if (inputValue == null) { @@ -128,6 +113,7 @@ public static Optional> getInputTaskForTaskFr } public static void configureDefaultRuntimeSpecBuilder(Project project, NeoFormRuntimeSpecification.Builder builder) { - builder.withPostTaskAdapter("decompile", NeoFormAccessTransformerUtils.createAccessTransformerAdapter(project)); + builder.withPostTaskAdapter("decompile", NeoFormAccessTaskAdapterUtils.createAccessTransformerAdapter(project)); + builder.withPreTaskAdapter("recompile", NeoFormAccessTaskAdapterUtils.createInterfaceInjectionAdapter(project)); } } diff --git a/platform/src/main/java/net/neoforged/gradle/platform/extensions/DynamicProjectExtension.java b/platform/src/main/java/net/neoforged/gradle/platform/extensions/DynamicProjectExtension.java index 62abe7cdf..84e247d9f 100644 --- a/platform/src/main/java/net/neoforged/gradle/platform/extensions/DynamicProjectExtension.java +++ b/platform/src/main/java/net/neoforged/gradle/platform/extensions/DynamicProjectExtension.java @@ -12,7 +12,6 @@ import net.neoforged.gradle.common.extensions.IdeManagementExtension; import net.neoforged.gradle.common.extensions.JarJarExtension; import net.neoforged.gradle.common.runtime.extensions.CommonRuntimeExtension; -import net.neoforged.gradle.common.runtime.tasks.AccessTransformerFileGenerator; import net.neoforged.gradle.common.runtime.tasks.DefaultExecute; import net.neoforged.gradle.common.runtime.tasks.DownloadAssets; import net.neoforged.gradle.common.tasks.JarJar; @@ -726,10 +725,6 @@ public void runtime(final String neoFormVersion, Directory patches, Directory re CommonRuntimeExtension.configureCommonRuntimeTaskParameters(task, runtimeDefinition, workingDirectory); }); - final TaskProvider generateAts = project.getTasks().register("generateAccessTransformers", AccessTransformerFileGenerator.class, task -> { - CommonRuntimeExtension.configureCommonRuntimeTaskParameters(task, runtimeDefinition, workingDirectory); - }); - final TaskProvider packPatches = project.getTasks().register("packPatches", PackJar.class, task -> { task.getInputFiles().from(project.fileTree(patches).matching(filterable -> { filterable.include("**/*.patch"); @@ -785,9 +780,6 @@ public void runtime(final String neoFormVersion, Directory patches, Directory re task.from(createUserdevJson.flatMap(WithOutput::getOutput), spec -> { spec.rename(name -> "config.json"); }); - task.from(generateAts.flatMap(WithOutput::getOutput), spec -> { - spec.into("ats/"); - }); task.from(accessTransformers.getFiles(), spec -> { spec.into("ats/"); }); diff --git a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/AccessTransformerTests.groovy b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/AccessTransformerTests.groovy index 09b8aa2eb..5220a8989 100644 --- a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/AccessTransformerTests.groovy +++ b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/AccessTransformerTests.groovy @@ -4,6 +4,8 @@ package net.neoforged.gradle.userdev import net.neoforged.trainingwheels.gradle.functional.BuilderBasedTestSpecification import org.gradle.testkit.runner.TaskOutcome +import java.util.zip.ZipFile + class AccessTransformerTests extends BuilderBasedTestSpecification { @Override @@ -96,90 +98,6 @@ class AccessTransformerTests extends BuilderBasedTestSpecification { initialRun.task(":build").outcome == TaskOutcome.SUCCESS } - def "the userdev runtime supports loading ats from the script"() { - given: - def project = create("userdev_supports_ats_in_scripts", { - it.build(""" - java { - toolchain { - languageVersion = JavaLanguageVersion.of(21) - } - } - - minecraft.accessTransformers.entry 'public-f net.minecraft.client.Minecraft fixerUpper # fixerUpper' - - dependencies { - implementation 'net.neoforged:neoforge:+' - } - """) - it.file("src/main/java/net/neoforged/gradle/userdev/FunctionalTests.java", """ - package net.neoforged.gradle.userdev; - - import net.minecraft.client.Minecraft; - - public class FunctionalTests { - public static void main(String[] args) { - System.out.println(Minecraft.getInstance().fixerUpper.getClass().toString()); - } - } - """) - it.withToolchains() - it.withGlobalCacheDirectory(tempDir) - }) - - when: - def initialRun = project.run { - it.tasks('build') - } - - then: - initialRun.task(":neoFormRecompile").outcome == TaskOutcome.SUCCESS - initialRun.task(":build").outcome == TaskOutcome.SUCCESS - } - - def "the userdev runtime supports loading ats from the script and the file"() { - given: - def project = create("userdev_supports_ats_in_script_and_file", { - it.build(""" - java { - toolchain { - languageVersion = JavaLanguageVersion.of(21) - } - } - minecraft.accessTransformers.file rootProject.file('src/main/resources/META-INF/accesstransformer.cfg') - minecraft.accessTransformers.entry 'public-f net.minecraft.client.Minecraft LOGGER # LOGGER' - - dependencies { - implementation 'net.neoforged:neoforge:+' - } - """) - it.file("src/main/resources/META-INF/accesstransformer.cfg", """public-f net.minecraft.client.Minecraft fixerUpper # fixerUpper""") - it.file("src/main/java/net/neoforged/gradle/userdev/FunctionalTests.java", """ - package net.neoforged.gradle.userdev; - - import net.minecraft.client.Minecraft; - - public class FunctionalTests { - public static void main(String[] args) { - System.out.println(Minecraft.getInstance().fixerUpper.getClass().toString()); - System.out.println(Minecraft.LOGGER.getClass().toString()); - } - } - """) - it.withToolchains() - it.withGlobalCacheDirectory(tempDir) - }) - - when: - def initialRun = project.run { - it.tasks('build') - } - - then: - initialRun.task(":neoFormRecompile").outcome == TaskOutcome.SUCCESS - initialRun.task(":build").outcome == TaskOutcome.SUCCESS - } - def "the userdev runtime supports loading ats from multiple files"() { given: def project = create("userdev_supports_ats_in_multiple_distinctly_named_files", { diff --git a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/FunctionalTests.groovy b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/FunctionalTests.groovy index 8f33dc9cd..99342f1ef 100644 --- a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/FunctionalTests.groovy +++ b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/FunctionalTests.groovy @@ -407,4 +407,78 @@ class FunctionalTests extends BuilderBasedTestSpecification { run.task(':clean').outcome == TaskOutcome.SUCCESS run.task(':build').outcome == TaskOutcome.SUCCESS } + + def "a mod with userdev does not expose the userdev artifact to consumers"() { + given: + def project = create("gradle_multi_sourceset", { + it.build(""" + java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } + } + + dependencies { + api 'net.neoforged:neoforge:+' + } + + publishing { + repositories { + maven { + // change to point to your repo, e.g. http://my.org/repo + url = layout.buildDirectory.dir('repo') + } + } + + publications { + maven(MavenPublication) { + groupId = 'org.gradle.sample' + artifactId = 'library' + version = '1.1' + + from components.java + } + } + } + + """) + it.file("src/main/java/net/neoforged/gradle/userdev/FunctionalTests.java", """ + package net.neoforged.gradle.userdev; + + import net.minecraft.client.Minecraft; + + public class FunctionalTests { + public static void main(String[] args) { + System.out.println(Minecraft.getInstance().getClass().toString()); + } + } + """) + it.withToolchains() + it.withGlobalCacheDirectory(tempDir) + it.plugin("java-library") + it.plugin("maven-publish") + }) + + when: + def run = project.run { + it.tasks('clean', 'build', 'publish') + it.stacktrace() + } + + then: + run.task(':clean').outcome == TaskOutcome.SUCCESS + run.task(':build').outcome == TaskOutcome.SUCCESS + run.task(':publish').outcome == TaskOutcome.SUCCESS + + and: + def repo = run.file("build/repo/org/gradle/sample/library/1.1") + def moduleFile = new File(repo, "library-1.1.module") + def pomFile = new File(repo, "library-1.1.pom") + + then: + moduleFile.exists() + pomFile.exists() + !moduleFile.text.contains("neoforged") + !pomFile.text.contains("neoforged") + } } diff --git a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/InterfaceInjectionTests.groovy b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/InterfaceInjectionTests.groovy new file mode 100644 index 000000000..4916ab65b --- /dev/null +++ b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/InterfaceInjectionTests.groovy @@ -0,0 +1,231 @@ +package net.neoforged.gradle.userdev + + +import net.neoforged.trainingwheels.gradle.functional.BuilderBasedTestSpecification +import org.gradle.testkit.runner.TaskOutcome + +class InterfaceInjectionTests extends BuilderBasedTestSpecification { + + @Override + protected void configurePluginUnderTest() { + pluginUnderTest = "net.neoforged.gradle.userdev"; + injectIntoAllProject = true; + } + + def "the userdev runtime supports loading iis from a file"() { + given: + def project = create("userdev_supports_iis_from_file", { + it.build(""" + java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } + } + + minecraft.interfaceInjections.file rootProject.file('src/main/resources/META-INF/iis.json') + + dependencies { + implementation 'net.neoforged:neoforge:+' + } + """) + it.file("src/main/resources/META-INF/iis.json", """{"net/minecraft/client/Minecraft": ["com/example/examplemod/MyInjectedInterface"]}""") + it.file("src/main/java/net/neoforged/gradle/userdev/FunctionalTests.java", """ + package net.neoforged.gradle.userdev; + + import net.minecraft.client.Minecraft; + + public class FunctionalTests { + public static void main(String[] args) { + Minecraft.getInstance().doSomething(); + } + } + """) + it.file("src/main/java/com/example/examplemod/MyInjectedInterface.java", """ + package com.example.examplemod; + + public interface MyInjectedInterface { + default void doSomething() { }; + } + """) + it.withToolchains() + it.withGlobalCacheDirectory(tempDir) + }) + + when: + def initialRun = project.run { + it.tasks('build') + it.debug() + } + + then: + initialRun.task(":neoFormRecompile").outcome == TaskOutcome.SUCCESS + initialRun.task(":build").outcome == TaskOutcome.SUCCESS + } + + def "the userdev runtime supports loading iis from a file after the dependencies block"() { + given: + def project = create("userdev_supports_iis_from_file", { + it.build(""" + java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } + } + + dependencies { + implementation 'net.neoforged:neoforge:+' + } + + minecraft.interfaceInjections.file rootProject.file('src/main/resources/META-INF/iis.json') + """) + it.file("src/main/resources/META-INF/iis.json", """{"net/minecraft/client/Minecraft": ["com/example/examplemod/MyInjectedInterface"]}""") + it.file("src/main/java/net/neoforged/gradle/userdev/FunctionalTests.java", """ + package net.neoforged.gradle.userdev; + + import net.minecraft.client.Minecraft; + + public class FunctionalTests { + public static void main(String[] args) { + Minecraft.getInstance().doSomething(); + } + } + """) + it.file("src/main/java/com/example/examplemod/MyInjectedInterface.java", """ + package com.example.examplemod; + + public interface MyInjectedInterface { + default void doSomething() { }; + } + """) + it.withToolchains() + it.withGlobalCacheDirectory(tempDir) + }) + + when: + def initialRun = project.run { + it.tasks('build') + } + + then: + initialRun.task(":neoFormRecompile").outcome == TaskOutcome.SUCCESS + initialRun.task(":build").outcome == TaskOutcome.SUCCESS + } + + def "the userdev runtime supports loading iis from multiple files"() { + given: + def project = create("userdev_supports_iis_in_multiple_distinctly_named_files", { + it.build(""" + java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } + } + + minecraft.interfaceInjections.file rootProject.file('src/main/resources/META-INF/iis.json') + minecraft.interfaceInjections.file rootProject.file('src/main/resources/META-INF/iis2.json') + + dependencies { + implementation 'net.neoforged:neoforge:+' + } + """) + it.file("src/main/resources/META-INF/iis.json", """{"net/minecraft/client/Minecraft": ["com/example/examplemod/MyInjectedInterface"]}""") + it.file("src/main/resources/META-INF/iis2.json", """{"net/minecraft/client/Minecraft": ["com/example/examplemod/MySecondaryInterface"]}""") + it.file("src/main/java/net/neoforged/gradle/userdev/FunctionalTests.java", """ + package net.neoforged.gradle.userdev; + + import net.minecraft.client.Minecraft; + + public class FunctionalTests { + public static void main(String[] args) { + Minecraft.getInstance().doSomething(); + Minecraft.getInstance().doSecondSomething(); + } + } + """) + it.file("src/main/java/com/example/examplemod/MyInjectedInterface.java", """ + package com.example.examplemod; + + public interface MyInjectedInterface { + default void doSomething() { }; + } + """) + it.file("src/main/java/com/example/examplemod/MySecondaryInterface.java", """ + package com.example.examplemod; + + public interface MySecondaryInterface { + default void doSecondSomething() { }; + } + """) + it.withToolchains() + it.withGlobalCacheDirectory(tempDir) + }) + + when: + def initialRun = project.run { + it.tasks('build') + } + + then: + initialRun.task(":neoFormRecompile").outcome == TaskOutcome.SUCCESS + initialRun.task(":build").outcome == TaskOutcome.SUCCESS + } + + def "the userdev runtime supports loading iis from multiple files named the same in different directories"() { + given: + def project = create("userdev_supports_iis_in_files_named_the_same", { + it.build(""" + java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } + } + + minecraft.interfaceInjections.file rootProject.file('src/main/resources/META-INF/iis.json') + minecraft.interfaceInjections.file rootProject.file('src/main/resources/iis.json') + + dependencies { + implementation 'net.neoforged:neoforge:+' + } + """) + it.file("src/main/resources/META-INF/iis.json", """{"net/minecraft/client/Minecraft": ["com/example/examplemod/MyInjectedInterface"]}""") + it.file("src/main/resources/iis.json", """{"net/minecraft/client/Minecraft": ["com/example/examplemod/MySecondaryInterface"]}""") + it.file("src/main/java/net/neoforged/gradle/userdev/FunctionalTests.java", """ + package net.neoforged.gradle.userdev; + + import net.minecraft.client.Minecraft; + + public class FunctionalTests { + public static void main(String[] args) { + Minecraft.getInstance().doSomething(); + Minecraft.getInstance().doSecondSomething(); + } + } + """) + it.file("src/main/java/com/example/examplemod/MyInjectedInterface.java", """ + package com.example.examplemod; + + public interface MyInjectedInterface { + default void doSomething() { }; + } + """) + it.file("src/main/java/com/example/examplemod/MySecondaryInterface.java", """ + package com.example.examplemod; + + public interface MySecondaryInterface { + default void doSecondSomething() { }; + } + """) + it.withToolchains() + it.withGlobalCacheDirectory(tempDir) + }) + + when: + def initialRun = project.run { + it.tasks('build') + } + + then: + initialRun.task(":neoFormRecompile").outcome == TaskOutcome.SUCCESS + initialRun.task(":build").outcome == TaskOutcome.SUCCESS + } +} diff --git a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/MultiProjectTests.groovy b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/MultiProjectTests.groovy index bcf06bc12..9f42ddb41 100644 --- a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/MultiProjectTests.groovy +++ b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/MultiProjectTests.groovy @@ -105,6 +105,102 @@ class MultiProjectTests extends BuilderBasedTestSpecification { run.output.contains("Caused by: net.neoforged.fml.ModLoadingException: Loading errors encountered:") } + def "multiple projects with neoforge dependencies from version catalogs should be able to build"() { + given: + def rootProject = create("multi_neoforge_root", { + it.file("gradle/libs.versions.toml", + """ + [versions] + # Neoforge Settings + neoforge = "+" + + [libraries] + neoforge = { group = "net.neoforged", name = "neoforge", version.ref = "neoforge" } + """.trim()) + + it.build(""" + java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } + } + """) + it.withToolchains() + it.withGlobalCacheDirectory(tempDir) + }) + + def apiProject = create(rootProject, "api", { + it.build(""" + java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } + } + + dependencies { + api(libs.neoforge) + } + """) + it.file("src/main/java/net/neoforged/gradle/apitest/FunctionalTests.java", """ + package net.neoforged.gradle.apitest; + + import net.minecraft.client.Minecraft; + + public class FunctionalTests { + public static void main(String[] args) { + System.out.println(Minecraft.getInstance().getClass().toString()); + } + } + """) + it.withToolchains() + it.withGlobalCacheDirectory(tempDir) + it.plugin(this.pluginUnderTest) + it.plugin("java-library") + }) + + def mainProject = create(rootProject,"main", { + it.build(""" + java { + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } + } + + dependencies { + implementation project(':api') + //We still need a neoforge dependency here, because neoforge is not exposed from the api project. Compile would faile. + implementation libs.neoforge + } + """) + it.file("src/main/java/net/neoforged/gradle/main/ApiTests.java", """ + package net.neoforged.gradle.main; + + import net.minecraft.client.Minecraft; + import net.neoforged.gradle.apitest.FunctionalTests; + + public class ApiTests { + public static void main(String[] args) { + System.out.println(Minecraft.getInstance().getClass().toString()); + FunctionalTests.main(args); + } + } + """) + it.withToolchains() + it.withGlobalCacheDirectory(tempDir) + it.plugin(this.pluginUnderTest) + }) + + when: + def run = rootProject.run { + it.tasks(':main:build') + it.stacktrace() + it.debug() + } + + then: + run.task(':main:build').outcome == TaskOutcome.SUCCESS + } + def "multiple projects with neoforge dependencies should be able to run the game when renderDoc is enabled"() { given: def rootProject = create("multi_neoforge_root_renderdoc", { diff --git a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/RunTests.groovy b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/RunTests.groovy index a774678c3..ab8c0709d 100644 --- a/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/RunTests.groovy +++ b/userdev/src/functionalTest/groovy/net/neoforged/gradle/userdev/RunTests.groovy @@ -425,13 +425,14 @@ class RunTests extends BuilderBasedTestSpecification { import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; + import net.minecraft.core.registries.Registries; @ExtendWith(EphemeralTestServerProvider.class) public class TestTest { @Test public void testIngredient(MinecraftServer server) { // required to load tags Assertions.assertTrue( - Ingredient.of(ItemTags.AXES).test(Items.DIAMOND_AXE.getDefaultInstance()) + Ingredient.of(server.registryAccess().lookupOrThrow(Registries.ITEM).getOrThrow(ItemTags.AXES)).test(Items.DIAMOND_AXE.getDefaultInstance()) ); } } diff --git a/userdev/src/main/java/net/neoforged/gradle/userdev/dependency/UserDevDependencyManager.java b/userdev/src/main/java/net/neoforged/gradle/userdev/dependency/UserDevDependencyManager.java index 2acf60c3c..aa3fe835f 100644 --- a/userdev/src/main/java/net/neoforged/gradle/userdev/dependency/UserDevDependencyManager.java +++ b/userdev/src/main/java/net/neoforged/gradle/userdev/dependency/UserDevDependencyManager.java @@ -85,8 +85,8 @@ private void registerReplacementHandler(Project project) { "NeoForgeUserDevAdditionalReplacementDependenciesFor" + runtimeDefinition.getSpecification().getIdentifier(), configuration -> { configuration.setDescription("Additional dependencies for the NeoForge UserDev replacement for " + runtimeDefinition.getSpecification().getIdentifier()); - configuration.extendsFrom(runtimeDefinition.getNeoFormRuntimeDefinition().getMinecraftDependenciesConfiguration()); - configuration.extendsFrom(runtimeDefinition.getAdditionalUserDevDependencies()); + ConfigurationUtils.extendsFrom(project, configuration, runtimeDefinition.getNeoFormRuntimeDefinition().getMinecraftDependenciesConfiguration()); + ConfigurationUtils.extendsFrom(project, configuration, runtimeDefinition.getAdditionalUserDevDependencies()); } ); diff --git a/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/definition/UserDevRuntimeDefinition.java b/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/definition/UserDevRuntimeDefinition.java index d942398d7..629fa672e 100644 --- a/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/definition/UserDevRuntimeDefinition.java +++ b/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/definition/UserDevRuntimeDefinition.java @@ -18,6 +18,7 @@ import org.gradle.api.artifacts.Configuration; import org.gradle.api.artifacts.Dependency; import org.gradle.api.artifacts.result.ResolvedArtifactResult; +import org.gradle.api.file.FileCollection; import org.gradle.api.file.FileTree; import org.gradle.api.file.RegularFile; import org.gradle.api.provider.MapProperty; @@ -102,12 +103,16 @@ public TaskProvider getListLibrariesTaskProvider() { return neoformRuntimeDefinition.getListLibrariesTaskProvider(); } + @Override + public @NotNull FileCollection getAdditionalRecompileDependencies() { + return neoformRuntimeDefinition.getAdditionalRecompileDependencies(); + } + @Override protected void buildRunInterpolationData(RunImpl run, @NotNull MapProperty interpolationData) { neoformRuntimeDefinition.buildRunInterpolationData(run, interpolationData); if (userdevConfiguration.getModules() != null && !userdevConfiguration.getModules().get().isEmpty()) { - final String name = String.format("moduleResolverForgeUserDev%s", getSpecification().getVersionedName()); final Configuration modulesCfg = ConfigurationUtils .temporaryUnhandledConfiguration( getSpecification().getProject().getConfigurations(), @@ -132,9 +137,9 @@ protected void buildRunInterpolationData(RunImpl run, @NotNull MapProperty { @@ -65,10 +64,12 @@ public UserDevRuntimeExtension(Project project) { .withDistributionType(DistributionType.JOINED) .withAdditionalDependencies(getProject().files(userDevAdditionalDependenciesConfiguration)); - final TaskTreeAdapter atAdapter = createAccessTransformerAdapter(userDevProfile.getAccessTransformerDirectory().get(), userDevJar) - .andThen(NeoFormAccessTransformerUtils.createAccessTransformerAdapter(getProject())); + final TaskTreeAdapter atAndIISAdapter = createAccessTransformerAdapter(userDevProfile.getAccessTransformerDirectory().get(), userDevJar) + .andThen(NeoFormAccessTaskAdapterUtils.createAccessTransformerAdapter(getProject())); - builder.withPostTaskAdapter("decompile", atAdapter); + builder.withPostTaskAdapter("decompile", atAndIISAdapter); + + builder.withPreTaskAdapter("recompile", NeoFormAccessTaskAdapterUtils.createInterfaceInjectionAdapter(getProject())); builder.withPostTaskAdapter("patch", createPatchAdapter(userDevJar, userDevProfile.getSourcePatchesDirectory().get())); @@ -137,7 +138,12 @@ private TaskTreeAdapter createAccessTransformerAdapter(final String accessTransf userDev.matching(filter -> filter.include(accessTransformerDirectory + "/**")); return (definition, previousTasksOutput, runtimeWorkspace, gameArtifacts, mappingVersionData, dependentTaskConfigurationHandler) -> { - final TaskProvider accessTransformerTask = CommonRuntimeTaskUtils.createSourceAccessTransformer(definition, "Forges", runtimeWorkspace, dependentTaskConfigurationHandler, accessTransformerFiles, Collections.emptyList(), definition.getListLibrariesTaskProvider(), definition.getAllDependencies()); + if (accessTransformerFiles.isEmpty()) { + // No access transformers found, so we don't need to do anything + return null; + } + + final TaskProvider accessTransformerTask = CommonRuntimeTaskUtils.createSourceAccessTransformer(definition, "Forges", accessTransformerFiles, definition.getListLibrariesTaskProvider(), definition.getAllDependencies()); accessTransformerTask.configure(task -> task.getInputFile().set(previousTasksOutput.flatMap(WithOutput::getOutput))); accessTransformerTask.configure(task -> task.dependsOn(previousTasksOutput)); return accessTransformerTask; diff --git a/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/specification/UserDevRuntimeSpecification.java b/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/specification/UserDevRuntimeSpecification.java index 2b962ad4e..ca760eced 100644 --- a/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/specification/UserDevRuntimeSpecification.java +++ b/userdev/src/main/java/net/neoforged/gradle/userdev/runtime/specification/UserDevRuntimeSpecification.java @@ -51,7 +51,14 @@ public UserDevRuntimeSpecification(Project project, String forgeName, String forgeVersion, Artifact artifact) { - super(project, "neoForge", version, distribution, preTaskTypeAdapters, postTypeAdapters, taskCustomizers, UserDevRuntimeExtension.class); + super(project, + "neoForge", + version, + distribution, + preTaskTypeAdapters, + postTypeAdapters, + taskCustomizers, + UserDevRuntimeExtension.class); this.userDevArchive = userDevArchive; this.profile = profile; this.forgeGroup = forgeGroup; diff --git a/vanilla/src/functionalTest/groovy/net/neoforged/gradle/vanilla/AccessTransformerTests.groovy b/vanilla/src/functionalTest/groovy/net/neoforged/gradle/vanilla/AccessTransformerTests.groovy index df0c1106c..da7a72370 100644 --- a/vanilla/src/functionalTest/groovy/net/neoforged/gradle/vanilla/AccessTransformerTests.groovy +++ b/vanilla/src/functionalTest/groovy/net/neoforged/gradle/vanilla/AccessTransformerTests.groovy @@ -54,91 +54,6 @@ class AccessTransformerTests extends BuilderBasedTestSpecification { initialRun.task(":build").outcome == TaskOutcome.SUCCESS } - def "the vanilla runtime supports loading ats from the script"() { - given: - def project = create("vanilla_supports_ats_in_scripts", { - it.build(""" - java { - toolchain { - languageVersion = JavaLanguageVersion.of(21) - } - } - - minecraft.accessTransformers.entry 'public-f net.minecraft.client.Minecraft fixerUpper # fixerUpper' - - dependencies { - implementation 'net.minecraft:client:+' - } - """) - it.file("src/main/java/net/neoforged/gradle/vanilla/FunctionalTests.java", """ - package net.neoforged.gradle.vanilla; - - import net.minecraft.client.Minecraft; - - public class FunctionalTests { - public static void main(String[] args) { - System.out.println(Minecraft.getInstance().fixerUpper.getClass().toString()); - } - } - """) - it.withToolchains() - it.withGlobalCacheDirectory(tempDir) - }) - - when: - def initialRun = project.run { - it.tasks('build') - } - - then: - initialRun.task(":clientApplyUserAccessTransformer").outcome == TaskOutcome.SUCCESS - initialRun.task(":build").outcome == TaskOutcome.SUCCESS - } - - def "the vanilla runtime supports loading ats from the script and the file"() { - given: - def project = create("vanilla_supports_ats_in_script_and_file", { - it.build(""" - java { - toolchain { - languageVersion = JavaLanguageVersion.of(21) - } - } - minecraft.accessTransformers.file rootProject.file('src/main/resources/META-INF/accesstransformer.cfg') - minecraft.accessTransformers.entry 'public-f net.minecraft.client.Minecraft LOGGER # LOGGER' - - dependencies { - implementation 'net.minecraft:client:+' - } - """) - it.file("src/main/resources/META-INF/accesstransformer.cfg", """public-f net.minecraft.client.Minecraft fixerUpper # fixerUpper""") - it.file("src/main/java/net/neoforged/gradle/vanilla/FunctionalTests.java", """ - package net.neoforged.gradle.vanilla; - - import net.minecraft.client.Minecraft; - - public class FunctionalTests { - public static void main(String[] args) { - System.out.println(Minecraft.getInstance().fixerUpper.getClass().toString()); - System.out.println(Minecraft.LOGGER.getClass().toString()); - } - } - """) - it.withToolchains() - it.withGlobalCacheDirectory(tempDir) - }) - - when: - def initialRun = project.run { - it.tasks('build') - - } - - then: - initialRun.task(":clientApplyUserAccessTransformer").outcome == TaskOutcome.SUCCESS - initialRun.task(":build").outcome == TaskOutcome.SUCCESS - } - def "the vanilla runtime supports loading ats from multiple files"() { given: def project = create("vanilla_supports_ats_in_multiple_distinctly_named_files", { diff --git a/vanilla/src/main/java/net/neoforged/gradle/vanilla/runtime/extensions/VanillaRuntimeExtension.java b/vanilla/src/main/java/net/neoforged/gradle/vanilla/runtime/extensions/VanillaRuntimeExtension.java index 2658acd6b..2f643a8b9 100644 --- a/vanilla/src/main/java/net/neoforged/gradle/vanilla/runtime/extensions/VanillaRuntimeExtension.java +++ b/vanilla/src/main/java/net/neoforged/gradle/vanilla/runtime/extensions/VanillaRuntimeExtension.java @@ -165,26 +165,28 @@ protected void bakeDefinition(VanillaRuntimeDefinition definition) { ) ); - task.configure((Runtime mcpRuntimeTask) -> configureCommonRuntimeTaskParameters(mcpRuntimeTask, step.getName(), spec, runtimeWorkingDirectory)); - - if (!spec.getPostTypeAdapters().containsKey(step.getName())) { - definition.getTasks().put(task.getName(), task); - } else { - int taskPostAdapterIndex = 0; - for (TaskTreeAdapter taskTreeAdapter : spec.getPostTypeAdapters().get(step.getName())) { - final AtomicInteger additionalPostAdapterTasks = new AtomicInteger(0); - final int currentPostAdapterIndex = taskPostAdapterIndex++; - final TaskProvider taskProvider = taskTreeAdapter.adapt(definition, task, vanillaDirectory, definition.getGameArtifactProvidingTasks(), definition.getMappingVersionData(), dependentTaskProvider -> dependentTaskProvider.configure(additionalTask -> configureCommonRuntimeTaskParameters(additionalTask, step.getName() + "PostAdapter" + currentPostAdapterIndex + "-" + additionalPostAdapterTasks.getAndIncrement(), spec, runtimeWorkingDirectory))); - if (taskProvider != null) { - taskProvider.configure(adaptedTask -> configureCommonRuntimeTaskParameters(adaptedTask, step.getName() + "PostAdapter" + currentPostAdapterIndex + "-" + additionalPostAdapterTasks.getAndIncrement(), spec, runtimeWorkingDirectory)); - task = taskProvider; + if (task != null) { + task.configure((Runtime mcpRuntimeTask) -> configureCommonRuntimeTaskParameters(mcpRuntimeTask, step.getName(), spec, runtimeWorkingDirectory)); + + if (!spec.getPostTypeAdapters().containsKey(step.getName())) { + definition.getTasks().put(task.getName(), task); + } else { + int taskPostAdapterIndex = 0; + for (TaskTreeAdapter taskTreeAdapter : spec.getPostTypeAdapters().get(step.getName())) { + final AtomicInteger additionalPostAdapterTasks = new AtomicInteger(0); + final int currentPostAdapterIndex = taskPostAdapterIndex++; + final TaskProvider taskProvider = taskTreeAdapter.adapt(definition, task, vanillaDirectory, definition.getGameArtifactProvidingTasks(), definition.getMappingVersionData(), dependentTaskProvider -> dependentTaskProvider.configure(additionalTask -> configureCommonRuntimeTaskParameters(additionalTask, step.getName() + "PostAdapter" + currentPostAdapterIndex + "-" + additionalPostAdapterTasks.getAndIncrement(), spec, runtimeWorkingDirectory))); + if (taskProvider != null) { + taskProvider.configure(adaptedTask -> configureCommonRuntimeTaskParameters(adaptedTask, step.getName() + "PostAdapter" + currentPostAdapterIndex + "-" + additionalPostAdapterTasks.getAndIncrement(), spec, runtimeWorkingDirectory)); + task = taskProvider; + } } + + definition.getTasks().put(task.getName(), task); } - definition.getTasks().put(task.getName(), task); + currentInput = task; } - - currentInput = task; } final TaskProvider sourcesTask = Iterators.getLast(definition.getTasks().values().iterator()); diff --git a/vanilla/src/main/java/net/neoforged/gradle/vanilla/runtime/steps/ApplyAccessTransformerStep.java b/vanilla/src/main/java/net/neoforged/gradle/vanilla/runtime/steps/ApplyAccessTransformerStep.java index 1e5909933..32771d3eb 100644 --- a/vanilla/src/main/java/net/neoforged/gradle/vanilla/runtime/steps/ApplyAccessTransformerStep.java +++ b/vanilla/src/main/java/net/neoforged/gradle/vanilla/runtime/steps/ApplyAccessTransformerStep.java @@ -3,7 +3,6 @@ import net.neoforged.gradle.common.runtime.tasks.BinaryAccessTransformer; import net.neoforged.gradle.dsl.common.util.GameArtifact; import net.neoforged.gradle.util.StringCapitalizationUtils; -import net.neoforged.gradle.common.runtime.tasks.NoopRuntime; import net.neoforged.gradle.common.util.CommonRuntimeTaskUtils; import net.neoforged.gradle.dsl.common.extensions.AccessTransformers; import net.neoforged.gradle.dsl.common.extensions.Minecraft; @@ -25,20 +24,14 @@ public TaskProvider buildTask(VanillaRuntimeDefinition defini final Minecraft minecraftExtension = definition.getSpecification().getProject().getExtensions().getByType(Minecraft.class); final AccessTransformers accessTransformerFiles = minecraftExtension.getAccessTransformers(); - if (accessTransformerFiles.getFiles().isEmpty() && (!accessTransformerFiles.getEntries().isPresent() || accessTransformerFiles.getEntries().get().isEmpty())) { - return definition.getSpecification().getProject().getTasks().register(CommonRuntimeUtils.buildTaskName(definition.getSpecification(), String.format("apply%sAccessTransformer", StringCapitalizationUtils.capitalize("user"))), NoopRuntime.class, task -> { - task.getInput().set(inputProvidingTask.flatMap(WithOutput::getOutput)); - task.dependsOn(inputProvidingTask); - }); + if (accessTransformerFiles.getFiles().isEmpty()) { + return null; } final TaskProvider task = CommonRuntimeTaskUtils.createBinaryAccessTransformer( definition, "user", - workingDirectory, - additionalTaskConfigurator, - accessTransformerFiles.getFiles().getAsFileTree(), - accessTransformerFiles.getEntries().get() + accessTransformerFiles.getFiles().getAsFileTree() ); task.configure(t -> {