Improve the handling of the IDEA extension. (#272)

Author: marchermans

README.md

@@ -514,8 +514,6 @@ using [Gradle properties](https://docs.gradle.org/current/userguide/project_prop
 This implements run specific dependency management for the classpath of a run.
 In the past this had to happen via a manual modification of the "minecraft_classpath" token, however tokens don't exist anymore as a component that can be configured on a run.
 It was as such not possible to add none FML aware libraries to your classpath of a run.
-This PR enables this feature again.
-
 
 ### Usage:
 #### Direct
@@ -699,27 +697,73 @@ If you have configured your IDEA IDE to run with its own compiler, you can disab
 ```properties
 neogradle.subsystems.conventions.ide.idea.compiler-detection=false
 ```
-This will set the DSL property:
+This auto-detection will set the DSL property, disabling this property while running and compiling with idea means that you need to set this property yourself.
 ```groovy
 idea {
-    runs {
+    project {
+        runs {
+            runWithIdea = true / false
+        }
+    }
+}
+```
+
+> [!NOTE]
+> This API is only available on the root project, since that is where the idea project model resides.
+
+If for what ever reason IDEA does not properly register its model in your root project you can also use:
+```groovy
+minecraft {
+    idea {
         runWithIdea = true / false
     }
 }
 ```
-##### IDEA Compiler output directory
-If you want to change the output directory of the IDEA compiler, you can set the following property in your gradle.properties:
+
+> [!WARNING]
+> This model is project specific, as apposed to the API shown above which is only available on the root project.
+> It should as such be set on all projects at once. We suggest using a convention plugin or a similar Config Cache compatible mechanism.
+
+##### Using Arg Files
+Sometimes IDEA will generate a Config Cache incompatible init script when its command line arguments are shortened using an args file and running with Gradle is enabled (which is the default).
+To prevent gradle from being mad at idea for the incompatible script you can make NG generate a launch configuration that does not shorten the command line.
+
+> [!NOTE]
+> This might not work on all operating systems. Some configurations of paths might prevent you from launching the game because the launch command got too long.
+
+You can either use the following convention:
 ```properties
-neogradle.subsystems.conventions.ide.idea.compiler-output-dir=<path>
+neogradle.subsystems.conventions.ide.idea.use-args-file=false
 ```
-By default, this is set to 'out', and configured in the DSL as:
+
+Or the following model APIs:
+
 ```groovy
 idea {
-    runs {
-        outDirectory = '<path>'
+    project {
+        runs {
+            useArgsFile = true / false
+        }
     }
 }
 ```
+Will configure the system to use your preferred convention.
+
+> [!NOTE]
+> This API is only available on the root project, since that is where the idea project model resides.
+
+If for what ever reason IDEA does not properly register its model in your root project you can also use:
+```groovy
+minecraft {
+    idea {
+        useArgsFile = true / false
+    }
+}
+```
+
+> [!WARNING]
+> This model is project specific, as apposed to the API shown above which is only available on the root project.
+> It should as such be set on all projects at once. We suggest using a convention plugin or a similar Config Cache compatible mechanism.
 
 ##### Post Sync Task Usage
 By default, the import in IDEA is run during the sync task.

build.gradle

@@ -51,7 +51,9 @@ subprojects.forEach { Project subProject ->
     subProject.apply plugin: 'eclipse'
     subProject.apply plugin: 'idea'
 
-    gradleutils.setupSigning(project: subProject, signAllPublications: true)
+    //TODO: Figure out why eclipse project signing is fucked with GU
+    if (subProject.name != "eclipse")
+        gradleutils.setupSigning(project: subProject, signAllPublications: true)
 
     //General project metadata. Everything has the same version and group.
     subProject.version = subProject.rootProject.version

common/src/main/java/net/neoforged/gradle/common/extensions/subsystems/ConventionsExtension.java

@@ -149,6 +149,7 @@ public IDEAExtension(WithEnabledProperty parent) {
             getShouldUseCompilerDetection().convention(getBooleanProperty("compiler-detection", true, false));
             getShouldUsePostSyncTask().convention(getBooleanProperty("use-post-sync-task", false, false));
             getShouldReconfigureTemplatesForTests().convention(getBooleanProperty("reconfigure-unit-test-templates", false, false));
+            getShouldUseArgsFile().convention(getBooleanProperty("use-args-file", true, true));
         }
     }
 }

common/src/main/java/net/neoforged/gradle/common/runs/ide/IdeRunIntegrationManager.java

@@ -12,6 +12,7 @@
 import net.neoforged.gradle.common.util.ProjectUtils;
 import net.neoforged.gradle.common.util.SourceSetUtils;
 import net.neoforged.gradle.common.util.run.RunsUtil;
+import net.neoforged.gradle.dsl.common.extensions.Minecraft;
 import net.neoforged.gradle.dsl.common.extensions.subsystems.Subsystems;
 import net.neoforged.gradle.dsl.common.extensions.subsystems.conventions.ide.IDEA;
 import net.neoforged.gradle.dsl.common.runs.ide.extensions.IdeaRunExtension;
@@ -83,8 +84,25 @@ public void setup(final Project project) {
         final IdeaModel ideaModel = rootProject.getExtensions().getByType(IdeaModel.class);
         final IdeaProject ideaProject = ideaModel.getProject();
         final ExtensionAware extensionAware = (ExtensionAware) ideaProject;
+        final IdeaRunsExtension global;
         if (extensionAware.getExtensions().findByType(IdeaRunsExtension.class) == null && extensionAware.getExtensions().findByName("runs") == null) {
-            extensionAware.getExtensions().create("runs", IdeaRunsExtension.class, project);
+            global = extensionAware.getExtensions().create("runs", IdeaRunsExtension.class, project);
+        }
+        else if (extensionAware.getExtensions().findByType(IdeaRunsExtension.class) != null)
+        {
+            global = extensionAware.getExtensions().findByType(IdeaRunsExtension.class);
+        }
+        else
+        {
+            project.getLogger().warn("Runs extension for idea can not be registered on the Idea project model. Use the one in the minecraft extension.");
+            global = null;
+        }
+
+        final Minecraft minecraft = project.getExtensions().getByType(Minecraft.class);
+        final IdeaRunsExtension projectLocal = minecraft.getExtensions().create("idea", IdeaRunsExtension.class, project);
+        if (global != null) {
+            projectLocal.getUseArgsFile().convention(global.getUseArgsFile());
+            projectLocal.getRunWithIdea().convention(global.getRunWithIdea());
         }
     }
 
@@ -123,6 +141,8 @@ public void configureIdeaConventions(Project project, IDEA ideaConventions) {
                             return FileUtils.contains(GradleXml, "<option name=\"delegatedBuild\" value=\"false\" />");
                         })
         );
