Migrate from our one-off to the design we'd like Gradle to adopt.

Author: nedtwigg

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

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2021 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.gradle.spotless;
+
+import java.io.File;
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import javax.annotation.Nullable;
+
+import org.gradle.api.GradleException;
+import org.gradle.api.Task;
+
+import com.diffplug.spotless.FileSignature;
+
+class JvmLocalCache {
+	private static GradleException cacheIsStale() {
+		return new GradleException("Spotless JVM-local cache is stale. Regenerate the cache with\n" +
+				"  " + (FileSignature.machineIsWin() ? "rmdir /q /s" : "rm -rf") + " .gradle/configuration-cache\n" +
+				"To make this workaround obsolete, please upvote https://github.com/diffplug/spotless/issues/987");
+	}
+
+	interface CacheKey<T> {
+		T get();
+
+		void set(T value);
+	}
+
+	static <T> CacheKey<T> createCacheKey(Task task, String keyName, @Nullable T initialValue) {
+		CacheKeyImpl key = new CacheKeyImpl<T>(new InternalCacheKey(task.getProject().getProjectDir(), task.getPath(), keyName));
+		if (initialValue != null) {
+			key.set(initialValue);
+		}
+		return key;
+	}
+
+	static class CacheKeyImpl<T> implements CacheKey<T>, Serializable {
+		InternalCacheKey internalKey;
+
+		CacheKeyImpl(InternalCacheKey internalKey) {
+			this.internalKey = internalKey;
+		}
+
+		@Override
+		public void set(T value) {
+			daemonState.put(internalKey, value);
+		}
+
+		@Override
+		public T get() {
+			Object value = daemonState.get(internalKey);
+			if (value == null) {
+				// TODO: throw TriggerConfigurationException(); (see https://github.com/diffplug/spotless/issues/987)
+				throw cacheIsStale();
+			} else {
+				return (T) value;
+			}
+		}
+	}
+
+	private static Map<InternalCacheKey, Object> daemonState = Collections.synchronizedMap(new HashMap<>());
+
+	private static class InternalCacheKey implements Serializable {
+		private File projectDir;
+		private String taskPath;
+		private String keyName;
+
+		InternalCacheKey(File projectDir, String taskPath, String keyName) {
+			this.projectDir = projectDir;
+			this.taskPath = taskPath;
+			this.keyName = keyName;
+		}
+
+		@Override
+		public boolean equals(Object o) {
+			if (this == o)
+				return true;
+			if (o == null || getClass() != o.getClass())
+				return false;
+			InternalCacheKey that = (InternalCacheKey) o;
+			return projectDir.equals(that.projectDir) && taskPath.equals(that.taskPath) && keyName.equals(that.keyName);
+		}
+
+		@Override
+		public int hashCode() {
+			return Objects.hash(projectDir, taskPath, keyName);
+		}
+	}
+}

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

@@ -38,6 +38,7 @@
 import org.gradle.api.tasks.PathSensitivity;
 import org.gradle.work.Incremental;
 
+import com.diffplug.gradle.spotless.JvmLocalCache.CacheKey;
 import com.diffplug.spotless.FormatExceptionPolicy;
 import com.diffplug.spotless.FormatExceptionPolicyStrict;
 import com.diffplug.spotless.Formatter;
