feat(Maven): Support path excludes for Tycho

If the `skipExcluded` flag in the Analyzer configuration is set,
exclude projects matched by path excludes from the Maven build. This
should speed up the processing time and can prevent problematic
modules to cause the build to fail.

Signed-off-by: Oliver Heger <oliver.heger@bosch.io>

Author: oheger-bosch

plugins/package-managers/maven/src/main/kotlin/Tycho.kt

@@ -21,8 +21,11 @@ package org.ossreviewtoolkit.plugins.packagemanagers.maven
 
 import java.io.File
 import java.io.PrintStream
+import java.nio.file.Path
 import java.util.concurrent.atomic.AtomicReference
 
+import kotlin.io.path.invariantSeparatorsPathString
+
 import org.apache.logging.log4j.kotlin.logger
 import org.apache.maven.AbstractMavenLifecycleParticipant
 import org.apache.maven.cli.MavenCli
@@ -187,8 +190,7 @@ class Tycho(
                 System.setProperty(MavenCli.MULTIMODULE_PROJECT_DIRECTORY, projectRoot.absolutePath)
 
                 cli.doMain(
-                    // The "package" goal is required; otherwise the Tycho extension is not activated.
-                    arrayOf("package", "dependency:tree", "-DoutputType=json"),
+                    generateMavenOptions(projectRoot),
                     projectRoot.path,
                     null,
                     null
@@ -260,11 +262,47 @@ class Tycho(
 
         return rootIssues
     }
+
+    /**
+     * Generate the command line options to be passed to the Maven CLI for the given [root] folder.
+     */
+    private fun generateMavenOptions(root: File): Array<String> =
+        buildList {
+            // The "package" goal is required; otherwise the Tycho extension is not activated.
+            add("package")
+            add("dependency:tree")
+            add("-DoutputType=json")
+
+            generateModuleExcludes(root)?.takeUnless { it.isEmpty() }?.let { excludedModules ->
+                add("-pl")
+                add(excludedModules)
+            }
+        }.toTypedArray()
+
+    /**
+     * Generate a list of submodules to be excluded for the Maven build with the given [rootProject] folder based on
+     * the configured exclusions. The resulting string (if any) is used as the value of Maven's `-pl` option.
+     */
+    private fun generateModuleExcludes(rootProject: File): String? {
+        if (!analyzerConfig.skipExcluded) return null
+
+        val analysisRootPath = analysisRoot.toPath()
+        val rootProjectPath = rootProject.toPath()
+        return rootProject.walk().filter { it.name == "pom.xml" }
+            .map { it.toPath().parent }
+            .filter { excludes.isPathExcluded(analysisRootPath.relativeSubPath(it)) }
+            .joinToString(",") { "!${rootProjectPath.relativeSubPath(it)}" }
+    }
 }
 
 /** The name of the logger used by the Maven dependency tree plugin. */
 private const val DEPENDENCY_TREE_LOGGER = "org.apache.maven.plugins.dependency.tree.TreeMojo"
 
+/**
+ * Return the relative path of [other] to this [Path].
+ */
+private fun Path.relativeSubPath(other: Path): String = relativize(other).invariantSeparatorsPathString
+
 /**
  * A special exception class to indicate that a Tycho build failed completely.
  */

plugins/package-managers/maven/src/test/kotlin/TychoTest.kt

@@ -26,14 +26,19 @@ import io.kotest.engine.spec.tempdir
 import io.kotest.engine.spec.tempfile
 import io.kotest.inspectors.forAll
 import io.kotest.matchers.collections.beEmpty
+import io.kotest.matchers.collections.contain
 import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
+import io.kotest.matchers.comparables.shouldBeGreaterThan
 import io.kotest.matchers.should
 import io.kotest.matchers.shouldBe
+import io.kotest.matchers.shouldNot
 import io.kotest.matchers.string.shouldContain
 
 import io.mockk.every
 import io.mockk.mockk
+import io.mockk.slot
 import io.mockk.spyk
+import io.mockk.verify
 
 import java.io.File
 import java.io.PrintStream
@@ -47,6 +52,11 @@ import org.eclipse.aether.graph.DependencyNode
 import org.ossreviewtoolkit.model.Identifier
 import org.ossreviewtoolkit.model.Package
 import org.ossreviewtoolkit.model.Severity
+import org.ossreviewtoolkit.model.config.AnalyzerConfiguration
+import org.ossreviewtoolkit.model.config.Excludes
+import org.ossreviewtoolkit.model.config.PathExclude
+import org.ossreviewtoolkit.model.config.PathExcludeReason
+import org.ossreviewtoolkit.model.config.RepositoryConfiguration
 import org.ossreviewtoolkit.model.utils.DependencyGraphBuilder
 import org.ossreviewtoolkit.plugins.packagemanagers.maven.utils.DependencyTreeMojoNode
 import org.ossreviewtoolkit.plugins.packagemanagers.maven.utils.JSON
@@ -186,6 +196,99 @@ class TychoTest : WordSpec({
                 subProject3.identifier("Tycho").toCoordinates()
             )
         }
+
+        "exclude projects from the build according to path excludes" {
+            val analysisRoot = tempdir()
+            val tychoRoot = analysisRoot.createSubModule("tycho-root")
+            tychoRoot.createSubModule("tycho-sub1")
+            tychoRoot.createSubModule("tycho-sub2")
+            tychoRoot.createSubModule("tycho-excluded-sub1")
+            val module = tychoRoot.createSubModule("tycho-excluded-sub2")
+            module.createSubModule("tycho-excluded-sub2-sub")
+            val rootProject = createMavenProject("root", tychoRoot.pom)
+
+            val excludes = Excludes(
+                paths = listOf(
+                    PathExclude("tycho-root/tycho-excluded-sub1", PathExcludeReason.EXAMPLE_OF),
+                    PathExclude("tycho-root/tycho-excluded-sub2/**", PathExcludeReason.TEST_OF),
+                    PathExclude("other-root/**", PathExcludeReason.EXAMPLE_OF)
+                )
+            )
+            val analyzerConfig = AnalyzerConfiguration(skipExcluded = true)
+            val repositoryConfig = RepositoryConfiguration(excludes = excludes)
+
+            val tycho = spyk(Tycho("Tycho", analysisRoot, analyzerConfig, repositoryConfig))
+            val cli = injectCliMock(tycho, listOf(rootProject).toJson(), listOf(rootProject))
+
+            tycho.resolveDependencies(tychoRoot.pom, emptyMap())
+
+            val slotArgs = slot<Array<String>>()
+            verify {
+                cli.doMain(capture(slotArgs), any(), any(), any())
+            }
+
+            with(slotArgs.captured) {
+                val indexPl = indexOf("-pl")
+                indexPl shouldBeGreaterThan -1
+                val excludedProjects = get(indexPl + 1).split(",")
+                excludedProjects shouldContainExactlyInAnyOrder listOf(
+                    "!tycho-excluded-sub1",
+                    "!tycho-excluded-sub2",
+                    "!tycho-excluded-sub2/tycho-excluded-sub2-sub"
+                )
+            }
+        }
+
+        "not add a -pl option if no projects are excluded" {
+            val analysisRoot = tempdir()
+            val tychoRoot = analysisRoot.createSubModule("tycho-root")
+            tychoRoot.createSubModule("tycho-sub1")
+            tychoRoot.createSubModule("tycho-sub2")
+            val rootProject = createMavenProject("root", tychoRoot.pom)
+
+            val excludes = Excludes(paths = listOf(PathExclude("other-root/**", PathExcludeReason.EXAMPLE_OF)))
+            val analyzerConfig = AnalyzerConfiguration(skipExcluded = true)
+            val repositoryConfig = RepositoryConfiguration(excludes = excludes)
+
+            val tycho = spyk(Tycho("Tycho", analysisRoot, analyzerConfig, repositoryConfig))
+            val cli = injectCliMock(tycho, listOf(rootProject).toJson(), listOf(rootProject))
+
+            tycho.resolveDependencies(tychoRoot.pom, emptyMap())
+
+            val slotArgs = slot<Array<String>>()
+            verify {
+                cli.doMain(capture(slotArgs), any(), any(), any())
+            }
+
+            slotArgs.captured.toList() shouldNot contain("-pl")
+        }
+
+        "not exclude projects if skipExcluded is false" {
+            val analysisRoot = tempdir()
+            val tychoRoot = analysisRoot.createSubModule("tycho-root")
+            tychoRoot.createSubModule("tycho-sub1")
+            tychoRoot.createSubModule("tycho-sub2")
+            tychoRoot.createSubModule("tycho-excluded-sub1")
+            val rootProject = createMavenProject("root", tychoRoot.pom)
+
+            val excludes = Excludes(
+                paths = listOf(PathExclude("tycho-root/tycho-excluded-sub1", PathExcludeReason.EXAMPLE_OF))
+            )
+            val analyzerConfig = AnalyzerConfiguration()
+            val repositoryConfig = RepositoryConfiguration(excludes = excludes)
+
+            val tycho = spyk(Tycho("Tycho", analysisRoot, analyzerConfig, repositoryConfig))
+            val cli = injectCliMock(tycho, listOf(rootProject).toJson(), listOf(rootProject))
+
+            tycho.resolveDependencies(tychoRoot.pom, emptyMap())
+
+            val slotArgs = slot<Array<String>>()
+            verify {
+                cli.doMain(capture(slotArgs), any(), any(), any())
+            }
+
+            slotArgs.captured.toList() shouldNot contain("-pl")
+        }
     }
 })
 
@@ -245,3 +348,19 @@ private fun injectCliMock(
 
     return cli
 }
+
+/**
+ * Return a reference to the Maven pom file in this folder.
+ */
+private val File.pom: File
+    get() = resolve("pom.xml")
+
+/**
+ * Create a sub folder with the given [name] and a pom file to simulate a Maven module. Return the created folder
+ * for the module.
+ */
+private fun File.createSubModule(name: String): File =
+    resolve(name).apply {
+        mkdirs()
+        pom.also { it.writeText("pom-$name") }
+    }