feat(model,scanner): extract NONE-padding logic into reusable helpers

Prep work for upcoming PR oss-review-toolkit#10502.

* Add ScanResult.padNoneLicenseFindings(paths)
  Creates a copy whose summary contains a single
  LicenseFinding(SpdxConstants.NONE, UNKNOWN_LINE) for every path in
  *paths* that currently lacks a licence finding.

* Add ScannerRun.padNoneLicenseFindings()
  Uses the run’s FileList map to obtain all paths per provenance and
  delegates to the ScanResult helper for every contained result.

* Remove the ad-hoc padding code from Scanner.kt and replace it with a
  single call to scannerRun.padNoneLicenseFindings() when
  includeFilesWithoutFindings is enabled.

* Introduce ScannerRunTest.padNoneLicenseFindings()
  Ensures a file without licence findings receives exactly one NONE entry.

This refactor keeps behaviour unchanged while centralising the padding
logic in the model layer, improving reuse and testability.

Signed-off-by: Jonatan Männchen <jonatan@maennchen.ch>

Author: maennchen

model/src/main/kotlin/ScanResult.kt

@@ -22,6 +22,7 @@ package org.ossreviewtoolkit.model
 import com.fasterxml.jackson.annotation.JsonInclude
 
 import org.ossreviewtoolkit.model.utils.PathLicenseMatcher
+import org.ossreviewtoolkit.utils.spdx.SpdxConstants
 
 /**
  * The result of a single scan of a single package.
@@ -73,4 +74,23 @@ data class ScanResult(
      */
     fun filterByIgnorePatterns(ignorePatterns: Collection<String>): ScanResult =
         copy(summary = summary.filterByIgnorePatterns(ignorePatterns))
+
+    /**
+     * Return a [ScanResult] whose [summary] contains SpdxConstants.NONE findings for all [paths] that do not
+     * already have a license finding.
+     */
+    internal fun padNoneLicenseFindings(paths: Set<String>): ScanResult {
+        val pathsWithFindings = summary.licenseFindings.mapTo(mutableSetOf()) { it.location.path }
+        val pathsWithoutFindings = paths - pathsWithFindings
+
+        val findingsThatAreNone = pathsWithoutFindings.mapTo(mutableSetOf()) {
+            LicenseFinding(SpdxConstants.NONE, TextLocation(it, TextLocation.UNKNOWN_LINE))
+        }
+
+        return copy(
+            summary = summary.copy(
+                licenseFindings = summary.licenseFindings + findingsThatAreNone
+            )
+        )
+    }
 }

model/src/main/kotlin/ScannerRun.kt

@@ -273,6 +273,22 @@ data class ScannerRun(
         scanResultsById.mapValues { (_, scanResults) ->
             scanResults.flatMapTo(mutableSetOf()) { it.summary.issues }
         }.zipWithSets(issues)
+
+    /**
+     * Return a [ScannerRun] where all scan results have been padded with findings for files that do not have any
+     * license findings.
+     */
+    internal fun padNoneLicenseFindings(): ScannerRun {
+        val paddedScanResults = scanResults.mapTo(mutableSetOf()) { scanResult ->
+            val allPaths = fileListByProvenance[scanResult.provenance]?.files?.mapTo(mutableSetOf()) {
+                it.path
+            }.orEmpty()
+
+            scanResult.padNoneLicenseFindings(allPaths)
+        }
+
+        return copy(scanResults = paddedScanResults)
+    }
 }
 
 private fun scanResultForProvenanceResolutionIssues(packageProvenance: KnownProvenance?, issues: List<Issue>) =

model/src/test/kotlin/ScannerRunTest.kt

@@ -28,6 +28,7 @@ import io.kotest.matchers.should
 import org.ossreviewtoolkit.model.FileList.Entry
 import org.ossreviewtoolkit.model.utils.alignRevisions
 import org.ossreviewtoolkit.model.utils.clearVcsPath
