fix gradle custom step with closure and configuration cache

lib-extra/src/main/java/com/diffplug/spotless/extra/GitAttributesLineEndings.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2023 DiffPlug
+ * Copyright 2016-2025 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -193,6 +193,8 @@ static class RuntimeInit {
 			/////////////////////////////////
 			// USER AND SYSTEM-WIDE VALUES //
 			/////////////////////////////////
+			FS.DETECTED.setGitSystemConfig(new File("no-global-git-config-for-spotless")); // this fixes a problem
+			// that was only occurring on Java 11. If we remove support for Java 11, we could probably remove it.
 			systemConfig = SystemReader.getInstance().openSystemConfig(null, FS.DETECTED);
 			Errors.log().run(systemConfig::load);
 			userConfig = SystemReader.getInstance().openUserConfig(systemConfig, FS.DETECTED);

lib/src/main/java/com/diffplug/spotless/ConfigurationCacheHackList.java

@@ -22,6 +22,8 @@
 import java.util.List;
 import java.util.Objects;
 
+import com.diffplug.spotless.yaml.SerializeToByteArrayHack;
+
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 
 /**
@@ -51,27 +53,43 @@
  * to make Spotless work with all of Gradle's cache systems at once.
  */
 public class ConfigurationCacheHackList implements java.io.Serializable {
-	private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 6914178791997323870L;
+
 	private boolean optimizeForEquality;
 	private ArrayList<Object> backingList = new ArrayList<>();
 
+	private boolean shouldWeSerializeToByteArrayFirst() {
+		return backingList.stream().anyMatch(step -> step instanceof SerializeToByteArrayHack);
+	}
+
 	private void writeObject(java.io.ObjectOutputStream out) throws IOException {
+		boolean serializeToByteArrayFirst = shouldWeSerializeToByteArrayFirst();
+		out.writeBoolean(serializeToByteArrayFirst);
 		out.writeBoolean(optimizeForEquality);
 		out.writeInt(backingList.size());
 		for (Object obj : backingList) {
 			// if write out the list on its own, we'll get java's non-deterministic object-graph serialization
 			// by writing each object to raw bytes independently, we avoid this
-			out.writeObject(LazyForwardingEquality.toBytes((Serializable) obj));
+			if (serializeToByteArrayFirst) {
+				out.writeObject(LazyForwardingEquality.toBytes((Serializable) obj));
+			} else {
+				out.writeObject(obj);
+			}
 		}
 	}
 
 	@SuppressFBWarnings("MC_OVERRIDABLE_METHOD_CALL_IN_READ_OBJECT")
 	private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
+		boolean serializeToByteArrayFirst = in.readBoolean();
 		optimizeForEquality = in.readBoolean();
 		backingList = new ArrayList<>();
 		int size = in.readInt();
 		for (int i = 0; i < size; i++) {
-			backingList.add(LazyForwardingEquality.fromBytes((byte[]) in.readObject()));
+			if (serializeToByteArrayFirst) {
+				backingList.add(LazyForwardingEquality.fromBytes((byte[]) in.readObject()));
+			} else {
+				backingList.add(in.readObject());
+			}
 		}
 	}
 

lib/src/main/java/com/diffplug/spotless/yaml/SerializeToByteArrayHack.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2025 DiffPlug
+ *
+ * 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.diffplug.spotless.yaml;
+
+import java.io.File;
+
+import javax.annotation.Nullable;
+
+import com.diffplug.spotless.FormatterStep;
+
+/**
+ * This step is a flag which marks that `ConfigurationCacheHackList` should
+ * serialize each item individually into `byte[]` array, rather than using normal
+ * serialization.
+ *
+ * The reason to use this is if you are using `toggleOffOn` *and* two kinds of
+ * google-java-format (e.g. one for format and the other for imports), then
+ * problems with Java's handling of object graphs will cause your up-to-date checks
+ * to always fail. `CombinedJavaFormatStepTest` recreates this situation. By adding
+ * this step, it will trigger this workaround which fixes the up-to-dateness bug.
+ *
+ * But, turning it on will break all `custom` steps that use Groovy closures. So
+ * by default you get regular serialization. If you're using `toggleOffOn` and having
+ * problems with up-to-dateness, then adding this step can be a workaround.
+ */
+public class SerializeToByteArrayHack implements FormatterStep {
+	private static final long serialVersionUID = 8071047581828362545L;
+
+	@Override
+	public String getName() {
+		return "hack to force serializing objects to byte array";
+	}
+
+	@Nullable
+	@Override
+	public String format(String rawUnix, File file) throws Exception {
+		return null;
+	}
+
+	@Override
+	public void close() throws Exception {
+
+	}
+}

plugin-gradle/CHANGES.md

@@ -12,6 +12,10 @@ We adhere to the [keepachangelog](https://keepachangelog.com/en/1.0.0/) format (
 * Bump minimum `eclipse-cdt` version to `11.0` (removed support for `10.7`). ([#2373](https://github.com/diffplug/spotless/pull/2373))
 ### Fixed
 * `toggleOffOn` now works with the configuration cache. ([#2378](https://github.com/diffplug/spotless/pull/2378) fixes [#2317](https://github.com/diffplug/spotless/issues/2317))
+* Using `custom` with a Groovy closure now works with and without configuration cache. ([#2376](https://github.com/diffplug/spotless/pull/2376))
+  * Minimum required Gradle version for this to work has bumped from `8.0` to `8.4`.
+  * The global git system config is now ignored for line-ending purposes.
+  * Added `SerializeToByteArrayHack` as a flag for a limitation at the intersection of `toggleOffOn` and `custom`. 
 * You can now use `removeUnusedImports` and `googleJavaFormat` at the same time again. (fixes [#2159](https://github.com/diffplug/spotless/issues/2159))
 * The default list of type annotations used by `formatAnnotations` now includes Jakarta Validation's `Valid` and constraints validations (fixes [#2334](https://github.com/diffplug/spotless/issues/2334))
 * `indentWith[Spaces|Tabs]` has been deprecated in favor of `leadingTabsToSpaces` and `leadingSpacesToTabs`. ([#2350](https://github.com/diffplug/spotless/pull/2350) fixes [#794](https://github.com/diffplug/spotless/issues/794))

plugin-gradle/src/main/java/com/diffplug/gradle/spotless/FormatExtension.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2024 DiffPlug
+ * Copyright 2016-2025 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -457,12 +457,11 @@ protected Integer calculateState() throws Exception {
 	 */
 	public void custom(String name, Closure<String> formatter) {
 		requireNonNull(formatter, "formatter");
-		Closure<String> dehydrated = formatter.dehydrate();
-		custom(name, new ClosureFormatterFunc(dehydrated));
+		custom(name, new ClosureFormatterFunc(formatter));
 	}
 
 	static class ClosureFormatterFunc implements FormatterFunc, Serializable {
-		private final Closure<String> closure;
+		private Closure<String> closure;
 
 		ClosureFormatterFunc(Closure<String> closure) {
 			this.closure = closure;
@@ -472,6 +471,14 @@ static class ClosureFormatterFunc implements FormatterFunc, Serializable {
 		public String apply(String unixNewlines) {
 			return closure.call(unixNewlines);
 		}
+
+		private void writeObject(java.io.ObjectOutputStream stream) throws java.io.IOException {
+			stream.writeObject(closure.dehydrate());
+		}
+
+		private void readObject(java.io.ObjectInputStream stream) throws java.io.IOException, ClassNotFoundException {
+			this.closure = (Closure<String>) stream.readObject();
+		}
 	}
 
 	/**

plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessPlugin.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2024 DiffPlug
+ * Copyright 2016-2025 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,7 +29,7 @@ public class SpotlessPlugin implements Plugin<Project> {
 	static final String SPOTLESS_MODERN = "spotlessModern";
 	static final String VER_GRADLE_min = "6.1.1";
 	static final String VER_GRADLE_javaPluginExtension = "7.1";
-	static final String VER_GRADLE_minVersionForCustom = "8.0";
+	static final String VER_GRADLE_minVersionForCustom = "8.4";
 	private static final int MINIMUM_JRE = 11;
 
 	@Override

plugin-gradle/src/test/java/com/diffplug/gradle/spotless/BumpThisNumberIfACustomStepChangesTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2024 DiffPlug
+ * Copyright 2016-2025 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,9 +17,39 @@
 
 import java.io.IOException;
 
+import org.gradle.testkit.runner.GradleRunner;
 import org.junit.jupiter.api.Test;
 
-class BumpThisNumberIfACustomStepChangesTest extends GradleIntegrationHarness {
+abstract class BumpThisNumberIfACustomStepChangesTest extends GradleIntegrationHarness {
+	private boolean useConfigCache;
+
+	BumpThisNumberIfACustomStepChangesTest(boolean useConfigCache) {
+		this.useConfigCache = useConfigCache;
+	}
+
+	static class WithConfigCache extends BumpThisNumberIfACustomStepChangesTest {
+		WithConfigCache() {
+			super(true);
+		}
+	}
+
+	static class WithoutConfigCache extends BumpThisNumberIfACustomStepChangesTest {
+		WithoutConfigCache() {
+			super(false);
+		}
+	}
+
+	@Override
+	public GradleRunner gradleRunner() throws IOException {
+		if (useConfigCache) {
+			setFile("gradle.properties").toLines("org.gradle.unsafe.configuration-cache=true",
+					"org.gradle.configuration-cache=true");
+			return super.gradleRunner().withGradleVersion(GradleVersionSupport.CUSTOM_STEPS.version);
+		} else {
+			return super.gradleRunner();
+		}
+	}
+
 	private void writeBuildFile(String toInsert) throws IOException {
 		setFile("build.gradle").toLines(
 				"plugins {",
@@ -50,7 +80,12 @@ void customRuleNeverUpToDate() throws IOException {
 		writeContentWithBadFormatting();
 		applyIsUpToDate(false);
 		checkIsUpToDate(false);
-		checkIsUpToDate(false);
+		if (useConfigCache) {
+			// if the config cache is in-effect, then it's okay for custom rules to become "up-to-date"
+			checkIsUpToDate(true);
+		} else {
+			checkIsUpToDate(false);
+		}
 	}
 
 	@Test

testlib/src/test/java/com/diffplug/spotless/combined/CombinedJavaFormatStepTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023-2024 DiffPlug
+ * Copyright 2023-2025 DiffPlug
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,6 +31,7 @@
 import com.diffplug.spotless.java.GoogleJavaFormatStep;
 import com.diffplug.spotless.java.ImportOrderStep;
 import com.diffplug.spotless.java.RemoveUnusedImportsStep;
+import com.diffplug.spotless.yaml.SerializeToByteArrayHack;
 
 public class CombinedJavaFormatStepTest extends ResourceHarness {
 
@@ -45,6 +46,7 @@ void checkIssue1679() {
 		FenceStep toggleOffOnPair = FenceStep.named(FenceStep.defaultToggleName()).openClose("formatting:off", "formatting:on");
 		try (StepHarness formatter = StepHarness.forSteps(
 				toggleOffOnPair.preserveWithin(List.of(
+						new SerializeToByteArrayHack(),
 						gjf,
 						indentWithSpaces,
 						importOrder,