refactor(Maven)!: Introduce a function type to resolve packages

Instead of using `MavenSupport` directly in `MavenDependencyHandler`
to create packages for dependencies, use a package resolver function.
The main reason for this change is that for Tycho a partially
different algorithm for the creation of packages is required. However,
the change is also beneficial to simplify the logic in
`MavenDependencyHandler` and to reduce its coupling with other objects
in the Maven package manager implementation.

Signed-off-by: Oliver Heger <[email protected]>

Author: oheger-bosch

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

@@ -81,7 +81,12 @@ class Maven(
         localProjectBuildingResults += mavenSupport.prepareMavenProjects(definitionFiles)
 
         val localProjects = localProjectBuildingResults.mapValues { it.value.project }
-        val dependencyHandler = MavenDependencyHandler(managerName, projectType, mavenSupport, localProjects, sbtMode)
+        val dependencyHandler = MavenDependencyHandler(
+            managerName,
+            projectType,
+            localProjects,
+            mavenSupport.defaultPackageResolverFun(sbtMode)
+        )
         graphBuilder = DependencyGraphBuilder(dependencyHandler)
     }
 

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

@@ -151,7 +151,8 @@ class Tycho(
         mavenSupport: MavenSupport,
         mavenProjects: Map<String, MavenProject>
     ): DependencyGraphBuilder<DependencyNode> {
-        val dependencyHandler = MavenDependencyHandler(managerName, projectType, mavenSupport, mavenProjects, false)
+        val dependencyHandler =
+            MavenDependencyHandler(managerName, projectType, mavenProjects, mavenSupport.defaultPackageResolverFun())
         return DependencyGraphBuilder(dependencyHandler)
     }
 

plugins/package-managers/maven/src/main/kotlin/utils/MavenDependencyHandler.kt

@@ -30,10 +30,16 @@ import org.ossreviewtoolkit.model.Package
 import org.ossreviewtoolkit.model.PackageLinkage
 import org.ossreviewtoolkit.model.createAndLogIssue
 import org.ossreviewtoolkit.model.utils.DependencyHandler
-import org.ossreviewtoolkit.plugins.packagemanagers.maven.Maven
 import org.ossreviewtoolkit.utils.common.collectMessages
 import org.ossreviewtoolkit.utils.ort.showStackTrace
 
+/**
+ * Type alias for a function used by [MavenDependencyHandler] to create [Package] objects for detected dependencies.
+ * The function expects the [DependencyNode] representing the dependency. It returns the created [Package] object or
+ * throws an exception if the package could not be created (which will then lead to the creation of issue).
+ */
+typealias PackageResolverFun = (DependencyNode) -> Package
+
 /**
  * A specialized [DependencyHandler] implementation for the dependency model of Maven.
  */
