Improvement around dependencies/repositories extensions

subprojects/gradle-plugin-development/src/functionalTest/groovy/dev/gradleplugins/GradlePluginDevelopmentUnitTestingFunctionalTest.groovy

@@ -6,6 +6,7 @@ import dev.gradleplugins.fixtures.sources.SourceElement
 import dev.gradleplugins.fixtures.test.DefaultTestExecutionResult
 import dev.gradleplugins.integtests.fixtures.ArchiveTestFixture
 import org.gradle.api.internal.artifacts.dependencies.SelfResolvingDependencyInternal
+import org.gradle.util.GradleVersion
 import org.hamcrest.CoreMatchers
 
 abstract class AbstractGradlePluginDevelopmentUnitTestingFunctionalTest extends AbstractGradlePluginDevelopmentFunctionalSpec implements ArchiveTestFixture {
@@ -85,10 +86,15 @@ abstract class AbstractGradlePluginDevelopmentUnitTestingFunctionalTest extends
             }
 
             import static ${GradleRuntimeCompatibility.canonicalName}.groovyVersionOf
+            import ${GradleVersion.canonicalName}
 
             test {
                 dependencies {
-                    implementation platform('org.spockframework:spock-bom:2.0-groovy-3.0')
+                    if (GradleVersion.current() > GradleVersion.version('6.5')) {
+                        implementation platform('org.spockframework:spock-bom:2.0-groovy-3.0')
+                    } else {
+                        implementation platform('org.spockframework:spock-bom:2.0-groovy-2.5')
+                    }
                     implementation 'org.spockframework:spock-core'
                 }
 

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

@@ -0,0 +1,30 @@
+package dev.gradleplugins;
+
+import org.gradle.api.Action;
+import org.gradle.api.Named;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.artifacts.ExternalModuleDependency;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.provider.Provider;
+
+public interface GradlePluginDevelopmentDependencyBucket extends Named {
+    void add(Dependency dependency);
+
+    <DependencyType extends Dependency> void add(DependencyType dependency, Action<? super DependencyType> configureAction);
+
+    <DependencyType extends Dependency> void add(Provider<DependencyType> dependencyProvider);
+
+    <DependencyType extends Dependency> void add(Provider<DependencyType> dependencyProvider, Action<? super DependencyType> configureAction);
+
+    void add(FileCollection fileCollection);
+
+    void add(Project project);
+
+    void add(CharSequence dependencyNotation);
+
+    void add(CharSequence dependencyNotation, Action<? super ExternalModuleDependency> configureAction);
+
+    Provider<Configuration> getAsConfiguration();
+}

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

@@ -49,6 +49,6 @@ public interface GradlePluginDevelopmentDependencyExtension {
      */
     static GradlePluginDevelopmentDependencyExtension from(DependencyHandler dependencies) {
         Objects.requireNonNull(dependencies);
-        return new DefaultGradlePluginDevelopmentDependencyExtension(dependencies);
+        return dependencies.getExtensions().getByType(GradlePluginDevelopmentDependencyExtension.class);
     }
 }

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

@@ -3,6 +3,7 @@
 import org.gradle.api.Action;
 import org.gradle.api.artifacts.dsl.RepositoryHandler;
 import org.gradle.api.artifacts.repositories.MavenArtifactRepository;
+import org.gradle.api.plugins.ExtensionAware;
 
 /**
  * Extension methods for {@link RepositoryHandler}.
@@ -34,6 +35,6 @@ public interface GradlePluginDevelopmentRepositoryExtension {
      * @return the extension methods, never null
      */
     static GradlePluginDevelopmentRepositoryExtension from(RepositoryHandler repositories) {
-        return new DefaultGradlePluginDevelopmentRepositoryExtension(repositories);
+        return ((ExtensionAware) repositories).getExtensions().getByType(GradlePluginDevelopmentRepositoryExtension.class);
     }
 }

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

