Refactor Extension DSL and remove fallback mechanism

3 files changed, 56 insertions, 95 deletions

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 15349ff0..12b1557b 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -46,7 +46,7 @@ inline fun <reified T : DokkaPlugin> DokkaContext.plugin(): T = plugin(T::class)
     ?: throw java.lang.IllegalStateException("Plugin ${T::class.qualifiedName} is not present in context.")
 
 interface DokkaContextConfiguration {
-    fun addExtensionDependencies(extension: Extension<*>)
+    fun addExtensionDependencies(extension: Extension<*, *, *>)
 }
 
 private class DokkaContextConfigurationImpl(
@@ -55,7 +55,7 @@ private class DokkaContextConfigurationImpl(
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
     private val pluginStubs = mutableMapOf<KClass<*>, DokkaPlugin>()
-    internal val extensions = mutableMapOf<ExtensionPoint<*>, MutableList<Extension<*>>>()
+    val extensions = mutableMapOf<ExtensionPoint<*>, MutableList<Extension<*, *, *>>>()
     val pointsUsed: MutableSet<ExtensionPoint<*>> = mutableSetOf()
     val pointsPopulated: MutableSet<ExtensionPoint<*>> = mutableSetOf()
     override val unusedPoints: Set<ExtensionPoint<*>>
@@ -67,14 +67,14 @@ private class DokkaContextConfigurationImpl(
         VISITED;
     }
 
-    internal val verticesWithState = mutableMapOf<Extension<*>, State>()
-    internal val adjacencyList: MutableMap<Extension<*>, MutableList<Extension<*>>> = mutableMapOf()
+    val verticesWithState = mutableMapOf<Extension<*, *, *>, State>()
+    val adjacencyList: MutableMap<Extension<*, *, *>, MutableList<Extension<*, *, *>>> = mutableMapOf()
 
     private fun topologicalSort() {
 
-        val result: MutableList<Extension<*>> = mutableListOf()
+        val result: MutableList<Extension<*, *, *>> = mutableListOf()
 
-        fun visit(n: Extension<*>) {
+        fun visit(n: Extension<*, *, *>) {
             val state = verticesWithState[n]
             if (state == State.VISITED)
                 return
@@ -107,14 +107,11 @@ private class DokkaContextConfigurationImpl(
         )
         pointsUsed += point
 
-        val extensions = extensions[point].orEmpty() as List<Extension<T>>
+        val extensions = extensions[point].orEmpty() as List<Extension<T, *, *>>
         return when (extensions.size) {
             0 -> throwBadArity("none was")
             1 -> extensions.single().action.get(this)
-            else -> {
-                val notFallbacks = extensions.filterNot { it.isFallback }
-                if (notFallbacks.size == 1) notFallbacks.single().action.get(this) else throwBadArity("many were")
-            }
+            else -> throwBadArity("many were")
         }
     }
 
@@ -132,13 +129,15 @@ private class DokkaContextConfigurationImpl(
         plugin.internalInstall(this, this.configuration)
     }
 
-    override fun addExtensionDependencies(extension: Extension<*>) {
-        val orderDsl = OrderDsl()
-        extension.ordering?.invoke(orderDsl)
+    override fun addExtensionDependencies(extension: Extension<*, *, *>) {
+        if (extension.ordering is OrderingKind.ByDsl) {
+            val orderDsl = OrderDsl()
+            extension.ordering.block.invoke(orderDsl)
 
-        verticesWithState += extension to State.UNVISITED
-        adjacencyList.getOrPut(extension, ::mutableListOf) += orderDsl.following.toList()
-        orderDsl.previous.forEach { adjacencyList.getOrPut(it, ::mutableListOf) += extension }
+            verticesWithState += extension to State.UNVISITED
+            adjacencyList.getOrPut(extension, ::mutableListOf) += orderDsl.following.toList()
+            orderDsl.previous.forEach { adjacencyList.getOrPut(it, ::mutableListOf) += extension }
+        }
     }
 
     fun logInitialisationInfo() {
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index 7ead43b8..bf82daa7 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -7,8 +7,6 @@ import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty1
 import kotlin.reflect.full.createInstance
 
-private typealias ExtensionDelegate<T> = ReadOnlyProperty<DokkaPlugin, Extension<T>>
-
 abstract class DokkaPlugin {
     private val extensionDelegates = mutableListOf<KProperty<*>>()
 
@@ -25,15 +23,10 @@ abstract class DokkaPlugin {
             )
         }
 
-    protected fun <T : Any> extending(isFallback: Boolean = false, definition: ExtendingDSL.() -> Extension<T>) =
-        if (isFallback) {
-            ExtensionProvider { definition().markedAsFallback() }
-        } else {
-            ExtensionProvider(definition)
-        }
+    protected fun <T : Any> extending(definition: ExtendingDSL.() -> Extension<T, *, *>) = ExtensionProvider(definition)
 
     protected class ExtensionProvider<T : Any> internal constructor(
-        private val definition: ExtendingDSL.() -> Extension<T>
+        private val definition: ExtendingDSL.() -> Extension<T, *, *>
     ) {
         operator fun provideDelegate(thisRef: DokkaPlugin, property: KProperty<*>) = lazy {
             ExtendingDSL(
@@ -45,7 +38,7 @@ abstract class DokkaPlugin {
 
     internal fun internalInstall(ctx: DokkaContextConfiguration, configuration: DokkaConfiguration) {
         extensionDelegates.asSequence()
-            .filterIsInstance<KProperty1<DokkaPlugin, Extension<*>>>() // should be always true
+            .filterIsInstance<KProperty1<DokkaPlugin, Extension<*, *, *>>>() // should be always true
             .map { it.get(this) }
             .forEach { if (it.condition.invoke(configuration)) ctx.addExtensionDependencies(it) }
     }
@@ -76,8 +69,8 @@ fun throwIllegalQuery(): Nothing =
 inline fun <reified T : DokkaPlugin, reified R : ConfigurableBlock> configuration(context: DokkaContext): ReadOnlyProperty<Any?, R> {
     return object : ReadOnlyProperty<Any?, R> {
         override fun getValue(thisRef: Any?, property: KProperty<*>): R {
-            return context.configuration.pluginsConfiguration.get(T::class.qualifiedName
-                ?: throw AssertionError("Plugin must be named class")).let {
+            return context.configuration.pluginsConfiguration[T::class.qualifiedName
+                ?: throw AssertionError("Plugin must be named class")].let {
                     Gson().fromJson(it, R::class.java)
             }
         }
diff --git a/core/src/main/kotlin/plugability/extensions.kt b/core/src/main/kotlin/plugability/extensions.kt
index 20b60469..c6dd0b85 100644
--- a/core/src/main/kotlin/plugability/extensions.kt
+++ b/core/src/main/kotlin/plugability/extensions.kt
@@ -9,79 +9,43 @@ data class ExtensionPoint<T : Any> internal constructor(
     override fun toString() = "ExtensionPoint: $pluginClass/$pointName"
 }
 
-abstract class Extension<T : Any> internal constructor(
+sealed class OrderingKind {
+    object None : OrderingKind()
+    class ByDsl(val block: (OrderDsl.() -> Unit)) : OrderingKind()
+}
+
+sealed class OverrideKind {
+    object None : OverrideKind()
+    class Present(val overriden: Extension<*, *, *>) : OverrideKind()
+}
+
+class Extension<T : Any, Ordering : OrderingKind, Override : OverrideKind> internal constructor(
     internal val extensionPoint: ExtensionPoint<T>,
     internal val pluginClass: String,
     internal val extensionName: String,
     internal val action: LazyEvaluated<T>,
-    internal val ordering: (OrderDsl.() -> Unit)? = null,
-    internal val conditions: Array<DokkaConfiguration.() -> Boolean> = emptyArray(),
-    internal val isFallback: Boolean
+    internal val ordering: Ordering,
+    internal val override: Override,
+    internal val conditions: List<DokkaConfiguration.() -> Boolean>
 ) {
     override fun toString() = "Extension: $pluginClass/$extensionName"
 
     override fun equals(other: Any?) =
-        if (other is Extension<*>) this.pluginClass == other.pluginClass && this.extensionName == other.extensionName
+        if (other is Extension<*, *, *>) this.pluginClass == other.pluginClass && this.extensionName == other.extensionName
         else false
 
     override fun hashCode() = listOf(pluginClass, extensionName).hashCode()
 
-    abstract fun addCondition(condition: (DokkaConfiguration.() -> Boolean)): Extension<T>
-
-    abstract fun markedAsFallback(): Extension<T>
-
-    open val condition: DokkaConfiguration.() -> Boolean
-        get() = { conditions.all { it(this) }}
+    val condition: DokkaConfiguration.() -> Boolean
+        get() = { conditions.all { it(this) } }
 }
 
-class ExtensionOrdered<T : Any> internal constructor(
+private fun <T : Any> Extension(
     extensionPoint: ExtensionPoint<T>,
     pluginClass: String,
     extensionName: String,
-    action: LazyEvaluated<T>,
-    ordering: (OrderDsl.() -> Unit),
-    conditions: Array<DokkaConfiguration.() -> Boolean> = emptyArray(),
-    isFallback: Boolean = false
-) : Extension<T>(
-    extensionPoint,
-    pluginClass,
-    extensionName,
-    action,
-    ordering,
-    conditions,
-    isFallback
-) {
-    override fun addCondition(condition: DokkaConfiguration.() -> Boolean) =
-        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, ordering!!, conditions + condition)
-
-    override fun markedAsFallback() =
-        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, ordering!!, conditions, true)
-}
-
-class ExtensionUnordered<T : Any> internal constructor(
-    extensionPoint: ExtensionPoint<T>,
-    pluginClass: String,
-    extensionName: String,
-    action: LazyEvaluated<T>,
-    conditions: Array<DokkaConfiguration.() -> Boolean> = emptyArray(),
-    isFallback: Boolean = false
-) : Extension<T>(
-    extensionPoint,
-    pluginClass,
-    extensionName,
-    action,
-    null,
-    conditions,
-    isFallback
-) {
-    override fun addCondition(condition: DokkaConfiguration.() -> Boolean) =
-        ExtensionUnordered(extensionPoint, pluginClass, extensionName, action, conditions + condition)
-
-    override fun markedAsFallback() =
-        ExtensionUnordered(extensionPoint, pluginClass, extensionName, action, conditions, true)
-}
-
-internal data class Ordering(val previous: Set<Extension<*>>, val following: Set<Extension<*>>)
+    action: LazyEvaluated<T>
+) = Extension(extensionPoint, pluginClass, extensionName, action, OrderingKind.None, OverrideKind.None, emptyList())
 
 @DslMarker
 annotation class ExtensionsDsl
@@ -90,29 +54,34 @@ annotation class ExtensionsDsl
 class ExtendingDSL(private val pluginClass: String, private val extensionName: String) {
 
     infix fun <T : Any> ExtensionPoint<T>.with(action: T) =
-        ExtensionUnordered(this, this@ExtendingDSL.pluginClass, extensionName, LazyEvaluated.fromInstance(action))
+        Extension(this, this@ExtendingDSL.pluginClass, extensionName, LazyEvaluated.fromInstance(action))
 
     infix fun <T : Any> ExtensionPoint<T>.providing(action: (DokkaContext) -> T) =
-        ExtensionUnordered(this, this@ExtendingDSL.pluginClass, extensionName, LazyEvaluated.fromRecipe(action))
+        Extension(this, this@ExtendingDSL.pluginClass, extensionName, LazyEvaluated.fromRecipe(action))
 
-    infix fun <T : Any> ExtensionUnordered<T>.order(block: OrderDsl.() -> Unit) =
-        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, block)
+    infix fun <T : Any, Override : OverrideKind> Extension<T, OrderingKind.None, Override>.order(
+        block: OrderDsl.() -> Unit
+    ) = Extension(extensionPoint, pluginClass, extensionName, action, OrderingKind.ByDsl(block), override, conditions)
 
-    infix fun <T : Any> Extension<T>.applyIf(condition: DokkaConfiguration.() -> Boolean): Extension<T> =
-        this.addCondition(condition)
+    infix fun <T : Any, Override : OverrideKind, Ordering: OrderingKind> Extension<T, Ordering, Override>.applyIf(
+        condition: DokkaConfiguration.() -> Boolean
+    ) = Extension(extensionPoint, pluginClass, extensionName, action, ordering, override, conditions + condition)
 
+    infix fun <T : Any, Override : OverrideKind, Ordering: OrderingKind> Extension<T, Ordering, Override>.override(
+        overriden: Extension<T, *, *>
+    ) = Extension(extensionPoint, pluginClass, extensionName, action, ordering, OverrideKind.Present(overriden), conditions)
 }
 
 @ExtensionsDsl
 class OrderDsl {
-    internal val previous = mutableSetOf<Extension<*>>()
-    internal val following = mutableSetOf<Extension<*>>()
+    internal val previous = mutableSetOf<Extension<*, *, *>>()
+    internal val following = mutableSetOf<Extension<*, *, *>>()
 
-    fun after(vararg extensions: Extension<*>) {
+    fun after(vararg extensions: Extension<*, *, *>) {
         previous += extensions
     }
 
-    fun before(vararg extensions: Extension<*>) {
+    fun before(vararg extensions: Extension<*, *, *>) {
         following += extensions
     }
 }
\ No newline at end of file