Assign dependency scope based on regex filters

Add new filter variables that can be used to categorize a dependency as 'runtime'.
  If not specified or not matched, a 'development' scope is assumed.

Author: bigdaz

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

@@ -9,6 +9,8 @@ import org.gradle.api.internal.artifacts.configurations.ResolveConfigurationDepe
 import org.gradle.api.logging.Logging
 import org.gradle.dependencygraph.DependencyGraphRenderer
 import org.gradle.dependencygraph.model.*
+import org.gradle.dependencygraph.model.DependencyScope.RUNTIME
+import org.gradle.dependencygraph.model.DependencyScope.DEVELOPMENT
 import org.gradle.dependencygraph.util.*
 import org.gradle.initialization.EvaluateSettingsBuildOperationType
 import org.gradle.initialization.LoadProjectsBuildOperationType
@@ -21,6 +23,9 @@ 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_REPORT_DIR = "DEPENDENCY_GRAPH_REPORT_DIR"
 
@@ -42,13 +47,20 @@ 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 configurationFilter by lazy {
+    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 dependencyGraphReportDir by lazy {
         pluginParameters.loadOptional(PARAM_REPORT_DIR)
     }
@@ -157,15 +169,18 @@ abstract class DependencyExtractor :
         // It is possible to do better. By tracking the current build operation context, we can assign more precisely.
         // See the Gradle Enterprise Build Scan Plugin: `ConfigurationResolutionCapturer_5_0`
         val rootPath = projectIdentityPath ?: details.buildPath
+        val configurationName = details.configurationName
 
-        if (!configurationFilter.include(rootPath, details.configurationName)) {
-            LOGGER.debug("Ignoring resolved configuration: $rootPath - ${details.configurationName}")
+        if (!includeFilter.include(rootPath, configurationName)) {
+            LOGGER.debug("Ignoring resolved configuration: $rootPath - $configurationName")
             return
         }
 
+        val scope = if (runtimeFilter.include(rootPath, configurationName)) RUNTIME else DEVELOPMENT
+
         val rootId = if (projectIdentityPath == null) "build $rootPath" else componentId(rootComponent)
         val rootOrigin = DependencyOrigin(rootId, rootPath)
-        val resolvedConfiguration = ResolvedConfiguration(rootOrigin, details.configurationName)
+        val resolvedConfiguration = ResolvedConfiguration(rootOrigin, configurationName, scope)
 
         for (dependencyComponent in getResolvedDependencies(rootComponent)) {
             val directDep = createComponentNode(

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

@@ -1,14 +1,14 @@
 package org.gradle.dependencygraph.extractor
 
 class ResolvedConfigurationFilter(projectFilter: String?, configurationFilter: String?) {
-    private val projectRegex = projectFilter?.toRegex()
-    private val configurationRegex = configurationFilter?.toRegex()
+    private val projectFilter = projectFilter?.toRegex()
+    private val configurationFilter = configurationFilter?.toRegex()
 
     fun include(projectPath: String, configurationName: String): Boolean {
-        if (projectRegex != null && !projectRegex.matches(projectPath)) {
+        if (projectFilter != null && !projectFilter.matches(projectPath)) {
             return false
         }
-        if (configurationRegex != null && !configurationRegex.matches(configurationName)) {
+        if (configurationFilter != null && !configurationFilter.matches(configurationName)) {
             return false
         }
         return true

plugin/src/main/kotlin/org/gradle/dependencygraph/model/DependencyScope.kt

@@ -0,0 +1,17 @@
+package org.gradle.dependencygraph.model
+
+/**
+ * Represents the scope of a resolved dependency.
+ * At this point, the scopes are limited to those exposed in the GitHub DependencySubmission API.
+ * Later development may extend this to a richer set of scopes.
+ */
+enum class DependencyScope {
+    DEVELOPMENT, RUNTIME;
+
+    companion object {
+        fun getEffectiveScope(scopes: List<DependencyScope>): DependencyScope {
+            if (scopes.contains(RUNTIME)) return RUNTIME
+            return DEVELOPMENT
+        }
+    }
+}

plugin/src/main/kotlin/org/gradle/dependencygraph/model/ResolvedConfiguration.kt

@@ -3,6 +3,7 @@ package org.gradle.dependencygraph.model
 data class ResolvedConfiguration(
     val rootOrigin: DependencyOrigin,
     val configurationName: String,
+    val scope: DependencyScope,
     val allDependencies: MutableList<ResolvedDependency> = mutableListOf()
 ) {
     fun addDependency(component: ResolvedDependency) {

plugin/src/main/kotlin/org/gradle/dependencygraph/simple/SimpleDependencyGraphRenderer.kt

@@ -3,6 +3,7 @@ package org.gradle.dependencygraph.simple
 import org.gradle.dependencygraph.DependencyGraphRenderer
 import org.gradle.dependencygraph.model.BuildLayout
 import org.gradle.dependencygraph.model.ResolvedConfiguration
+import org.gradle.dependencygraph.model.DependencyScope
 import org.gradle.dependencygraph.util.JacksonJsonSerializer
 import org.gradle.dependencygraph.util.PluginParameters
 import java.io.File
@@ -40,21 +41,24 @@ class SimpleDependencyGraphRenderer : DependencyGraphRenderer {
         resolvedConfigurations: List<ResolvedConfiguration>
     ) {
         val outputFile = File(outputDirectory, "dependency-scopes.json")
-        val dependencyList: MutableMap<String, MutableSet<SimpleDependencyOrigin>> = mutableMapOf()
+        val dependencyList: MutableMap<String, MutableSet<SimpleDependencyResolution>> = mutableMapOf()
         for (config in resolvedConfigurations) {
             for (dependency in config.allDependencies) {
-                val dependencyOrigins = dependencyList.getOrPut(dependency.id) { mutableSetOf() }
-                dependencyOrigins.add(
-                    SimpleDependencyOrigin(
+                if (dependency.isProject) continue
+
+                val dependencyScopes = dependencyList.getOrPut(dependency.id) { mutableSetOf() }
+                dependencyScopes.add(
+                    SimpleDependencyResolution(
                         config.rootOrigin.path,
-                        config.configurationName
+                        config.configurationName,
+                        config.scope
                     )
                 )
             }
         }
 
-        val simpleDependencies = dependencyList.map { (id, origins) ->
-            SimpleDependency(id, origins.toList())
+        val simpleDependencies = dependencyList.map { (id, resolutions) ->
+            SimpleDependency(id, DependencyScope.getEffectiveScope(resolutions.map {it.scope}), resolutions.toList())
         }
         val jsonContent = JacksonJsonSerializer.serializeToJson(simpleDependencies)
         outputFile.writeText(jsonContent)
@@ -67,7 +71,7 @@ class SimpleDependencyGraphRenderer : DependencyGraphRenderer {
         val outputFile = File(outputDirectory, "dependency-list.txt")
         val dependencyList = resolvedConfigurations.flatMap { config ->
             config.allDependencies.map {
-                "${it.coordinates.group}:${it.coordinates.module}:${it.coordinates.version} ---- ${config.rootOrigin.id} ${config.rootOrigin.path} ${config.configurationName}"
+                "${it.coordinates.group}:${it.coordinates.module}:${it.coordinates.version}"
             }
         }.distinct().sorted()
 
@@ -78,7 +82,8 @@ class SimpleDependencyGraphRenderer : DependencyGraphRenderer {
 
 data class SimpleDependency(
     val dependency: String,
-    val resolvedBy: List<SimpleDependencyOrigin>
+    val effectiveScope: DependencyScope,
+    val resolvedBy: List<SimpleDependencyResolution>
 )
 
-data class SimpleDependencyOrigin(val path: String, val configuration: String)
+data class SimpleDependencyResolution(val path: String, val configuration: String, val scope: DependencyScope)

plugin/src/main/kotlin/org/gradle/github/dependencygraph/GitHubRepositorySnapshotBuilder.kt

@@ -3,6 +3,7 @@ package org.gradle.github.dependencygraph
 import org.gradle.dependencygraph.model.ResolvedDependency
 import org.gradle.dependencygraph.model.ResolvedConfiguration
 import org.gradle.dependencygraph.model.BuildLayout
+import org.gradle.dependencygraph.model.DependencyScope
 import org.gradle.github.dependencygraph.model.*
 
 class GitHubRepositorySnapshotBuilder(
@@ -21,12 +22,12 @@ class GitHubRepositorySnapshotBuilder(
     fun buildManifest(manifestName: String, resolvedConfigurations: List<ResolvedConfiguration>, buildLayout: BuildLayout): GitHubManifest {
         val dependencyCollector = DependencyCollector()
 
-        for (resolutionRoot in resolvedConfigurations) {
-            for (dependency in resolutionRoot.allDependencies) {
+        for (configuration in resolvedConfigurations) {
+            for (dependency in configuration.allDependencies) {
                 // Ignore project dependencies (transitive deps of projects will be reported with project)
                 if (dependency.isProject) continue
 
-                dependencyCollector.addResolved(dependency)
+                dependencyCollector.addResolved(dependency, determineGitHubScope(configuration))
             }
         }
 
@@ -37,6 +38,13 @@ class GitHubRepositorySnapshotBuilder(
         )
     }
 
+    private fun determineGitHubScope(configuration: ResolvedConfiguration): GitHubDependency.Scope {
+        return when(configuration.scope) {
+            DependencyScope.DEVELOPMENT -> GitHubDependency.Scope.development
+            DependencyScope.RUNTIME -> GitHubDependency.Scope.runtime
+        }
+    }
+
     /**
      * Manifest file is the root build settings file if it exists, or the root build file if not.
      */
@@ -67,11 +75,12 @@ class GitHubRepositorySnapshotBuilder(
         /**
          * Merge each resolved component with the same ID into a single GitHubDependency.
          */
-        fun addResolved(component: ResolvedDependency) {
+        fun addResolved(component: ResolvedDependency, scope: GitHubDependency.Scope) {
             val dep = dependencyBuilders.getOrPut(component.id) {
                 GitHubDependencyBuilder(component.packageUrl())
             }
             dep.addRelationship(relationship(component))
+            dep.addScope(scope)
             dep.addDependencies(component.dependencies)
         }
 
@@ -89,6 +98,7 @@ class GitHubRepositorySnapshotBuilder(
 
         private class GitHubDependencyBuilder(val package_url: String) {
             var relationship: GitHubDependency.Relationship = GitHubDependency.Relationship.indirect
+            var scope: GitHubDependency.Scope = GitHubDependency.Scope.development
             val dependencies = mutableListOf<String>()
 
             fun addRelationship(newRelationship: GitHubDependency.Relationship) {
@@ -98,6 +108,12 @@ class GitHubRepositorySnapshotBuilder(
                 }
             }
 
+            fun addScope(newScope: GitHubDependency.Scope) {
+                if (scope == GitHubDependency.Scope.development) {
+                    scope = newScope
+                }
+            }
+
             fun addDependencies(newDependencies: List<String>) {
                 // Add any dependencies that are not in the existing set
                 for (newDependency in newDependencies.subtract(dependencies.toSet())) {
@@ -106,7 +122,7 @@ class GitHubRepositorySnapshotBuilder(
             }
 
             fun build(): GitHubDependency {
-                return GitHubDependency(package_url, relationship, dependencies)
+                return GitHubDependency(package_url, relationship, scope, dependencies)
             }
         }
     }

plugin/src/main/kotlin/org/gradle/github/dependencygraph/model/GitHubDependency.kt

@@ -3,9 +3,13 @@ package org.gradle.github.dependencygraph.model
 data class GitHubDependency(
     val package_url: String,
     val relationship: Relationship,
+    val scope: Scope,
     val dependencies: List<String>
 ) {
     enum class Relationship {
         indirect, direct
     }
+    enum class Scope {
+        runtime, development
+    }
 }

plugin/src/test/groovy/org/gradle/github/dependencygraph/internal/ResolvedConfigurationTest.groovy

@@ -95,4 +95,18 @@ class ResolvedConfigurationTest extends Specification {
         !filter.include(":proj-a:proj-b:", "")
         !filter.include("parent-proj:proj-a", "")
     }
+
+    def "filters on excluded project path"() {
+        when:
+        def filter = new ResolvedConfigurationFilter(/^:(?!buildSrc).*/, null)
+
+        then:
+        filter.include(":proj-a", "")
+        filter.include(":proj-a:proj-b", "")
+        filter.include(":proj-a:buildSrc", "")
+
+        !filter.include(":buildSrc", "")
+        !filter.include(":buildSrc:", "")
+        !filter.include(":buildSrc:proj-b:", "")
+    }
 }