@@ -0,0 +1,119 @@
+package dev.gradleplugins.internal;
+
+import dev.gradleplugins.GradlePluginDevelopmentDependencyBucket;
+import dev.gradleplugins.internal.util.FilterTransformer;
+import dev.gradleplugins.internal.util.PeekTransformer;
+import org.apache.commons.lang3.StringUtils;
+import org.gradle.api.Action;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.artifacts.ExternalModuleDependency;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.tasks.SourceSet;
+
+import java.util.Collections;
+
+public final class DependencyBucketFactory {
+    private final Project project;
+    private final Provider<SourceSet> sourceSetProvider;
+
+    public DependencyBucketFactory(Project project, Provider<SourceSet> sourceSetProvider) {
+        this.project = project;
+        this.sourceSetProvider = sourceSetProvider;
+    }
+
+    public GradlePluginDevelopmentDependencyBucket create(String bucketName) {
+        return new DefaultDependencyBucket(bucketName);
+    }
+
+    public final class DefaultDependencyBucket implements GradlePluginDevelopmentDependencyBucket {
+        private final String dependencyBucketName;
+        private final DependencyFactory dependencyFactory;
+        private final Provider<Configuration> configurationProvider;
+        private final Provider<String> configurationNameProvider;
+
+        public DefaultDependencyBucket(String dependencyBucketName) {
+            this.dependencyBucketName = dependencyBucketName;
+            this.dependencyFactory = DependencyFactory.forProject(project);
+            this.configurationNameProvider = sourceSetProvider.map(sourceSet -> {
+                final String sourceSetName = sourceSet.getName();
+                if (sourceSet.getName().equals("main")) {
+                    return dependencyBucketName;
+                } else {
+                    return sourceSetName + StringUtils.capitalize(dependencyBucketName);
+                }
+            });
+            this.configurationProvider = configurationNameProvider.map(project.getConfigurations()::getByName);
+        }
+
+        @Override
+        public String getName() {
+            return dependencyBucketName;
+        }
+
+        @SuppressWarnings("unchecked")
+        private <T> Provider<? extends Iterable<T>> asCollectionProvider(Provider<? extends Iterable<? extends T>> provider) {
+            return (Provider<? extends Iterable<T>>) project.getObjects().listProperty(Object.class).value(provider);
+        }
+
+        private /*static*/ <T> Provider<? extends Iterable<T>> asList(Provider<T> provider) {
+            return provider.map(Collections::singletonList).orElse(Collections.emptyList());
+        }
+
+        private Provider<String> ifThisBucket(Configuration configuration) {
+            return configurationNameProvider.map(new FilterTransformer<>(it -> it.equals(configuration.getName())));
+        }
+
+        @Override
+        public void add(Dependency dependency) {
+            project.getConfigurations().configureEach(it -> {
+                it.getDependencies().addAllLater(asCollectionProvider(asList(ifThisBucket(it).map(__ -> dependency))));
+            });
+        }
+
+        @Override
+        public <DependencyType extends Dependency> void add(DependencyType dependency, Action<? super DependencyType> configureAction) {
+            configureAction.execute(dependency);
+            add(dependency);
+        }
+
+        @Override
+        public <DependencyType extends Dependency> void add(Provider<DependencyType> dependencyProvider) {
+            project.getConfigurations().configureEach(it -> {
+                it.getDependencies().addAllLater(asCollectionProvider(asList(ifThisBucket(it).flatMap(__ -> dependencyProvider))));
+            });
+        }
+
+        @Override
+        public <DependencyType extends Dependency> void add(Provider<DependencyType> dependencyProvider, Action<? super DependencyType> configureAction) {
+            add(dependencyProvider.map(new PeekTransformer<>(configureAction)));
+        }
+
+        @Override
+        public void add(FileCollection fileCollection) {
+            add(dependencyFactory.create(fileCollection));
+        }
+
+        @Override
+        public void add(Project project) {
+            add(dependencyFactory.create(project));
+        }
+
+        @Override
+        public void add(CharSequence dependencyNotation) {
+            add(dependencyFactory.create(dependencyNotation));
+        }
+
+        @Override
+        public void add(CharSequence dependencyNotation, Action<? super ExternalModuleDependency> configureAction) {
+            add(dependencyFactory.create(dependencyNotation), configureAction);
+        }
+
+        @Override
+        public Provider<Configuration> getAsConfiguration() {
+            return configurationProvider;
+        }
+    }
+}