Filter by exclusion as well as inclusion

Using a Regex include filter can be problematic when trying to
_exclude_ a matching entry (or entries).
Adding specific exclude filters matching the current include filters
makes configuration more straightforward.

Author: bigdaz

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

@@ -113,6 +113,10 @@ abstract class BaseExtractorTest extends Specification {
         }
         apply plugin: GitHubDependencyGraphPlugin
         """.stripMargin()
+        resetArguments()
+    }
+
+    protected SimpleGradleExecuter resetArguments() {
         getExecuter().withArguments("--init-script", "init.gradle")
     }
 
@@ -194,6 +198,12 @@ abstract class BaseExtractorTest extends Specification {
             return (manifestData.file as Map).source_location
         }
 
+        def assertResolved(List<String> expectedResolved) {
+            def resolved = manifestData.resolved as Map<String, Map>
+            assert resolved.keySet() == expectedResolved as Set
+            return true
+        }
+
         def assertResolved(Map<String, Map> expectedResolved = [:]) {
             def resolved = manifestData.resolved as Map<String, Map>
 

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

@@ -37,7 +37,7 @@ class ConfigurationFilterDependencyExtractorTest extends BaseExtractorTest {
 
     def "can filter projects to extract dependencies"() {
         given:
-        settingsFile << "include 'a', 'b'"
+        settingsFile << "include 'a', 'b', 'c'"
 
         buildFile << """
             project(':a') {
@@ -52,18 +52,45 @@ class ConfigurationFilterDependencyExtractorTest extends BaseExtractorTest {
                     api 'org.test:bar:1.0'
                 }
             }
+            project(':c') {
+                apply plugin: 'java-library'
+                dependencies {
+                    api 'org.test:baz:1.0'
+                }
+            }
         """
 
         when:
         executer.withArgument("-DDEPENDENCY_GRAPH_INCLUDE_PROJECTS=:b")
         run()
 
         then:
-        def manifest = gitHubManifest()
-        manifest.sourceFile == "settings.gradle"
-        manifest.assertResolved([
-            "org.test:bar:1.0": [package_url: purlFor(bar)]
-        ])
+        gitHubManifest().assertResolved(["org.test:bar:1.0"])
+
+        when:
+        resetArguments()
+        executer.withArgument("-DDEPENDENCY_GRAPH_INCLUDE_PROJECTS=:[ab]")
+        run()
+
+        then:
+        gitHubManifest().assertResolved(["org.test:foo:1.0", "org.test:bar:1.0"])
+
+        when:
+        resetArguments()
+        executer.withArgument("-DDEPENDENCY_GRAPH_EXCLUDE_PROJECTS=:[bc]")
+        run()
+
+        then:
+        gitHubManifest().assertResolved(["org.test:foo:1.0"])
+
+        when:
+        resetArguments()
+        executer.withArgument("-DDEPENDENCY_GRAPH_INCLUDE_PROJECTS=:[ab]")
+        executer.withArgument("-DDEPENDENCY_GRAPH_EXCLUDE_PROJECTS=:b")
+        run()
+
+        then:
+        gitHubManifest().assertResolved(["org.test:foo:1.0"])
     }
 
     def "can filter configurations to extract dependencies"() {
@@ -92,12 +119,15 @@ class ConfigurationFilterDependencyExtractorTest extends BaseExtractorTest {
         run()
 
         then:
-        def manifest = gitHubManifest()
-        manifest.sourceFile == "settings.gradle"
-        manifest.assertResolved([
-            "org.test:foo:1.0": [package_url: purlFor(foo)],
-            "org.test:bar:1.0": [package_url: purlFor(bar)]
-        ])
+        gitHubManifest().assertResolved(["org.test:foo:1.0", "org.test:bar:1.0"])
+
+        when:
+        resetArguments()
+        executer.withArgument("-DDEPENDENCY_GRAPH_EXCLUDE_CONFIGURATIONS=test(Compile|Runtime)Classpath")
+        run()
+
+        then:
+        gitHubManifest().assertResolved(["org.test:foo:1.0", "org.test:bar:1.0"])
     }
 
     def "can filter runtime projects to determine scope"() {
@@ -120,50 +150,36 @@ class ConfigurationFilterDependencyExtractorTest extends BaseExtractorTest {
         """
 
         when:
