Cleanup.

Author: nedtwigg

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

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2024 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;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Gradle requires three things:
+ * - Gradle defines cache equality based on your serialized representation
+ * - Combined with remote build cache, you cannot have any absolute paths in
+ * your serialized representation
+ * - Combined with configuration cache, you must be able to roundtrip yourself
+ * through serialization
+ *
+ * These requirements are at odds with each other, as described in these issues
+ * - Gradle issue to define custom equality
+ * https://github.com/gradle/gradle/issues/29816
+ * - Spotless plea for developer cache instead of configuration cache
+ * https://github.com/diffplug/spotless/issues/987
+ * - Spotless cache miss bug fixed by this class
+ * https://github.com/diffplug/spotless/issues/2168
+ *
+ * This class is a `List<FormatterStep>` which can optimize the
+ * serialized representation for either
+ * - roundtrip integrity
+ * - OR
+ * - equality
+ *
+ * Because it is not possible to provide both at the same time.
+ * It is a horrific hack, but it works, and it's the only way I can figure
+ * to make Spotless work with all of Gradle's cache systems at once.
+ */
+public class ConfigurationCacheHackList implements java.io.Serializable {
+	private final boolean optimizeForEquality;
+	private final ArrayList<Object> backingList = new ArrayList<>();
+
+	public static ConfigurationCacheHackList forEquality() {
+		return new ConfigurationCacheHackList(true);
+	}
+
+	public static ConfigurationCacheHackList forRoundtrip() {
+		return new ConfigurationCacheHackList(false);
+	}
+
+	private ConfigurationCacheHackList(boolean optimizeForEquality) {
+		this.optimizeForEquality = optimizeForEquality;
+	}
+
+	public void clear() {
+		backingList.clear();
+	}
+
+	public void addAll(Collection<? extends FormatterStep> c) {
+		for (FormatterStep step : c) {
+			if (step instanceof FormatterStepSerializationRoundtrip) {
+				var clone = ((FormatterStepSerializationRoundtrip) step).hackClone(optimizeForEquality);
+				backingList.add(clone);
+			} else {
+				backingList.add(step);
+			}
+		}
+	}
+
+	public List<FormatterStep> getSteps() {
+		var result = new ArrayList<FormatterStep>(backingList.size());
+		for (Object obj : backingList) {
+			if (obj instanceof FormatterStepSerializationRoundtrip.HackClone) {
+				result.add(((FormatterStepSerializationRoundtrip.HackClone) obj).rehydrate());
+			} else {
+				result.add((FormatterStep) obj);
+			}
+		}
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o)
+			return true;
+		if (o == null || getClass() != o.getClass())
+			return false;
+		ConfigurationCacheHackList stepList = (ConfigurationCacheHackList) o;
+		return optimizeForEquality == stepList.optimizeForEquality &&
+				backingList.equals(stepList.backingList);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(optimizeForEquality, backingList);
+	}
+}

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

@@ -66,6 +66,13 @@ protected FormatterFunc stateToFormatter(EqualityState equalityState) throws Exc
 		return new HackClone<>(this, optimizeForEquality);
 	}
 
+	/**
+	 * This class has one setting (optimizeForEquality) and two pieces of data
+	 * - the original step, which is marked transient so it gets discarded during serialization
+	 * - the cleaned step, which is lazily created during serialization, and the serialized form is optimized for either equality or roundtrip integrity
+	 *
+	 * It works in conjunction with ConfigurationCacheHackList to allow Spotless to work with all of Gradle's cache systems.
+	 */
 	static class HackClone<RoundtripState extends Serializable, EqualityState extends Serializable> implements Serializable {
 		transient FormatterStepSerializationRoundtrip<?, ?> original;
 		boolean optimizeForEquality;
@@ -90,11 +97,6 @@ private void writeObject(java.io.ObjectOutputStream out) throws IOException {
 		}
 
 		public FormatterStep rehydrate() {
-			try {
-				throw new Exception("rehydrate optimizeForEquality=" + optimizeForEquality + " orig=" + original + " cleaned=" + cleaned);
-			} catch (Exception e) {
-				e.printStackTrace();
-			}
 			return original != null ? original : Objects.requireNonNull(cleaned, "how is clean null if this has been serialized?");
 		}
 

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

@@ -35,7 +35,7 @@
 import org.gradle.api.tasks.PathSensitivity;
 import org.gradle.work.Incremental;
 
-import com.diffplug.spotless.ConfigurationCacheHack;
+import com.diffplug.spotless.ConfigurationCacheHackList;
 import com.diffplug.spotless.FormatExceptionPolicy;
 import com.diffplug.spotless.FormatExceptionPolicyStrict;
 import com.diffplug.spotless.Formatter;
@@ -149,16 +149,16 @@ public File getOutputDirectory() {
 		return outputDirectory;
 	}
 
-	private final ConfigurationCacheHack.StepList stepsInternalRoundtrip = new ConfigurationCacheHack.StepList(ConfigurationCacheHack.OptimizeFor.ROUNDTRIP);
-	private final ConfigurationCacheHack.StepList stepsInternalEquality = new ConfigurationCacheHack.StepList(ConfigurationCacheHack.OptimizeFor.EQUALITY);
+	private final ConfigurationCacheHackList stepsInternalRoundtrip = ConfigurationCacheHackList.forRoundtrip();
+	private final ConfigurationCacheHackList stepsInternalEquality = ConfigurationCacheHackList.forEquality();
 
 	@Internal
-	public ConfigurationCacheHack.StepList getStepsInternalRoundtrip() {
+	public ConfigurationCacheHackList getStepsInternalRoundtrip() {
 		return stepsInternalRoundtrip;
 	}
 
 	@Input
-	public ConfigurationCacheHack.StepList getStepsInternalEquality() {
+	public ConfigurationCacheHackList getStepsInternalEquality() {
 		return stepsInternalEquality;
 	}