Delombok the plugin codebase

Signed-off-by: Daniel Lacasse <[email protected]>

subprojects/gradle-plugin-development/build.gradle

@@ -130,8 +130,6 @@ functionalTest {
 }
 
 dependencies {
-    compileOnly "org.projectlombok:lombok:${lombokVersion}"
-    annotationProcessor "org.projectlombok:lombok:${lombokVersion}"
     implementation 'org.apache.commons:commons-lang3:3.5'
     implementation 'com.google.code.gson:gson:2.8.6'
     compileOnly "org.jetbrains.kotlin:kotlin-stdlib-jdk8"

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/DefaultGradlePluginDevelopmentTestSuiteFactory.java

@@ -4,7 +4,6 @@
 import dev.gradleplugins.internal.FinalizableComponent;
 import dev.gradleplugins.internal.GradlePluginDevelopmentTestSuiteInternal;
 import dev.gradleplugins.internal.ReleasedVersionDistributions;
-import lombok.val;
 import org.gradle.api.Project;
 import org.gradle.api.Transformer;
 import org.gradle.api.internal.provider.Providers;
@@ -30,7 +29,7 @@ final class DefaultGradlePluginDevelopmentTestSuiteFactory implements GradlePlug
 
     @Override
     public GradlePluginDevelopmentTestSuite create(String name) {
-        val result = project.getObjects().newInstance(GradlePluginDevelopmentTestSuiteInternal.class, name, project, minimumGradleVersion(project), gradleDistributions());
+        final GradlePluginDevelopmentTestSuiteInternal result = project.getObjects().newInstance(GradlePluginDevelopmentTestSuiteInternal.class, name, project, minimumGradleVersion(project), gradleDistributions());
         // Register as finalized action because it adds configuration which early finalize source set property
         result.whenFinalized(new ConfigurePluginUnderTestMetadataTask(project));
         result.getSourceSet().convention(project.provider(() -> {

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/internal/ConfigurePluginUnderTestMetadataTask.java

@@ -1,11 +1,11 @@
 package dev.gradleplugins.internal;
 
 import dev.gradleplugins.GradlePluginDevelopmentTestSuite;
-import lombok.val;
 import org.gradle.api.Action;
 import org.gradle.api.NamedDomainObjectProvider;
 import org.gradle.api.Project;
 import org.gradle.api.Transformer;
+import org.gradle.api.artifacts.ArtifactView;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.tasks.ClasspathNormalizer;
 import org.gradle.api.tasks.SourceSet;
@@ -55,8 +55,8 @@ private static void ignorePluginUnderTestMetadataFile(Project project) {
 
     private static Transformer<Object, SourceSet> asPluginClasspath(Project project) {
         return sourceSet -> {
-            val runtimeClasspath = project.getConfigurations().getByName(sourceSet.getRuntimeClasspathConfigurationName());
-            val view = runtimeClasspath.getIncoming().artifactView(config -> {
+            final Configuration runtimeClasspath = project.getConfigurations().getByName(sourceSet.getRuntimeClasspathConfigurationName());
+            final ArtifactView view = runtimeClasspath.getIncoming().artifactView(config -> {
                 config.componentFilter(componentId -> {
                     if (componentId instanceof OpaqueComponentIdentifier) {
                         return !componentId.getDisplayName().equals(ClassPathNotation.GRADLE_API.displayName)

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/internal/DeferredRepositoryFactory.java

@@ -2,7 +2,6 @@
 
 import dev.gradleplugins.GroovyGradlePluginDevelopmentExtension;
 import dev.gradleplugins.JavaGradlePluginDevelopmentExtension;
-import lombok.val;
 import org.gradle.api.Action;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.dsl.RepositoryHandler;
@@ -39,11 +38,11 @@ public void spock() {
 
     private static void mutateRepositories(Project project, Action<? super RepositoryHandler> action) {
         // NOTE: We work around the existence (or not) of the extension because Nokee repository is naughty and use GroovySpockFrameworkTestSuite via SpockFrameworkTestSuiteBasePlugin
-        val extension = ((ExtensionAware) project.getExtensions().findByType(GradlePluginDevelopmentExtension.class));
+        final ExtensionAware extension = (ExtensionAware) project.getExtensions().findByType(GradlePluginDevelopmentExtension.class);
         if (extension == null) {
             action.execute(project.getRepositories());
         } else {
-            val defaultRepositoriesDisabled = ((GradlePluginDevelopmentExtensionInternal) Optional.<Object>ofNullable(extension.getExtensions().findByType(JavaGradlePluginDevelopmentExtension.class)).orElseGet(() -> extension.getExtensions().findByType(GroovyGradlePluginDevelopmentExtension.class))).isDefaultRepositoriesDisabled();
+            final boolean defaultRepositoriesDisabled = ((GradlePluginDevelopmentExtensionInternal) Optional.<Object>ofNullable(extension.getExtensions().findByType(JavaGradlePluginDevelopmentExtension.class)).orElseGet(() -> extension.getExtensions().findByType(GroovyGradlePluginDevelopmentExtension.class))).isDefaultRepositoriesDisabled();
             if (!defaultRepositoriesDisabled) {
                 action.execute(project.getRepositories());
             }

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/internal/GradlePluginDevelopmentTestSuiteInternal.java

@@ -6,7 +6,6 @@
 import dev.gradleplugins.GradlePluginTestingStrategyFactory;
 import dev.gradleplugins.GradleRuntimeCompatibility;
 import dev.gradleplugins.TaskView;
-import lombok.Getter;
 import org.apache.commons.lang3.StringUtils;
 import org.gradle.api.Action;
 import org.gradle.api.NamedDomainObjectProvider;
@@ -48,7 +47,7 @@ public abstract class GradlePluginDevelopmentTestSuiteInternal implements Gradle
     private final GradlePluginTestingStrategyFactory strategyFactory;
     private final Dependencies dependencies;
     private final String name;
-    @Getter private final List<Action<? super Test>> testTaskActions = new ArrayList<>();
+    private final List<Action<? super Test>> testTaskActions = new ArrayList<>();
     private final List<Action<? super GradlePluginDevelopmentTestSuite>> finalizeActions = new ArrayList<>();
     private final TestTaskView testTasks;
     private final TaskProvider<PluginUnderTestMetadata> pluginUnderTestMetadataTask;
@@ -71,6 +70,10 @@ public GradlePluginDevelopmentTestSuiteInternal(String name, Project project, Ta
         getTestingStrategies().finalizeValueOnRead();
     }
 
+    public List<Action<? super Test>> getTestTaskActions() {
+        return testTaskActions;
+    }
+
     // From Gradle codebase
     private static final class GUtil {
         private static final Pattern UPPER_LOWER = Pattern.compile("(?m)([A-Z]*)([a-z0-9]*)");

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/internal/GradlePluginTestingStrategyFactoryInternal.java

@@ -4,20 +4,28 @@
 import dev.gradleplugins.GradlePluginTestingStrategy;
 import dev.gradleplugins.GradlePluginTestingStrategyFactory;
 import dev.gradleplugins.GradleVersionCoverageTestingStrategy;
-import lombok.EqualsAndHashCode;
-import lombok.val;
 import org.apache.commons.lang3.StringUtils;
 import org.gradle.api.provider.Provider;
 import org.gradle.util.VersionNumber;
 
-import java.util.*;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
-import static dev.gradleplugins.internal.GradlePluginTestingStrategyInternal.*;
+import static dev.gradleplugins.internal.GradlePluginTestingStrategyInternal.LATEST_GLOBAL_AVAILABLE;
+import static dev.gradleplugins.internal.GradlePluginTestingStrategyInternal.LATEST_NIGHTLY;
+import static dev.gradleplugins.internal.GradlePluginTestingStrategyInternal.MINIMUM_GRADLE;
 import static dev.gradleplugins.internal.ReleasedVersionDistributions.GRADLE_DISTRIBUTIONS;
 
 public final class GradlePluginTestingStrategyFactoryInternal implements GradlePluginTestingStrategyFactory {
@@ -36,7 +44,7 @@ public GradlePluginTestingStrategyFactoryInternal(Provider<String> minimumVersio
     @Override
     public GradleVersionCoverageTestingStrategy getCoverageForMinimumVersion() {
         return new DefaultGradleVersionCoverageTestingStrategy(MINIMUM_GRADLE, () -> minimumVersion.get(), () -> {
-            val result = minimumVersion.get();
+            final String result = minimumVersion.get();
             assertKnownMinimumVersion(result);
             return result;
         });
@@ -51,9 +59,8 @@ public GradleVersionCoverageTestingStrategy getCoverageForLatestNightlyVersion()
     public Provider<Set<GradleVersionCoverageTestingStrategy>> getCoverageForLatestGlobalAvailableVersionOfEachSupportedMajorVersions() {
         return minimumVersion.map(version -> {
             assertKnownMinimumVersion(version);
-            val minimumMajorVersion = VersionNumber.parse(version).getMajor();
-            val h = releasedVersions.getAllVersions().stream().filter(it -> !it.isSnapshot() && !it.getVersion().contains("-rc-")).map(it -> VersionNumber.parse(it.getVersion())).filter(it -> it.getMajor() >= minimumMajorVersion).collect(
-            Collectors.groupingBy(it -> it.getMajor()));
+            final int minimumMajorVersion = VersionNumber.parse(version).getMajor();
+            final Map<Integer, List<VersionNumber>> h = releasedVersions.getAllVersions().stream().filter(it -> !it.isSnapshot() && !it.getVersion().contains("-rc-")).map(it -> VersionNumber.parse(it.getVersion())).filter(it -> it.getMajor() >= minimumMajorVersion).collect(Collectors.groupingBy(it -> it.getMajor()));
             return h.entrySet().stream().sorted(Map.Entry.comparingByKey()).map(Map.Entry::getValue).map(it -> {
                 it.sort(Comparator.reverseOrder());
                 return coverageForGradleVersion(format(it.iterator().next()));
@@ -62,7 +69,7 @@ public Provider<Set<GradleVersionCoverageTestingStrategy>> getCoverageForLatestG
     }
 
     private static String format(VersionNumber version) {
-        val builder = new StringBuilder();
+        final StringBuilder builder = new StringBuilder();
         builder.append(version.getMajor()).append(".").append(version.getMinor());
         if (version.getMicro() > 0) {
             builder.append(".").append(version.getMicro());
@@ -185,10 +192,9 @@ public String toString() {
         }
     }
 
-    @EqualsAndHashCode
     private static final class DefaultCompositeGradlePluginTestingStrategy implements CompositeGradlePluginTestingStrategy {
         private final Iterable<GradlePluginTestingStrategy> strategies;
-        @EqualsAndHashCode.Exclude private final String name;
+        private final String name;
 
         private DefaultCompositeGradlePluginTestingStrategy(Iterable<GradlePluginTestingStrategy> strategies) {
             this.strategies = strategies;
@@ -207,6 +213,21 @@ public String getName() {
             return name;
         }
 
+        @Override
+        public boolean equals(Object o) {
+            if (this == o)
+                return true;
+            if (o == null || getClass() != o.getClass())
+                return false;
+            DefaultCompositeGradlePluginTestingStrategy that = (DefaultCompositeGradlePluginTestingStrategy) o;
+            return Objects.equals(strategies, that.strategies);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(strategies);
+        }
+
         @Override
         public String toString() {
             return "strategy composed of <" + StreamSupport.stream(strategies.spliterator(), false).map(Object::toString).collect(Collectors.joining(", ")) + ">";

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/internal/RegisterTestingStrategyPropertyExtensionRule.java

@@ -1,9 +1,7 @@
 package dev.gradleplugins.internal;
 
 import dev.gradleplugins.GradlePluginTestingStrategy;
-import lombok.val;
 import org.gradle.api.Action;
-import org.gradle.api.invocation.Gradle;
 import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.provider.Property;
 import org.gradle.api.reflect.TypeOf;
@@ -21,7 +19,7 @@ public RegisterTestingStrategyPropertyExtensionRule(ObjectFactory objects) {
 
     @Override
     public void execute(Test task) {
-        val testingStrategy = objects.property(GradlePluginTestingStrategy.class);
+        final Property<GradlePluginTestingStrategy> testingStrategy = objects.property(GradlePluginTestingStrategy.class);
         task.getExtensions().add(TESTING_STRATEGY_PROPERTY_TYPE, TESTING_STRATEGY_EXTENSION_NAME, testingStrategy);
     }
 

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/internal/ReleasedVersionDistributions.java

@@ -2,14 +2,14 @@
 
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
-import lombok.Value;
 import org.gradle.api.resources.TextResourceFactory;
 
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.net.URL;
 import java.util.List;
+import java.util.Objects;
 
 public class ReleasedVersionDistributions {
     public static final ReleasedVersionDistributions GRADLE_DISTRIBUTIONS = new ReleasedVersionDistributions();
@@ -63,12 +63,49 @@ public List<GradleRelease> getAllVersions() {
         return allVersions;
     }
 
-    @Value
-    public static class GradleRelease {
-        String version;
-        boolean snapshot;
-        boolean current;
-        String rcFor;
+    public static final class GradleRelease {
+        private final String version;
+        private final boolean snapshot;
+        private final boolean current;
+        private final String rcFor;
+
+        public GradleRelease(String version, boolean snapshot, boolean current, String rcFor) {
+            this.version = version;
+            this.snapshot = snapshot;
+            this.current = current;
+            this.rcFor = rcFor;
+        }
+
+        public String getVersion() {
+            return version;
+        }
+
+        public boolean isSnapshot() {
+            return snapshot;
+        }
+
+        public boolean isCurrent() {
+            return current;
+        }
+
+        public String getRcFor() {
+            return rcFor;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o)
+                return true;
+            if (o == null || getClass() != o.getClass())
+                return false;
+            GradleRelease that = (GradleRelease) o;
+            return snapshot == that.snapshot && current == that.current && Objects.equals(version, that.version) && Objects.equals(rcFor, that.rcFor);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(version, snapshot, current, rcFor);
+        }
     }
 
     private static final class HostedGradleVersionsService implements GradleVersionsService {

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/internal/plugins/DefaultGradlePluginDevelopmentTestingExtension.java

@@ -4,7 +4,6 @@
 import dev.gradleplugins.GradlePluginDevelopmentTestSuiteFactory;
 import dev.gradleplugins.GradlePluginDevelopmentTestingExtension;
 import dev.gradleplugins.internal.GradlePluginDevelopmentTestSuiteInternal;
-import lombok.val;
 import org.gradle.api.component.SoftwareComponentContainer;
 import org.gradle.api.reflect.HasPublicType;
 import org.gradle.api.reflect.TypeOf;
@@ -23,7 +22,7 @@ public DefaultGradlePluginDevelopmentTestingExtension(GradlePluginDevelopmentTes
 
     @Override
     public GradlePluginDevelopmentTestSuite registerSuite(String name) {
-        val result = factory.create(name);
+        final GradlePluginDevelopmentTestSuite result = factory.create(name);
         components.add((GradlePluginDevelopmentTestSuiteInternal) result);
         return result;
     }

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/internal/plugins/GradlePluginDevelopmentPlugin.java

@@ -1,6 +1,5 @@
 package dev.gradleplugins.internal.plugins;
 
-import lombok.RequiredArgsConstructor;
 import org.gradle.BuildAdapter;
 import org.gradle.BuildResult;
 import org.gradle.api.Plugin;
@@ -145,10 +144,13 @@ private interface GradleFailureVisitor {
         void visitCause(Throwable cause);
     }
 
-    @RequiredArgsConstructor
     private static class UnwrappingGradleFailureVisitor implements GradleFailureVisitor {
         private final GradleFailureVisitor delegate;
 
+        public UnwrappingGradleFailureVisitor(GradleFailureVisitor delegate) {
+            this.delegate = delegate;
+        }
+
         @Override
         public void visitCause(Throwable cause) {
             while (cause != null) {
@@ -163,10 +165,13 @@ public void visitCause(Throwable cause) {
         }
     }
 
-    @RequiredArgsConstructor
     private static class MultiGradleFailureVisitor implements GradleFailureVisitor {
         private final List<GradleFailureVisitor> delegates;
 
+        public MultiGradleFailureVisitor(List<GradleFailureVisitor> delegates) {
+            this.delegates = delegates;
+        }
+
         @Override
         public void visitCause(Throwable cause) {
             for (GradleFailureVisitor delegate : delegates) {

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/internal/plugins/GradlePluginDevelopmentTestSuiteRegistrationAction.java

@@ -2,7 +2,6 @@
 
 import dev.gradleplugins.GradlePluginDevelopmentTestSuite;
 import dev.gradleplugins.GradlePluginDevelopmentTestSuiteFactory;
-import lombok.val;
 import org.gradle.api.Action;
 import org.gradle.api.Project;
 import org.gradle.api.component.SoftwareComponent;

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/internal/plugins/GroovyGradlePluginDevelopmentPlugin.java

@@ -16,14 +16,16 @@
 
 package dev.gradleplugins.internal.plugins;
 
+import dev.gradleplugins.GradlePluginDevelopmentCompatibilityExtension;
 import dev.gradleplugins.GradleRuntimeCompatibility;
 import dev.gradleplugins.GroovyGradlePluginDevelopmentExtension;
 import dev.gradleplugins.internal.DeferredRepositoryFactory;
 import dev.gradleplugins.internal.DependencyBucketFactory;
 import dev.gradleplugins.internal.DependencyFactory;
-import lombok.val;
+import dev.gradleplugins.internal.GradlePluginDevelopmentExtensionInternal;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
+import org.gradle.api.provider.Provider;
 import org.gradle.util.GradleVersion;
 
 import static dev.gradleplugins.GradlePluginDevelopmentCompatibilityExtension.compatibility;
@@ -52,8 +54,8 @@ public void apply(Project project) {
         }
         project.getPluginManager().apply("groovy");
 
-        val groovy = registerLanguageExtension(project, "groovy", GroovyGradlePluginDevelopmentExtension.class);
-        val extension = project.provider(() -> compatibility(gradlePlugin(project)));
+        final GradlePluginDevelopmentExtensionInternal groovy = registerLanguageExtension(project, "groovy", GroovyGradlePluginDevelopmentExtension.class);
+        final Provider<GradlePluginDevelopmentCompatibilityExtension> extension = project.provider(() -> compatibility(gradlePlugin(project)));
 
         // Configure the Groovy version and dependency
         groovy.getGroovyVersion().convention(extension.flatMap(it -> it.getMinimumGradleVersion().map(GradleRuntimeCompatibility::groovyVersionOf)));

subprojects/gradle-plugin-development/src/main/java/dev/gradleplugins/internal/plugins/RegisterTestingExtensionOnGradleDevelExtensionRule.java

@@ -1,7 +1,6 @@
 package dev.gradleplugins.internal.plugins;
 
 import dev.gradleplugins.GradlePluginDevelopmentTestSuiteFactory;
-import lombok.val;
 import org.gradle.api.Action;
 import org.gradle.api.Project;
 import org.gradle.api.plugins.AppliedPlugin;
@@ -17,7 +16,7 @@ final class RegisterTestingExtensionOnGradleDevelExtensionRule implements Action
 
     @Override
     public void execute(AppliedPlugin ignored) {
-        val gradlePluginExtension = project.getExtensions().getByType(GradlePluginDevelopmentExtension.class);
+        final GradlePluginDevelopmentExtension gradlePluginExtension = project.getExtensions().getByType(GradlePluginDevelopmentExtension.class);
         ((ExtensionAware) gradlePluginExtension).getExtensions().add("testing", project.getObjects().newInstance(DefaultGradlePluginDevelopmentTestingExtension.class, GradlePluginDevelopmentTestSuiteFactory.forProject(project)));
     }
 }