Make the mapping of authors to copyrights configurable

Disable the feature by default as that seems to be the common
expectation.

Resolves #4314.

Signed-off-by: Sebastian Schuberth <sebastian.schuberth@bosch.io>

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

@@ -275,6 +275,7 @@ class EvaluatorCommand : CliktCommand(name = "evaluate", help = "Evaluate ORT re
         val licenseInfoResolver = LicenseInfoResolver(
             provider = DefaultLicenseInfoProvider(ortResultInput, packageConfigurationProvider),
             copyrightGarbage = copyrightGarbage,
+            addAuthorsToCopyrights = config.addAuthorsToCopyrights,
             archiver = config.scanner.archive.createFileArchiver(),
             licenseFilenamePatterns = LicenseFilenamePatterns.getInstance()
         )

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

@@ -219,10 +219,12 @@ class ReporterCommand : CliktCommand(
 
         val packageConfigurationProvider = packageConfigurationOption.createProvider()
 
+        val config = globalOptionsForSubcommands.config
         val licenseInfoResolver = LicenseInfoResolver(
             provider = DefaultLicenseInfoProvider(ortResult, packageConfigurationProvider),
             copyrightGarbage = copyrightGarbage,
-            archiver = globalOptionsForSubcommands.config.scanner.archive.createFileArchiver(),
+            addAuthorsToCopyrights = config.addAuthorsToCopyrights,
+            archiver = config.scanner.archive.createFileArchiver(),
             licenseFilenamePatterns = LicenseFilenamePatterns.getInstance()
         )
 

helper-cli/src/main/kotlin/common/Utils.kt

@@ -228,6 +228,7 @@ internal data class ProcessedCopyrightStatement(
 internal fun OrtResult.processAllCopyrightStatements(
     omitExcluded: Boolean = true,
     copyrightGarbage: Set<String> = emptySet(),
+    addAuthorsToCopyrights: Boolean = false,
     packageConfigurationProvider: PackageConfigurationProvider = SimplePackageConfigurationProvider.EMPTY
 ): List<ProcessedCopyrightStatement> {
     val result = mutableListOf<ProcessedCopyrightStatement>()
@@ -236,7 +237,8 @@ internal fun OrtResult.processAllCopyrightStatements(
 
     val licenseInfoResolver = createLicenseInfoResolver(
         packageConfigurationProvider = packageConfigurationProvider,
-        copyrightGarbage = CopyrightGarbage(copyrightGarbage.toSortedSet())
+        copyrightGarbage = CopyrightGarbage(copyrightGarbage.toSortedSet()),
+        addAuthorsToCopyrights = addAuthorsToCopyrights
     )
 
     getProjectAndPackageIds().forEach { id ->

model/src/main/kotlin/config/OrtConfiguration.kt

@@ -43,6 +43,11 @@ data class OrtConfiguration(
      */
     val licenseFilePatterns: LicenseFilenamePatterns = LicenseFilenamePatterns.DEFAULT,
 
+    /**
+     * A flag to indicate whether authors should be considered as copyright holders.
+     */
+    val addAuthorsToCopyrights: Boolean = false,
+
     /**
      * The threshold from which on issues count as severe.
      */

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

@@ -46,6 +46,7 @@ import org.ossreviewtoolkit.utils.ORT_NAME
 class LicenseInfoResolver(
     private val provider: LicenseInfoProvider,
     private val copyrightGarbage: CopyrightGarbage,
+    val addAuthorsToCopyrights: Boolean,
     val archiver: FileArchiver?,
     val licenseFilenamePatterns: LicenseFilenamePatterns = LicenseFilenamePatterns.DEFAULT
 ) {
@@ -98,24 +99,26 @@ class LicenseInfoResolver(
                     licenseInfo.declaredLicenseInfo.processed.mapped.filterValues { it == license }.keys
                 )
 
-                licenseInfo.declaredLicenseInfo.authors.takeIf { it.isNotEmpty() }?.let {
-                    locations.add(ResolvedLicenseLocation(
-                        provenance = UnknownProvenance,
-                        location = UNDEFINED_TEXT_LOCATION,
-                        appliedCuration = null,
-                        matchingPathExcludes = emptyList(),
-                        copyrights = licenseInfo.declaredLicenseInfo.authors.mapTo(mutableSetOf()) { author ->
-                            val statement = "Copyright (C) $author".takeUnless {
-                                author.contains("Copyright", ignoreCase = true)
-                            } ?: author
-
-                            ResolvedCopyrightFinding(
-                                statement = statement,
-                                location = UNDEFINED_TEXT_LOCATION,
-                                matchingPathExcludes = emptyList()
-                            )
-                        }
-                    ))
+                if (addAuthorsToCopyrights) {
+                    licenseInfo.declaredLicenseInfo.authors.takeIf { it.isNotEmpty() }?.let {
+                        locations.add(ResolvedLicenseLocation(
+                            provenance = UnknownProvenance,
+                            location = UNDEFINED_TEXT_LOCATION,
+                            appliedCuration = null,
+                            matchingPathExcludes = emptyList(),
+                            copyrights = licenseInfo.declaredLicenseInfo.authors.mapTo(mutableSetOf()) { author ->
+                                val statement = "Copyright (C) $author".takeUnless {
+                                    author.contains("Copyright", ignoreCase = true)
+                                } ?: author
+
+                                ResolvedCopyrightFinding(
+                                    statement = statement,
+                                    location = UNDEFINED_TEXT_LOCATION,
+                                    matchingPathExcludes = emptyList()
+                                )
+                            }
+                        ))
+                    }
                 }
             }
         }

model/src/main/kotlin/utils/OrtResultExtensions.kt

@@ -57,11 +57,15 @@ fun OrtResult.collectDeclaredLicenses(omitExcluded: Boolean = false): Map<Identi
 fun OrtResult.createLicenseInfoResolver(
     packageConfigurationProvider: PackageConfigurationProvider = SimplePackageConfigurationProvider.EMPTY,
     copyrightGarbage: CopyrightGarbage = CopyrightGarbage(),
+    addAuthorsToCopyrights: Boolean = false,
     archiver: FileArchiver? = null
-): LicenseInfoResolver {
-    val licenseInfoProvider = DefaultLicenseInfoProvider(this, packageConfigurationProvider)
-    return LicenseInfoResolver(licenseInfoProvider, copyrightGarbage, archiver, LicenseFilenamePatterns.getInstance())
-}
+) = LicenseInfoResolver(
+        DefaultLicenseInfoProvider(this, packageConfigurationProvider),
+        copyrightGarbage,
+        addAuthorsToCopyrights,
+        archiver,
+        LicenseFilenamePatterns.getInstance()
+    )
 
 /**
  * Copy this [OrtResult] and add all [labels] to the existing labels, overwriting existing labels on conflict.

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

@@ -522,15 +522,15 @@ class LicenseInfoResolverTest : WordSpec() {
                 result should containNumberOfLocationsForLicense(bsdLicense, 4)
             }
 
-            "resolve copyrights from authors" {
+            "resolve copyrights from authors if enabled" {
                 val licenseInfos = listOf(
                     createLicenseInfo(
                         id = pkgId,
                         authors = authors,
                         declaredLicenses = declaredLicenses
                     )
                 )
-                val resolver = createResolver(licenseInfos)
+                val resolver = createResolver(licenseInfos, addAuthorsToCopyrights = true)
 
                 val result = resolver.resolveLicenseInfo(pkgId)
                 result should containCopyrightStatementsForLicenseExactly(
@@ -542,6 +542,21 @@ class LicenseInfoResolverTest : WordSpec() {
                     "Copyright (C) The Author", "Copyright (C) The Other Author"
                 )
             }
+
+            "not resolve copyrights from authors if disabled" {
+                val licenseInfos = listOf(
+                    createLicenseInfo(
+                        id = pkgId,
+                        authors = authors,
+                        declaredLicenses = declaredLicenses
+                    )
+                )
+                val resolver = createResolver(licenseInfos, addAuthorsToCopyrights = false)
+
+                val result = resolver.resolveLicenseInfo(pkgId)
+                result should containCopyrightStatementsForLicenseExactly("LicenseRef-a")
+                result should containCopyrightStatementsForLicenseExactly("LicenseRef-b")
+            }
         }
 
         "resolveLicenseFiles()" should {
@@ -612,11 +627,13 @@ class LicenseInfoResolverTest : WordSpec() {
     private fun createResolver(
         data: List<LicenseInfo>,
         copyrightGarbage: Set<String> = emptySet(),
+        addAuthorsToCopyrights: Boolean = false,
         archiver: FileArchiver = FileArchiver.createDefault()
     ) = LicenseInfoResolver(
-        SimpleLicenseInfoProvider(data),
-        CopyrightGarbage(copyrightGarbage.toSortedSet()),
-        archiver
+        provider = SimpleLicenseInfoProvider(data),
+        copyrightGarbage = CopyrightGarbage(copyrightGarbage.toSortedSet()),
+        addAuthorsToCopyrights = addAuthorsToCopyrights,
+        archiver = archiver
     )
 
     private fun createLicenseInfo(

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

@@ -40,9 +40,10 @@ import org.ossreviewtoolkit.utils.test.createDefault
 
 class LicenseViewTest : WordSpec() {
     private val licenseInfoResolver = LicenseInfoResolver(
-        DefaultLicenseInfoProvider(ortResult, SimplePackageConfigurationProvider.EMPTY),
-        CopyrightGarbage(),
-        FileArchiver.createDefault()
+        provider = DefaultLicenseInfoProvider(ortResult, SimplePackageConfigurationProvider.EMPTY),
+        copyrightGarbage = CopyrightGarbage(),
+        addAuthorsToCopyrights = false,
+        archiver = FileArchiver.createDefault()
     )
 
     private fun LicenseView.getLicensesWithSources(

reporter/src/main/kotlin/ReporterInput.kt

@@ -74,6 +74,7 @@ data class ReporterInput(
     val licenseInfoResolver: LicenseInfoResolver = LicenseInfoResolver(
         provider = DefaultLicenseInfoProvider(ortResult, packageConfigurationProvider),
         copyrightGarbage = copyrightGarbage,
+        addAuthorsToCopyrights = ortConfig.addAuthorsToCopyrights,
         archiver = ortConfig.scanner.archive.createFileArchiver(),
         licenseFilenamePatterns = ortConfig.licenseFilePatterns
     ),

reporter/src/main/kotlin/utils/FreemarkerTemplateProcessor.kt

@@ -451,6 +451,7 @@ private fun ReporterInput.replaceOrtResult(ortResult: OrtResult): ReporterInput
         licenseInfoResolver = LicenseInfoResolver(
             provider = DefaultLicenseInfoProvider(ortResult, packageConfigurationProvider),
             copyrightGarbage = copyrightGarbage,
+            addAuthorsToCopyrights = licenseInfoResolver.addAuthorsToCopyrights,
             archiver = licenseInfoResolver.archiver,
             licenseFilenamePatterns = licenseInfoResolver.licenseFilenamePatterns
         )