Apply unused io.spring.javaformat plugin

buildSrc/build.gradle

@@ -1,13 +1,19 @@
 plugins {
 	id 'java-gradle-plugin'
 	id 'checkstyle'
+	id 'io.spring.javaformat' version "${javaFormatVersion}"
 }
 
 repositories {
 	mavenCentral()
 	gradlePluginPortal()
 }
 
+tasks.named('compileJava') {
+	dependsOn 'format'
+	mustRunAfter 'format'
+}
+
 ext {
 	def propertiesFile = new File(new File("$projectDir").parentFile, "gradle.properties")
 	propertiesFile.withInputStream {
@@ -64,4 +70,4 @@ test {
 	useJUnitPlatform()
 }
 
-jar.dependsOn check
+jar.dependsOn check

buildSrc/gradle.properties

@@ -1,4 +1,4 @@
 org.gradle.caching=true
 assertjVersion=3.27.3
-javaFormatVersion=0.0.43
+javaFormatVersion=0.0.47
 junitVersion=5.12.2

buildSrc/src/main/java/org/springframework/build/CheckstyleConventions.java

@@ -53,18 +53,21 @@ public void apply(Project project) {
 			checkstyle.setToolVersion("10.25.0");
 			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
 			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
-			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();
-			checkstyleDependencies.add(
-					project.getDependencies().create("io.spring.javaformat:spring-javaformat-checkstyle:" + version));
+			DependencySet checkstyleDependencies = project.getConfigurations()
+				.getByName("checkstyle")
+				.getDependencies();
+			checkstyleDependencies
+				.add(project.getDependencies().create("io.spring.javaformat:spring-javaformat-checkstyle:" + version));
 		});
 	}
 
 	private static void configureNoHttpPlugin(Project project) {
 		project.getPlugins().apply(NoHttpPlugin.class);
 		NoHttpExtension noHttp = project.getExtensions().getByType(NoHttpExtension.class);
 		noHttp.setAllowlistFile(project.file("src/nohttp/allowlist.lines"));
-		noHttp.getSource().exclude("**/test-output/**", "**/.settings/**", "**/.classpath",
-				"**/.project", "**/.gradle/**", "**/node_modules/**", "**/spring-jcl/**", "buildSrc/build/**");
+		noHttp.getSource()
+			.exclude("**/test-output/**", "**/.settings/**", "**/.classpath", "**/.project", "**/.gradle/**",
+					"**/node_modules/**", "**/spring-jcl/**", "buildSrc/build/**");
 		List<String> buildFolders = List.of("bin", "build", "out");
 		project.allprojects(subproject -> {
 			Path rootPath = project.getRootDir().toPath();

buildSrc/src/main/java/org/springframework/build/ConventionsPlugin.java

@@ -27,11 +27,12 @@
  * Plugin to apply conventions to projects that are part of Spring Framework's build.
  * Conventions are applied in response to various plugins being applied.
  *
- * <p>When the {@link JavaBasePlugin} is applied, the conventions in {@link CheckstyleConventions},
- * {@link TestConventions} and {@link JavaConventions} are applied.
- * The {@link ArchitecturePlugin} plugin is also applied.
- * When the {@link KotlinBasePlugin} is applied, the conventions in {@link KotlinConventions}
- * are applied.
+ * <p>
+ * When the {@link JavaBasePlugin} is applied, the conventions in
+ * {@link CheckstyleConventions}, {@link TestConventions} and {@link JavaConventions} are
+ * applied. The {@link ArchitecturePlugin} plugin is also applied. When the
+ * {@link KotlinBasePlugin} is applied, the conventions in {@link KotlinConventions} are
+ * applied.
  *
  * @author Brian Clozel
  */

buildSrc/src/main/java/org/springframework/build/JavaConventions.java

@@ -42,30 +42,26 @@ public class JavaConventions {
 
 	/**
 	 * The Java version we should use as the JVM baseline for building the project.
-	 * <p>NOTE: If you update this value, you should also update the value used in
-	 * the {@code javadoc} task in {@code framework-api.gradle}.
+	 * <p>
+	 * NOTE: If you update this value, you should also update the value used in the
+	 * {@code javadoc} task in {@code framework-api.gradle}.
 	 */
 	private static final JavaLanguageVersion DEFAULT_LANGUAGE_VERSION = JavaLanguageVersion.of(24);
 
 	/**
-	 * The Java version we should use as the baseline for the compiled bytecode
-	 * (the "-release" compiler argument).
+	 * The Java version we should use as the baseline for the compiled bytecode (the
+	 * "-release" compiler argument).
 	 */
 	private static final JavaLanguageVersion DEFAULT_RELEASE_VERSION = JavaLanguageVersion.of(17);
 
 	static {
-		List<String> commonCompilerArgs = List.of(
-				"-Xlint:serial", "-Xlint:cast", "-Xlint:classfile", "-Xlint:dep-ann",
-				"-Xlint:divzero", "-Xlint:empty", "-Xlint:finally", "-Xlint:overrides",
-				"-Xlint:path", "-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options",
-				"-parameters"
-		);
+		List<String> commonCompilerArgs = List.of("-Xlint:serial", "-Xlint:cast", "-Xlint:classfile", "-Xlint:dep-ann",
+				"-Xlint:divzero", "-Xlint:empty", "-Xlint:finally", "-Xlint:overrides", "-Xlint:path",
+				"-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options", "-parameters");
 		COMPILER_ARGS = new ArrayList<>();
 		COMPILER_ARGS.addAll(commonCompilerArgs);
-		COMPILER_ARGS.addAll(List.of(
-				"-Xlint:varargs", "-Xlint:fallthrough", "-Xlint:rawtypes", "-Xlint:deprecation",
-				"-Xlint:unchecked", "-Werror"
-		));
+		COMPILER_ARGS.addAll(List.of("-Xlint:varargs", "-Xlint:fallthrough", "-Xlint:rawtypes", "-Xlint:deprecation",
+				"-Xlint:unchecked", "-Werror"));
 		TEST_COMPILER_ARGS = new ArrayList<>();
 		TEST_COMPILER_ARGS.addAll(commonCompilerArgs);
 		TEST_COMPILER_ARGS.addAll(List.of("-Xlint:-varargs", "-Xlint:-fallthrough", "-Xlint:-rawtypes",
@@ -96,21 +92,23 @@ private static void applyToolchainConventions(Project project) {
 	 */
 	private void applyJavaCompileConventions(Project project) {
 		project.afterEvaluate(p -> {
-			p.getTasks().withType(JavaCompile.class)
-					.matching(compileTask -> compileTask.getName().startsWith(JavaPlugin.COMPILE_JAVA_TASK_NAME))
-					.forEach(compileTask -> {
-						compileTask.getOptions().setCompilerArgs(COMPILER_ARGS);
-						compileTask.getOptions().setEncoding("UTF-8");
-						setJavaRelease(compileTask);
-					});
-			p.getTasks().withType(JavaCompile.class)
-					.matching(compileTask -> compileTask.getName().startsWith(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME)
-							|| compileTask.getName().equals("compileTestFixturesJava"))
-					.forEach(compileTask -> {
-						compileTask.getOptions().setCompilerArgs(TEST_COMPILER_ARGS);
-						compileTask.getOptions().setEncoding("UTF-8");
-						setJavaRelease(compileTask);
-					});
+			p.getTasks()
+				.withType(JavaCompile.class)
+				.matching(compileTask -> compileTask.getName().startsWith(JavaPlugin.COMPILE_JAVA_TASK_NAME))
+				.forEach(compileTask -> {
+					compileTask.getOptions().setCompilerArgs(COMPILER_ARGS);
+					compileTask.getOptions().setEncoding("UTF-8");
+					setJavaRelease(compileTask);
+				});
+			p.getTasks()
+				.withType(JavaCompile.class)
+				.matching(compileTask -> compileTask.getName().startsWith(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME)
+						|| compileTask.getName().equals("compileTestFixturesJava"))
+				.forEach(compileTask -> {
+					compileTask.getOptions().setCompilerArgs(TEST_COMPILER_ARGS);
+					compileTask.getOptions().setEncoding("UTF-8");
+					setJavaRelease(compileTask);
+				});
 
 		});
 	}
@@ -123,7 +121,7 @@ private void setJavaRelease(JavaCompile task) {
 		int defaultVersion = DEFAULT_RELEASE_VERSION.asInt();
 		int releaseVersion = defaultVersion;
 		int compilerVersion = task.getJavaCompiler().get().getMetadata().getLanguageVersion().asInt();
-		for (int version = defaultVersion ; version <= compilerVersion ; version++) {
+		for (int version = defaultVersion; version <= compilerVersion; version++) {
 			if (task.getName().contains("Java" + version)) {
 				releaseVersion = version;
 				break;

buildSrc/src/main/java/org/springframework/build/KotlinConventions.java

@@ -28,8 +28,9 @@
 public class KotlinConventions {
 
 	void apply(Project project) {
-		project.getPlugins().withId("org.jetbrains.kotlin.jvm",
-				(plugin) -> project.getTasks().withType(KotlinCompile.class, this::configure));
+		project.getPlugins()
+			.withId("org.jetbrains.kotlin.jvm",
+					(plugin) -> project.getTasks().withType(KotlinCompile.class, this::configure));
 	}
 
 	private void configure(KotlinCompile compile) {
@@ -39,11 +40,14 @@ private void configure(KotlinCompile compile) {
 			options.getJvmTarget().set(JvmTarget.JVM_17);
 			options.getJavaParameters().set(true);
 			options.getAllWarningsAsErrors().set(true);
-			options.getFreeCompilerArgs().addAll(
-					"-Xsuppress-version-warnings",
-					"-Xjsr305=strict", // For dependencies using JSR 305
-					"-opt-in=kotlin.RequiresOptIn",
-					"-Xjdk-release=17" // Needed due to https://youtrack.jetbrains.com/issue/KT-49746
+			options.getFreeCompilerArgs()
+				.addAll("-Xsuppress-version-warnings", "-Xjsr305=strict", // For
+																			// dependencies
+																			// using JSR
+																			// 305
+						"-opt-in=kotlin.RequiresOptIn", "-Xjdk-release=17" // Needed due
+																			// to
+																			// https://youtrack.jetbrains.com/issue/KT-49746
 			);
 		});
 	}

buildSrc/src/main/java/org/springframework/build/SpringFrameworkExtension.java

@@ -31,10 +31,13 @@ public class SpringFrameworkExtension {
 
 	public SpringFrameworkExtension(Project project) {
 		this.enableJavaPreviewFeatures = project.getObjects().property(Boolean.class);
-		project.getTasks().withType(JavaCompile.class).configureEach(javaCompile ->
-				javaCompile.getOptions().getCompilerArgumentProviders().add(asArgumentProvider()));
-		project.getTasks().withType(Test.class).configureEach(test ->
-				test.getJvmArgumentProviders().add(asArgumentProvider()));
+		project.getTasks()
+			.withType(JavaCompile.class)
+			.configureEach(
+					javaCompile -> javaCompile.getOptions().getCompilerArgumentProviders().add(asArgumentProvider()));
+		project.getTasks()
+			.withType(Test.class)
+			.configureEach(test -> test.getJvmArgumentProviders().add(asArgumentProvider()));
 
 	}
 
@@ -50,4 +53,5 @@ private CommandLineArgumentProvider asArgumentProvider() {
 			return Collections.emptyList();
 		};
 	}
+
 }

buildSrc/src/main/java/org/springframework/build/TestConventions.java

@@ -30,8 +30,8 @@
  * Conventions that are applied in the presence of the {@link JavaBasePlugin}. When the
  * plugin is applied:
  * <ul>
- * <li>The {@link TestRetryPlugin Test Retry} plugin is applied so that flaky tests
- * are retried 3 times when running on the CI server.
+ * <li>The {@link TestRetryPlugin Test Retry} plugin is applied so that flaky tests are
+ * retried 3 times when running on the CI server.
  * </ul>
  *
  * @author Brian Clozel
@@ -45,11 +45,10 @@ void apply(Project project) {
 	}
 
 	private void configureTestConventions(Project project) {
-		project.getTasks().withType(Test.class,
-				test -> {
-					configureTests(project, test);
-					configureTestRetryPlugin(project, test);
-				});
+		project.getTasks().withType(Test.class, test -> {
+			configureTests(project, test);
+			configureTestRetryPlugin(project, test);
+		});
 	}
 
 	private void configureTests(Project project, Test test) {
@@ -60,18 +59,12 @@ private void configureTests(Project project, Test test) {
 			}
 		});
 		test.include("**/*Tests.class", "**/*Test.class");
-		test.setSystemProperties(Map.of(
-				"java.awt.headless", "true",
-				"io.netty.leakDetection.level", "paranoid"
-		));
+		test.setSystemProperties(Map.of("java.awt.headless", "true", "io.netty.leakDetection.level", "paranoid"));
 		if (project.hasProperty("testGroups")) {
 			test.systemProperty("testGroups", project.getProperties().get("testGroups"));
 		}
-		test.jvmArgs(
-				"--add-opens=java.base/java.lang=ALL-UNNAMED",
-				"--add-opens=java.base/java.util=ALL-UNNAMED",
-				"-Xshare:off"
-		);
+		test.jvmArgs("--add-opens=java.base/java.lang=ALL-UNNAMED", "--add-opens=java.base/java.util=ALL-UNNAMED",
+				"-Xshare:off");
 	}
 
 	private void configureTestRetryPlugin(Project project, Test test) {

buildSrc/src/main/java/org/springframework/build/architecture/ArchitectureCheck.java

@@ -64,10 +64,8 @@ public abstract class ArchitectureCheck extends DefaultTask {
 	public ArchitectureCheck() {
 		getOutputDirectory().convention(getProject().getLayout().getBuildDirectory().dir(getName()));
 		getProhibitObjectsRequireNonNull().convention(true);
-		getRules().addAll(packageInfoShouldBeNullMarked(),
-				classesShouldNotImportForbiddenTypes(),
-				javaClassesShouldNotImportKotlinAnnotations(),
-				allPackagesShouldBeFreeOfTangles(),
+		getRules().addAll(packageInfoShouldBeNullMarked(), classesShouldNotImportForbiddenTypes(),
+				javaClassesShouldNotImportKotlinAnnotations(), allPackagesShouldBeFreeOfTangles(),
 				noClassesShouldCallStringToLowerCaseWithoutLocale(),
 				noClassesShouldCallStringToUpperCaseWithoutLocale());
 		getRuleDescriptions().set(getRules().map((rules) -> rules.stream().map(ArchRule::getDescription).toList()));
@@ -76,12 +74,12 @@ public ArchitectureCheck() {
 	@TaskAction
 	void checkArchitecture() throws IOException {
 		JavaClasses javaClasses = new ClassFileImporter()
-				.importPaths(this.classes.getFiles().stream().map(File::toPath).toList());
+			.importPaths(this.classes.getFiles().stream().map(File::toPath).toList());
 		List<EvaluationResult> violations = getRules().get()
-				.stream()
-				.map((rule) -> rule.evaluate(javaClasses))
-				.filter(EvaluationResult::hasViolation)
-				.toList();
+			.stream()
+			.map((rule) -> rule.evaluate(javaClasses))
+			.filter(EvaluationResult::hasViolation)
+			.toList();
 		File outputFile = getOutputDirectory().file("failure-report.txt").get().getAsFile();
 		outputFile.getParentFile().mkdirs();
 		if (!violations.isEmpty()) {
@@ -134,4 +132,5 @@ final FileTree getInputClasses() {
 	// The rules themselves can't be an input as they aren't serializable so we use
 	// their descriptions instead
 	abstract ListProperty<String> getRuleDescriptions();
+
 }

buildSrc/src/main/java/org/springframework/build/architecture/ArchitecturePlugin.java

@@ -48,15 +48,14 @@ private void registerTasks(Project project) {
 				continue;
 			}
 			TaskProvider<ArchitectureCheck> checkArchitecture = project.getTasks()
-					.register(taskName(sourceSet), ArchitectureCheck.class,
-							(task) -> {
-								task.setClasses(sourceSet.getOutput().getClassesDirs());
-								task.getResourcesDirectory().set(sourceSet.getOutput().getResourcesDir());
-								task.dependsOn(sourceSet.getProcessResourcesTaskName());
-								task.setDescription("Checks the architecture of the classes of the " + sourceSet.getName()
-										+ " source set.");
-								task.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
-							});
+				.register(taskName(sourceSet), ArchitectureCheck.class, (task) -> {
+					task.setClasses(sourceSet.getOutput().getClassesDirs());
+					task.getResourcesDirectory().set(sourceSet.getOutput().getResourcesDir());
+					task.dependsOn(sourceSet.getProcessResourcesTaskName());
+					task.setDescription(
+							"Checks the architecture of the classes of the " + sourceSet.getName() + " source set.");
+					task.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
+				});
 			architectureChecks.add(checkArchitecture);
 		}
 		if (!architectureChecks.isEmpty()) {
@@ -66,8 +65,7 @@ private void registerTasks(Project project) {
 	}
 
 	private static String taskName(SourceSet sourceSet) {
-		return "checkArchitecture"
-				+ sourceSet.getName().substring(0, 1).toUpperCase()
+		return "checkArchitecture" + sourceSet.getName().substring(0, 1).toUpperCase()
 				+ sourceSet.getName().substring(1);
 	}