Move LicenseExpressionExtensions to instance functions for better API from Groovy and Java

Author: vlsi

plugins/license-gather-plugin/src/main/kotlin/com/github/vlsi/gradle/license/GatherLicenseTask.kt

@@ -24,7 +24,6 @@ import com.github.vlsi.gradle.license.api.LicenseExpression
 import com.github.vlsi.gradle.license.api.LicenseExpressionParser
 import com.github.vlsi.gradle.license.api.OsgiBundleLicenseParser
 import com.github.vlsi.gradle.license.api.SpdxLicense
-import com.github.vlsi.gradle.license.api.asExpression
 import com.github.vlsi.gradle.license.api.text
 import groovy.util.slurpersupport.GPathResult
 import org.gradle.api.Action
@@ -137,8 +136,8 @@ open class GatherLicenseTask @Inject constructor(
         objectFactory.setProperty<LicenseExpression>()
             .convention(
                 listOf(
-                    SpdxLicense.Apache_2_0.asExpression(),
-                    SpdxLicense.MPL_2_0.asExpression()
+                    SpdxLicense.Apache_2_0.expression,
+                    SpdxLicense.MPL_2_0.expression
                 )
             )
 
@@ -152,7 +151,7 @@ open class GatherLicenseTask @Inject constructor(
         objectFactory.setProperty<LicenseExpression>()
 
     fun ignoreMissingLicenseFor(license: License) {
-        ignoreMissingLicenseFor(license.asExpression())
+        ignoreMissingLicenseFor(license.expression)
     }
 
     fun ignoreMissingLicenseFor(license: LicenseExpression) {
@@ -186,7 +185,7 @@ open class GatherLicenseTask @Inject constructor(
     private val licenseExpressionParser = LicenseExpressionParser()
 
     fun addDependency(module: String, license: License) {
-        addDependency(module, license.asExpression())
+        addDependency(module, license.expression)
     }
 
     fun addDependency(module: String, licenseExpression: LicenseExpression) {
@@ -202,7 +201,7 @@ open class GatherLicenseTask @Inject constructor(
     }
 
     fun expectLicense(module: String, license: License) {
-        expectLicense(module, license.asExpression())
+        expectLicense(module, license.expression)
     }
 
     fun expectLicense(module: String, licenseExpression: LicenseExpression) {
@@ -212,7 +211,7 @@ open class GatherLicenseTask @Inject constructor(
     }
 
     fun overrideLicense(module: String, license: License) {
-        overrideLicense(module, license.asExpression())
+        overrideLicense(module, license.expression)
     }
 
     fun overrideLicense(module: String, licenseExpression: LicenseExpression) {
@@ -224,7 +223,7 @@ open class GatherLicenseTask @Inject constructor(
     private fun Any.toLicenseExpression() =
         when (this) {
             is String -> licenseExpressionParser.parse(this)
-            is License -> this.asExpression()
+            is License -> this.expression
             is LicenseExpression -> this
             else -> throw GradleException("Illegal value $this for LicenseExpression. Expecting String, License, or LicenseExpression")
         }
@@ -489,7 +488,7 @@ open class GatherLicenseTask @Inject constructor(
         licenseExpressionParser: LicenseExpressionParser
     ) {
         val bundleLicenseParser = OsgiBundleLicenseParser(licenseExpressionParser) {
-            SpdxLicense.fromUriOrNull(it)?.asExpression()
+            SpdxLicense.fromUriOrNull(it)?.expression
         }
         for (e in detectedLicenses) {
             if (e.value.license != null) {

plugins/license-gather-plugin/src/main/kotlin/com/github/vlsi/gradle/license/GuessBasedNormalizer.kt

@@ -23,7 +23,6 @@ import com.github.vlsi.gradle.license.api.SimpleLicense
 import com.github.vlsi.gradle.license.api.SimpleLicenseExpression
 import com.github.vlsi.gradle.license.api.SpdxLicense
 import com.github.vlsi.gradle.license.api.WithException
-import com.github.vlsi.gradle.license.api.asExpression
 import org.slf4j.Logger
 import java.net.URI
 
@@ -33,7 +32,7 @@ class GuessBasedNormalizer(
 ) : LicenseExpressionNormalizer() {
 
     private val nameGuesser = TfIdfBuilder<LicenseExpression>().apply {
-        SpdxLicense.values().forEach { addDocument(it.asExpression(), it.title) }
+        SpdxLicense.values().forEach { addDocument(it.expression, it.title) }
     }.build()
 
     private fun String.trimTextExtensions() = removeSuffix(".txt").removeSuffix(".md")
@@ -52,9 +51,9 @@ class GuessBasedNormalizer(
 
     override fun normalize(license: SimpleLicense): LicenseExpression? {
         if (license.title.equals("PUBLIC DOMAIN", ignoreCase = true)) {
-            return SpdxLicense.CC0_1_0.asExpression()
+            return SpdxLicense.CC0_1_0.expression
         }
-        SpdxLicense.fromIdOrNull(license.title)?.let { return it.asExpression() }
+        SpdxLicense.fromIdOrNull(license.title)?.let { return it.expression }
 
         val guessList = nameGuesser.predict(license.title)
             .entries

plugins/license-gather-plugin/src/main/kotlin/com/github/vlsi/gradle/license/LicenseCompatibilityInterpreter.kt

@@ -24,7 +24,6 @@ import com.github.vlsi.gradle.license.api.ConjunctionLicenseExpression
 import com.github.vlsi.gradle.license.api.DisjunctionLicenseExpression
 import com.github.vlsi.gradle.license.api.LicenseEquivalence
 import com.github.vlsi.gradle.license.api.LicenseExpression
-import com.github.vlsi.gradle.license.api.disjunctions
 
 enum class CompatibilityResult {
     ALLOW, UNKNOWN, REJECT;
@@ -54,7 +53,7 @@ internal class LicenseCompatibilityInterpreter(
     private val resolvedCases: Map<LicenseExpression, LicenseCompatibility>
 ) {
     val resolvedParts = resolvedCases.asSequence().flatMap { (license, _) ->
-        licenseEquivalence.expand(license).disjunctions().asSequence().map { it to license }
+        licenseEquivalence.expand(license).disjunctions.asSequence().map { it to license }
     }.groupingBy { it.first }.aggregate { key, acc: LicenseExpression?, element, first ->
         if (first) {
             element.second

plugins/license-gather-plugin/src/main/kotlin/com/github/vlsi/gradle/license/MetadataStore.kt

@@ -34,7 +34,6 @@ import com.github.vlsi.gradle.license.api.SpdxLicense
 import com.github.vlsi.gradle.license.api.StandardLicense
 import com.github.vlsi.gradle.license.api.StandardLicenseException
 import com.github.vlsi.gradle.license.api.WithException
-import com.github.vlsi.gradle.license.api.asExpression
 import com.github.vlsi.gradle.license.api.orLater
 import groovy.util.XmlSlurper
 import groovy.util.slurpersupport.GPathResult
@@ -86,8 +85,8 @@ object MetadataStore {
 
         fun GPathResult.readLicenseExpression(): LicenseExpression =
             when (name()) {
-                "license" -> toLicense().asExpression()
-                "or-later" -> toLicense().orLater()
+                "license" -> toLicense().expression
+                "or-later" -> toLicense().orLater
                 "expression" -> expressionParser.parse(text())
                 "and" -> ConjunctionLicenseExpression(
                     getList("*")

plugins/license-gather-plugin/src/main/kotlin/com/github/vlsi/gradle/license/PomLicenseLoader.kt

@@ -22,7 +22,6 @@ import com.github.vlsi.gradle.license.api.License
 import com.github.vlsi.gradle.license.api.LicenseExpression
 import com.github.vlsi.gradle.license.api.LicenseExpressionNormalizer
 import com.github.vlsi.gradle.license.api.SimpleLicense
-import com.github.vlsi.gradle.license.api.asExpression
 import groovy.util.XmlSlurper
 import groovy.util.slurpersupport.GPathResult
 import kotlinx.coroutines.runBlocking
@@ -76,12 +75,12 @@ class LicenseDetector(
             } else {
                 val parsedRawLicense =
                     if (licenses.size == 1) {
-                        licenses.first().asExpression()
+                        licenses.first().expression
                     } else {
                         // When more than one license is present, assume AND was intended
                         // It allows less freedom, however it seems to be a safe choice.
                         ConjunctionLicenseExpression(
-                            licenses.mapTo(mutableSetOf()) { it.asExpression() }
+                            licenses.mapTo(mutableSetOf()) { it.expression }
                         )
                     }
                 normalizer.normalize(parsedRawLicense)

plugins/license-gather-plugin/src/main/kotlin/com/github/vlsi/gradle/license/api/License.kt

@@ -24,10 +24,25 @@ interface License : LicenseExpressionSet, java.io.Serializable {
     val uri: List<URI>
 
     override val disjunctions: Set<LicenseExpression>
-        get() = setOf(asExpression())
+        get() = setOf(expression)
 
     override val conjunctions: Set<LicenseExpression>
         get() = disjunctions
+
+    val expression: JustLicense
+        get() = JustLicense(this)
+
+    val orLater: OrLaterLicense
+        get() = OrLaterLicense(this)
+
+    infix fun with(exception: LicenseException): LicenseExpression =
+        expression with exception
+
+    infix fun and(other: License): LicenseExpression = expression and other
+    infix fun and(other: LicenseExpression): LicenseExpression = expression and other
+
+    infix fun or(other: License): LicenseExpression = expression or other
+    infix fun or(other: LicenseExpression): LicenseExpression = expression or other
 }
 
 interface LicenseException : java.io.Serializable {

plugins/license-gather-plugin/src/main/kotlin/com/github/vlsi/gradle/license/api/LicenseExpression.kt

@@ -33,6 +33,27 @@ sealed class LicenseExpression : LicenseExpressionSet, java.io.Serializable {
     override val disjunctions: Set<LicenseExpression>
         get() = setOf(this)
 
+    infix fun and(other: License): LicenseExpression = this and other.expression
+    infix fun or(other: License): LicenseExpression = this or other.expression
+
+    infix fun and(other: LicenseExpression): LicenseExpression {
+        val ops = conjunctions + other.conjunctions
+        return when (ops.size) {
+            0 -> throw IllegalArgumentException("Empty argument to ConjunctionLicenseExpression")
+            1 -> ops.first()
+            else -> ConjunctionLicenseExpression(ops)
+        }
+    }
+
+    infix fun or(other: LicenseExpression): LicenseExpression {
+        val ops = disjunctions + other.disjunctions
+        return when (ops.size) {
+            0 -> throw IllegalArgumentException("Empty argument to DisjunctionLicenseExpression")
+            1 -> ops.first()
+            else -> DisjunctionLicenseExpression(ops)
+        }
+    }
+
     object NONE : LicenseExpression()
     object NOASSERTION : LicenseExpression()
 }
@@ -50,10 +71,16 @@ abstract class SimpleLicenseExpression(open val license: License) : LicenseExpre
             else -> it.title + it.uri.asString()
         }
     }
+
+    infix fun with(exception: LicenseException): WithException =
+        WithException(this, exception)
 }
 
 data class JustLicense(override val license: License) : SimpleLicenseExpression(license) {
     override fun toString() = super.toString()
+
+    val orLater: OrLaterLicense
+        get() = OrLaterLicense(license)
 }
 
 data class OrLaterLicense(override val license: License) : SimpleLicenseExpression(license) {