+
+        runsExtension.getUseArgsFile().convention(ideaConventions.getShouldUseArgsFile());
     }
 
     private static final class RunsImportAction implements IdeManagementExtension.IdeImportAction {
@@ -175,6 +195,9 @@ private void createIdeaRun(Project project, Run run, RunConfigurationContainer i
             if (!defaultRun && !run.getShouldExportToIDE().get())
                 return;
 
+            final Minecraft minecraft = project.getExtensions().getByType(Minecraft.class);
+            final IdeaRunsExtension ideaRunsExtension = minecraft.getExtensions().getByType(IdeaRunsExtension.class);
+
             final String ideRunName = run.getIDERunName().isPresent() ? run.getIDERunName().get() : run.getName();
             final String runName = StringUtils.capitalize(project.getName() + ": " + StringUtils.capitalize(ideRunName));
 
@@ -208,7 +231,9 @@ private void createIdeaRun(Project project, Run run, RunConfigurationContainer i
                     ideaRun.setModuleName(RunsUtil.getIntellijModuleName(run.getExtensions().getByType(IdeaRunExtension.class).getPrimarySourceSet().get()));
                     ideaRun.setProgramParameters(RunsUtil.escapeAndJoin(RunsUtil.deduplicateElementsFollowingEachOther(programArguments.stream()).collect(Collectors.toList())));
                     ideaRun.setEnvs(productionEnvironment);
-                    ideaRun.setShortenCommandLine(ShortenCommandLine.ARGS_FILE);
+
+                    if (ideaRunsExtension.getUseArgsFile().get())
+                        ideaRun.setShortenCommandLine(ShortenCommandLine.ARGS_FILE);
 
                     ideaRun.beforeRun(beforeRuns -> {
                         beforeRuns.create("Build", Make.class);
@@ -240,7 +265,9 @@ private void createIdeaRun(Project project, Run run, RunConfigurationContainer i
                                     "@%s".formatted(preparedUnitTestEnvironment.jvmArgumentsFile().getAbsolutePath())
                     ));
                     ideaRun.setEnvs(testEnvironment);
-                    ideaRun.setShortenCommandLine(ShortenCommandLine.ARGS_FILE);
+
+                    if (ideaRunsExtension.getUseArgsFile().get())
+                        ideaRun.setShortenCommandLine(ShortenCommandLine.ARGS_FILE);
 
                     ideaRun.beforeRun(beforeRuns -> {
                         beforeRuns.create("Build", Make.class);

dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/extensions/subsystems/conventions/ide/IDEA.groovy

@@ -33,4 +33,10 @@ interface IDEA extends BaseDSLElement<IDEA> {
      */
     @DSLProperty
     Property<Boolean> getShouldReconfigureTemplatesForTests();
+
+    /**
+     * Whether or not IDEA should run with args files.
+     */
+    @DSLProperty
+    Property<Boolean> getShouldUseArgsFile()
 }

dsl/common/src/main/groovy/net/neoforged/gradle/dsl/common/runs/idea/extensions/IdeaRunsExtension.groovy

@@ -14,16 +14,17 @@ abstract class IdeaRunsExtension implements BaseDSLElement<IdeaRunsExtension> {
 
     private final Project project;
     private final Property<Boolean> runWithIdea;
-    private final DirectoryProperty outDirectory;
+    private final Property<Boolean> useArgsFile;
 
     @Inject
     IdeaRunsExtension(final Project project) {
-        this.project = project;
+        this.project = project
 
-        this.runWithIdea = project.getObjects().property(Boolean);
-        this.outDirectory = project.getObjects().directoryProperty();
+        this.runWithIdea = project.getObjects().property(Boolean)
+        this.useArgsFile = project.getObjects().property(Boolean)
 
-        getRunWithIdea().convention(false);
+        getRunWithIdea().convention(false)
+        getUseArgsFile().convention(true)
     }
 
     @Override
@@ -35,4 +36,9 @@ abstract class IdeaRunsExtension implements BaseDSLElement<IdeaRunsExtension> {
     Property<Boolean> getRunWithIdea() {
         return runWithIdea;
     }
+
+    @DSLProperty
+    Property<Boolean> getUseArgsFile() {
+        return useArgsFile;
+    }
 }

gradle.properties

@@ -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.16
+groovy_dsl_improver_version=1.0.18
 eclipse_launch_configs_version=0.1.3
 vscode_launch_configs_version=1.0.8