refactor: Simplified system

Author: 0ffz

features/build.gradle.kts core/build.gradle.ktsfeatures/build.gradle.kts renamed to core/build.gradle.kts

@@ -25,7 +25,8 @@ kotlin {
     sourceSets {
         commonMain.dependencies {
             implementation(idofrontLibs.kotlinx.serialization.json)
-            implementation(idofrontLibs.koin.core)
+            implementation(libs.kodein.di)
+            implementation(idofrontLibs.kermit)
         }
         commonTest.dependencies {
             implementation(kotlin("test"))

core/src/commonMain/kotlin/com/mineinabyss/features/Feature.kt

@@ -0,0 +1,25 @@
+package com.mineinabyss.features
+
+import org.kodein.di.DI
+import org.kodein.di.DirectDI
+import kotlin.reflect.KClass
+
+
+data class Feature<T : Any>(
+    val name: String,
+    val type: KClass<T>, //TODO remove when updating geary, handled by extract now but needed for interop
+    val dependencies: FeatureDependencies,
+    val subFeatures: Set<Feature<*>>,
+    val diBuilder: DI.Builder.() -> Unit,
+    val extract: DirectDI.() -> T,
+    val onLoad: DirectDI.() -> Unit,
+) {
+    fun overrideScope(block: DI.Builder.() -> Unit): Feature<T> {
+        return copy(diBuilder = {
+            diBuilder()
+            block()
+        })
+    }
+
+    override fun toString(): String = name
+}

core/src/commonMain/kotlin/com/mineinabyss/features/FeatureBuilder.kt

@@ -0,0 +1,110 @@
+package com.mineinabyss.features
+
+import org.kodein.di.DI
+import org.kodein.di.DirectDI
+import kotlin.reflect.KClass
+
+data class LoadPredicate(val reason: String, val predicate: DirectDI.() -> Boolean)
+
+class FeatureBuilder(
+    val name: String,
+    val type: KClass<out Any>,
+) : FeatureDSL {
+    private var dependencies = FeatureDependencies(listOf(), listOf())
+    private var diBuilder: DI.Builder.() -> Unit = {}
+    private var onEnable: MutableList<FeatureDI.() -> Unit> = mutableListOf()
+    private val onLoad: MutableList<DirectDI.() -> Unit> = mutableListOf()
+    private val subFeatures = mutableSetOf<Feature<*>>()
+
+    fun dependencies(block: DI.Builder.() -> Unit) {
+        diBuilder = block
+    }
+
+    fun onLoad(block: DirectDI.() -> Unit) {
+        onLoad += block
+    }
+
+    class FeatureDependenciesBuilder {
+        private val features = mutableListOf<Feature<*>>()
+        private val plugins = mutableListOf<String>()
+        private val conditions = mutableListOf<LoadPredicate>()
+
+        fun features(vararg feature: Feature<*>) {
+            features += feature
+        }
+
+        fun plugins(vararg plugins: String) {
+            this.plugins += plugins
+        }
+
+        fun condition(
+            reason: String = "Conditions not met",
+            predicate: DirectDI.() -> Boolean,
+        ) {
+            conditions += LoadPredicate(reason, predicate)
+        }
+
+        fun build() = FeatureDependencies(
+            features = features.toList(),
+            conditions = conditions.toList(),
+        )
+    }
+
+    fun dependsOn(block: FeatureDependenciesBuilder.() -> Unit) {
+        dependencies = FeatureDependenciesBuilder().apply(block).build()
+    }
+
+    fun install(vararg features: Feature<*>) {
+        subFeatures += features
+    }
+
+
+    //TODO disabling feature should close any AutoCloseable scoped entries
+//    fun scopedModule(block: ScopeDSL.() -> Unit) {
+//        scopedModule = block
+//    }
+//
+//    fun commands(block: context(DICommandContext) RootIdoCommands.() -> Unit) {
+//        onLoad {
+//            val context = DICommandContext(get(), get())
+//            get<Plugin>().commands {
+//                block(context, this)
+//            }
+//        }
+//    }
+//
+//    fun mainCommand(block: context(DICommandContext) IdoRootCommand.() -> Unit) {
+//        onLoad {
+//            get<MainCommand>().subcommand(block)
+//        }
+//    }
+
+
+    fun onEnable(block: FeatureDI.() -> Unit) {
+        onEnable += block
+    }
+
+    fun <T : Any> build(extract: DirectDI.() -> T): Feature<T> {
+        val onEnable = onEnable.toList()
+        val onLoad = onLoad.toList()
+
+        return Feature(
+            name = name,
+            type = type as KClass<T>,
+            dependencies = dependencies,
+            subFeatures = subFeatures.toSet(),
+            diBuilder = {
+                diBuilder()
+
+                // Call onEnable when ready
+                onReady {
+                    val featureDI = object : DirectDI by this, FeatureDI {}
+                    onEnable.forEach { it(featureDI) }
+                }
+            },
+            extract = extract,
+            onLoad = { onLoad.forEach { it() } },
+        )
+    }
+}
+

core/src/commonMain/kotlin/com/mineinabyss/features/FeatureDSL.kt

@@ -0,0 +1,35 @@
+package com.mineinabyss.features
+
+import org.kodein.di.DirectDI
+import org.kodein.di.instance
+import kotlin.jvm.JvmName
+
+@DslMarker
+annotation class FeatureDSLMarker
+
+@FeatureDSLMarker
+interface FeatureDSL
+
+interface FeatureDI : DirectDI
+
+fun FeatureDI.addCloseable(block: AutoCloseable) {
+    instance<FeatureContext>().onClose.add(block)
+}
+
+fun FeatureDI.addCloseables(vararg closeable: AutoCloseable) {
+    closeable.forEach { instance<FeatureContext>().onClose.add(it) }
+}
+
+context(di: DirectDI)
+inline fun <reified T : Any> get() = di.instance<T>()
+
+fun feature(name: String, block: FeatureBuilder.() -> Unit): Feature<Unit> {
+    return FeatureBuilder(name, Unit::class).apply(block).build(extract = { })
+}
+
+@JvmName("featureWithType")
+inline fun <reified T : Any> feature(name: String, block: FeatureBuilder.() -> Unit): Feature<T> {
+    return FeatureBuilder(name, T::class).apply(block).build(extract = { instance<T>() })
+}
+
+data class DICommandContext(val manager: FeatureManager, val feature: Feature<*>)

core/src/commonMain/kotlin/com/mineinabyss/features/FeatureDependencies.kt

@@ -0,0 +1,6 @@
+package com.mineinabyss.features
+
+data class FeatureDependencies(
+    val features: List<Feature<*>>,
+    val conditions: List<LoadPredicate>,
+)

core/src/commonMain/kotlin/com/mineinabyss/features/FeatureInstance.kt

@@ -0,0 +1,18 @@
+package com.mineinabyss.features
+
+import org.kodein.di.DI
+import org.kodein.di.instance
+
+class FeatureInstance(
+    val di: DI,
+) {
+    val context by di.instance<FeatureContext>()
+
+    fun close() {
+        context.onClose.reversed().forEach { it.close() }
+    }
+}
+
+class FeatureContext {
+    val onClose: MutableList<AutoCloseable> = mutableListOf()
+}