Remove the feature to add authors to copyrights

The feature was a crude way to curate copyright statements by curating
authors and enabling the addition of authors as copyrights (with a
missing year even). That appraoch does not work if authors and copyrights
need to stay separate, as e.g. by German law not every author is a
copyright holder.

So remove this feature in favor of an upcoming change that introduces
proper and dedicated curations for concluded copyright statements.

Signed-off-by: Sebastian Schuberth <sschuberth@gmail.com>

Author: sschuberth

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

@@ -302,7 +302,6 @@ 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

@@ -237,7 +237,6 @@ class ReporterCommand : CliktCommand(
         val licenseInfoResolver = LicenseInfoResolver(
             provider = DefaultLicenseInfoProvider(ortResult, packageConfigurationProvider),
             copyrightGarbage = copyrightGarbage,
-            addAuthorsToCopyrights = config.addAuthorsToCopyrights,
             archiver = config.scanner.archive.createFileArchiver(),
             licenseFilenamePatterns = LicenseFilenamePatterns.getInstance()
         )

helper-cli/src/main/kotlin/utils/Extensions.kt

@@ -124,7 +124,6 @@ internal fun OrtResult.fetchScannedSources(id: Identifier): File {
 internal fun OrtResult.processAllCopyrightStatements(
     omitExcluded: Boolean = true,
     copyrightGarbage: Set<String> = emptySet(),
-    addAuthorsToCopyrights: Boolean = false,
     packageConfigurationProvider: PackageConfigurationProvider = PackageConfigurationProvider.EMPTY
 ): List<ProcessedCopyrightStatement> {
     val result = mutableListOf<ProcessedCopyrightStatement>()
@@ -133,8 +132,7 @@ internal fun OrtResult.processAllCopyrightStatements(
 
     val licenseInfoResolver = createLicenseInfoResolver(
         packageConfigurationProvider = packageConfigurationProvider,
-        copyrightGarbage = CopyrightGarbage(copyrightGarbage.toSortedSet()),
-        addAuthorsToCopyrights = addAuthorsToCopyrights
+        copyrightGarbage = CopyrightGarbage(copyrightGarbage.toSortedSet())
     )
 
     collectProjectsAndPackages().forEach { id ->

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

@@ -40,11 +40,6 @@ 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/DefaultLicenseInfoProvider.kt

@@ -61,20 +61,17 @@ class DefaultLicenseInfoProvider(
     private fun createDeclaredLicenseInfo(id: Identifier): DeclaredLicenseInfo =
         ortResult.getProject(id)?.let { project ->
             DeclaredLicenseInfo(
-                authors = project.authors,
                 licenses = project.declaredLicenses,
                 processed = project.declaredLicensesProcessed,
                 appliedCurations = emptyList()
             )
         } ?: ortResult.getPackage(id)?.let { (pkg, curations) ->
             DeclaredLicenseInfo(
-                authors = pkg.authors,
                 licenses = pkg.declaredLicenses,
                 processed = pkg.declaredLicensesProcessed,
                 appliedCurations = curations.filter { it.curation.declaredLicenseMapping.isNotEmpty() }
             )
         } ?: DeclaredLicenseInfo(
-            authors = sortedSetOf(),
             licenses = emptySet(),
             processed = ProcessedDeclaredLicense(null),
             appliedCurations = emptyList()

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

@@ -77,11 +77,6 @@ data class ConcludedLicenseInfo(
  * Information about the declared license of a package or project.
  */
 data class DeclaredLicenseInfo(
-    /**
-     * The set of authors.
-     */
-    val authors: SortedSet<String>,
-
     /**
      * The unmodified set of declared licenses.
      */

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

@@ -43,7 +43,6 @@ import org.ossreviewtoolkit.utils.spdx.SpdxSingleLicenseExpression
 class LicenseInfoResolver(
     private val provider: LicenseInfoProvider,
     private val copyrightGarbage: CopyrightGarbage,
-    val addAuthorsToCopyrights: Boolean,
     val archiver: FileArchiver?,
     val licenseFilenamePatterns: LicenseFilenamePatterns = LicenseFilenamePatterns.DEFAULT
 ) {
@@ -97,26 +96,6 @@ class LicenseInfoResolver(
                 originalDeclaredLicenses += licenseInfo.declaredLicenseInfo.processed.mapped.filterValues {
                     it == license
                 }.keys
-
-                licenseInfo.declaredLicenseInfo.authors.takeIf { it.isNotEmpty() && addAuthorsToCopyrights }?.also {
-                    locations += ResolvedLicenseLocation(
-                        provenance = UnknownProvenance,
-                        location = UNDEFINED_TEXT_LOCATION,
-                        appliedCuration = null,
-                        matchingPathExcludes = emptyList(),
-                        copyrights = it.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

@@ -34,12 +34,10 @@ import org.ossreviewtoolkit.model.licenses.LicenseInfoResolver
 fun OrtResult.createLicenseInfoResolver(
     packageConfigurationProvider: PackageConfigurationProvider = PackageConfigurationProvider.EMPTY,
     copyrightGarbage: CopyrightGarbage = CopyrightGarbage(),
-    addAuthorsToCopyrights: Boolean = false,
     archiver: FileArchiver? = null
 ) = LicenseInfoResolver(
         DefaultLicenseInfoProvider(this, packageConfigurationProvider),
         copyrightGarbage,
-        addAuthorsToCopyrights,
         archiver,
         LicenseFilenamePatterns.getInstance()
     )

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

@@ -546,42 +546,6 @@ class LicenseInfoResolverTest : WordSpec({
             result should containNumberOfLocationsForLicense(gplLicense, 2)
             result should containNumberOfLocationsForLicense(bsdLicense, 4)
         }
-
-        "resolve copyrights from authors if enabled" {
-            val licenseInfos = listOf(
-                createLicenseInfo(
-                    id = pkgId,
-                    authors = authors,
-                    declaredLicenses = declaredLicenses
-                )
-            )
-            val resolver = createResolver(licenseInfos, addAuthorsToCopyrights = true)
-
-            val result = resolver.resolveLicenseInfo(pkgId)
-            result should containCopyrightStatementsForLicenseExactly(
-                "LicenseRef-a",
-                "Copyright (C) The Author", "Copyright (C) The Other Author"
-            )
-            result should containCopyrightStatementsForLicenseExactly(
-                "LicenseRef-b",
-                "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 {
@@ -652,26 +616,22 @@ class LicenseInfoResolverTest : WordSpec({
 private fun createResolver(
     data: List<LicenseInfo>,
     copyrightGarbage: Set<String> = emptySet(),
-    addAuthorsToCopyrights: Boolean = false,
     archiver: FileArchiver = FileArchiver.createDefault()
 ) = LicenseInfoResolver(
     provider = SimpleLicenseInfoProvider(data),
     copyrightGarbage = CopyrightGarbage(copyrightGarbage.toSortedSet()),
-    addAuthorsToCopyrights = addAuthorsToCopyrights,
     archiver = archiver
 )
 
 private fun createLicenseInfo(
     id: Identifier,
-    authors: SortedSet<String> = sortedSetOf(),
     declaredLicenses: Set<String> = emptySet(),
     detectedLicenses: List<Findings> = emptyList(),
     concludedLicense: SpdxExpression? = null
 ) =
     LicenseInfo(
         id = id,
         declaredLicenseInfo = DeclaredLicenseInfo(
-            authors = authors,
             licenses = declaredLicenses,
             processed = DeclaredLicenseProcessor.process(declaredLicenses),
             appliedCurations = emptyList()