chore(spdx-utils): Say "simple mapping" instead of "custom mapping"

Match the name of the file containing the mapping by calling variables
after "simple mapping", which also is a bit more specific than "custom
mapping".

While at it, also distinguish between mapping to licenses or
expressions. For consistency this is also done for the mapping of
deprecated expressions.

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

Author: sschuberth

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

@@ -28,37 +28,38 @@ import com.fasterxml.jackson.module.kotlin.readValue
  */
 object SpdxSimpleLicenseMapping {
     /**
-     * The raw map which associates custom license IDs with their corresponding SPDX license ID.
+     * The map of simple license names associated with their corresponding [SPDX license][SpdxLicense].
      */
-    internal val customLicenseIdsMap by lazy {
+    internal val simpleLicenseMapping by lazy {
         val resource = checkNotNull(javaClass.getResource("/simple-license-mapping.yml"))
         yamlMapper.readValue<Map<String, SpdxLicense>>(resource)
     }
 
     /**
-     * The map of custom license ids associated with their corresponding SPDX expression.
+     * The map of simple license names associated with their corresponding [SPDX expression][SpdxLicenseIdExpression].
      */
-    internal val customLicenseIds = customLicenseIdsMap.mapValues { (_, v) -> v.toExpression() }
+    internal val simpleExpressionMapping = simpleLicenseMapping.mapValues { (_, v) -> v.toExpression() }
         .toSortedMap(String.CASE_INSENSITIVE_ORDER)
 
     /**
-     * The map of deprecated SPDX license ids associated with their current SPDX expression.
+     * The map of deprecated SPDX license IDs associated with their current [SPDX expression]
+     * [SpdxSingleLicenseExpression].
      */
-    private val deprecatedLicenseIds by lazy {
+    private val deprecatedExpressionMapping by lazy {
         val resource = checkNotNull(javaClass.getResource("/deprecated-license-mapping.yml"))
         yamlMapper.readValue<Map<String, SpdxSingleLicenseExpression>>(resource)
     }
 
     /**
      * The map of varied SPDX license ids associated with their corresponding SPDX expression.
      */
-    val mapping = (customLicenseIds + deprecatedLicenseIds).toSortedMap(String.CASE_INSENSITIVE_ORDER)
+    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 customLicenseIds)[license] ?: SpdxLicense.forId(license)?.toExpression()
+        (if (mapDeprecated) mapping else simpleExpressionMapping)[license] ?: SpdxLicense.forId(license)?.toExpression()
 }

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

@@ -36,10 +36,10 @@ import org.ossreviewtoolkit.utils.spdx.parser.SpdxExpressionParser
 import org.ossreviewtoolkit.utils.spdx.parser.Token
 
 class SpdxSimpleLicenseMappingTest : WordSpec({
-    "The raw map" should {
+    "The license map" should {
         "not contain any duplicate keys with respect to capitalization" {
-            val keys = SpdxSimpleLicenseMapping.customLicenseIdsMap.keys.toMutableList()
-            val uniqueKeys = SpdxSimpleLicenseMapping.customLicenseIds.keys
+            val keys = SpdxSimpleLicenseMapping.simpleLicenseMapping.keys.toMutableList()
+            val uniqueKeys = SpdxSimpleLicenseMapping.simpleExpressionMapping.keys
 
             // Remove keys one by one as calling "-" would remove all occurrences of a key.
             uniqueKeys.forEach { uniqueKey -> keys.remove(uniqueKey) }
@@ -48,13 +48,13 @@ class SpdxSimpleLicenseMappingTest : WordSpec({
         }
 
         "not contain any deprecated values" {
-            SpdxSimpleLicenseMapping.customLicenseIdsMap.values.forAll {
+            SpdxSimpleLicenseMapping.simpleLicenseMapping.values.forAll {
                 it.deprecated shouldBe false
             }
         }
 
         "not associate licenses without a version to *-only" {
-            SpdxSimpleLicenseMapping.customLicenseIdsMap.forAll { (key, license) ->
+            SpdxSimpleLicenseMapping.simpleLicenseMapping.forAll { (key, license) ->
                 if (license.id.endsWith("-only")) key should containADigit()
             }
         }
@@ -76,13 +76,13 @@ class SpdxSimpleLicenseMappingTest : WordSpec({
         }
 
         "not contain plain SPDX license ids" {
-            SpdxSimpleLicenseMapping.customLicenseIds.keys.forAll { declaredLicense ->
+            SpdxSimpleLicenseMapping.simpleExpressionMapping.keys.forAll { declaredLicense ->
                 SpdxLicense.forId(declaredLicense) should beNull()
             }
         }
 
         "be case-insensitive" {
-            SpdxSimpleLicenseMapping.customLicenseIds.forAll { (key, license) ->
+            SpdxSimpleLicenseMapping.simpleExpressionMapping.forAll { (key, license) ->
                 SpdxSimpleLicenseMapping.map(key.lowercase(), mapDeprecated = false) shouldBe license
                 SpdxSimpleLicenseMapping.map(key.uppercase(), mapDeprecated = false) shouldBe license
                 SpdxSimpleLicenseMapping.map(key.titlecase(), mapDeprecated = false) shouldBe license