@@ -48,10 +49,12 @@ public abstract class SpotlessTask extends DefaultTask {
 	@Internal
 	abstract Property<SpotlessTaskService> getTaskService();
 
-	private void hydrateIfNull(Object o) {
-		if (o == null) {
-			getTaskService().get().hydrate(this);
-		}
+	protected <T> CacheKey<T> createCacheKey(String keyName) {
+		return createCacheKey(keyName, null);
+	}
+
+	protected <T> CacheKey<T> createCacheKey(String keyName, @Nullable T initialValue) {
+		return JvmLocalCache.createCacheKey(this, keyName, initialValue);
 	}
 
 	// set by SpotlessExtension, but possibly overridden by FormatExtension
@@ -66,16 +69,15 @@ public void setEncoding(String encoding) {
 		this.encoding = Objects.requireNonNull(encoding);
 	}
 
-	protected transient LineEnding.Policy lineEndingsPolicy;
+	protected final CacheKey<LineEnding.Policy> lineEndingsPolicy = createCacheKey("lineEndingsPolicy");
 
 	@Input
 	public LineEnding.Policy getLineEndingsPolicy() {
-		hydrateIfNull(lineEndingsPolicy);
-		return lineEndingsPolicy;
+		return lineEndingsPolicy.get();
 	}
 
 	public void setLineEndingsPolicy(LineEnding.Policy lineEndingsPolicy) {
-		this.lineEndingsPolicy = Objects.requireNonNull(lineEndingsPolicy);
+		this.lineEndingsPolicy.set(lineEndingsPolicy);
 	}
 
 	/*** API which performs git up-to-date tasks. */
@@ -90,7 +92,7 @@ public void setLineEndingsPolicy(LineEnding.Policy lineEndingsPolicy) {
 	 */
 	private transient ObjectId subtreeSha = ObjectId.zeroId();
 	/** Stored so that the configuration cache can recreate the GitRatchetGradle state. */
-	protected transient String ratchetFrom;
+	protected String ratchetFrom;
 
 	public void setupRatchet(String ratchetFrom) {
 		this.ratchetFrom = ratchetFrom;
@@ -119,7 +121,9 @@ ObjectId getRootTreeSha() {
 
 	@Input
 	public ObjectId getRatchetSha() {
-		hydrateIfNull(subtreeSha);
+		if (subtreeSha == null) {
+			setupRatchet(ratchetFrom);
+		}
 		return subtreeSha;
 	}
 
@@ -158,20 +162,19 @@ public File getOutputDirectory() {
 		return outputDirectory;
 	}
 
-	protected transient List<FormatterStep> steps = new ArrayList<>();
+	protected final CacheKey<List<FormatterStep>> steps = createCacheKey("steps", new ArrayList<FormatterStep>());
 
 	@Input
 	public List<FormatterStep> getSteps() {
-		hydrateIfNull(steps);
-		return Collections.unmodifiableList(steps);
+		return Collections.unmodifiableList(steps.get());
 	}
 
 	public void setSteps(List<FormatterStep> steps) {
-		this.steps = PluginGradlePreconditions.requireElementsNonNull(steps);
+		this.steps.set(PluginGradlePreconditions.requireElementsNonNull(steps));
 	}
 
 	public boolean addStep(FormatterStep step) {
-		return this.steps.add(Objects.requireNonNull(step));
+		return this.steps.get().add(Objects.requireNonNull(step));
 	}
 
 	/** Returns the name of this format. */
@@ -186,10 +189,10 @@ String formatName() {
 
 	Formatter buildFormatter() {
 		return Formatter.builder()
-				.lineEndingsPolicy(lineEndingsPolicy)
+				.lineEndingsPolicy(lineEndingsPolicy.get())
 				.encoding(Charset.forName(encoding))
 				.rootDir(getProjectDir().get().getAsFile().toPath())
-				.steps(steps)
+				.steps(steps.get())
 				.exceptionPolicy(exceptionPolicy)
 				.build();
 	}

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

@@ -20,8 +20,6 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.StandardCopyOption;
-import java.util.List;
-import java.util.Objects;
 
 import javax.inject.Inject;
 
@@ -37,10 +35,7 @@
 import org.gradle.work.InputChanges;
 
 import com.diffplug.common.base.StringPrinter;
-import com.diffplug.spotless.FileSignature;
 import com.diffplug.spotless.Formatter;
-import com.diffplug.spotless.FormatterStep;
-import com.diffplug.spotless.LineEnding;
 import com.diffplug.spotless.PaddedCell;
 
 @CacheableTask
@@ -69,7 +64,6 @@ public void performAction(InputChanges inputs) throws Exception {
 			Files.createDirectories(outputDirectory.toPath());
 		}
 
-		assertHydrated(this);
 		try (Formatter formatter = buildFormatter()) {
 			for (FileChange fileChange : inputs.getFileChanges(target)) {
 				File input = fileChange.getFile();
@@ -131,42 +125,4 @@ private File getOutputFile(File input) {
 		}
 		return new File(outputDirectory, outputFileName);
 	}
-
-	static boolean isHydrated(SpotlessTask task) {
-		return task.lineEndingsPolicy != null;
-	}
-
-	static void assertHydrated(SpotlessTask task) {
-		if (!isHydrated(task)) {
-			throw new GradleException("Spotless needs a workaround to support configuration cache:\n" +
-					"  (in your root build.gradle)\n" +
-					"  apply plugin: 'com.diffplug.spotless-setup\n" +
-					"  spotlessSetup { jvmLocalCache = true }\n" +
-					"To make this workaround obsolete, please upvote https://github.com/diffplug/spotless/issues/987");
-		}
-	}
-
-	static GradleException cacheIsStale() {
-		return new GradleException("Spotless JVM-local cache is stale. Regenerate the cache with\n" +
-				"  " + (FileSignature.machineIsWin() ? "rmdir /q /s" : "rm -rf") + " .gradle/configuration-cache\n" +
-				"To make this workaround obsolete, please upvote https://github.com/diffplug/spotless/issues/987");
-	}
-
-	static class LiveCache {
-		LineEnding.Policy lineEndingsPolicy;
-		List<FormatterStep> steps;
-		String ratchetFrom;
-
-		LiveCache(SpotlessTask task) {
-			lineEndingsPolicy = Objects.requireNonNull(task.lineEndingsPolicy);
-			steps = Objects.requireNonNull(task.steps);
-			ratchetFrom = Objects.requireNonNull(task.ratchetFrom);
-		}
-
-		void hydrate(SpotlessTask task) {
-			task.lineEndingsPolicy = lineEndingsPolicy;
-			task.steps = steps;
-			task.setupRatchet(ratchetFrom);
-		}
-	}
 }

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

@@ -44,46 +44,14 @@
  * apply already did).
  */
 public abstract class SpotlessTaskService implements BuildService<BuildServiceParameters.None>, AutoCloseable, OperationCompletionListener {
-	private boolean enableConfigCacheDaemonLocal;
 	private Map<String, SpotlessApply> apply = Collections.synchronizedMap(new HashMap<>());
 	private Map<String, SpotlessTask> source = Collections.synchronizedMap(new HashMap<>());
 	private Map<String, Provisioner> provisioner = Collections.synchronizedMap(new HashMap<>());
 
-	void registerDependenciesTask(RegisterDependenciesTask task) {
-		enableConfigCacheDaemonLocal = task.getJvmLocalCache();
-	}
-
 	void registerSourceAlreadyRan(SpotlessTask task) {
 		source.put(task.getPath(), task);
-		if (enableConfigCacheDaemonLocal) {
-			storeOrHydrate(task);
-		}
-	}
-
-	void hydrate(SpotlessTask task) {
-		storeOrHydrate(task);
-	}
-
-	private void storeOrHydrate(SpotlessTask task) {
-		if (!enableConfigCacheDaemonLocal) {
-			SpotlessTaskImpl.assertHydrated(task);
-			return;
-		}
-		String cacheKey = task.getProjectDir().getAsFile().get().getAbsolutePath() + ">" + task.getPath();
-		if (SpotlessTaskImpl.isHydrated(task)) {
-			daemonLocalMap.put(cacheKey, new SpotlessTaskImpl.LiveCache(task));
-		} else {
-			SpotlessTaskImpl.LiveCache cached = daemonLocalMap.get(cacheKey);
-			if (cached == null) {
-				throw SpotlessTaskImpl.cacheIsStale();
-			} else {
-				cached.hydrate(task);
-			}
-		}
 	}
 
-	private static final Map<String, SpotlessTaskImpl.LiveCache> daemonLocalMap = Collections.synchronizedMap(new HashMap<>());
-
 	Provisioner provisionerFor(Project project) {
 		return provisioner.computeIfAbsent(project.getPath(), unused -> {
 			return GradleProvisioner.newDedupingProvisioner(project);