Allow to deactivate package managers

README.md

@@ -369,6 +369,9 @@ supported:
   * [Cargo](https://doc.rust-lang.org/cargo/)
 * Scala
   * [SBT](https://www.scala-sbt.org/)
+* Unmanged
+  * This is a special "package manager" that mananges all files that cannot be associated to any of the other package
+  managers.
 
 <a name="analyzer-for-spdx-documents"></a>
 

advisor/src/main/kotlin/Advisor.kt

@@ -47,9 +47,11 @@ class Advisor(
         private val LOADER = ServiceLoader.load(AdviceProviderFactory::class.java)!!
 
         /**
-         * The list of all available [AdviceProvider]s in the classpath.
+         * The set of all available [advice provider factories][AdviceProviderFactory] in the classpath, sorted by name.
          */
-        val ALL by lazy { LOADER.iterator().asSequence().toList().sortedBy { it.providerName } }
+        val ALL: Set<AdviceProviderFactory> by lazy {
+            LOADER.iterator().asSequence().toSortedSet(compareBy { it.providerName })
+        }
     }
 
     @JvmOverloads

analyzer/src/funTest/kotlin/managers/SbtFunTest.kt

@@ -50,7 +50,7 @@ class SbtFunTest : StringSpec({
         Git().run(projectDir, "clean", "-fd")
 
         val ortResult = Analyzer(DEFAULT_ANALYZER_CONFIGURATION).run {
-            analyze(findManagedFiles(projectDir, listOf(Sbt.Factory())))
+            analyze(findManagedFiles(projectDir, setOf(Sbt.Factory())))
         }
 
         val expectedResult = readOrtResult(expectedOutputFile)
@@ -72,7 +72,7 @@ class SbtFunTest : StringSpec({
         Git().run(projectDir, "clean", "-fd")
 
         val ortResult = Analyzer(DEFAULT_ANALYZER_CONFIGURATION).run {
-            analyze(findManagedFiles(projectDir, listOf(Sbt.Factory())))
+            analyze(findManagedFiles(projectDir, setOf(Sbt.Factory())))
         }
 
         val expectedResult = yamlMapper.readValue<OrtResult>(

analyzer/src/main/kotlin/Analyzer.kt

@@ -53,7 +53,7 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
     @JvmOverloads
     fun findManagedFiles(
         absoluteProjectPath: File,
-        packageManagers: List<PackageManagerFactory> = PackageManager.ALL,
+        packageManagers: Set<PackageManagerFactory> = PackageManager.ALL,
         repositoryConfiguration: RepositoryConfiguration = RepositoryConfiguration()
     ): ManagedFileInfo {
         require(absoluteProjectPath.isAbsolute)
@@ -81,8 +81,9 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
             it.parentFile.absoluteFile == absoluteProjectPath
         }
 
-        if (factoryFiles.isEmpty() || !hasDefinitionFileInRootDirectory) {
-            Unmanaged.Factory().create(absoluteProjectPath, config, repositoryConfiguration).let {
+        val unmanagedFactory = packageManagers.find { it is Unmanaged.Factory }
+        if (unmanagedFactory != null && (factoryFiles.isEmpty() || !hasDefinitionFileInRootDirectory)) {
+            unmanagedFactory.create(absoluteProjectPath, config, repositoryConfiguration).let {
                 managedFiles[it] = listOf(absoluteProjectPath)
             }
         }

analyzer/src/main/kotlin/PackageManager.kt

@@ -68,9 +68,11 @@ abstract class PackageManager(
         private val LOADER = ServiceLoader.load(PackageManagerFactory::class.java)!!
 
         /**
-         * The list of all available package managers in the classpath.
+         * The set of all available [package manager factories][PackageManagerFactory] in the classpath, sorted by name.
          */
-        val ALL by lazy { LOADER.iterator().asSequence().toList().sortedBy { it.managerName } }
+        val ALL: Set<PackageManagerFactory> by lazy {
+            LOADER.iterator().asSequence().toSortedSet(compareBy { it.managerName })
+        }
 
         private val PACKAGE_MANAGER_DIRECTORIES = listOf(
             // Ignore intermediate build system directories.
@@ -93,8 +95,7 @@ abstract class PackageManager(
          * Recursively search the [directory] for files managed by any of the [packageManagers]. The search is performed
          * depth-first so that root project files are found before any subproject files for a specific manager.
          */
-        fun findManagedFiles(directory: File, packageManagers: List<PackageManagerFactory> = ALL):
-                ManagedProjectFiles {
+        fun findManagedFiles(directory: File, packageManagers: Set<PackageManagerFactory> = ALL): ManagedProjectFiles {
             require(directory.isDirectory) {
                 "The provided path is not a directory: ${directory.absolutePath}"
             }

analyzer/src/main/kotlin/managers/Pub.kt

@@ -250,7 +250,7 @@ class Pub(
                 // first to generate the local.properties file by using `flutter pub get`.
                 val gradleFactory = Gradle.Factory()
                 val gradleDefinitionFiles =
-                    findManagedFiles(analysisRoot, listOf(gradleFactory)).getOrDefault(gradleFactory, emptyList())
+                    findManagedFiles(analysisRoot, setOf(gradleFactory)).getOrDefault(gradleFactory, emptyList())
 
                 if (gradleDefinitionFiles.isNotEmpty()) {
                     log.info { "Found ${gradleDefinitionFiles.size} ${gradleFactory.managerName} project(s) at:" }

analyzer/src/main/kotlin/managers/Unmanaged.kt

@@ -45,6 +45,9 @@ class Unmanaged(
     repoConfig: RepositoryConfiguration
 ) : PackageManager(name, analysisRoot, analyzerConfig, repoConfig) {
     class Factory : AbstractPackageManagerFactory<Unmanaged>("Unmanaged") {
+        // The empty list returned here deliberately causes this special package manager to never be considered in
+        // PackageManager.findManagedFiles(). Instead, it will only be explicitly instantiated as part of
+        // Analyzer.findManagedFiles().
         override val globsForDefinitionFiles = emptyList<String>()
 
         override fun create(

analyzer/src/main/resources/META-INF/services/org.ossreviewtoolkit.analyzer.PackageManagerFactory

@@ -18,4 +18,5 @@ org.ossreviewtoolkit.analyzer.managers.Pub$Factory
 org.ossreviewtoolkit.analyzer.managers.Sbt$Factory
 org.ossreviewtoolkit.analyzer.managers.SpdxDocumentFile$Factory
 org.ossreviewtoolkit.analyzer.managers.Stack$Factory
+org.ossreviewtoolkit.analyzer.managers.Unmanaged$Factory
 org.ossreviewtoolkit.analyzer.managers.Yarn$Factory

analyzer/src/test/kotlin/PackageManagerTest.kt

@@ -81,7 +81,7 @@ class PackageManagerTest : WordSpec({
 
             // The test project contains at least one file per package manager, so the result should also contain an
             // entry for each package manager.
-            managedFiles.keys shouldContainExactlyInAnyOrder PackageManager.ALL
+            managedFiles.keys shouldContainExactlyInAnyOrder PackageManager.ALL.filterNot { it is Unmanaged.Factory }
 
             // The keys in expected and actual maps of definition files are different instances of package manager
             // factories. So to compare values use the package manager names as keys instead.
@@ -132,7 +132,7 @@ class PackageManagerTest : WordSpec({
         "find only files for active package managers" {
             val managedFiles = PackageManager.findManagedFiles(
                 projectDir,
-                listOf(Gradle.Factory(), Pip.Factory(), Sbt.Factory())
+                setOf(Gradle.Factory(), Pip.Factory(), Sbt.Factory())
             )
 
             managedFiles.size shouldBe 3
@@ -155,7 +155,7 @@ class PackageManagerTest : WordSpec({
         }
 
         "find no files if no package managers are active" {
-            val managedFiles = PackageManager.findManagedFiles(projectDir, emptyList())
+            val managedFiles = PackageManager.findManagedFiles(projectDir, emptySet())
 
             managedFiles.size shouldBe 0
         }

cli/src/main/kotlin/commands/AnalyzerCommand.kt

@@ -142,13 +142,23 @@ class AnalyzerCommand : CliktCommand(name = "analyze", help = "Determine depende
                 "times. For example: --label distribution=external"
     ).associate()
 
-    private val packageManagers by option(
+    private val activatedPackageManagers by option(
         "--package-managers", "-m",
-        help = "The comma-separated package managers to activate, any of ${allPackageManagersByName.keys}."
+        help = "The comma-separated package managers to activate, any of ${allPackageManagersByName.keys}. Note that " +
+                "deactivation overrides activation."
     ).convert { name ->
         allPackageManagersByName[name]
             ?: throw BadParameterValue("Package managers must be one or more of ${allPackageManagersByName.keys}.")
-    }.split(",").default(PackageManager.ALL)
+    }.split(",").default(PackageManager.ALL.toList())
+
+    private val deactivatedPackageManagers by option(
+        "--not-package-managers", "-n",
+        help = "The comma-separated package managers to deactivate, any of ${allPackageManagersByName.keys}. Note " +
+                "that deactivation overrides activation."
+    ).convert { name ->
+        allPackageManagersByName[name]
+            ?: throw BadParameterValue("Package managers must be one or more of ${allPackageManagersByName.keys}.")
+    }.split(",").default(emptyList())
 
     private val globalOptionsForSubcommands by requireObject<GlobalOptions>()
 
@@ -174,7 +184,7 @@ class AnalyzerCommand : CliktCommand(name = "analyze", help = "Determine depende
         println("The following configuration files and directories are used:")
         println("\t" + configurationFiles.joinToString("\n\t"))
 
-        val distinctPackageManagers = packageManagers.distinct()
+        val distinctPackageManagers = activatedPackageManagers.toSet() - deactivatedPackageManagers.toSet()
         println("The following package managers are activated:")
         println("\t" + distinctPackageManagers.joinToString())
 

downloader/src/main/kotlin/VersionControlSystem.kt

@@ -41,9 +41,12 @@ abstract class VersionControlSystem {
         private val LOADER = ServiceLoader.load(VersionControlSystem::class.java)!!
 
         /**
-         * The (prioritized) list of all available Version Control Systems in the classpath.
+         * The set of all available [Version Control Systems][VersionControlSystem] in the classpath, sorted by
+         * priority.
          */
-        val ALL by lazy { LOADER.iterator().asSequence().toList().sortedByDescending { it.priority } }
+        val ALL: Set<VersionControlSystem> by lazy {
+            LOADER.iterator().asSequence().toSortedSet(compareByDescending { it.priority })
+        }
 
         /**
          * Return the applicable VCS for the given [vcsType], or null if none is applicable.

reporter/src/main/kotlin/Reporter.kt

@@ -38,9 +38,11 @@ interface Reporter {
         private val LOADER = ServiceLoader.load(Reporter::class.java)!!
 
         /**
-         * The list of all available reporters in the classpath.
+         * The set of all available [reporters][Reporter] in the classpath, sorted by name.
          */
-        val ALL by lazy { LOADER.iterator().asSequence().toList().sortedBy { it.reporterName } }
+        val ALL: Set<Reporter> by lazy {
+            LOADER.iterator().asSequence().toSortedSet(compareBy { it.reporterName })
+        }
     }
 
     /**

scanner/src/main/kotlin/Scanner.kt

@@ -198,9 +198,11 @@ abstract class Scanner(
         private val LOADER = ServiceLoader.load(ScannerFactory::class.java)!!
 
         /**
-         * The list of all available scanners in the classpath.
+         * The set of all available [scanner factories][ScannerFactory] in the classpath, sorted by name.
          */
-        val ALL by lazy { LOADER.iterator().asSequence().toList().sortedBy { it.scannerName } }
+        val ALL: Set<ScannerFactory> by lazy {
+            LOADER.iterator().asSequence().toSortedSet(compareBy { it.scannerName })
+        }
     }
 
     /**