@@ -44,19 +50,14 @@ class MavenDependencyHandler(
     /** The type of projects to handle. */
     private val projectType: String,
 
-    /** The helper object to invoke Maven-related functionality. */
-    internal val support: MavenSupport,
-
     /**
      * A map with information about the local projects in the current Maven build. Dependencies pointing to projects
      * sometimes need to be treated in a special way.
      */
     localProjects: Map<String, MavenProject>,
 
-    /**
-     * A flag whether [SBT compatibility mode][Maven.enableSbtMode] is enabled.
-     */
-    private val sbtMode: Boolean
+    /** The function for creating [Package] objects for detected dependencies. */
+    private val packageResolverFun: PackageResolverFun
 ) : DependencyHandler<DependencyNode> {
     /**
      * A set of identifiers that are known to point to local projects. This is updated for packages that are resolved
@@ -95,7 +96,7 @@ class MavenDependencyHandler(
         if (isLocalProject(dependency)) return null
 
         return runCatching {
-            val pkg = support.parsePackage(dependency.artifact, dependency.repositories, sbtMode = sbtMode)
+            val pkg = packageResolverFun(dependency)
 
             // There is the corner case that a dependency references a project, but in a different version than
             // the one used by the local build. Then, this dependency is actually a package, but Maven's

plugins/package-managers/maven/src/main/kotlin/utils/MavenSupport.kt

@@ -563,6 +563,16 @@ class MavenSupport(private val workspaceReader: WorkspaceReader) : Closeable {
         )
     }
 
+    /**
+     * Return a [PackageResolverFun] that uses functionality provided by this object (mainly the [parsePackage]
+     * function) to resolve a package for a given dependency. The function is configured with the given
+     * [SBT compatibility mode][sbtMode].
+     */
+    fun defaultPackageResolverFun(sbtMode: Boolean = false): PackageResolverFun =
+        { dependencyNode ->
+            parsePackage(dependencyNode.artifact, dependencyNode.repositories, sbtMode = sbtMode)
+        }
+
     /**
      * Create a [MavenSession] and setup the [LegacySupport] and [SessionScope] because this is required to load
      * extensions using Maven Wagon.

plugins/package-managers/maven/src/test/kotlin/utils/MavenDependencyHandlerTest.kt

@@ -40,7 +40,6 @@ import org.apache.maven.project.ProjectBuildingException
 
 import org.eclipse.aether.artifact.Artifact
 import org.eclipse.aether.graph.DependencyNode
-import org.eclipse.aether.repository.RemoteRepository
 
 import org.ossreviewtoolkit.model.Identifier
 import org.ossreviewtoolkit.model.Issue
@@ -134,31 +133,13 @@ class MavenDependencyHandlerTest : WordSpec({
     "createPackage" should {
         "create a package for a dependency" {
             val dependency = createDependency(PACKAGE_ID_SUFFIX)
-            val artifact = dependency.artifact
-            val repos = listOf(createRepository(), createRepository())
             val pkg = createPackage(PACKAGE_ID_SUFFIX)
             val issues = mutableListOf<Issue>()
 
-            val handler = createHandler()
-
-            every { dependency.repositories } returns repos
-            every { handler.support.parsePackage(artifact, repos) } returns pkg
-
-            handler.createPackage(dependency, issues) shouldBe pkg
-            issues should beEmpty()
-        }
-
-        "take the sbtMode flag into account" {
-            val dependency = createDependency(PACKAGE_ID_SUFFIX)
-            val artifact = dependency.artifact
-            val repos = listOf(createRepository())
-            val pkg = createPackage(PACKAGE_ID_SUFFIX)
-            val issues = mutableListOf<Issue>()
-
-            val handler = createHandler(sbtMode = true)
-
-            every { dependency.repositories } returns repos
-            every { handler.support.parsePackage(artifact, repos, sbtMode = true) } returns pkg
+            val handler = createHandler { node ->
+                node shouldBe dependency
+                pkg
+            }
 
             handler.createPackage(dependency, issues) shouldBe pkg
             issues should beEmpty()
@@ -176,28 +157,18 @@ class MavenDependencyHandlerTest : WordSpec({
 
         "return null for a package that is resolved to a project dependency" {
             val dependency = createDependency(PACKAGE_ID_SUFFIX)
-            val artifact = dependency.artifact
-            val repos = listOf(createRepository(), createRepository())
             val pkg = createPackage(PROJECT_ID_SUFFIX)
 
-            val handler = createHandler()
-
-            every { dependency.repositories } returns repos
-            every { handler.support.parsePackage(artifact, repos) } returns pkg
+            val handler = createHandler { pkg }
 
             handler.createPackage(dependency, mutableListOf()) should beNull()
         }
 
         "report the correct linkage for a package that is resolved to a project dependency" {
             val dependency = createDependency(PACKAGE_ID_SUFFIX)
-            val artifact = dependency.artifact
-            val repos = listOf(createRepository(), createRepository())
             val pkg = createPackage(PROJECT_ID_SUFFIX)
 
-            val handler = createHandler()
-
-            every { dependency.repositories } returns repos
-            every { handler.support.parsePackage(artifact, repos) } returns pkg
+            val handler = createHandler { pkg }
 
             handler.createPackage(dependency, mutableListOf())
 
@@ -210,14 +181,9 @@ class MavenDependencyHandlerTest : WordSpec({
                 IOException("General failure when reading hard disk.")
             )
             val dependency = createDependency(PACKAGE_ID_SUFFIX)
-            val artifact = dependency.artifact
-            val repos = listOf(createRepository())
             val issues = mutableListOf<Issue>()
 
-            val handler = createHandler()
-
-            every { dependency.repositories } returns repos
-            every { handler.support.parsePackage(artifact, repos) } throws exception
+            val handler = createHandler { throw exception }
 
             handler.createPackage(dependency, issues) should beNull()
 
@@ -249,6 +215,9 @@ private val LOCAL_PROJECTS = mapOf(
 /** ID of an inter-project dependency. */
 private val PROJECT_ID_SUFFIX = LOCAL_PROJECTS.keys.first()
 
+/** Constant for a resolver function that can be used if no interaction with the resolver is expected. */
+private val unusedPackageResolverFun: PackageResolverFun = { throw NotImplementedError() }
+
 /**
  * Return an [Identifier] from the given [mavenId]. The identifiers used by Maven internally are very close to
  * ORT's identifiers; only the type component is missing.
@@ -283,19 +252,11 @@ private fun createDependency(id: String): DependencyNode {
 }
 
 /**
- * Create the [MavenDependencyHandler] instance to be tested with mock dependencies and test data with the given
- * [sbtMode] flag.
- */
-private fun createHandler(sbtMode: Boolean = false): MavenDependencyHandler {
-    val mvn = mockk<MavenSupport>()
-    return MavenDependencyHandler(MANAGER_NAME, PROJECT_TYPE, mvn, LOCAL_PROJECTS, sbtMode)
-}
-
-/**
- * Convenience function to create a mock [RemoteRepository]. Note: This function solves some nasty false-positive
- * warnings about explicit type arguments.
+ * Create the [MavenDependencyHandler] instance to be tested with default parameters and the given
+ * [packageResolverFun].
  */
-private fun createRepository(): RemoteRepository = mockk()
+private fun createHandler(packageResolverFun: PackageResolverFun = unusedPackageResolverFun): MavenDependencyHandler =
+    MavenDependencyHandler(MANAGER_NAME, PROJECT_TYPE, LOCAL_PROJECTS, packageResolverFun)
 
 /**
  * Convenience function to create a mock [MavenProject]. Note: This function solves some nasty false-positive