Improve configuration-cache support

fixes #384
freefair · Feb 15, 2022 · 6aec34a · 6aec34a
1 parent f9a7113
commit 6aec34a
Show file tree

Hide file tree

Showing 15 changed files with 161 additions and 56 deletions.
diff --git a/aspectj-plugin/src/main/java/io/freefair/gradle/plugins/aspectj/AjcAction.java b/aspectj-plugin/src/main/java/io/freefair/gradle/plugins/aspectj/AjcAction.java
@@ -8,6 +8,7 @@
 import org.gradle.api.NonNullApi;
 import org.gradle.api.Task;
 import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.file.ProjectLayout;
 import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.provider.Property;
 import org.gradle.api.tasks.ClasspathNormalizer;
@@ -26,6 +27,11 @@
 @NonNullApi
 public class AjcAction implements Action<Task> {
 
+    @Getter(AccessLevel.NONE)
+    private final ProjectLayout projectLayout;
+    @Getter(AccessLevel.NONE)
+    private final JavaExecHandleFactory javaExecHandleFactory;
+
     private final ConfigurableFileCollection classpath;
 
     private final Property<Boolean> enabled;
@@ -38,11 +44,9 @@ public void options(Action<AspectJCompileOptions> action) {
         action.execute(getOptions());
     }
 
-    @Getter(AccessLevel.NONE)
-    private final JavaExecHandleFactory javaExecHandleFactory;
-
     @Inject
-    public AjcAction(ObjectFactory objectFactory, JavaExecHandleFactory javaExecHandleFactory) {
+    public AjcAction(ProjectLayout projectLayout, ObjectFactory objectFactory, JavaExecHandleFactory javaExecHandleFactory) {
+        this.projectLayout = projectLayout;
         options = new AspectJCompileOptions(objectFactory);
         classpath = objectFactory.fileCollection();
         additionalInpath = objectFactory.fileCollection();
@@ -93,7 +97,7 @@ private AspectJCompileSpec createSpec(AbstractCompile compile) {
         AspectJCompileSpec spec = new AspectJCompileSpec();
 
         spec.setDestinationDir(compile.getDestinationDirectory().get().getAsFile());
-        spec.setWorkingDir(compile.getProject().getProjectDir());
+        spec.setWorkingDir(projectLayout.getProjectDirectory().getAsFile());
         spec.setTempDir(compile.getTemporaryDir());
         spec.setCompileClasspath(new ArrayList<>(compile.getClasspath().filter(File::exists).getFiles()));
         spec.setTargetCompatibility(compile.getTargetCompatibility());

diff --git a/aspectj-plugin/src/main/java/io/freefair/gradle/plugins/aspectj/AspectjCompile.java b/aspectj-plugin/src/main/java/io/freefair/gradle/plugins/aspectj/AspectjCompile.java
@@ -2,22 +2,27 @@
 
 import io.freefair.gradle.plugins.aspectj.internal.AspectJCompileSpec;
 import io.freefair.gradle.plugins.aspectj.internal.AspectJCompiler;
+import lombok.AccessLevel;
 import lombok.Getter;
 import org.gradle.api.Action;
-import org.gradle.api.file.ConfigurableFileCollection;
-import org.gradle.api.file.FileCollection;
-import org.gradle.api.file.FileTree;
+import org.gradle.api.file.*;
 import org.gradle.api.tasks.*;
 import org.gradle.api.tasks.compile.AbstractCompile;
 import org.gradle.api.tasks.compile.CompileOptions;
 import org.gradle.process.internal.JavaExecHandleFactory;
 
+import javax.inject.Inject;
 import java.util.ArrayList;
 
 @Getter
 @CacheableTask
 public class AspectjCompile extends AbstractCompile {
 
+    @Getter(AccessLevel.NONE)
+    private final FileSystemOperations fileSystemOperations;
+    @Getter(AccessLevel.NONE)
+    private final ProjectLayout projectLayout;
+
     @Classpath
     private final ConfigurableFileCollection aspectjClasspath = getProject().getObjects().fileCollection();
 
@@ -27,6 +32,12 @@ public class AspectjCompile extends AbstractCompile {
     @Nested
     private final AspectJCompileOptions ajcOptions = getProject().getObjects().newInstance(AspectJCompileOptions.class);
 
+    @Inject
+    public AspectjCompile(FileSystemOperations fileSystemOperations, ProjectLayout projectLayout) {
+        this.fileSystemOperations = fileSystemOperations;
+        this.projectLayout = projectLayout;
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -46,7 +57,7 @@ public FileCollection getClasspath() {
 
     @TaskAction
     protected void compile() {
-        getProject().delete(getDestinationDirectory());
+        fileSystemOperations.delete(spec -> spec.delete(getDestinationDirectory()).setFollowSymlinks(false));
 
         AspectJCompileSpec spec = createSpec();
         WorkResult result = getCompiler().execute(spec);
@@ -61,7 +72,7 @@ private AspectJCompileSpec createSpec() {
         AspectJCompileSpec spec = new AspectJCompileSpec();
         spec.setSourceFiles(getSource());
         spec.setDestinationDir(getDestinationDirectory().getAsFile().get());
-        spec.setWorkingDir(getProject().getProjectDir());
+        spec.setWorkingDir(projectLayout.getProjectDirectory().getAsFile());
         spec.setTempDir(getTemporaryDir());
         spec.setCompileClasspath(new ArrayList<>(getClasspath().getFiles()));
         spec.setSourceCompatibility(getSourceCompatibility());

diff --git a/...erator-plugin/src/main/java/io/freefair/gradle/plugin/codegenerator/GenerateCodeTask.java b/...erator-plugin/src/main/java/io/freefair/gradle/plugin/codegenerator/GenerateCodeTask.java
@@ -7,14 +7,12 @@
 import io.github.classgraph.ClassInfo;
 import io.github.classgraph.ClassInfoList;
 import io.github.classgraph.ScanResult;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import lombok.Setter;
-import lombok.SneakyThrows;
+import lombok.*;
 import lombok.extern.slf4j.Slf4j;
 import org.gradle.api.DefaultTask;
 import org.gradle.api.file.ConfigurableFileCollection;
 import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.file.ProjectLayout;
 import org.gradle.api.provider.MapProperty;
 import org.gradle.api.provider.Property;
 import org.gradle.api.tasks.*;
@@ -28,7 +26,9 @@
 @Setter
 public class GenerateCodeTask extends DefaultTask {
 
-    @Internal
+    @Getter(AccessLevel.NONE)
+    private final ProjectLayout projectLayout;
+    @Getter(AccessLevel.NONE)
     private final WorkerExecutor workerExecutor;
 
     @InputDirectory
@@ -50,7 +50,8 @@ public class GenerateCodeTask extends DefaultTask {
     private final ConfigurableFileCollection codeGeneratorClasspath = getProject().files();
 
     @Inject
-    public GenerateCodeTask(WorkerExecutor workerExecutor) {
+    public GenerateCodeTask(ProjectLayout projectLayout, WorkerExecutor workerExecutor) {
+        this.projectLayout = projectLayout;
         this.workerExecutor = workerExecutor;
     }
 
@@ -72,7 +73,7 @@ public void generate() {
             getLogger().debug(classesImplementing.stream().map(ClassInfo::getName).collect(Collectors.joining(",")));
         }
 
-        ProjectContext context = new ProjectContext(getProject().getProjectDir(), inputDir.getAsFile().getOrElse(this.getTemporaryDir()), outputDir.getAsFile().get(), configurationValues.getOrElse(Collections.emptyMap()), sourceSet.getOrElse("none"));
+        ProjectContext context = new ProjectContext(projectLayout.getProjectDirectory().getAsFile(), inputDir.getAsFile().getOrElse(this.getTemporaryDir()), outputDir.getAsFile().get(), configurationValues.getOrElse(Collections.emptyMap()), sourceSet.getOrElse("none"));
 
         WorkQueue workQueue = workerExecutor.classLoaderIsolation(spec -> spec.getClasspath().from(codeGeneratorClasspath));
 

diff --git a/jsass-plugin/src/main/java/io/freefair/gradle/plugins/jsass/PrepareWebjars.java b/jsass-plugin/src/main/java/io/freefair/gradle/plugins/jsass/PrepareWebjars.java
@@ -1,36 +1,47 @@
 package io.freefair.gradle.plugins.jsass;
 
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.Setter;
 import org.gradle.api.DefaultTask;
-import org.gradle.api.file.ConfigurableFileCollection;
-import org.gradle.api.file.DirectoryProperty;
-import org.gradle.api.file.DuplicatesStrategy;
+import org.gradle.api.file.*;
 import org.gradle.api.tasks.*;
 
+import javax.inject.Inject;
 import java.io.File;
 
 @Getter
 @Setter
 @Deprecated
 public class PrepareWebjars extends DefaultTask {
 
+    @Getter(AccessLevel.NONE)
+    private final FileSystemOperations fileSystemOperations;
+    @Getter(AccessLevel.NONE)
+    private final ArchiveOperations archiveOperations;
+
     @OutputDirectory
     private final DirectoryProperty outputDirectory = getProject().getObjects().directoryProperty();
 
     @InputFiles
     @PathSensitive(PathSensitivity.NAME_ONLY)
     private final ConfigurableFileCollection webjars = getProject().files();
 
+    @Inject
+    public PrepareWebjars(FileSystemOperations fileSystemOperations, ArchiveOperations archiveOperations) {
+        this.fileSystemOperations = fileSystemOperations;
+        this.archiveOperations = archiveOperations;
+    }
+
     @TaskAction
     public void extractWebjars() {
-        getProject().sync(sync -> {
+        fileSystemOperations.sync(sync -> {
             sync.into(outputDirectory);
 
             sync.setDuplicatesStrategy(DuplicatesStrategy.WARN);
 
             webjars.filter(File::isFile).getFiles().forEach(file ->
-                    sync.from(getProject().zipTree(file), jarSpec -> {
+                    sync.from(archiveOperations.zipTree(file), jarSpec -> {
                         jarSpec.include("META-INF/resources/webjars/**");
                         jarSpec.setIncludeEmptyDirs(false);
                         jarSpec.eachFile(fcd -> fcd.setPath(fcd.getPath().replaceFirst("META-INF/resources/webjars/(.*?)/(.*?)/", "$1/")));

diff --git a/lombok-plugin/src/main/java/io/freefair/gradle/plugins/lombok/tasks/Delombok.java b/lombok-plugin/src/main/java/io/freefair/gradle/plugins/lombok/tasks/Delombok.java
@@ -1,17 +1,20 @@
 package io.freefair.gradle.plugins.lombok.tasks;
 
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.Setter;
 import org.gradle.api.DefaultTask;
 import org.gradle.api.file.ConfigurableFileCollection;
 import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.file.FileSystemOperations;
 import org.gradle.api.file.FileTree;
 import org.gradle.api.internal.file.FileTreeInternal;
 import org.gradle.api.internal.file.UnionFileTree;
 import org.gradle.api.provider.Property;
 import org.gradle.api.tasks.*;
-import org.gradle.util.GUtil;
+import org.gradle.process.ExecOperations;
 
+import javax.inject.Inject;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
@@ -26,6 +29,11 @@
 @CacheableTask
 public class Delombok extends DefaultTask implements LombokTask {
 
+    @Getter(AccessLevel.NONE)
+    private final FileSystemOperations fileSystemOperations;
+    @Getter(AccessLevel.NONE)
+    private final ExecOperations execOperations;
+
     /**
      * Print the name of each file as it is being delombok-ed.
      */
@@ -111,6 +119,12 @@ public class Delombok extends DefaultTask implements LombokTask {
     @Internal
     private final ConfigurableFileCollection input = getProject().files();
 
+    @Inject
+    public Delombok(FileSystemOperations fileSystemOperations, ExecOperations execOperations) {
+        this.fileSystemOperations = fileSystemOperations;
+        this.execOperations = execOperations;
+    }
+
     @InputFiles
     @PathSensitive(PathSensitivity.RELATIVE)
     @SkipWhenEmpty
@@ -127,7 +141,7 @@ protected FileTree getFilteredInput() {
 
     @TaskAction
     public void delombok() throws IOException {
-        getProject().delete(getTarget().getAsFile().get());
+        fileSystemOperations.delete(spec -> spec.delete(getTarget()).setFollowSymlinks(false));
 
         List<String> args = new LinkedList<>();
 
@@ -175,7 +189,7 @@ public void delombok() throws IOException {
 
         Files.write(optionsFile.toPath(), args);
 
-        getProject().javaexec(delombok -> {
+        execOperations.javaexec(delombok -> {
             delombok.setClasspath(getLombokClasspath());
             delombok.getMainClass().set("lombok.launch.Main");
             delombok.args("delombok");

diff --git a/lombok-plugin/src/main/java/io/freefair/gradle/plugins/lombok/tasks/LombokApiJar.java b/lombok-plugin/src/main/java/io/freefair/gradle/plugins/lombok/tasks/LombokApiJar.java
@@ -1,10 +1,14 @@
 package io.freefair.gradle.plugins.lombok.tasks;
 
+import lombok.AccessLevel;
 import lombok.Getter;
 import org.gradle.api.NonNullApi;
+import org.gradle.api.file.FileSystemOperations;
+import org.gradle.api.internal.ProcessOperations;
 import org.gradle.api.tasks.CacheableTask;
 import org.gradle.api.tasks.TaskAction;
 
+import javax.inject.Inject;
 import java.io.File;
 
 /**
@@ -19,16 +23,24 @@
 @CacheableTask
 public class LombokApiJar extends LombokJarTask {
 
-    public LombokApiJar() {
+    @Getter(AccessLevel.NONE)
+    private final FileSystemOperations fileSystemOperations;
+    @Getter(AccessLevel.NONE)
+    private final ProcessOperations processOperations;
+
+    @Inject
+    public LombokApiJar(FileSystemOperations fileSystemOperations, ProcessOperations processOperations) {
+        this.fileSystemOperations = fileSystemOperations;
+        this.processOperations = processOperations;
         getArchiveAppendix().convention("api");
     }
 
     @TaskAction
     public void copy() {
-        getProject().delete(getArchiveFile());
+        fileSystemOperations.delete(spec -> spec.delete(getArchiveFile()).setFollowSymlinks(false));
 
         File destinationDir = getDestinationDirectory().getAsFile().get();
-        getProject().javaexec(apiJar -> {
+        processOperations.javaexec(apiJar -> {
             apiJar.setClasspath(getLombokClasspath());
             apiJar.getMainClass().set("lombok.launch.Main");
             apiJar.args("publicApi", destinationDir.getAbsolutePath());

diff --git a/lombok-plugin/src/main/java/io/freefair/gradle/plugins/lombok/tasks/LombokConfig.java b/lombok-plugin/src/main/java/io/freefair/gradle/plugins/lombok/tasks/LombokConfig.java
@@ -1,14 +1,18 @@
 package io.freefair.gradle.plugins.lombok.tasks;
 
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.Setter;
 import org.gradle.api.DefaultTask;
 import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.file.FileSystemOperations;
 import org.gradle.api.file.RegularFileProperty;
 import org.gradle.api.provider.ListProperty;
 import org.gradle.api.provider.Property;
 import org.gradle.api.tasks.*;
+import org.gradle.process.ExecOperations;
 
+import javax.inject.Inject;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
@@ -22,6 +26,11 @@
 @UntrackedTask(because = "lombok config bubbling traverses the file system")
 public class LombokConfig extends DefaultTask implements LombokTask {
 
+    @Getter(AccessLevel.NONE)
+    private final FileSystemOperations fileSystemOperations;
+    @Getter(AccessLevel.NONE)
+    private final ExecOperations execOperations;
+
     @Classpath
     private final ConfigurableFileCollection lombokClasspath = getProject().files();
 
@@ -60,14 +69,16 @@ public class LombokConfig extends DefaultTask implements LombokTask {
     @OutputFile
     private final RegularFileProperty outputFile = getProject().getObjects().fileProperty();
 
-    public LombokConfig() {
+    @Inject
+    public LombokConfig(FileSystemOperations fileSystemOperations, ExecOperations execOperations) {
+        this.fileSystemOperations = fileSystemOperations;
+        this.execOperations = execOperations;
         getOutputs().upToDateWhen(t -> ((LombokConfig) t).getPaths().isEmpty());
     }
 
     @TaskAction
     public void exec() throws IOException {
-
-        getProject().delete(outputFile);
+        fileSystemOperations.delete(spec -> spec.delete(outputFile).setFollowSymlinks(false));
 
         List<File> actualPaths = paths.getFiles()
                 .stream()
@@ -81,7 +92,7 @@ public void exec() throws IOException {
 
         try (OutputStream out = new FileOutputStream(outputFile.getAsFile().get())) {
 
-            getProject().javaexec(config -> {
+            execOperations.javaexec(config -> {
                 config.setClasspath(getLombokClasspath());
                 config.getMainClass().set("lombok.launch.Main");
                 config.args("config");