Add dev.mokkery.mockable plugin

Author: lupuuss

build-mokkery/src/main/kotlin/Utils.kt

@@ -9,8 +9,20 @@ import org.jetbrains.kotlin.gradle.plugin.SubpluginOption
 import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
 import org.jetbrains.kotlin.gradle.tasks.CompilerPluginOptions
 import org.jetbrains.kotlin.gradle.tasks.KotlinNativeCompile
+import java.net.URI
 import java.util.*
 
+const val testingRepoName = "testing"
+
+val Project.testingRepoUrl: URI
+    get() = rootProject
+    .layout
+    .buildDirectory
+    .dir("testing-repository")
+    .get()
+    .asFile
+    .toURI()
+
 fun Project.loadLocalProperties() {
     val secretPropsFile = rootProject.file("local.properties")
     if (secretPropsFile.exists()) {

build-mokkery/src/main/kotlin/mokkery-publish.gradle.kts

@@ -12,23 +12,20 @@ plugins {
     id("org.jetbrains.dokka")
 }
 
+publishing.repositories {
+    maven {
+        name = testingRepoName
+        url = testingRepoUrl
+    }
+}
+
 loadLocalProperties()
 
 dokka.dokkaSourceSets.configureEach {
     sourceLink {
         localDirectory = rootDir
         remoteUrl = URI("${GitHttpsUrl}/tree/master")
-        remoteLineSuffix ="#L"
-    }
-}
-
-publishing.repositories {
-    maven {
-        name = "testing"
-        url = rootProject.layout
-            .buildDirectory
-            .dir("testing-repository")
-            .let(::uri)
+        remoteLineSuffix = "#L"
     }
 }
 

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

@@ -10,3 +10,6 @@ fun <T> CompilerConfiguration.getSingleOrDefault(option: MokkeryOption<T>): T {
         ?: option.defaultValues.singleOrNull()
         ?: error("No value for ${option.configurationKey}")
 }
+
+fun <T> CompilerConfiguration.getAllOrDefault(option: MokkeryOption<T>): List<T> = get(option.configurationKey)
+    ?: option.defaultValues

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

@@ -0,0 +1,10 @@
+package dev.mokkery.plugin.core
+
+import org.jetbrains.kotlin.name.Name
+
+object MokkeryCore {
+
+    object Names {
+        val mockableConstructorMarkerParam = Name.identifier("mokkeryMockableMarker")
+    }
+}

mokkery-core-plugin/src/main/kotlin/dev/mokkery/plugin/core/fir/FirClass.kt

@@ -0,0 +1,10 @@
+package dev.mokkery.plugin.core.fir
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.constructors
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
+
+fun FirClassSymbol<*>.hasMokkeryGeneratedConstructor(
+    session: FirSession
+): Boolean = constructors(session).any(FirConstructorSymbol::isMokkeryGeneratedConstructor)

mokkery-core-plugin/src/main/kotlin/dev/mokkery/plugin/core/fir/FirConstructor.kt

@@ -0,0 +1,11 @@
+package dev.mokkery.plugin.core.fir
+
+import dev.mokkery.plugin.core.MokkeryCore
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
+import org.jetbrains.kotlin.fir.types.isUnit
+
+fun FirConstructorSymbol.isMokkeryGeneratedConstructor(): Boolean {
+    val param = valueParameterSymbols.firstOrNull() ?: return false
+    return param.name == MokkeryCore.Names.mockableConstructorMarkerParam
+            && param.resolvedReturnType.isUnit
+}

mokkery-core-plugin/src/main/kotlin/dev/mokkery/plugin/core/ir/IrConstructor.kt

@@ -0,0 +1,15 @@
+package dev.mokkery.plugin.core.ir
+
+import dev.mokkery.plugin.core.MokkeryCore
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrConstructor
+import org.jetbrains.kotlin.ir.declarations.IrParameterKind
+import org.jetbrains.kotlin.ir.types.isUnit
+import org.jetbrains.kotlin.ir.util.constructors
+
+fun IrClass.findMokkeryConstructor(): IrConstructor? = constructors.find { it.isMokkeryConstructor() }
+
+fun IrConstructor.isMokkeryConstructor(): Boolean {
+    val valueParam = parameters.find { it.kind == IrParameterKind.Regular } ?: return false
+    return valueParam.name == MokkeryCore.Names.mockableConstructorMarkerParam && valueParam.type.isUnit()
+}

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

@@ -40,7 +40,9 @@ private class CachedMokkeryProjection<T>(
     private val builder: (MokkeryOption<*>) -> T
 ) : MokkeryOptionProjection<T> {
     private val store = mutableMapOf<MokkeryOption<*>, T>()
-    override fun project(option: MokkeryOption<*>): T = store.getOrPut(option) { builder(option) }
+    override fun project(option: MokkeryOption<*>): T = synchronized(store) {
+        store.getOrPut(option) { builder(option) }
+    }
 }
 
 @Suppress("UNCHECKED_CAST")

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

@@ -4,6 +4,7 @@ import dev.mokkery.MockMode
 import dev.mokkery.annotations.InternalMokkeryApi
 import dev.mokkery.internal.serialization.AnnotationSelectorSerializer
 import dev.mokkery.internal.serialization.BooleanSerializer
+import dev.mokkery.internal.serialization.FqNameSerializer
 import dev.mokkery.internal.serialization.MokkerySerializer
 import dev.mokkery.internal.serialization.VerifyModeSerializer
 import dev.mokkery.internal.serialization.enumSerializer
@@ -24,6 +25,11 @@ public data class MokkeryOptionType<T>(
             serializer = BooleanSerializer
         )
 
+        public val fqName: MokkeryOptionType<String> = MokkeryOptionType(
+            description = "<fq-name>",
+            serializer = FqNameSerializer
+        )
+
         public val verifyMode: MokkeryOptionType<VerifyMode> = MokkeryOptionType(
             description = $$"VerifyMode expression <exhaustive|order|exhaustiveOrder|not|soft|atLeast($n)|atMost($n)|inRange($range)|exactly($n)>",
             serializer = VerifyModeSerializer

mokkery-core-tooling/src/main/kotlin/dev/mokkery/internal/serialization/FqNameSerializer.kt

@@ -0,0 +1,30 @@
+package dev.mokkery.internal.serialization
+
+internal object FqNameSerializer : MokkerySerializer<String> {
+    override fun serialize(obj: String): String = obj.also(::validate)
+
+    override fun deserialize(string: String): String = string.also(::validate)
+
+    private fun validate(fqName: String) {
+        require(fqName.isNotEmpty()) { "Invalid FQ name - must not be empty" }
+        val segments = fqName.split(".")
+        var offset = 0
+        segments.forEach { segment ->
+            if (segment.isEmpty()) fqNameError(fqName, offset, "empty segment")
+            val illegalIndex = segment.indexOfFirst { !it.isJavaIdentifierPart() }
+                .takeIf { it != -1 }
+                ?: if (!segment.first().isJavaIdentifierStart()) 0 else null
+            if (illegalIndex != null) {
+                val char = segment[illegalIndex]
+                val message = if (illegalIndex == 0) "illegal start character '$char'"
+                              else "illegal character '$char'"
+                fqNameError(fqName, offset + illegalIndex, message)
+            }
+            offset += segment.length + 1
+        }
+    }
+
+    private fun fqNameError(fqName: String, position: Int, message: String): Nothing {
+        error("Invalid FQ name - $message:\n$fqName\n${" ".repeat(position)}^")
+    }
+}