Adjust mokkery-core-tooling make creating new options from separate project easier

Author: lupuuss

mokkery-core-plugin/src/main/kotlin/dev/mokkery/plugin/core/MokkeryConfigApi.kt

@@ -4,8 +4,9 @@ import dev.mokkery.internal.options.MokkeryOption
 import org.jetbrains.kotlin.config.CompilerConfiguration
 
 fun <T> CompilerConfiguration.getSingleOrDefault(option: MokkeryOption<T>): T {
+    require(!option.allowMultipleOccurrences) { "`getSingleOrDefault` is not supported for `allowMultipleOccurrences = true`" }
     return get(option.configurationKey)
         ?.singleOrNull()
-        ?: option.defaultValue
+        ?: option.defaultValues.singleOrNull()
         ?: error("No value for ${option.configurationKey}")
 }

mokkery-core-tooling/src/main/kotlin/dev/mokkery/internal/options/MokkeryOption.kt

@@ -9,7 +9,7 @@ public data class MokkeryOption<T>(
     public val required: Boolean,
     public val allowMultipleOccurrences: Boolean,
     public val type: MokkeryOptionType<T>,
-    public val defaultValue: T?,
+    public val defaultValues: List<T>,
 )
 
 @InternalMokkeryApi

mokkery-core-tooling/src/main/kotlin/dev/mokkery/internal/options/MokkeryOptions.kt

@@ -7,6 +7,8 @@ import dev.mokkery.internal.options.MokkeryOptionType.Companion.annotationSelect
 import dev.mokkery.internal.options.MokkeryOptionType.Companion.boolean
 import dev.mokkery.internal.options.MokkeryOptionType.Companion.mockMode
 import dev.mokkery.internal.options.MokkeryOptionType.Companion.verifyMode
+import dev.mokkery.internal.options.MokkeryOptionsNamespace.Companion.named
+import dev.mokkery.internal.options.MokkeryOptionsNamespace.Companion.root
 import dev.mokkery.options.AnnotationSelector
 import dev.mokkery.options.AnnotationSelector.Companion.all
 import dev.mokkery.verify.VerifyMode
