List the formatter inside the plugin in the IntelliJ settings

updateOpenJavaFormatXml now writes the jars BundledFormatter extracts
into implementationClassPath when palantirJavaFormat is empty, and the
declared ones otherwise, so the IDE runs the build's formatter as it
did when the formatter came from Maven Central. The extracted jars are
where the IDE loads them from after a clean, too.

The task takes the bundle's hash as an input, and is not up to date
while the extracted jars are missing: after their directory is deleted
the next build extracts them again and writes the XML, instead of
leaving the IDE with paths to jars that are gone. The check is a class,
which the configuration cache stores with the task.

Author: abashev

gradle-open-java-format/src/main/groovy/com/palantir/javaformat/gradle/PalantirJavaFormatIdeaPlugin.java

@@ -46,6 +46,8 @@ public void apply(Project rootProject) {
                                 .from(rootProject
                                         .getConfigurations()
                                         .getByName(PalantirJavaFormatProviderPlugin.CONFIGURATION_NAME));
+                        task.getBundledFormatter().set(BundledFormatter.hash());
+                        task.getGradleUserHome().set(rootProject.getGradle().getGradleUserHomeDir());
                     });
 
             TaskProvider<UpdateWorkspaceXmlFile> updateWorkspaceXml = rootProject

gradle-open-java-format/src/main/groovy/com/palantir/javaformat/gradle/UpdatePalantirJavaFormatIdeaXmlFile.java

@@ -20,31 +20,69 @@
 import java.net.URI;
 import java.util.List;
 import org.gradle.api.DefaultTask;
+import org.gradle.api.Task;
 import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.file.DirectoryProperty;
 import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.api.specs.Spec;
 import org.gradle.api.tasks.Classpath;
+import org.gradle.api.tasks.Input;
 import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.tasks.Internal;
 import org.gradle.api.tasks.OutputFile;
 import org.gradle.api.tasks.TaskAction;
 import org.gradle.work.DisableCachingByDefault;
 
 @DisableCachingByDefault(because = "Writes the developer's local .idea configuration; nothing to cache")
 public abstract class UpdatePalantirJavaFormatIdeaXmlFile extends DefaultTask {
 
+    /**
+     * The jars a build declared for the formatter. Most builds declare none, and the IDE then gets the formatter inside
+     * the plugin.
+     */
     @InputFiles
     @Classpath
     public abstract ConfigurableFileCollection getImplementationConfig();
 
+    /** The hash of the formatter inside the plugin, which names the directory its jars are extracted into. */
+    @Input
+    public abstract Property<String> getBundledFormatter();
+
+    /** Where the formatter inside the plugin is extracted to. */
+    @Internal
+    public abstract DirectoryProperty getGradleUserHome();
+
+    public UpdatePalantirJavaFormatIdeaXmlFile() {
+        // The IDE loads the jars from where the XML says: while they are gone, the task is not up to date.
+        getOutputs().upToDateWhen(new BundledFormatterIsExtracted());
+    }
+
     @org.gradle.api.tasks.Optional
     @OutputFile
     public abstract RegularFileProperty getXmlOutputFile();
 
     @TaskAction
     public final void updateXml() {
-        List<URI> uris =
-                getImplementationConfig().getFiles().stream().map(File::toURI).toList();
+        List<URI> uris = BundledFormatter.jarsUnlessOverridden(
+                        getImplementationConfig().getFiles(),
+                        getGradleUserHome().get().getAsFile())
+                .stream()
+                .map(File::toURI)
+                .toList();
         XmlUtils.updateIdeaXmlFile(
                 getXmlOutputFile().getAsFile().get(),
                 node -> ConfigureJavaFormatterXml.configureJavaFormat(node, uris));
     }
+
+    /** A class, not a lambda: the configuration cache stores it with the task. */
+    private static final class BundledFormatterIsExtracted implements Spec<Task> {
+        @Override
+        public boolean isSatisfiedBy(Task task) {
+            var xml = (UpdatePalantirJavaFormatIdeaXmlFile) task;
+            return !xml.getImplementationConfig().isEmpty()
+                    || BundledFormatter.isExtracted(
+                            xml.getGradleUserHome().get().getAsFile());
+        }
+    }
 }

gradle-open-java-format/src/main/java/com/palantir/javaformat/gradle/BundledFormatter.java

@@ -64,6 +64,12 @@ public static List<File> jars(File gradleUserHome) {
         return jars(gradleUserHome.toPath(), BundledFormatter.class.getClassLoader());
     }
 
+    /** Whether the jars are all there under this Gradle user home, so that {@link #jars} would not extract them. */
+    public static boolean isExtracted(File gradleUserHome) {
+        var plugin = BundledFormatter.class.getClassLoader();
+        return isComplete(gradleUserHome.toPath().resolve(CACHES).resolve(hash(plugin)), list(plugin));
+    }
+
     /**
      * The jars a build declared in palantirJavaFormat, which override the formatter inside the plugin; or, when it
      * declared none, as most builds do, the plugin's own.
@@ -77,10 +83,7 @@ static String hash(ClassLoader plugin) {
     }
 
     static List<File> jars(Path gradleUserHome, ClassLoader plugin) {
-        var list = new String(resource(plugin, LIST), StandardCharsets.UTF_8)
-                .lines()
-                .map(Jar::parse)
-                .toList();
+        var list = list(plugin);
         var caches = gradleUserHome.resolve(CACHES);
         var target = caches.resolve(hash(plugin));
         if (!isComplete(target, list)) {
@@ -89,6 +92,13 @@ static List<File> jars(Path gradleUserHome, ClassLoader plugin) {
         return list.stream().map(jar -> target.resolve(jar.name()).toFile()).toList();
     }
 
+    private static List<Jar> list(ClassLoader plugin) {
+        return new String(resource(plugin, LIST), StandardCharsets.UTF_8)
+                .lines()
+                .map(Jar::parse)
+                .toList();
+    }
+
     private static boolean isComplete(Path dir, List<Jar> list) {
         return list.stream().allMatch(jar -> Files.isRegularFile(dir.resolve(jar.name())));
     }