feat(model): Handle path excludes when resolving license files

Fixes #11869.

Signed-off-by: Frank Viernau <frank.viernau@gmail.com>

Author: fviernau

model/src/main/kotlin/licenses/LicenseInfoResolver.kt

@@ -77,8 +77,8 @@ class LicenseInfoResolver(
     /**
      * Get the [ResolvedLicenseFileInfo] for the project or package identified by [id]. Requires an [archiver] to be
      * configured, otherwise always returns empty results. To determine the applicable license files the files in
-     * the archive are matched against the configured license and patent file patterns (see [LicenseFilePatterns]) as
-     * follows:
+     * the archive are matched against path excludes and the configured license and patent file patterns (see
+     * [LicenseFilePatterns]) as follows:
      *
      * 1. For a repository provenance, all filenames in the VCS path are matched. If there are matches, then these are
      *    used as the result, otherwise that search is repeated recursively in the parent directory.
@@ -260,18 +260,19 @@ class LicenseInfoResolver(
         }
 
     private fun createLicenseFileInfo(id: Identifier): ResolvedLicenseFileInfo {
-        val provenances = provider.get(id).detectedLicenseInfo.findings.mapNotNull {
-            it.provenance as? KnownProvenance
-        }
-
-        val licenseFiles = provenances.flatMap { provenance ->
-            resolveLicenseFiles(id, provenance)
+        val licenseFiles = provider.get(id).detectedLicenseInfo.findings.flatMap { findings ->
+            val provenance = findings.provenance as? KnownProvenance ?: return@flatMap emptySet()
+            resolveLicenseFiles(id, provenance, findings.pathExcludes)
         }
 
         return ResolvedLicenseFileInfo(id, licenseFiles)
     }
 
-    private fun resolveLicenseFiles(id: Identifier, provenance: KnownProvenance): List<ResolvedLicenseFile> {
+    private fun resolveLicenseFiles(
+        id: Identifier,
+        provenance: KnownProvenance,
+        pathExcludes: Collection<PathExclude>
+    ): List<ResolvedLicenseFile> {
         if (archiver == null) return emptyList()
         val archiveDir = createOrtTempDir("archive")
 
@@ -286,6 +287,8 @@ class LicenseInfoResolver(
 
         val relativeFilePaths = archiveDir.walk().filter { it.isFile }.mapTo(mutableSetOf()) {
             it.relativeTo(archiveDir).invariantSeparatorsPath
+        }.filterNot { path ->
+            pathExcludes.any { it.matches(path) }
         }
 
         val rootLicenseFiles = when (provenance) {

model/src/test/kotlin/licenses/LicenseInfoResolverTest.kt

@@ -92,6 +92,7 @@ private val ARTIFACT_PROVENANCE = ArtifactProvenance(
     )
 )
 
+@Suppress("LargeClass")
 class LicenseInfoResolverTest : WordSpec({
     "resolveLicenseInfo()" should {
         "resolve declared licenses" {
@@ -680,6 +681,15 @@ class LicenseInfoResolverTest : WordSpec({
 
             result.files.map { it.path }.shouldContainExactlyInAnyOrder("path1/LICENSE")
         }
+
+        "return only non-excluded license files" {
+            val archiver = createArchiver(REPOSITORY_PROVENANCE, "LICENSE", "LICENSE2")
+            val licenseInfo = createLicenseInfo(ID, REPOSITORY_PROVENANCE, pathExcludes = listOf("LICENSE"))
+
+            val result = createResolver(data = listOf(licenseInfo), archiver = archiver).resolveLicenseFiles(ID)
+
+            result.files.map { it.path }.shouldContainExactlyInAnyOrder("LICENSE2")
+        }
     }
 
     "resolveLicenseFiles() for artifact provenance" should {
@@ -706,6 +716,15 @@ class LicenseInfoResolverTest : WordSpec({
                 "path2/LICENSE"
             )
         }
+
+        "return only non-excluded license files" {
+            val archiver = createArchiver(ARTIFACT_PROVENANCE, "LICENSE", "LICENSE2")
+            val licenseInfo = createLicenseInfo(ID, ARTIFACT_PROVENANCE, pathExcludes = listOf("LICENSE"))
+
+            val result = createResolver(data = listOf(licenseInfo), archiver = archiver).resolveLicenseFiles(ID)
+
+            result.files.map { it.path }.shouldContainExactlyInAnyOrder("LICENSE2")
+        }
     }
 
     "resolveLicenseFiles()" should {
@@ -816,7 +835,7 @@ private fun createLicenseInfo(
     id: Identifier,
     provenance: KnownProvenance,
     vararg pathAndLicense: Pair<String, String>,
-    pathExcludes: Collection<PathExclude> = emptyList()
+    pathExcludes: Collection<String> = emptyList()
 ) = createLicenseInfo(
     id = id,
     detectedLicenses = listOf(
@@ -826,7 +845,7 @@ private fun createLicenseInfo(
                 license to listOf(TextLocation(path, 1))
             }.toFindingsSet(),
             copyrights = emptySet(),
-            pathExcludes = pathExcludes.toList(),
+            pathExcludes = pathExcludes.map { PathExclude(pattern = it, reason = PathExcludeReason.OTHER) },
             licenseFindingCurations = emptyList(),
             relativeFindingsPath = ""
         )