Apply the configuration filter for 'resolve-all-dependencies'

Previously, excluded configurations would be excluded from the graph, but they
would still be resolved. By avoiding resolution altogether, we allow users to
exclude any unresolvable dependency configurations.

Fixes #126

plugin-test/src/test/groovy/org/gradle/github/dependencygraph/ConfigurationFilterDependencyExtractorTest.groovy

@@ -284,4 +284,43 @@ class ConfigurationFilterDependencyExtractorTest extends BaseExtractorTest {
  ])
  }
 
+ def "does not attempt to resolve excluded configurations"() {
+ given:
+ settingsFile << "include 'a', 'b'"
+
+ buildFile << """
+ project(':a') {
+ apply plugin: 'java-library'
+ dependencies {
+ api 'org.test:foo:1.0'
+ }
+ configurations.all {
+ incoming.beforeResolve {
+ throw new RuntimeException("Should not resolve project :a")
+ }
+ }
+ }
+ project(':b') {
+ apply plugin: 'java-library'
+ dependencies {
+ api 'org.test:bar:1.0'
+ testImplementation 'org.test:baz:1.0'
+ }
+ configurations.testCompileClasspath {
+ incoming.beforeResolve {
+ throw new RuntimeException("Should not resolve configuration 'testCompileClasspath'")
+ }
+ }
+ }
+ """
+
+ when:
+ executer.withArgument("-DDEPENDENCY_GRAPH_EXCLUDE_PROJECTS=:a")
+ executer.withArgument("-DDEPENDENCY_GRAPH_EXCLUDE_CONFIGURATIONS=test(Compile|Runtime)Classpath")
+ run()
+
+ then:
+ gitHubManifest().assertResolved(["org.test:bar:1.0"])
+ }
+
 }

plugin/src/main/kotlin/org/gradle/forceresolve/ForceDependencyResolutionPlugin.kt

@@ -5,6 +5,8 @@ import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.invocation.Gradle
 import org.gradle.api.tasks.TaskProvider
+import org.gradle.dependencygraph.extractor.ResolvedConfigurationFilter
+import org.gradle.dependencygraph.util.PluginParameters
 import org.gradle.util.GradleVersion
 
 private const val RESOLVE_PROJECT_TASK = "ForceDependencyResolutionPlugin_resolveProjectDependencies"
@@ -14,14 +16,22 @@ private const val RESOLVE_ALL_TASK = "ForceDependencyResolutionPlugin_resolveAll
  * Adds a task to resolve all dependencies in a Gradle build tree.
  */
 class ForceDependencyResolutionPlugin : Plugin<Gradle> {
+
+ // Properties are lazily initialized so that System Properties are initialized by the time
+ // the values are used. This is required due to a bug in older Gradle versions. (https://github.com/gradle/gradle/issues/6825)
+ private val pluginParameters = PluginParameters()
+ private val configurationFilter by lazy {
+ ResolvedConfigurationFilter(pluginParameters)
+ }
+
  override fun apply(gradle: Gradle) {
  gradle.projectsEvaluated {
  val resolveAllDeps = gradle.rootProject.tasks.register(RESOLVE_ALL_TASK)
 
  // Depend on "dependencies" task in all projects
  gradle.allprojects { project ->
  val projectTaskFactory = getResolveProjectDependenciesTaskFactory()
- val resolveProjectDeps = projectTaskFactory.create(project)
+ val resolveProjectDeps = projectTaskFactory.create(project, configurationFilter)
  resolveAllDeps.configure {
  it.dependsOn(resolveProjectDeps)
  }
@@ -47,19 +57,22 @@ class ForceDependencyResolutionPlugin : Plugin<Gradle> {
  }
 
  private interface ResolveProjectDependenciesTaskFactory {
- fun create(project: Project): TaskProvider<out Task>
+ fun create(project: Project, filter: ResolvedConfigurationFilter): TaskProvider<out Task>
 
  object Current : ResolveProjectDependenciesTaskFactory {
- override fun create(project: Project): TaskProvider<out Task> {
- return project.tasks.register(RESOLVE_PROJECT_TASK, ResolveProjectDependenciesTask::class.java)
+ override fun create(project: Project, filter: ResolvedConfigurationFilter): TaskProvider<out Task> {
+ return project.tasks.register(RESOLVE_PROJECT_TASK, ResolveProjectDependenciesTask::class.java) {
+ it.configurationFilter = filter
+ }
  }
  }
 
  object Legacy : ResolveProjectDependenciesTaskFactory {
- override fun create(project: Project): TaskProvider<out Task> {
- return project.tasks.register(RESOLVE_PROJECT_TASK, LegacyResolveProjectDependenciesTask::class.java)
+ override fun create(project: Project, filter: ResolvedConfigurationFilter): TaskProvider<out Task> {
+ return project.tasks.register(RESOLVE_PROJECT_TASK, LegacyResolveProjectDependenciesTask::class.java) {
+ it.configurationFilter = filter
+ }
  }
  }
  }
-
 }

plugin/src/main/kotlin/org/gradle/forceresolve/LegacyResolveProjectDependenciesTask.kt

@@ -2,13 +2,20 @@ package org.gradle.forceresolve
 
 import org.gradle.api.DefaultTask
 import org.gradle.api.artifacts.Configuration
+import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.TaskAction
+import org.gradle.dependencygraph.extractor.ResolvedConfigurationFilter
 import org.gradle.work.DisableCachingByDefault
 
 @DisableCachingByDefault(because = "Not worth caching")
 abstract class LegacyResolveProjectDependenciesTask: DefaultTask() {
+ @Internal
+ var configurationFilter: ResolvedConfigurationFilter? = null
+
  private fun getReportableConfigurations(): List<Configuration> {
- return project.configurations.filter { it.isCanBeResolved }
+ return project.configurations.filter {
+ it.isCanBeResolved && configurationFilter!!.include(project.path, it.name)
+ }
  }
 
  @TaskAction

plugin/src/main/kotlin/org/gradle/forceresolve/ResolveProjectDependenciesTask.kt

@@ -4,22 +4,29 @@ import org.gradle.api.DefaultTask
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.result.ResolvedComponentResult
 import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.TaskAction
+import org.gradle.dependencygraph.extractor.ResolvedConfigurationFilter
 import org.gradle.internal.serialization.Cached
 import org.gradle.work.DisableCachingByDefault
 
 @DisableCachingByDefault(because = "Not worth caching")
 abstract class ResolveProjectDependenciesTask: DefaultTask() {
  private val configurationResolvers = Cached.of { createConfigurationResolvers() }
 
+ @Internal
+ var configurationFilter: ResolvedConfigurationFilter? = null
+
  private fun createConfigurationResolvers(): List<Provider<ResolvedComponentResult>> {
  return getReportableConfigurations().map {
  it.incoming.resolutionResult.rootComponent
  }
  }
 
  private fun getReportableConfigurations(): List<Configuration> {
- return project.configurations.filter { it.isCanBeResolved }
+ return project.configurations.filter {
+ it.isCanBeResolved && configurationFilter!!.include(project.path, it.name)
+ }
  }
 
  @TaskAction