Dont break config avoidance for other tasks

plugin-gradle/CHANGES.md

@@ -2,6 +2,9 @@
 
 ### Version 3.25.0-SNAPSHOT - TBD ([javadoc](https://diffplug.github.io/spotless/javadoc/snapshot/), [snapshot](https://oss.sonatype.org/content/repositories/snapshots/com/diffplug/spotless/spotless-plugin-gradle/))
 
+* Spotless no longer breaks configuration avoidance for other tasks (specifically the `check` task and all of its dependees) ([#463](https://github.com/diffplug/spotless/pull/463)).
+ * Important change: **Formerly, Spotless did not create its tasks until the `afterEvaluate` phase. Spotless now creates them as soon as the plugin is applied**, and it creates the format-specific tasks as soon as the formats are defined. There is no performance degradation associated with this change, and it makes configuring Spotless easier.
+
 ### Version 3.24.3 - September 23rd 2019 ([javadoc](https://diffplug.github.io/spotless/javadoc/spotless-plugin-gradle/3.24.3/), [jcenter](https://bintray.com/diffplug/opensource/spotless-plugin-gradle/3.24.3))
 
 * Update jgit from `5.3.2.201906051522-r` to `5.5.0.201909110433-r`. ([#445](https://github.com/diffplug/spotless/pull/445))

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

@@ -26,15 +26,38 @@
 import org.gradle.api.Action;
 import org.gradle.api.GradleException;
 import org.gradle.api.Project;
+import org.gradle.api.Task;
+import org.gradle.api.execution.TaskExecutionGraph;
+import org.gradle.api.plugins.BasePlugin;
 
 import com.diffplug.common.base.Errors;
 import com.diffplug.spotless.LineEnding;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import groovy.lang.Closure;
+
 public class SpotlessExtension {
  final Project project;
+ final Task rootCheckTask, rootApplyTask;
+
+ static final String EXTENSION = "spotless";
+ static final String CHECK = "Check";
+ static final String APPLY = "Apply";
+
+ private static final String TASK_GROUP = "Verification";
+ private static final String CHECK_DESCRIPTION = "Checks that sourcecode satisfies formatting steps.";
+ private static final String APPLY_DESCRIPTION = "Applies code formatting steps to sourcecode in-place.";
+
+ private static final String FILES_PROPERTY = "spotlessFiles";
 
  public SpotlessExtension(Project project) {
  this.project = requireNonNull(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);
  }
 
  /** Line endings (if any). */
@@ -201,14 +224,66 @@ private <T extends FormatExtension> T maybeCreate(String name, Class<T> clazz) {
  } else {
  try {
  Constructor<T> constructor = clazz.getConstructor(SpotlessExtension.class);
- T newlyCreated = constructor.newInstance(this);
- formats.put(name, newlyCreated);
- return newlyCreated;
+ T formatExtension = constructor.newInstance(this);
+ formats.put(name, formatExtension);
+ createFormatTask(name, formatExtension);
+ return formatExtension;
  } catch (NoSuchMethodException e) {
  throw new GradleException("Must have a constructor " + clazz.getSimpleName() + "(SpotlessExtension root)", e);
  } catch (Exception e) {
  throw Errors.asRuntime(e);
  }
  }
  }
+
+ @SuppressWarnings("rawtypes")
+ private void createFormatTask(String name, FormatExtension formatExtension) {
+ // create the SpotlessTask
+ String taskName = EXTENSION + SpotlessPlugin.capitalize(name);
+ SpotlessTask spotlessTask = project.getTasks().create(taskName, SpotlessTask.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
+ Task checkTask = project.getTasks().create(taskName + CHECK);
+ Task applyTask = project.getTasks().create(taskName + APPLY);
+
+ checkTask.dependsOn(spotlessTask);
+ applyTask.dependsOn(spotlessTask);
+ // when the task graph is ready, we'll configure the spotlessTask appropriately
+ project.getGradle().getTaskGraph().whenReady(new Closure(null) {
+ private static final long serialVersionUID = 1L;
+
+ // called by gradle
+ @SuppressFBWarnings("UMAC_UNCALLABLE_METHOD_OF_ANONYMOUS_CLASS")
+ public Object doCall(TaskExecutionGraph graph) {
+ if (graph.hasTask(checkTask)) {
+ spotlessTask.setCheck();
+ }
+ if (graph.hasTask(applyTask)) {
+ spotlessTask.setApply();
+ }
+ return Closure.DONE;
+ }
+ });
+
+ // set the filePatterns property
+ project.afterEvaluate(unused -> {
+ String filePatterns;
+ if (project.hasProperty(FILES_PROPERTY) && project.property(FILES_PROPERTY) instanceof String) {
+ filePatterns = (String) project.property(FILES_PROPERTY);
+ } else {
+ // needs to be non-null since it is an @Input property of the task
+ filePatterns = "";
+ }
+ spotlessTask.setFilePatterns(filePatterns);
+ });
+
+ // the root tasks depend on the control tasks
+ rootCheckTask.dependsOn(checkTask);
+ rootApplyTask.dependsOn(applyTask);
+ }
 }

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

@@ -18,112 +18,45 @@
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
-import org.gradle.api.execution.TaskExecutionGraph;
 import org.gradle.api.plugins.BasePlugin;
-import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.util.GradleVersion;
 
 import com.diffplug.spotless.SpotlessCache;
 
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import groovy.lang.Closure;
-
 public class SpotlessPlugin implements Plugin<Project> {
  SpotlessExtension spotlessExtension;
 
- static final String EXTENSION = "spotless";
- static final String CHECK = "Check";
- static final String APPLY = "Apply";
-
- private static final String TASK_GROUP = "Verification";
- private static final String CHECK_DESCRIPTION = "Checks that sourcecode satisfies formatting steps.";
- private static final String APPLY_DESCRIPTION = "Applies code formatting steps to sourcecode in-place.";
- private static final String FILES_PROPERTY = "spotlessFiles";
-
  @Override
  public void apply(Project project) {
  // make sure there's a `clean` task
  project.getPlugins().apply(BasePlugin.class);
 
  // setup the extension
- spotlessExtension = project.getExtensions().create(EXTENSION, SpotlessExtension.class, project);
+ spotlessExtension = project.getExtensions().create(SpotlessExtension.EXTENSION, SpotlessExtension.class, project);
+
+ // clear spotless' cache when the user does a clean
+ Task clean = project.getTasks().getByName(BasePlugin.CLEAN_TASK_NAME);
+ clean.doLast(unused -> SpotlessCache.clear());
 
- // after the project has been evaluated, configure the check and format tasks per source set
- project.afterEvaluate(this::createTasks);
+ project.afterEvaluate(unused -> {
+ // Add our check task as a dependency on the global check task
+ // getTasks() returns a "live" collection, so this works even if the
+ // task doesn't exist at the time this call is made
+ if (spotlessExtension.enforceCheck) {
+ if (GradleVersion.current().compareTo(SpotlessPluginLegacy.CONFIG_AVOIDANCE_INTRODUCED) >= 0) {
+ SpotlessPluginConfigAvoidance.enforceCheck(spotlessExtension, project);
+ } else {
+ SpotlessPluginLegacy.enforceCheck(spotlessExtension, project);
+ }
+ }
+ });
  }
 
  /** The extension for this plugin. */
  public SpotlessExtension getExtension() {
  return spotlessExtension;
  }
 
- @SuppressWarnings("rawtypes")
- void createTasks(Project project) {
- Task rootCheckTask = project.task(EXTENSION + CHECK);
- rootCheckTask.setGroup(TASK_GROUP);
- rootCheckTask.setDescription(CHECK_DESCRIPTION);
- Task rootApplyTask = project.task(EXTENSION + APPLY);
- rootApplyTask.setGroup(TASK_GROUP);
- rootApplyTask.setDescription(APPLY_DESCRIPTION);
- String filePatterns;
- if (project.hasProperty(FILES_PROPERTY) && project.property(FILES_PROPERTY) instanceof String) {
- filePatterns = (String) project.property(FILES_PROPERTY);
- } else {
- // needs to be non-null since it is an @Input property of the task
- filePatterns = "";
- }
-
- spotlessExtension.formats.forEach((key, value) -> {
- // create the task that does the work
- String taskName = EXTENSION + capitalize(key);
- SpotlessTask spotlessTask = project.getTasks().create(taskName, SpotlessTask.class);
- value.setupTask(spotlessTask);
- spotlessTask.setFilePatterns(filePatterns);
-
- // create the check and apply control tasks
- Task checkTask = project.getTasks().create(taskName + CHECK);
- Task applyTask = project.getTasks().create(taskName + APPLY);
- // the root tasks depend on them
- rootCheckTask.dependsOn(checkTask);
- rootApplyTask.dependsOn(applyTask);
- // and they depend on the work task
- checkTask.dependsOn(spotlessTask);
- applyTask.dependsOn(spotlessTask);
-
- // when the task graph is ready, we'll configure the spotlessTask appropriately
- project.getGradle().getTaskGraph().whenReady(new Closure(null) {
- private static final long serialVersionUID = 1L;
-
- // called by gradle
- @SuppressFBWarnings("UMAC_UNCALLABLE_METHOD_OF_ANONYMOUS_CLASS")
- public Object doCall(TaskExecutionGraph graph) {
- if (graph.hasTask(checkTask)) {
- spotlessTask.setCheck();
- }
- if (graph.hasTask(applyTask)) {
- spotlessTask.setApply();
- }
- return Closure.DONE;
- }
- });
- });
-
- // Add our check task as a dependency on the global check task
- // getTasks() returns a "live" collection, so this works even if the
- // task doesn't exist at the time this call is made
- if (spotlessExtension.enforceCheck) {
- project.getTasks()
- .matching(task -> task.getName().equals(JavaBasePlugin.CHECK_TASK_NAME))
- .all(task -> task.dependsOn(rootCheckTask));
- }
-
- // clear spotless' cache when the user does a clean, but only after any spotless tasks
- Task clean = project.getTasks().getByName(BasePlugin.CLEAN_TASK_NAME);
- clean.doLast(unused -> SpotlessCache.clear());
- project.getTasks()
- .withType(SpotlessTask.class)
- .all(task -> task.mustRunAfter(clean));
- }
-
  static String capitalize(String input) {
  return Character.toUpperCase(input.charAt(0)) + input.substring(1);
  }

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2016 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 org.gradle.api.Project;
+import org.gradle.api.Task;
+import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.api.tasks.TaskProvider;
+
+class SpotlessPluginConfigAvoidance {
+ static void enforceCheck(SpotlessExtension extension, Project project) {
+ TaskProvider<Task> check = project.getTasks().named(JavaBasePlugin.CHECK_TASK_NAME);
+ check.configure(task -> task.dependsOn(extension.rootCheckTask));
+ }
+}

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2016 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 org.gradle.api.Project;
+import org.gradle.api.Task;
+import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.util.GradleVersion;
+
+class SpotlessPluginLegacy {
+ static final GradleVersion CONFIG_AVOIDANCE_INTRODUCED = GradleVersion.version("4.9");
+
+ static void enforceCheck(SpotlessExtension extension, Project project) {
+ Task check = project.getTasks().getByName(JavaBasePlugin.CHECK_TASK_NAME);
+ check.dependsOn(extension.rootCheckTask);
+ }
+}

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

@@ -169,8 +169,8 @@ public void setApply() {
  /** Returns the name of this format. */
  String formatName() {
  String name = getName();
- if (name.startsWith(SpotlessPlugin.EXTENSION)) {
- return name.substring(SpotlessPlugin.EXTENSION.length()).toLowerCase(Locale.ROOT);
+ if (name.startsWith(SpotlessExtension.EXTENSION)) {
+ return name.substring(SpotlessExtension.EXTENSION.length()).toLowerCase(Locale.ROOT);
  } else {
  return name;
  }
@@ -179,10 +179,10 @@ String formatName() {
  @TaskAction
  public void performAction(IncrementalTaskInputs inputs) throws Exception {
  if (target == null) {
- throw new GradleException("You must specify 'Iterable<File> toFormat'");
+ throw new GradleException("You must specify 'Iterable<File> target'");
  }
  if (!check && !apply) {
- throw new GradleException("Don't call " + getName() + " directly, call " + getName() + SpotlessPlugin.CHECK + " or " + getName() + SpotlessPlugin.APPLY);
+ throw new GradleException("Don't call " + getName() + " directly, call " + getName() + SpotlessExtension.CHECK + " or " + getName() + SpotlessExtension.APPLY);
  }
 
  Predicate<File> shouldInclude;

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

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2016 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.IOException;
+
+import org.assertj.core.api.Assertions;
+import org.gradle.testkit.runner.GradleRunner;
+import org.junit.Test;
+
+public class ConfigAvoidanceTest extends GradleIntegrationTest {
+ protected final GradleRunner gradleRunnerConfigAvoidance() throws IOException {
+ return gradleRunner().withGradleVersion(SpotlessPluginLegacy.CONFIG_AVOIDANCE_INTRODUCED.getVersion());
+ }
+
+ @Test
+ public void noConfigOnHelp() throws IOException {
+ setFile("build.gradle").toLines(
+ "buildscript { repositories { mavenCentral() } }",
+ "plugins {",
+ " id 'com.diffplug.gradle.spotless'",
+ "}",
+ "apply plugin: 'java'",
+ "spotless {",
+ " java {",
+ " googleJavaFormat('1.2')",
+ " }",
+ "}",
+ "",
+ "class ConfigureCanary extends DefaultTask {",
+ " ConfigureCanary() {",
+ " println('Canary was configured')",
+ " }",
+ "",
+ " @TaskAction",
+ " def action() {",
+ " println('Canary ran')",
+ " }",
+ "}",
+ "def canary = tasks.register('canary', ConfigureCanary) {}",
+ "tasks.named('check').configure {",
+ " dependsOn(canary)",
+ "}");
+ setFile("src/main/java/test.java").toResource("java/googlejavaformat/JavaCodeUnformatted.test");
+
+ String help_4_9 = gradleRunnerConfigAvoidance().withArguments("help").build().getOutput();
+ Assertions.assertThat(help_4_9).doesNotContain("Canary was configured");
+ String check_4_9 = gradleRunnerConfigAvoidance().withArguments("check").buildAndFail().getOutput();
+ Assertions.assertThat(check_4_9).contains("Canary was configured", "Canary ran", "Execution failed for task ':spotlessJava'");
+ }
+}