Fix applying the Gradle plugin without Spotless

Author: abashev

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

@@ -35,10 +35,13 @@ public void apply(Project project) {
         Supplier<FormatterService> memoizedService =
                 rootProject.getExtensions().getByType(JavaFormatExtension.class)::serviceLoad;
 
-        SpotlessInterop spotlessInterop = rootProject.getObjects().newInstance(SpotlessInterop.class, memoizedService);
         project.getPluginManager().withPlugin("java", _javaPlugin -> {
             SPOTLESS_PLUGINS.forEach(spotlessPluginId -> project.getPluginManager()
                     .withPlugin(spotlessPluginId, _spotlessPlugin -> {
+                        // Not before this point: Gradle's decoration of SpotlessInterop loads Spotless classes, which
+                        // are missing from a project that never applies Spotless.
+                        SpotlessInterop spotlessInterop =
+                                rootProject.getObjects().newInstance(SpotlessInterop.class, memoizedService);
                         SpotlessExtension spotlessExtension =
                                 project.getExtensions().getByType(SpotlessExtension.class);
                         spotlessExtension.java(spotlessInterop);

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

@@ -0,0 +1,46 @@
+/*
+ * (c) Copyright 2026 Palantir Technologies Inc. All rights reserved.
+ *
+ * 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 static org.assertj.core.api.Assertions.assertThat;
+
+import com.palantir.javaformat.gradle.testing.GradleTestProject;
+import java.nio.file.Path;
+import org.gradle.testkit.runner.BuildResult;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+/**
+ * Most projects that apply the formatter never apply Spotless, so there are no Spotless classes on their buildscript
+ * classpath. The Spotless integration has to stay dormant there instead of failing the whole plugin.
+ */
+class AppliesWithoutSpotlessTest {
+
+    @TempDir
+    private Path projectDir;
+
+    @Test
+    void applies_without_spotless_on_the_classpath() {
+        GradleTestProject project = new GradleTestProject(projectDir)
+                .plugins("java", "dev.openjavaformat.java-format")
+                .withoutSpotlessOnClasspath();
+
+        BuildResult result = project.succeeds("tasks", "--all");
+
+        assertThat(result.getOutput()).contains("formatDiff");
+    }
+}

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

@@ -16,7 +16,9 @@
 
 package com.palantir.javaformat.gradle.testing;
 
+import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.UncheckedIOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
@@ -25,6 +27,8 @@
 import java.util.Arrays;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Objects;
+import java.util.Properties;
 import java.util.Set;
 import org.gradle.testkit.runner.BuildResult;
 import org.gradle.testkit.runner.GradleRunner;
@@ -46,11 +50,15 @@ public final class GradleTestProject {
      */
     private static final String GRADLE_VERSION = "9.3.1";
 
+    /** Written by java-gradle-plugin: the classpath {@link GradleRunner#withPluginClasspath()} injects. */
+    private static final String PLUGIN_METADATA = "plugin-under-test-metadata.properties";
+
     private final Path projectDir;
     private final Set<String> plugins = new LinkedHashSet<>();
     private final StringBuilder buildGradle = new StringBuilder();
     private final StringBuilder gradleProperties = new StringBuilder();
     private boolean configurationCache;
+    private boolean spotlessOnClasspath = true;
 
     public GradleTestProject(Path projectDir) {
         this.projectDir = projectDir;
@@ -96,6 +104,16 @@ public GradleTestProject withConfigurationCache() {
         return this;
     }
 
+    /**
+     * Leaves the Spotless jars out of the classpath injected next to the plugin under test. build.gradle puts them there
+     * so that generated projects can apply Spotless, which gives every other test Spotless classes whether it applies
+     * Spotless or not — unlike a real project that never does.
+     */
+    public GradleTestProject withoutSpotlessOnClasspath() {
+        this.spotlessOnClasspath = false;
+        return this;
+    }
+
     public Path file(String relativePath) {
         return projectDir.resolve(relativePath);
     }
@@ -132,12 +150,27 @@ private GradleRunner runner(String... arguments) {
         List<String> allArguments = new ArrayList<>(Arrays.asList(arguments));
         allArguments.add("--stacktrace");
         allArguments.add(configurationCache ? "--configuration-cache" : "--no-configuration-cache");
-        return GradleRunner.create()
+        GradleRunner runner = GradleRunner.create()
                 .withProjectDir(projectDir.toFile())
-                .withPluginClasspath()
                 .withGradleVersion(GRADLE_VERSION)
                 .withArguments(allArguments)
                 .forwardOutput();
+        return spotlessOnClasspath
+                ? runner.withPluginClasspath()
+                : runner.withPluginClasspath(pluginClasspathWithoutSpotless());
+    }
+
+    private static List<File> pluginClasspathWithoutSpotless() {
+        Properties metadata = new Properties();
+        try (InputStream in = GradleTestProject.class.getClassLoader().getResourceAsStream(PLUGIN_METADATA)) {
+            metadata.load(Objects.requireNonNull(in, PLUGIN_METADATA + " is not on the test classpath"));
+        } catch (IOException e) {
+            throw new UncheckedIOException("Could not read " + PLUGIN_METADATA, e);
+        }
+        return Arrays.stream(metadata.getProperty("implementation-classpath").split(File.pathSeparator))
+                .map(File::new)
+                .filter(file -> !file.getName().startsWith("spotless-"))
+                .toList();
     }
 
     private void write() {