refactor(spdx-utils): Map deprecated and simple licenses separately

The previous approach was intertwining the mapping of deprecated and
simple licenses in an "all or nothing" manner. However, conservative
users of the API might only want to rely on unambiguous / uncontroversial
mappings. Allow such users to only map deprecated licenses by mapping them
separately from simple licenses.

Signed-off-by: Sebastian Schuberth <sebastian@doubleopen.org>

Author: sschuberth

utils/ort/src/test/kotlin/DeclaredLicenseProcessorTest.kt

@@ -48,7 +48,9 @@ class DeclaredLicenseProcessorTest : StringSpec() {
     /**
      * A collection of declared license strings found in open source packages.
      */
-    private val declaredLicenses = SpdxSimpleLicenseMapping.mapping.keys + SpdxDeclaredLicenseMapping.mapping.keys
+    private val declaredLicenses = SpdxDeclaredLicenseMapping.mapping.keys +
+        SpdxSimpleLicenseMapping.simpleExpressionMapping.keys +
+        SpdxSimpleLicenseMapping.deprecatedExpressionMapping.keys
 
     init {
         "Declared licenses can be processed" {

utils/spdx/src/main/kotlin/SpdxSimpleLicenseMapping.kt

@@ -38,28 +38,29 @@ object SpdxSimpleLicenseMapping {
     /**
      * The map of simple license names associated with their corresponding [SPDX expression][SpdxLicenseIdExpression].
      */
-    internal val simpleExpressionMapping = simpleLicenseMapping.mapValues { (_, v) -> v.toExpression() }
-        .toSortedMap(String.CASE_INSENSITIVE_ORDER)
+    val simpleExpressionMapping by lazy {
+        simpleLicenseMapping.mapValuesTo(sortedMapOf(String.CASE_INSENSITIVE_ORDER)) { (_, v) -> v.toExpression() }
+    }
 
     /**
      * The map of deprecated SPDX license IDs associated with their current [SPDX expression]
      * [SpdxSingleLicenseExpression].
      */
-    private val deprecatedExpressionMapping by lazy {
+    val deprecatedExpressionMapping by lazy {
         val resource = checkNotNull(javaClass.getResource("/deprecated-license-mapping.yml"))
-        yamlMapper.readValue<Map<String, SpdxSingleLicenseExpression>>(resource)
+        val mapping = yamlMapper.readValue<Map<String, SpdxSingleLicenseExpression>>(resource)
+        mapping.toSortedMap(String.CASE_INSENSITIVE_ORDER)
     }
 
     /**
-     * The map of varied SPDX license ids associated with their corresponding SPDX expression.
+     * Return the [SpdxSingleLicenseExpression] the [license] maps to, or null if there is no corresponding expression.
+     * If [mapDeprecated] is true, licenses marked as deprecated in the SPDX standard are mapped to their corresponding
+     * current expression. If [mapSimple] is true, licenses that are commonly known abbreviations or aliases are mapped
+     * to their corresponding official expression.
      */
-    val mapping = (simpleExpressionMapping + deprecatedExpressionMapping).toSortedMap(String.CASE_INSENSITIVE_ORDER)
-
-    /**
-     * Return the [SpdxExpression] the [license] id maps to, or null if there is no corresponding expression. If
-     * [mapDeprecated] is true, license ids marked as deprecated in the SPDX standard are mapped to their
-     * corresponding current expression, otherwise they are mapped to their corresponding deprecated expression.
-     */
-    fun map(license: String, mapDeprecated: Boolean = true) =
-        (if (mapDeprecated) mapping else simpleExpressionMapping)[license] ?: SpdxLicense.forId(license)?.toExpression()
+    fun map(license: String, mapDeprecated: Boolean = true, mapSimple: Boolean = true): SpdxSingleLicenseExpression? {
+        if (mapDeprecated) deprecatedExpressionMapping[license]?.also { return it }
+        if (mapSimple) simpleExpressionMapping[license]?.also { return it }
+        return SpdxLicense.forId(license)?.toExpression()
+    }
 }

utils/spdx/src/test/kotlin/SpdxSimpleLicenseMappingTest.kt

@@ -62,16 +62,19 @@ class SpdxSimpleLicenseMappingTest : WordSpec({
 
     "The mapping" should {
         "contain only single ID strings" {
-            SpdxSimpleLicenseMapping.mapping.keys.forAll { declaredLicense ->
-                val tokens = SpdxExpressionLexer(declaredLicense).tokens().toList()
+            val ids = SpdxSimpleLicenseMapping.simpleExpressionMapping.keys +
+                SpdxSimpleLicenseMapping.deprecatedExpressionMapping.keys
+
+            ids.forAll { id ->
+                val tokens = SpdxExpressionLexer(id).tokens().toList()
 
                 tokens shouldHaveAtLeastSize 1
                 tokens shouldHaveAtMostSize 2
 
                 tokens.first() should beOfType<Token.IDENTIFIER>()
                 tokens.getOrNull(1)?.let { it should beOfType<Token.PLUS>() }
 
-                SpdxExpressionParser(tokens.asSequence()).parse().toString() shouldBe declaredLicense
+                SpdxExpressionParser(tokens.asSequence()).parse().toString() shouldBe id
             }
         }