feat(analyzer): Honor includes to the PackageManager

Note that the `skipExcluded` configuration property is not supported as for
the excludes, for the sake of simplicity.

Signed-off-by: Nicolas Nobelis <[email protected]>

Author: nnobelis

analyzer/src/funTest/kotlin/PackageManagerFunTest.kt

@@ -33,8 +33,11 @@ import io.kotest.matchers.should
 import java.io.File
 
 import org.ossreviewtoolkit.model.config.Excludes
+import org.ossreviewtoolkit.model.config.Includes
 import org.ossreviewtoolkit.model.config.PathExclude
 import org.ossreviewtoolkit.model.config.PathExcludeReason
+import org.ossreviewtoolkit.model.config.config.PathInclude
+import org.ossreviewtoolkit.model.config.config.PathIncludeReason
 import org.ossreviewtoolkit.plugins.api.PluginConfig
 import org.ossreviewtoolkit.utils.common.div
 
@@ -184,6 +187,26 @@ class PackageManagerFunTest : WordSpec({
             managedFilesById["SBT"] should containExactly("sbt/build.sbt")
         }
 
+        "take path includes into account" {
+            val tempDir = "test/"
+            val definitionFilesWithExcludes = definitionFiles +
+                listOf("pom.xml", "build.gradle", "build.sbt").map { "$tempDir$it" }
+            val rootDir = tempdir()
+            definitionFilesWithExcludes.writeFiles(rootDir)
+
+            val pathInclude = PathInclude("$tempDir**", PathIncludeReason.SOURCE_OF)
+            val includes = Includes(paths = listOf(pathInclude))
+
+            val managedFilesById = PackageManager.findManagedFiles(rootDir, packageManagers, includes = includes)
+                .groupById(rootDir).toSortedMap(String.CASE_INSENSITIVE_ORDER)
+
+            managedFilesById["GradleInspector"] should containExactly(
+                "test/build.gradle"
+            )
+            managedFilesById["Maven"] should containExactly("test/pom.xml")
+            managedFilesById["SBT"] should containExactly("test/build.sbt")
+        }
+
         "handle specific excluded definition files" {
             val pathExclude = PathExclude("gradle-groovy/build.gradle", PathExcludeReason.OTHER)
             val excludes = Excludes(paths = listOf(pathExclude))
@@ -196,6 +219,18 @@ class PackageManagerFunTest : WordSpec({
             )
         }
 
+        "handle specific included definition files" {
+            val pathInclude = PathInclude("gradle-groovy/build.gradle", PathIncludeReason.SOURCE_OF)
+            val includes = Includes(paths = listOf(pathInclude))
+
+            val managedFiles = PackageManager.findManagedFiles(projectDir, packageManagers, includes = includes)
+            val managedFilesById = managedFiles.groupById(projectDir)
+
+            managedFilesById["GradleInspector"] should containExactly(
+                "gradle-groovy/build.gradle"
+            )
+        }
+
         "fail if the provided file is not a directory" {
             shouldThrow<IllegalArgumentException> {
                 PackageManager.findManagedFiles(projectDir / "pom.xml", packageManagers)

analyzer/src/main/kotlin/Analyzer.kt

@@ -36,6 +36,7 @@ import kotlinx.coroutines.withContext
 import org.apache.logging.log4j.kotlin.logger
 
 import org.ossreviewtoolkit.analyzer.PackageManager.Companion.excludes
+import org.ossreviewtoolkit.analyzer.PackageManager.Companion.includes
 import org.ossreviewtoolkit.downloader.VersionControlSystem
 import org.ossreviewtoolkit.model.AnalyzerResult
 import org.ossreviewtoolkit.model.AnalyzerRun
@@ -96,7 +97,8 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
             PackageManager.findManagedFiles(
                 absoluteProjectPath,
                 distinctPackageManagers,
-                config.excludes(repositoryConfiguration)
+                config.excludes(repositoryConfiguration),
+                config.includes(repositoryConfiguration)
             )
         }.mapNotNull { (manager, files) ->
             val mappedFiles = manager.mapDefinitionFiles(absoluteProjectPath, files, config)
@@ -175,6 +177,8 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
         val excludes = config.excludes(info.repositoryConfiguration)
 
         runBlocking {
+            // The excludes are passed to allow the package managers to take in account the scope excludes. Since there
+            // is no scope includes, the includes are not passed to the package managers.
             info.managedFiles.entries.map { (manager, files) ->
                 PackageManagerRunner(
                     manager = manager,

analyzer/src/main/kotlin/PackageManager.kt

@@ -38,6 +38,7 @@ import org.ossreviewtoolkit.model.VcsInfo
 import org.ossreviewtoolkit.model.VcsType
 import org.ossreviewtoolkit.model.config.AnalyzerConfiguration
 import org.ossreviewtoolkit.model.config.Excludes
+import org.ossreviewtoolkit.model.config.Includes
 import org.ossreviewtoolkit.model.config.PackageManagerConfiguration
 import org.ossreviewtoolkit.model.config.RepositoryConfiguration
 import org.ossreviewtoolkit.model.createAndLogIssue
@@ -84,7 +85,8 @@ abstract class PackageManager(val projectType: String) : Plugin {
         fun findManagedFiles(
             directory: File,
             packageManagers: Collection<PackageManager>,
-            excludes: Excludes = Excludes.EMPTY
+            excludes: Excludes = Excludes.EMPTY,
+            includes: Includes = Includes.EMPTY
         ): ManagedProjectFiles {
             require(directory.isDirectory) {
                 "The provided path is not a directory: ${directory.absolutePath}"
@@ -96,6 +98,8 @@ abstract class PackageManager(val projectType: String) : Plugin {
             val rootPath = directory.toPath()
             val distinctPackageManagers = packageManagers.distinct()
 
+            // Note: Even if the directory is not included and other includes are defined, it has to be walked as
+            // subdirectories or files may be included.
             directory.walk().onEnter { dir ->
                 val dirAsPath = dir.toPath()
 
@@ -119,7 +123,8 @@ abstract class PackageManager(val projectType: String) : Plugin {
                 }
             }.filter { it.isDirectory }.forEach { dir ->
                 val filesInCurrentDir = dir.walk().maxDepth(1).filterTo(mutableListOf()) {
-                    it.isFile && !excludes.isPathExcluded(rootPath, it.toPath())
+                    val isIncluded = includes.isPathIncluded(rootPath, it.toPath())
+                    it.isFile && !excludes.isPathExcluded(rootPath, it.toPath()) && isIncluded
                 }
 
                 distinctPackageManagers.forEach { manager ->
@@ -200,6 +205,15 @@ abstract class PackageManager(val projectType: String) : Plugin {
         internal fun AnalyzerConfiguration.excludes(repositoryConfiguration: RepositoryConfiguration): Excludes =
             repositoryConfiguration.excludes.takeIf { skipExcluded } ?: Excludes.EMPTY
 
+        /**
+         * Return an [Includes] instance to be applied during analysis based on the given [repositoryConfiguration].
+         * If this [AnalyzerConfiguration] has the [AnalyzerConfiguration.skipExcluded] flag set to true, the
+         * includes configured in [repositoryConfiguration] are actually applied. Otherwise, return an empty [Includes]
+         * object. This means that all dependencies are collected, and includes are applied later on the report level.
+         */
+        internal fun AnalyzerConfiguration.includes(repositoryConfiguration: RepositoryConfiguration): Includes =
+            repositoryConfiguration.includes.takeIf { skipExcluded } ?: Includes.EMPTY
+
         /**
          * Check whether the given [path] interpreted relatively against [root] is matched by a path exclude in this
          * [Excludes] object.