Resolve the formatter in the project that formats

A subproject's Spotless step resolved the root project's
palantirJavaFormat itself, which a parallel build does not allow: the
subproject's task runs without the root project's lock. And
palantirJavaFormat asked for no attributes, so in a root project
without java Gradle could not pick between Guava's variants for the
JRE and for Android, and the default formatter did not resolve. The
layout the docs recommend has no java on the root project.

The root project now offers palantirJavaFormat as a variant of its
own, openJavaFormatFormatterElements, with a capability of its own so
that a root project with java of its own still hands out this variant
and not runtimeElements. Every project that applies the Spotless step
resolves it through openJavaFormatFormatterClasspath, a dependency on
the root project that Gradle resolves in the project that asks.
palantirJavaFormat and both new configurations ask for the runtime
jars of a JVM library. A formatter declared in palantirJavaFormat,
files as well as modules, reaches every project as before.

MultiProjectTest passes, with the configuration cache and without, and
a new test there shows that a build that does not format still
resolves nothing.

Author: abashev

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

@@ -0,0 +1,92 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.palantir.javaformat.gradle;
+
+import java.util.Map;
+import org.gradle.api.NamedDomainObjectProvider;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.ModuleDependency;
+import org.gradle.api.attributes.AttributeContainer;
+import org.gradle.api.attributes.Bundling;
+import org.gradle.api.attributes.Category;
+import org.gradle.api.attributes.LibraryElements;
+import org.gradle.api.attributes.Usage;
+import org.gradle.api.attributes.java.TargetJvmEnvironment;
+import org.gradle.api.model.ObjectFactory;
+
+/**
+ * The formatter's jars for the tasks of one project, resolved in that project.
+ *
+ * <p>The formatter is declared once, in the root project's palantirJavaFormat. A task of a subproject cannot resolve
+ * that configuration itself: in a parallel build it runs without the root project's lock, and Gradle refuses. So the
+ * root project offers palantirJavaFormat as a variant of its own, and every project that formats resolves it through a
+ * dependency on the root project, which Gradle resolves in the project that asks.
+ */
+final class FormatterClasspath {
+
+    /** Picks the root project's variant out of its others, such as runtimeElements when it has java too. */
+    private static final String CAPABILITY = "dev.openjavaformat.internal:formatter-classpath";
+
+    private static final String ELEMENTS = "openJavaFormatFormatterElements";
+    private static final String DEPENDENCIES = "openJavaFormatFormatter";
+    private static final String CLASSPATH = "openJavaFormatFormatterClasspath";
+
+    private FormatterClasspath() {}
+
+    /** Offers the root project's palantirJavaFormat to the projects that format. */
+    static void offer(Project rootProject, Configuration palantirJavaFormat) {
+        rootProject.getConfigurations().consumable(ELEMENTS, conf -> {
+            conf.setDescription("Internal: the open-java-format implementation, for the projects that format");
+            conf.extendsFrom(palantirJavaFormat);
+            javaRuntime(conf.getAttributes(), rootProject.getObjects());
+            conf.getOutgoing().capability(CAPABILITY + ":1");
+        });
+    }
+
+    /** The formatter's jars for the tasks of this project. */
+    static NamedDomainObjectProvider<Configuration> of(Project project) {
+        var configurations = project.getConfigurations();
+        if (!configurations.getNames().contains(CLASSPATH)) {
+            var rootProject = (ModuleDependency) project.getDependencies().project(Map.of("path", ":"));
+            rootProject.capabilities(capabilities -> capabilities.requireCapability(CAPABILITY));
+            var dependencies = configurations.dependencyScope(DEPENDENCIES, conf -> {
+                conf.setDescription("Internal: the root project's open-java-format implementation");
+                conf.getDependencies().add(rootProject);
+            });
+            configurations.resolvable(CLASSPATH, conf -> {
+                conf.setDescription("Internal: resolves the open-java-format implementation for this project");
+                conf.extendsFrom(dependencies.get());
+                javaRuntime(conf.getAttributes(), project.getObjects());
+            });
+        }
+        return configurations.named(CLASSPATH);
+    }
+
+    /**
+     * What a Java library's runtime jars are asked for with. Without them Gradle cannot pick between the variants of a
+     * library that has one for the JRE and one for Android, as Guava does, which the formatter depends on.
+     */
+    static void javaRuntime(AttributeContainer attributes, ObjectFactory objects) {
+        attributes.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.class, Usage.JAVA_RUNTIME));
+        attributes.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.class, Category.LIBRARY));
+        attributes.attribute(
+                LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.class, LibraryElements.JAR));
+        attributes.attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.class, Bundling.EXTERNAL));
+        attributes.attribute(
+                TargetJvmEnvironment.TARGET_JVM_ENVIRONMENT_ATTRIBUTE,
+                objects.named(TargetJvmEnvironment.class, TargetJvmEnvironment.STANDARD_JVM));
+    }
+}

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

@@ -45,7 +45,10 @@ public void apply(Project rootProject) {
                                 "dev.openjavaformat:open-java-format:%s",
                                 JavaFormatExtension.class.getPackage().getImplementationVersion())));
             });
+            // Resolved here too, by the IntelliJ task, in a root project that may well not have java.
+            FormatterClasspath.javaRuntime(conf.getAttributes(), rootProject.getObjects());
         });
