Fix Gradle deprecation warnings

buildSrc/src/main/java/org/springframework/boot/build/MavenRepositoryPlugin.java

@@ -33,6 +33,8 @@
 import org.gradle.api.publish.PublishingExtension;
 import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
 
+import org.springframework.util.FileSystemUtils;
+
 /**
  * A plugin to make a project's {@code deployment} publication available as a Maven
  * repository. The repository can be consumed by depending upon the project using the
@@ -103,7 +105,7 @@ private CleanAction(File location) {
 
 		@Override
 		public void execute(Task task) {
-			task.getProject().delete(this.location);
+			FileSystemUtils.deleteRecursively(this.location);
 		}
 
 	}

buildSrc/src/main/java/org/springframework/boot/build/autoconfigure/AutoConfigurationMetadata.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2022 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,14 +26,23 @@
 import java.util.LinkedHashSet;
 import java.util.Properties;
 import java.util.Set;
-import java.util.concurrent.Callable;
 
 import org.gradle.api.DefaultTask;
 import org.gradle.api.Task;
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.file.RegularFile;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.tasks.InputFile;
+import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.tasks.Internal;
 import org.gradle.api.tasks.OutputFile;
+import org.gradle.api.tasks.PathSensitive;
 import org.gradle.api.tasks.PathSensitivity;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.TaskAction;
+import org.gradle.language.jvm.tasks.ProcessResources;
 
 import org.springframework.asm.ClassReader;
 import org.springframework.asm.Opcodes;
@@ -48,46 +57,64 @@
  */
 public class AutoConfigurationMetadata extends DefaultTask {
 
-	private SourceSet sourceSet;
+	private final DirectoryProperty resourcesDirectory;
 
-	private File outputFile;
+	private final String moduleName;
+
+	private final RegularFileProperty outputFile;
+
+	private FileCollection classesDirectories;
 
 	public AutoConfigurationMetadata() {
-		getInputs()
-				.file((Callable<File>) () -> new File(this.sourceSet.getOutput().getResourcesDir(),
-						"META-INF/spring.factories"))
-				.withPathSensitivity(PathSensitivity.RELATIVE).withPropertyName("spring.factories");
-		dependsOn((Callable<String>) () -> this.sourceSet.getProcessResourcesTaskName());
+		this.resourcesDirectory = getProject().getObjects().directoryProperty();
+		this.outputFile = getProject().getObjects().fileProperty();
+		this.moduleName = getProject().getName();
 		getProject().getConfigurations()
 				.maybeCreate(AutoConfigurationPlugin.AUTO_CONFIGURATION_METADATA_CONFIGURATION_NAME);
 	}
 
+	@Internal
+	public DirectoryProperty getResourcesDirectory() {
+		return this.resourcesDirectory;
+	}
+
+	@InputFile
+	@PathSensitive(PathSensitivity.RELATIVE)
+	Provider<RegularFile> getSpringFactories() {
+		return this.resourcesDirectory.map((resources) -> resources.file("META-INF/spring.factories"));
+	}
+
+	@InputFiles
+	@PathSensitive(PathSensitivity.RELATIVE)
+	FileCollection getClassesDirectories() {
+		return this.classesDirectories;
+	}
+
 	public void setSourceSet(SourceSet sourceSet) {
-		this.sourceSet = sourceSet;
+		this.resourcesDirectory.fileProvider(
+				getProject().getTasks().named(sourceSet.getProcessResourcesTaskName(), ProcessResources.class)
+						.map(ProcessResources::getDestinationDir));
+		this.classesDirectories = sourceSet.getOutput().getClassesDirs();
 	}
 
 	@OutputFile
-	public File getOutputFile() {
+	public RegularFileProperty getOutputFile() {
 		return this.outputFile;
 	}
 
-	public void setOutputFile(File outputFile) {
-		this.outputFile = outputFile;
-	}
-
 	@TaskAction
 	void documentAutoConfiguration() throws IOException {
 		Properties autoConfiguration = readAutoConfiguration();
-		getOutputFile().getParentFile().mkdirs();
-		try (FileWriter writer = new FileWriter(getOutputFile())) {
+		File outputFile = this.outputFile.get().getAsFile();
+		outputFile.getParentFile().mkdirs();
+		try (FileWriter writer = new FileWriter(outputFile)) {
 			autoConfiguration.store(writer, null);
 		}
 	}
 
 	private Properties readAutoConfiguration() throws IOException {
 		Properties autoConfiguration = CollectionFactory.createSortedProperties(true);
-		Properties springFactories = readSpringFactories(
-				new File(this.sourceSet.getOutput().getResourcesDir(), "META-INF/spring.factories"));
+		Properties springFactories = readSpringFactories(this.getSpringFactories().get().getAsFile());
 		String enableAutoConfiguration = springFactories
 				.getProperty("org.springframework.boot.autoconfigure.EnableAutoConfiguration");
 		Set<String> classNames = StringUtils.commaDelimitedListToSet(enableAutoConfiguration);
@@ -105,13 +132,13 @@ private Properties readAutoConfiguration() throws IOException {
 			}
 		}
 		autoConfiguration.setProperty("autoConfigurationClassNames", String.join(",", publicClassNames));
-		autoConfiguration.setProperty("module", getProject().getName());
+		autoConfiguration.setProperty("module", this.moduleName);
 		return autoConfiguration;
 	}
 
 	private File findClassFile(String className) {
 		String classFileName = className.replace(".", "/") + ".class";
-		for (File classesDir : this.sourceSet.getOutput().getClassesDirs()) {
+		for (File classesDir : this.classesDirectories) {
 			File classFile = new File(classesDir, classFileName);
 			if (classFile.isFile()) {
 				return classFile;

buildSrc/src/main/java/org/springframework/boot/build/autoconfigure/AutoConfigurationPlugin.java

@@ -18,7 +18,6 @@
 
 import java.io.File;
 import java.util.Collections;
-import java.util.concurrent.Callable;
 
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
@@ -39,7 +38,8 @@
  * <li>Applying the {@link ConfigurationPropertiesPlugin}.
  * <li>Adding a dependency on the auto-configuration annotation processor.
  * <li>Defining a task that produces metadata describing the auto-configuration. The
- * metadata is made available as an artifact in the
+ * metadata is made available as an artifact in the {@code autoConfigurationMetadata}
+ * configuration
  * </ul>
  *
  * @author Andy Wilkinson
@@ -66,13 +66,11 @@ public void apply(Project project) {
 					.add(project.getDependencies().project(Collections.singletonMap("path",
 							":spring-boot-project:spring-boot-tools:spring-boot-configuration-processor")));
 			project.getTasks().create("autoConfigurationMetadata", AutoConfigurationMetadata.class, (task) -> {
-				SourceSet main = project.getExtensions().getByType(JavaPluginExtension.class).getSourceSets()
-						.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
-				task.setSourceSet(main);
-				task.dependsOn(main.getClassesTaskName());
-				task.setOutputFile(new File(project.getBuildDir(), "auto-configuration-metadata.properties"));
+				task.setSourceSet(project.getExtensions().getByType(JavaPluginExtension.class).getSourceSets()
+						.getByName(SourceSet.MAIN_SOURCE_SET_NAME));
+				task.getOutputFile().set(new File(project.getBuildDir(), "auto-configuration-metadata.properties"));
 				project.getArtifacts().add(AutoConfigurationPlugin.AUTO_CONFIGURATION_METADATA_CONFIGURATION_NAME,
-						project.provider((Callable<File>) task::getOutputFile), (artifact) -> artifact.builtBy(task));
+						task.getOutputFile(), (artifact) -> artifact.builtBy(task));
 			});
 		});
 	}

buildSrc/src/main/java/org/springframework/boot/build/bom/BomPlugin.java

@@ -61,10 +61,9 @@ public void apply(Project project) {
 		createApiEnforcedConfiguration(project);
 		BomExtension bom = project.getExtensions().create("bom", BomExtension.class, project.getDependencies(),
 				project);
-		project.getTasks().create("bomrCheck", CheckBom.class, bom);
-		project.getTasks().create("bomrUpgrade", UpgradeBom.class, bom);
+		project.getTasks().register("bomrCheck", CheckBom.class, bom);
+		project.getTasks().register("bomrUpgrade", UpgradeBom.class, bom);
 		new PublishingCustomizer(project, bom).customize();
-
 	}
 
 	private void createApiEnforcedConfiguration(Project project) {

buildSrc/src/main/java/org/springframework/boot/build/bom/CheckBom.java

@@ -16,6 +16,9 @@
 
 package org.springframework.boot.build.bom;
 
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.stream.Collectors;
@@ -24,11 +27,16 @@
 
 import org.gradle.api.DefaultTask;
 import org.gradle.api.InvalidUserDataException;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.result.DependencyResult;
+import org.gradle.api.artifacts.result.ResolvedComponentResult;
+import org.gradle.api.artifacts.result.ResolvedDependencyResult;
+import org.gradle.api.provider.ListProperty;
 import org.gradle.api.tasks.TaskAction;
 
+import org.springframework.boot.build.bom.Library.Exclusion;
 import org.springframework.boot.build.bom.Library.Group;
 import org.springframework.boot.build.bom.Library.Module;
-import org.springframework.boot.build.bom.bomr.version.DependencyVersion;
 
 /**
  * Checks the validity of a bom.
@@ -37,34 +45,60 @@
  */
 public class CheckBom extends DefaultTask {
 
-	private final BomExtension bom;
+	private final ListProperty<ResolvedModule> resolvedModules;
 
 	@Inject
 	public CheckBom(BomExtension bom) {
-		this.bom = bom;
+		this.resolvedModules = getProject().getObjects().listProperty(ResolvedModule.class);
+		this.resolvedModules.set(getProject().provider(() -> {
+			List<ResolvedModule> results = new ArrayList<>();
+			for (Library library : bom.getLibraries()) {
+				for (Group group : library.getGroups()) {
+					for (Module module : group.getModules()) {
+						if (!module.getExclusions().isEmpty()) {
+							Configuration detachedConfiguration = getProject().getConfigurations()
+									.detachedConfiguration(getProject().getDependencies().create(group.getId() + ":"
+											+ module.getName() + ":" + library.getVersion().getVersion()));
+							results.add(new ResolvedModule(group.getId() + ":" + module.getName(),
+									detachedConfiguration.getIncoming().getResolutionResult().getRoot(),
+									module.getExclusions()));
+						}
+					}
+				}
+			}
+			return results;
+		}));
+
 	}
 
 	@TaskAction
 	void checkBom() {
-		for (Library library : this.bom.getLibraries()) {
-			for (Group group : library.getGroups()) {
-				for (Module module : group.getModules()) {
-					if (!module.getExclusions().isEmpty()) {
-						checkExclusions(group.getId(), module, library.getVersion().getVersion());
-					}
+		for (ResolvedModule module : this.resolvedModules.get()) {
+			checkExclusions(module);
+		}
+	}
+
+	private Set<String> dependencyIds(ResolvedComponentResult componentResult) {
+		Set<String> dependencyIds = new LinkedHashSet<>();
+		dependencyIds(componentResult, dependencyIds);
+		return dependencyIds;
+	}
+
+	private void dependencyIds(ResolvedComponentResult componentResult, Set<String> dependencyIds) {
+		String componentId = componentResult.getModuleVersion().getGroup() + ":"
+				+ componentResult.getModuleVersion().getName() + ":" + componentResult.getModuleVersion().getVersion();
+		if (dependencyIds.add(componentId)) {
+			for (DependencyResult result : componentResult.getDependencies()) {
+				if (result instanceof ResolvedDependencyResult) {
+					dependencyIds(((ResolvedDependencyResult) result).getSelected(), dependencyIds);
 				}
 			}
 		}
 	}
 
-	private void checkExclusions(String groupId, Module module, DependencyVersion version) {
-		Set<String> resolved = getProject().getConfigurations()
-				.detachedConfiguration(
-						getProject().getDependencies().create(groupId + ":" + module.getName() + ":" + version))
-				.getResolvedConfiguration().getResolvedArtifacts().stream()
-				.map((artifact) -> artifact.getModuleVersion().getId())
-				.map((id) -> id.getGroup() + ":" + id.getModule().getName()).collect(Collectors.toSet());
-		Set<String> exclusions = module.getExclusions().stream()
+	private void checkExclusions(ResolvedModule module) {
+		Set<String> resolved = dependencyIds(module.resolvedComponentResult);
+		Set<String> exclusions = module.exclusions.stream()
 				.map((exclusion) -> exclusion.getGroupId() + ":" + exclusion.getArtifactId())
 				.collect(Collectors.toSet());
 		Set<String> unused = new TreeSet<>();
@@ -83,9 +117,24 @@ private void checkExclusions(String groupId, Module module, DependencyVersion ve
 		}
 		exclusions.removeAll(resolved);
 		if (!unused.isEmpty()) {
-			throw new InvalidUserDataException(
-					"Unnecessary exclusions on " + groupId + ":" + module.getName() + ": " + exclusions);
+			throw new InvalidUserDataException("Unnecessary exclusions on " + module.id + ": " + exclusions);
 		}
 	}
 
+	private static final class ResolvedModule {
+
+		private final String id;
+
+		private final ResolvedComponentResult resolvedComponentResult;
+
+		private final List<Exclusion> exclusions;
+
+		private ResolvedModule(String id, ResolvedComponentResult resolvedComponentResult, List<Exclusion> exclusions) {
+			this.id = id;
+			this.resolvedComponentResult = resolvedComponentResult;
+			this.exclusions = exclusions;
+		}
+
+	}
+
 }

buildSrc/src/main/java/org/springframework/boot/build/bom/bomr/UpgradeBom.java

@@ -59,10 +59,14 @@
  */
 public class UpgradeBom extends DefaultTask {
 
-	private Set<String> repositoryUrls;
-
 	private final BomExtension bom;
 
+	private final Path buildFile;
+
+	private final Path gradleProperties;
+
+	private final Set<String> repositoryUrls;
+
 	private String milestone;
 
 	private String libraries;
@@ -77,6 +81,8 @@ public UpgradeBom(BomExtension bom) {
 				this.repositoryUrls.add(repositoryUrl);
 			}
 		});
+		this.buildFile = getProject().getBuildFile().toPath();
+		this.gradleProperties = new File(getProject().getRootProject().getProjectDir(), "gradle.properties").toPath();
 	}
 
 	@Option(option = "milestone", description = "Milestone to which dependency upgrade issues should be assigned")
@@ -118,9 +124,8 @@ void upgradeDependencies() {
 		List<Upgrade> upgrades = new InteractiveUpgradeResolver(new MavenMetadataVersionResolver(this.repositoryUrls),
 				this.bom.getUpgrade().getPolicy(), getServices().get(UserInputHandler.class))
 						.resolveUpgrades(matchingLibraries(this.libraries), this.bom.getLibraries());
-		Path buildFile = getProject().getBuildFile().toPath();
-		Path gradleProperties = new File(getProject().getRootProject().getProjectDir(), "gradle.properties").toPath();
-		UpgradeApplicator upgradeApplicator = new UpgradeApplicator(buildFile, gradleProperties);
+
+		UpgradeApplicator upgradeApplicator = new UpgradeApplicator(this.buildFile, this.gradleProperties);
 		for (Upgrade upgrade : upgrades) {
 			String title = "Upgrade to " + upgrade.getLibrary().getName() + " " + upgrade.getVersion();
 			Issue existingUpgradeIssue = findExistingUpgradeIssue(existingUpgradeIssues, upgrade);

buildSrc/src/main/java/org/springframework/boot/build/cli/ScoopManifest.java

@@ -28,10 +28,12 @@
  */
 public class ScoopManifest extends AbstractPackageManagerDefinitionTask {
 
+	private final String version = getProject().getVersion().toString();
+
 	@TaskAction
 	void createManifest() {
-		String version = getProject().getVersion().toString();
-		createDescriptor(Collections.singletonMap("scoopVersion", version.substring(0, version.lastIndexOf('.'))));
+		createDescriptor(
+				Collections.singletonMap("scoopVersion", this.version.substring(0, this.version.lastIndexOf('.'))));
 	}
 
 }