-        executer.withArgument("-DDEPENDENCY_GRAPH_RUNTIME_PROJECTS=:a")
+        executer.withArgument("-DDEPENDENCY_GRAPH_RUNTIME_INCLUDE_PROJECTS=:a")
         run()
 
         then:
-        def manifest = gitHubManifest()
-        manifest.sourceFile == "settings.gradle"
-        manifest.assertResolved([
-            "org.test:foo:1.0": [package_url: purlFor(foo), scope: "runtime"],
-            "org.test:bar:1.0": [package_url: purlFor(bar), scope: "development"],
+        gitHubManifest().assertResolved([
+            "org.test:foo:1.0": [scope: "runtime"],
+            "org.test:bar:1.0": [scope: "development"]
         ])
-    }
 
-    def "can filter runtime configurations to determine scope"() {
-        given:
-        settingsFile << "include 'a', 'b'"
+        when:
+        resetArguments()
+        executer.withArgument("-DDEPENDENCY_GRAPH_RUNTIME_EXCLUDE_PROJECTS=:b")
+        run()
 
-        buildFile << """
-            project(':a') {
-                apply plugin: 'java-library'
-                dependencies {
-                    api 'org.test:foo:1.0'
-                    testImplementation 'org.test:baz:1.0'
-                }
-            }
-            project(':b') {
-                apply plugin: 'java-library'
-                dependencies {
-                    implementation 'org.test:bar:1.0'
-                    testImplementation 'org.test:baz:1.0'
-                }
-            }
-        """
+        then:
+        gitHubManifest().assertResolved([
+            "org.test:foo:1.0": [scope: "runtime"],
+            "org.test:bar:1.0": [scope: "development"]
+        ])
 
         when:
-        executer.withArgument("-DDEPENDENCY_GRAPH_RUNTIME_CONFIGURATIONS=compileClasspath")
+        resetArguments()
+        executer.withArgument("-DDEPENDENCY_GRAPH_RUNTIME_INCLUDE_PROJECTS=:[ab]")
+        executer.withArgument("-DDEPENDENCY_GRAPH_RUNTIME_EXCLUDE_PROJECTS=:b")
         run()
 
         then:
-        def manifest = gitHubManifest()
-        manifest.sourceFile == "settings.gradle"
-        manifest.assertResolved([
-            "org.test:foo:1.0": [package_url: purlFor(foo), scope: "runtime"],
-            "org.test:bar:1.0": [package_url: purlFor(bar), scope: "runtime"],
-            "org.test:baz:1.0": [package_url: purlFor(baz), scope: "development", dependencies: ["org.test:bar:1.0"]]
+        gitHubManifest().assertResolved([
+            "org.test:foo:1.0": [scope: "runtime"],
+            "org.test:bar:1.0": [scope: "development"]
         ])
     }
 
@@ -189,22 +205,45 @@ class ConfigurationFilterDependencyExtractorTest extends BaseExtractorTest {
         """
 
         when:
-        executer.withArgument("-DDEPENDENCY_GRAPH_RUNTIME_CONFIGURATIONS=compileClasspath")
+        executer.withArgument("-DDEPENDENCY_GRAPH_RUNTIME_INCLUDE_CONFIGURATIONS=compileClasspath")
+        run()
+
+        then:
+        gitHubManifest().assertResolved([
+            "org.test:foo:1.0": [scope: "runtime"],
+            "org.test:bar:1.0": [scope: "runtime"],
+            "org.test:baz:1.0": [scope: "development", dependencies: ["org.test:bar:1.0"]]
+        ])
+
+        when:
+        resetArguments()
+        executer.withArgument("-DDEPENDENCY_GRAPH_RUNTIME_INCLUDE_CONFIGURATIONS=.*Classpath")
         run()
 
         then:
-        def manifest = gitHubManifest()
-        manifest.sourceFile == "settings.gradle"
-        manifest.assertResolved([
-            "org.test:foo:1.0": [package_url: purlFor(foo), scope: "runtime"],
-            "org.test:bar:1.0": [package_url: purlFor(bar), scope: "runtime"],
-            "org.test:baz:1.0": [package_url: purlFor(baz), scope: "development", dependencies: ["org.test:bar:1.0"]]
+        gitHubManifest().assertResolved([
+            "org.test:foo:1.0": [scope: "runtime"],
+            "org.test:bar:1.0": [scope: "runtime"],
+            "org.test:baz:1.0": [scope: "runtime", dependencies: ["org.test:bar:1.0"]]
+        ])
+
+        when:
+        resetArguments()
+        executer.withArgument("-DDEPENDENCY_GRAPH_RUNTIME_INCLUDE_CONFIGURATIONS=.*Classpath")
+        executer.withArgument("-DDEPENDENCY_GRAPH_RUNTIME_EXCLUDE_CONFIGURATIONS=test(Compile|Runtime)Classpath")
+        run()
+
+        then:
+        gitHubManifest().assertResolved([
+            "org.test:foo:1.0": [scope: "runtime"],
+            "org.test:bar:1.0": [scope: "runtime"],
+            "org.test:baz:1.0": [scope: "development", dependencies: ["org.test:bar:1.0"]]
         ])
     }
 
     def "can filter runtime projects and configurations to determine scope"() {
         given:
-        settingsFile << "include 'a', 'b'"
+        settingsFile << "include 'a', 'b', 'c'"
 
         buildFile << """
             project(':a') {
@@ -221,21 +260,27 @@ class ConfigurationFilterDependencyExtractorTest extends BaseExtractorTest {
                     testImplementation 'org.test:baz:1.0'
                 }
             }
+            project(':b') {
+                apply plugin: 'java-library'
+                dependencies {
+                    api 'org.test:baz:1.0'
+                }
+            }
         """
 
         when:
         executer
-            .withArgument("-DDEPENDENCY_GRAPH_RUNTIME_CONFIGURATIONS=compileClasspath")
-            .withArgument("-DDEPENDENCY_GRAPH_RUNTIME_PROJECTS=:a")
+            .withArgument("-DDEPENDENCY_GRAPH_RUNTIME_INCLUDE_PROJECTS=:[ab]")
+            .withArgument("-DDEPENDENCY_GRAPH_RUNTIME_INCLUDE_CONFIGURATIONS=.*Classpath")
+            .withArgument("-DDEPENDENCY_GRAPH_RUNTIME_EXCLUDE_PROJECTS=:b")
+            .withArgument("-DDEPENDENCY_GRAPH_RUNTIME_EXCLUDE_CONFIGURATIONS=test(Compile|Runtime)Classpath")
         run()
 
         then:
-        def manifest = gitHubManifest()
-        manifest.sourceFile == "settings.gradle"
-        manifest.assertResolved([
-            "org.test:foo:1.0": [package_url: purlFor(foo), scope: "runtime"],
-            "org.test:bar:1.0": [package_url: purlFor(bar), scope: "development"],
-            "org.test:baz:1.0": [package_url: purlFor(baz), scope: "development", dependencies: ["org.test:bar:1.0"]]
+        gitHubManifest().assertResolved([
+            "org.test:foo:1.0": [scope: "runtime"],
+            "org.test:bar:1.0": [scope: "development"],
+            "org.test:baz:1.0": [scope: "development", dependencies: ["org.test:bar:1.0"]]
         ])
     }
 

plugin/src/main/kotlin/org/gradle/dependencygraph/extractor/DependencyExtractor.kt

@@ -1,6 +1,5 @@
 package org.gradle.dependencygraph.extractor
 
-import org.gradle.api.GradleException
 import org.gradle.api.artifacts.component.ProjectComponentIdentifier
 import org.gradle.api.artifacts.result.ResolvedComponentResult
 import org.gradle.api.artifacts.result.ResolvedDependencyResult
@@ -13,7 +12,6 @@ import org.gradle.dependencygraph.model.DependencyScope.*
 import org.gradle.dependencygraph.util.*
 import org.gradle.initialization.EvaluateSettingsBuildOperationType
 import org.gradle.initialization.LoadProjectsBuildOperationType
-import org.gradle.internal.exceptions.Contextual
 import org.gradle.internal.exceptions.DefaultMultiCauseException
 import org.gradle.internal.operations.*
 import java.io.File
@@ -22,8 +20,12 @@ import java.util.*
 
 const val PARAM_INCLUDE_PROJECTS = "DEPENDENCY_GRAPH_INCLUDE_PROJECTS"
 const val PARAM_INCLUDE_CONFIGURATIONS = "DEPENDENCY_GRAPH_INCLUDE_CONFIGURATIONS"
-const val PARAM_RUNTIME_PROJECTS = "DEPENDENCY_GRAPH_RUNTIME_PROJECTS"
-const val PARAM_RUNTIME_CONFIGURATIONS = "DEPENDENCY_GRAPH_RUNTIME_CONFIGURATIONS"
+const val PARAM_EXCLUDE_PROJECTS = "DEPENDENCY_GRAPH_EXCLUDE_PROJECTS"
+const val PARAM_EXCLUDE_CONFIGURATIONS = "DEPENDENCY_GRAPH_EXCLUDE_CONFIGURATIONS"
+const val PARAM_RUNTIME_INCLUDE_PROJECTS = "DEPENDENCY_GRAPH_RUNTIME_INCLUDE_PROJECTS"
+const val PARAM_RUNTIME_INCLUDE_CONFIGURATIONS = "DEPENDENCY_GRAPH_RUNTIME_INCLUDE_CONFIGURATIONS"
+const val PARAM_RUNTIME_EXCLUDE_PROJECTS = "DEPENDENCY_GRAPH_RUNTIME_EXCLUDE_PROJECTS"
+const val PARAM_RUNTIME_EXCLUDE_CONFIGURATIONS = "DEPENDENCY_GRAPH_RUNTIME_EXCLUDE_CONFIGURATIONS"
 
 
 const val PARAM_REPORT_DIR = "DEPENDENCY_GRAPH_REPORT_DIR"
@@ -46,18 +48,8 @@ abstract class DependencyExtractor :
 
     // 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 includeFilter by lazy {
-        ResolvedConfigurationFilter(
-            pluginParameters.loadOptional(PARAM_INCLUDE_PROJECTS),
-            pluginParameters.loadOptional(PARAM_INCLUDE_CONFIGURATIONS)
-        )
-    }
-
-    private val runtimeFilter by lazy {
-        ResolvedConfigurationFilter(
-            pluginParameters.loadOptional(PARAM_RUNTIME_PROJECTS),
-            pluginParameters.loadOptional(PARAM_RUNTIME_CONFIGURATIONS)
-        )
+    private val configurationFilter by lazy {
+        ResolvedConfigurationFilter(pluginParameters)
     }
 
     private val dependencyGraphReportDir by lazy {
@@ -67,12 +59,12 @@ abstract class DependencyExtractor :
     abstract fun getRendererClassName(): String
 
     override fun started(buildOperation: BuildOperationDescriptor, startEvent: OperationStartEvent) {
-        // This method will never be called when registered in a `BuildServiceRegistry` (ie. Gradle 6.1 & higher)
+        // This method will never be called when registered in a `BuildServiceRegistry` (i.e. Gradle 6.1 & higher)
         // No-op
     }
 
     override fun progress(operationIdentifier: OperationIdentifier, progressEvent: OperationProgressEvent) {
-        // This method will never be called when registered in a `BuildServiceRegistry` (ie. Gradle 6.1 & higher)
+        // This method will never be called when registered in a `BuildServiceRegistry` (i.e. Gradle 6.1 & higher)
         // No-op
     }
 
@@ -170,7 +162,7 @@ abstract class DependencyExtractor :
         val rootPath = projectIdentityPath ?: details.buildPath
         val configurationName = details.configurationName
 
-        if (!includeFilter.include(rootPath, configurationName)) {
+        if (!configurationFilter.include(rootPath, configurationName)) {
             LOGGER.debug("Ignoring resolved configuration: $rootPath - $configurationName")
             return
         }
@@ -201,8 +193,8 @@ abstract class DependencyExtractor :
         rootPath: String,
         configurationName: String
     ): DependencyScope {
-        if (runtimeFilter.isConfigured()) {
-            return if (runtimeFilter.include(rootPath, configurationName)) RUNTIME else DEVELOPMENT
+        if (configurationFilter.scopesAreConfigured()) {
+            return if (configurationFilter.isRuntime(rootPath, configurationName)) RUNTIME else DEVELOPMENT
         }
         return UNKNOWN
     }