+        FormatterClasspath.offer(rootProject, configuration);
 
         rootProject.getExtensions().create("palantirJavaFormat", JavaFormatExtension.class, configuration);
     }

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

@@ -43,7 +43,8 @@ public void apply(Project project) {
                                         project.getProjectDir(),
                                         project.getExtensions()
                                                 .getByType(JavaPluginExtension.class)
-                                                .getSourceSets());
+                                                .getSourceSets(),
+                                        FormatterClasspath.of(project));
                         SpotlessExtension spotlessExtension =
                                 project.getExtensions().getByType(SpotlessExtension.class);
                         spotlessExtension.java(spotlessInterop);

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

@@ -24,7 +24,8 @@
 import java.util.regex.Pattern;
 import javax.inject.Inject;
 import org.gradle.api.Action;
-import org.gradle.api.artifacts.ConfigurationContainer;
+import org.gradle.api.NamedDomainObjectProvider;
+import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.file.FileCollection;
 import org.gradle.api.logging.Logger;
 import org.gradle.api.logging.Logging;
@@ -52,17 +53,19 @@ public abstract class SpotlessInterop implements Action<JavaExtension> {
 
     private final File projectDir;
     private final SourceSetContainer sourceSets;
-
-    @Inject
-    protected abstract ConfigurationContainer getConfigurations();
+    private final NamedDomainObjectProvider<Configuration> formatterClasspath;
 
     @Inject
     protected abstract ObjectFactory getObjects();
 
     @Inject
-    public SpotlessInterop(File projectDir, SourceSetContainer sourceSets) {
+    public SpotlessInterop(
+            File projectDir,
+            SourceSetContainer sourceSets,
+            NamedDomainObjectProvider<Configuration> formatterClasspath) {
         this.projectDir = projectDir;
         this.sourceSets = sourceSets;
+        this.formatterClasspath = formatterClasspath;
     }
 
     @Override
@@ -90,8 +93,7 @@ private FileCollection generatedSources() {
      */
     private FormatterStep spotlessJavaFormatStep() {
         logger.info("Using the Java-based formatter");
-        return PalantirJavaFormatStep.create(
-                getConfigurations().getByName(PalantirJavaFormatProviderPlugin.CONFIGURATION_NAME));
+        return PalantirJavaFormatStep.create(formatterClasspath.get());
     }
 
     /**

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

@@ -30,8 +30,12 @@ private PalantirJavaFormatStep() {}
 
     private static final String NAME = "open-java-format";
 
-    /** Creates a step which formats everything - code, import order, and unused imports. */
-    public static FormatterStep create(Configuration palantirJavaFormat) {
+    /**
+     * Creates a step which formats everything - code, import order, and unused imports - with the formatter in these
+     * jars. A configuration of the project the Spotless task belongs to: resolving another project's needs that
+     * project's lock, which a parallel build does not hold.
+     */
+    public static FormatterStep create(Configuration formatterClasspath) {
         ensureImplementationNotDirectlyLoadable();
         // Spotless keeps a step in two forms, and neither can hold the configuration or a loaded formatter, which do
         // not serialize. The configuration cache stores the jars, resolved when the entry is written at the earliest.
@@ -40,7 +44,7 @@ public static FormatterStep create(Configuration palantirJavaFormat) {
         // formatter is loaded from the jars on first use.
         return FormatterStep.createLazy(
                 NAME,
-                () -> FileSignature.promise(palantirJavaFormat.getFiles()),
+                () -> FileSignature.promise(formatterClasspath.getFiles()),
                 FileSignature.Promised::get,
                 PalantirJavaFormatStep::createFormat);
     }

gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/MultiProjectTest.java

@@ -135,6 +135,18 @@ void formats_with_a_formatter_dependency_that_has_variants_when_the_root_has_no_
                 .doesNotContain("variants-1.0-android.jar");
     }
 
+    @Test
+    void nothing_is_resolved_for_a_build_that_does_not_format() {
+        // A formatter that cannot be resolved fails a build only once a task needs its jars.
+        var project = project().buildGradle("""
+            dependencies {
+                palantirJavaFormat 'does.not:exist:1.0'
+            }
+            """);
+
+        project.succeeds("help");
+    }
+
     /** The layout of the docs, with no java on the root project. */
     private GradleTestProject project() {
         return new GradleTestProject(projectDir)

gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/testing/GradleTestProject.java

@@ -237,7 +237,15 @@ private void write() {
         script.append("}\n\nrepositories {\n    mavenCentral()\n}\n\n").append(buildGradle);
 
         StringBuilder settings = new StringBuilder("rootProject.name = 'test-project'\n");
-        subprojects.forEach(name -> settings.append("include '").append(name).append("'\n"));
+        for (var name : subprojects) {
+            settings.append("include '").append(name).append("'\n");
+            // Gradle refuses a project whose directory is missing.
+            try {
+                Files.createDirectories(file(name));
+            } catch (IOException e) {
+                throw new UncheckedIOException("Could not create " + name, e);
+            }
+        }
         // Forward slashes: the path goes into a Groovy string, where a Windows backslash would start an escape.
         buildCacheDir.ifPresent(dir -> settings.append("\nbuildCache {\n    local {\n        directory = file('")
                 .append(dir.toAbsolutePath().toString().replace('\\', '/'))