+import org.ossreviewtoolkit.utils.spdx.SpdxConstants
 
 class ScannerRunTest : WordSpec({
     "getFileList()" should {
@@ -145,4 +146,55 @@ class ScannerRunTest : WordSpec({
             )
         }
     }
+
+    "padNoneLicenseFindings()" should {
+        "add NONE license findings for files without findings" {
+            val provenance = RepositoryProvenance(
+                VcsInfo(type = VcsType.GIT, url = "https://github.com/example.git", revision = "revision"),
+                "revision"
+            )
+
+            val run = ScannerRun.EMPTY.copy(
+                provenances = setOf(
+                    ProvenanceResolutionResult(
+                        id = Identifier("maven::example:1.0"),
+                        packageProvenance = provenance
+                    )
+                ),
+                scanResults = setOf(
+                    ScanResult(
+                        provenance = provenance,
+                        scanner = ScannerDetails.EMPTY,
+                        summary = ScanSummary.EMPTY.copy(
+                            licenseFindings = setOf(
+                                LicenseFinding("MIT", TextLocation("file1.txt", 1, 1))
+                            )
+                        )
+                    )
+                ),
+                files = setOf(
+                    FileList(
+                        provenance = provenance,
+                        files = setOf(
+                            Entry(
+                                path = "file1.txt",
+                                sha1 = "1111111111111111111111111111111111111111"
+                            ),
+                            Entry(
+                                path = "file2.txt",
+                                sha1 = "2222222222222222222222222222222222222222"
+                            )
+                        )
+                    )
+                )
+            )
+
+            val paddedRun = run.padNoneLicenseFindings()
+
+            paddedRun.scanResults.single().summary.licenseFindings should containExactlyInAnyOrder(
+                LicenseFinding("MIT", TextLocation("file1.txt", 1, 1)),
+                LicenseFinding(SpdxConstants.NONE, TextLocation("file2.txt", TextLocation.UNKNOWN_LINE))
+            )
+        }
+    }
 })

scanner/src/main/kotlin/Scanner.kt

@@ -36,14 +36,12 @@ import org.ossreviewtoolkit.model.FileList
 import org.ossreviewtoolkit.model.Identifier
 import org.ossreviewtoolkit.model.Issue
 import org.ossreviewtoolkit.model.KnownProvenance
-import org.ossreviewtoolkit.model.LicenseFinding
 import org.ossreviewtoolkit.model.OrtResult
 import org.ossreviewtoolkit.model.Package
 import org.ossreviewtoolkit.model.PackageType
 import org.ossreviewtoolkit.model.ProvenanceResolutionResult
 import org.ossreviewtoolkit.model.ScanResult
 import org.ossreviewtoolkit.model.ScannerRun
-import org.ossreviewtoolkit.model.TextLocation
 import org.ossreviewtoolkit.model.VcsInfo
 import org.ossreviewtoolkit.model.config.DownloaderConfiguration
 import org.ossreviewtoolkit.model.config.ScannerConfiguration
@@ -68,7 +66,6 @@ import org.ossreviewtoolkit.utils.common.collectMessages
 import org.ossreviewtoolkit.utils.common.safeDeleteRecursively
 import org.ossreviewtoolkit.utils.ort.Environment
 import org.ossreviewtoolkit.utils.ort.showStackTrace
-import org.ossreviewtoolkit.utils.spdx.SpdxConstants
 import org.ossreviewtoolkit.utils.spdx.toSpdx
 
 class Scanner(
@@ -193,7 +190,7 @@ class Scanner(
 
         val vcsPathsForProvenances = getVcsPathsForProvenances(provenances)
 
-        val filteredScanResults = filterScanResultsByVcsPaths(controller.getAllScanResults(), vcsPathsForProvenances)
+        val scanResults = filterScanResultsByVcsPaths(controller.getAllScanResults(), vcsPathsForProvenances)
 
         val files = controller.getAllFileLists().mapTo(mutableSetOf()) { (provenance, fileList) ->
             FileList(
@@ -208,42 +205,25 @@ class Scanner(
             }
         }
 
-        val scanResults = if (scannerConfig.includeFilesWithoutFindings) {
-            filteredScanResults.mapTo(mutableSetOf()) { scanResult ->
-                val allPaths = controller.getAllFileLists()[scanResult.provenance]?.files?.mapTo(mutableSetOf()) {
-                    it.path
-                }.orEmpty()
-
-                val pathsWithFindings = scanResult.summary.licenseFindings.mapTo(mutableSetOf()) { it.location.path }
-                val pathsWithoutFindings = allPaths - pathsWithFindings
-
-                val findingsThatAreNone = pathsWithoutFindings.mapTo(mutableSetOf()) {
-                    LicenseFinding(SpdxConstants.NONE, TextLocation(it, TextLocation.UNKNOWN_LINE))
-                }
-
-                scanResult.copy(
-                    summary = scanResult.summary.copy(
-                        licenseFindings = scanResult.summary.licenseFindings + findingsThatAreNone
-                    )
-                )
-            }
-        } else {
-            filteredScanResults
-        }
-
         val scannerIds = scannerWrappers.mapTo(mutableSetOf()) { it.descriptor.id }
         val scanners = packages.associateBy({ it.id }) { scannerIds }
 
         val issues = controller.getIssues()
 
-        return ScannerRun.EMPTY.copy(
+        val scannerRun = ScannerRun.EMPTY.copy(
             config = scannerConfig,
             provenances = provenances,
             scanResults = scanResults,
             files = files,
             scanners = scanners,
             issues = issues
         )
+
+        if (scannerConfig.includeFilesWithoutFindings) {
+            return scannerRun.padNoneLicenseFindings()
+        }
+
+        return scannerRun
     }
 
     private suspend fun resolvePackageProvenances(controller: ScanController) {