Copy-paste the legacy implementations into the modern implementations, so that we don't have to reimplement all at once.

Author: nedtwigg

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

@@ -16,15 +16,77 @@
 package com.diffplug.gradle.spotless;
 
 import org.gradle.api.Project;
+import org.gradle.api.Task;
+import org.gradle.api.plugins.BasePlugin;
+import org.gradle.api.plugins.JavaBasePlugin;
 
 public class SpotlessExtensionModern extends SpotlessExtensionBase {
 	public SpotlessExtensionModern(Project project) {
 		super(project);
+		rootCheckTask = project.task(EXTENSION + CHECK);
+		rootCheckTask.setGroup(TASK_GROUP);
+		rootCheckTask.setDescription(CHECK_DESCRIPTION);
+		rootApplyTask = project.task(EXTENSION + APPLY);
+		rootApplyTask.setGroup(TASK_GROUP);
+		rootApplyTask.setDescription(APPLY_DESCRIPTION);
+		rootDiagnoseTask = project.task(EXTENSION + DIAGNOSE);
+		rootDiagnoseTask.setGroup(TASK_GROUP);	// no description on purpose
+
+		project.afterEvaluate(unused -> {
+			if (enforceCheck) {
+				project.getTasks().named(JavaBasePlugin.CHECK_TASK_NAME)
+						.configure(task -> task.dependsOn(rootCheckTask));
+			}
+		});
 	}
 
+	final Task rootCheckTask, rootApplyTask, rootDiagnoseTask;
+
 	@Override
 	protected void createFormatTasks(String name, FormatExtension formatExtension) {
 		// TODO level 1: implement SpotlessExtension::createFormatTasks, but using config avoidance
 		// TODO level 2: override configure(String name, Class<T> clazz, Action<T> configure) so that it is lazy
+
+		// create the SpotlessTask
+		String taskName = EXTENSION + SpotlessPlugin.capitalize(name);
+		SpotlessTaskModern spotlessTask = project.getTasks().create(taskName, SpotlessTaskModern.class);
+		project.afterEvaluate(unused -> formatExtension.setupTask(spotlessTask));
+
+		// clean removes the SpotlessCache, so we have to run after clean
+		Task clean = project.getTasks().getByName(BasePlugin.CLEAN_TASK_NAME);
+		spotlessTask.mustRunAfter(clean);
+
+		// create the check and apply control tasks
+		SpotlessCheck checkTask = project.getTasks().create(taskName + CHECK, SpotlessCheck.class);
+		checkTask.setSpotlessOutDirectory(spotlessTask.getOutputDirectory());
+		checkTask.source = spotlessTask;
+		checkTask.dependsOn(spotlessTask);
+
+		SpotlessApply applyTask = project.getTasks().create(taskName + APPLY, SpotlessApply.class);
+		applyTask.setSpotlessOutDirectory(spotlessTask.getOutputDirectory());
+		applyTask.linkSource(spotlessTask);
+		applyTask.dependsOn(spotlessTask);
+
+		// if the user runs both, make sure that apply happens first,
+		checkTask.mustRunAfter(applyTask);
+
+		// the root tasks depend on the control tasks
+		rootCheckTask.dependsOn(checkTask);
+		rootApplyTask.dependsOn(applyTask);
+
+		// create the diagnose task
+		SpotlessDiagnoseTask diagnoseTask = project.getTasks().create(taskName + DIAGNOSE, SpotlessDiagnoseTask.class);
+		diagnoseTask.source = spotlessTask;
+		rootDiagnoseTask.dependsOn(diagnoseTask);
+		diagnoseTask.mustRunAfter(clean);
+
+		if (project.hasProperty(IdeHook.PROPERTY)) {
+			// disable the normal tasks, to disable their up-to-date checking
+			spotlessTask.setEnabled(false);
+			checkTask.setEnabled(false);
+			applyTask.setEnabled(false);
+			// the rootApplyTask is no longer just a marker task, now it does a bit of work itself
+			rootApplyTask.doLast(unused -> IdeHook.performHook(spotlessTask));
+		}
 	}
 }

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

@@ -15,13 +15,80 @@
  */
 package com.diffplug.gradle.spotless;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import org.gradle.api.GradleException;
 import org.gradle.api.tasks.CacheableTask;
 import org.gradle.api.tasks.TaskAction;
+import org.gradle.api.tasks.incremental.IncrementalTaskInputs;
+
+import com.diffplug.common.base.Errors;
+import com.diffplug.common.base.Preconditions;
+import com.diffplug.common.base.Throwing;
+import com.diffplug.spotless.Formatter;
 
 @CacheableTask
 public class SpotlessTaskModern extends SpotlessTask {
 	@TaskAction
-	public void performAction() throws Exception {
+	public void performAction(IncrementalTaskInputs inputs) throws Exception {
 		// TODO: implement using the InputChanges api
+
+		if (target == null) {
+			throw new GradleException("You must specify 'Iterable<File> target'");
+		}
+
+		if (!inputs.isIncremental()) {
+			getLogger().info("Not incremental: removing prior outputs");
+			getProject().delete(outputDirectory);
+			Files.createDirectories(outputDirectory.toPath());
+		}
+
+		Throwing.Specific.Predicate<File, IOException> shouldInclude;
+		if (this.filePatterns.isEmpty()) {
+			shouldInclude = file -> true;
+		} else {
+			Preconditions.checkArgument(ratchet == null,
+					"Cannot use 'ratchetFrom' and '-PspotlessFiles' at the same time");
+
+			// a list of files has been passed in via project property
+			final String[] includePatterns = this.filePatterns.split(",");
+			final List<Pattern> compiledIncludePatterns = Arrays.stream(includePatterns)
+					.map(Pattern::compile)
+					.collect(Collectors.toList());
+			shouldInclude = file -> compiledIncludePatterns
+					.stream()
+					.anyMatch(filePattern -> filePattern.matcher(file.getAbsolutePath())
+							.matches());
+		}
+
+		try (Formatter formatter = buildFormatter()) {
+			inputs.outOfDate(inputDetails -> {
+				File input = inputDetails.getFile();
+				try {
+					if (shouldInclude.test(input) && input.isFile()) {
+						processInputFile(formatter, input);
+					}
+				} catch (IOException e) {
+					throw Errors.asRuntime(e);
+				}
+			});
+		}
+
+		inputs.removed(removedDetails -> {
+			File input = removedDetails.getFile();
+			try {
+				if (shouldInclude.test(input)) {
+					deletePreviousResult(input);
+				}
+			} catch (IOException e) {
+				throw Errors.asRuntime(e);
+			}
+		});
 	}
 }