@@ -23,8 +25,6 @@ public object MokkeryOptions : MokkeryOptionsContainer() {
     @InternalMokkeryApi
     public object Core : MokkeryOptionsContainer() {
 
-        private val root = MokkeryNamespace.root
-
         public val defaultVerifyMode: MokkeryOption<VerifyMode> by root.defaultSingleOption(
             type = verifyMode,
             description = "Default VerifyMode for every verify block.",
@@ -56,7 +56,7 @@ public object MokkeryOptions : MokkeryOptionsContainer() {
     @InternalMokkeryApi
     public object Stubs : MokkeryOptionsContainer() {
 
-        private val stubs by MokkeryNamespace.named
+        private val stubs by named
 
         public val allowClassInheritance: MokkeryOption<Boolean> by stubs.defaultSingleOption(
             type = boolean,
@@ -73,7 +73,7 @@ public object MokkeryOptions : MokkeryOptionsContainer() {
     @InternalMokkeryApi
     public object Annotations : MokkeryOptionsContainer() {
 
-        private val annotations by MokkeryNamespace.named
+        private val annotations by named
 
         public val copyToMock: MokkeryOption<AnnotationSelector> by annotations.defaultSingleOption(
             type = annotationSelector,

mokkery-core-tooling/src/main/kotlin/dev/mokkery/internal/options/MokkeryOptionsContainer.kt

@@ -6,24 +6,24 @@ import kotlin.properties.ReadOnlyProperty
 
 @Suppress("UNCHECKED_CAST")
 @InternalMokkeryApi
-public abstract class MokkeryOptionsContainer: Iterable<MokkeryOption<Any?>> {
+public abstract class MokkeryOptionsContainer: Iterable<MokkeryOption<Any>> {
 
-    private val _options = mutableMapOf<String, MokkeryOption<Any?>>()
+    private val _options = mutableMapOf<String, MokkeryOption<Any>>()
     private val _containers = mutableListOf<MokkeryOptionsContainer>()
 
 
-    public override operator fun iterator(): Iterator<MokkeryOption<Any?>> = _options
+    public override operator fun iterator(): Iterator<MokkeryOption<Any>> = _options
         .values
         .asSequence()
         .plus(_containers.flatten())
         .iterator()
 
-    public operator fun get(name: String): MokkeryOption<Any?>? {
+    public operator fun get(name: String): MokkeryOption<Any>? {
         return _options[name] ?: _containers.firstNotNullOfOrNull { it[name] }
     }
 
     public operator fun plusAssign(option: MokkeryOption<*>) {
-        _options += (option.name to option as MokkeryOption<Any?>)
+        _options += (option.name to option as MokkeryOption<Any>)
     }
 
     public operator fun plusAssign(container: MokkeryOptionsContainer) {
@@ -34,24 +34,25 @@ public abstract class MokkeryOptionsContainer: Iterable<MokkeryOption<Any?>> {
 }
 
 
-internal interface MokkeryNamespace {
+@InternalMokkeryApi
+public interface MokkeryOptionsNamespace {
 
-    val name: String
-    fun createName(name: String): String
+    public val name: String
+    public fun createName(name: String): String
 
-    companion object {
+    public companion object {
 
-        val root = object : MokkeryNamespace {
+        public val root: MokkeryOptionsNamespace = object : MokkeryOptionsNamespace {
 
             override val name: String = ""
 
             override fun createName(name: String): String = name
         }
 
-        val named: PropertyDelegateProvider<Any?, ReadOnlyProperty<Any?, MokkeryNamespace>>
+        public val named: PropertyDelegateProvider<Any?, ReadOnlyProperty<Any?, MokkeryOptionsNamespace>>
             get() = PropertyDelegateProvider { _, it ->
                 ReadOnlyProperty { _, _ ->
-                    object : MokkeryNamespace {
+                    object : MokkeryOptionsNamespace {
                         override val name: String = it.name
                         override fun createName(name: String): String = "${this.name}.$name"
                     }
@@ -60,23 +61,24 @@ internal interface MokkeryNamespace {
     }
 }
 
-internal fun <T> MokkeryNamespace.defaultSingleOption(
+@InternalMokkeryApi
+public fun <T> MokkeryOptionsNamespace.defaultSingleOption(
     type: MokkeryOptionType<T>,
     description: String,
     defaultValue: T,
 ): MokkeryOptionPropertyDelegateProvider<T> = option(
     type = type,
     description = description,
-    defaultValue = defaultValue,
+    defaultValues = listOf(defaultValue),
     required = false,
     allowMultipleOccurrences = false,
 )
 
-
-internal fun <T> MokkeryNamespace.option(
+@InternalMokkeryApi
+public fun <T> MokkeryOptionsNamespace.option(
     type: MokkeryOptionType<T>,
     description: String,
-    defaultValue: T?,
+    defaultValues: List<T>,
     required: Boolean,
     allowMultipleOccurrences: Boolean,
 ): MokkeryOptionPropertyDelegateProvider<T> = PropertyDelegateProvider { container, it ->
@@ -86,13 +88,14 @@ internal fun <T> MokkeryNamespace.option(
         required = required,
         allowMultipleOccurrences = allowMultipleOccurrences,
         type = type,
-        defaultValue = defaultValue,
+        defaultValues = defaultValues,
     )
     container += option
     ReadOnlyProperty { _, _ -> option }
 }
 
-internal typealias MokkeryOptionPropertyDelegateProvider<T> = PropertyDelegateProvider<
+@InternalMokkeryApi
+public typealias MokkeryOptionPropertyDelegateProvider<T> = PropertyDelegateProvider<
         MokkeryOptionsContainer,
         ReadOnlyProperty<Any?, MokkeryOption<T>>
         >

mokkery-gradle/src/main/kotlin/dev/mokkery/gradle/MokkeryGradlePlugin.kt

@@ -35,7 +35,7 @@ public class MokkeryGradlePlugin : KotlinCompilerPluginSupportPlugin {
         mokkery.rule.convention(ApplicationRule.AllTests)
         val gradleProperty = gradlePropertyProjection(target)
         MokkeryOptions.forEach {
-            it.get(gradleProperty)?.convention(it.defaultValue)
+            it.get(gradleProperty)?.convention(it.defaultValues.singleOrNull())
         }
         target.configureDependencies()
         super.apply(target)