Provide MainScope in DI.derived

Author: wkornewald

.github/workflows/build.yaml

@@ -16,7 +16,7 @@ jobs:
     runs-on: macos-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
       - name: Validate Gradle Wrapper
         uses: gradle/actions/wrapper-validation@v4
       - name: Install JDK

.github/workflows/docs.yaml

@@ -28,7 +28,7 @@ jobs:
     runs-on: macos-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           ref: ${{ inputs.ref }}
       - name: Install JDK

build-logic/build-logic-base/src/main/kotlin/com/ensody/buildlogic/AndroidExt.kt

@@ -36,7 +36,11 @@ fun Project.setupAndroid(
         testOptions {
             // Needed for Robolectric
             unitTests {
-                isIncludeAndroidResources = true
+                // TODO: Remove this workaround for https://issuetracker.google.com/issues/411739086 once fixed in AGP
+                isIncludeAndroidResources = listOf("androidUnitTest", "test").any { name ->
+                    val sourceSet = file("src/$name")
+                    sourceSet.exists() && sourceSet.walkTopDown().any { it.extension == "kt" }
+                }
             }
         }
 

build-logic/build-logic/src/main/kotlin/com/ensody/buildlogic/BuildLogicPlugin.kt

@@ -65,24 +65,18 @@ fun Project.setupBuildLogic(block: Project.() -> Unit) {
                     implementation(rootLibs.findLibrary("junit").get())
                 }
             }
-            // testDebugUnitTest throws an error if there are no tests
-            val hasTests = file("src").listFiles().orEmpty().any { sourceSet ->
-                sourceSet.name.endsWith("Test") && sourceSet.walkTopDown().any { it.extension == "kt" }
-            }
             tasks.register("testAll") {
                 group = "verification"
-                if (hasTests) {
-                    dependsOn(
-                        "testDebugUnitTest",
-                        "jvmTest",
-                        "iosSimulatorArm64Test",
-                        "iosX64Test",
-                        "macosArm64Test",
-                        "macosX64Test",
-                        "mingwX64Test",
-                        "linuxX64Test",
-                    )
-                }
+                dependsOn(
+                    "testDebugUnitTest",
+                    "jvmTest",
+                    "iosSimulatorArm64Test",
+                    "iosX64Test",
+                    "macosArm64Test",
+                    "macosX64Test",
+                    "mingwX64Test",
+                    "linuxX64Test",
+                )
             }
         }
         if (extensions.findByType<KotlinBaseExtension>() != null) {

reactivestate-compose/src/composeMain/kotlin/com/ensody/reactivestate/compose/ViewModelExt.kt

@@ -76,22 +76,14 @@ public inline fun <reified T : Any?> onViewModel(
         WrapperViewModel { viewModelScope ->
             // The viewModelScope can't be used directly because we have to destroy and re-create the ViewModel whenever
             // the DI graph gets modified.
-            val mutex = Mutex()
-            var scope: CoroutineScope? = null
+            var scopeRef: CoroutineScope? = null
             viewModelScope.invokeOnCompletion {
-                mutex.withSpinLock {
-                    scope?.cancel()
-                    scope = null
-                }
+                scopeRef?.cancel()
             }
             DI.derived {
-                val vmScope = MainScope()
-                mutex.withSpinLock {
-                    scope?.cancel()
-                    scope = vmScope
-                }
+                scopeRef = scope
                 ReactiveStateContext(
-                    vmScope + ContextualValRoot() + ContextualStateFlowStore.valued { InMemoryStateFlowStore(storage) },
+                    scope + ContextualValRoot() + ContextualStateFlowStore.valued { InMemoryStateFlowStore(storage) },
                     this,
                 ).provider()
             }

reactivestate-core/src/commonMain/kotlin/com/ensody/reactivestate/DI.kt

@@ -1,9 +1,13 @@
 package com.ensody.reactivestate
 
 import com.ensody.reactivestate.derived
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.getAndUpdate
+import kotlinx.coroutines.sync.Mutex
 import kotlin.reflect.KClass
 import com.ensody.reactivestate.derived as realDerived
 
@@ -111,11 +115,23 @@ public class DIImpl {
     public fun <T> derived(factory: DIResolver.() -> T): StateFlow<T> =
         derived(null, factory)
 
-    private fun <T> derived(klass: KClass<*>?, factory: DIResolver.() -> T): StateFlow<T> =
-        realDerived {
-            val resolver = DIResolverImpl(this, this@DIImpl, klass)
+    private fun <T> derived(klass: KClass<*>?, factory: DIResolver.() -> T): StateFlow<T> {
+        val mutex = Mutex()
+        var scope: CoroutineScope? = null
+        var lastResolver: DIResolverImpl? = null
+        return realDerived {
+            val nextScope = MainScope()
+            mutex.withSpinLock {
+                scope?.cancel()
+                scope = nextScope
+            }
+            val resolver = DIResolverImpl(this, nextScope, this@DIImpl, klass).also {
+                lastResolver?.scope?.cancel()
+                lastResolver = it
+            }
             resolver.factory().also { resolver.ready = true }
         }
+    }
 
     // We hide this function as an extension, so nobody can mistakenly get() arbitrary T values not belonging to the DI
     public inline fun <reified T : Any> DIResolver.get(noinline default: (() -> T)? = null): LazyProperty<T> =
@@ -171,6 +187,8 @@ public object InternalDI
 public interface DIResolver : Resolver {
     public val DI: DIImpl
 
+    public val scope: CoroutineScope
+
     @InternalReactiveStateApi
     public val InternalDI.owner: KClass<*>?
 
@@ -184,6 +202,7 @@ public fun <T> DIResolver.get(lazyProperty: LazyProperty<T>): T =
 
 private class DIResolverImpl(
     delegate: Resolver,
+    override val scope: CoroutineScope,
     override val DI: DIImpl,
     private val klass: KClass<*>?,
     var ready: Boolean = false,

reactivestate-core/src/commonMain/kotlin/com/ensody/reactivestate/ReactiveStateContext.kt

@@ -9,7 +9,7 @@ import kotlin.coroutines.CoroutineContext
  */
 @ExperimentalReactiveStateApi
 public data class ReactiveStateContext(
-    public val scope: CoroutineScope,
+    override val scope: CoroutineScope,
     private val resolver: DIResolver,
 ) : DIResolver by resolver {
     public operator fun plus(element: CoroutineContext.Element): ReactiveStateContext =

reactivestate-core/src/commonTest/kotlin/com/ensody/reactivestate/DITest.kt

@@ -1,20 +1,25 @@
 package com.ensody.reactivestate
 
+import com.ensody.reactivestate.test.CoroutineTest
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.test.runCurrent
 import kotlin.test.Test
+import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 import kotlin.test.assertFalse
 import kotlin.test.assertNotSame
 import kotlin.test.assertSame
 import kotlin.test.assertTrue
 
-internal class DITest {
+internal class DITest : CoroutineTest() {
     val someConfigFlag = MutableStateFlow(true)
     val testDI = DIImpl()
+    var destroyedBar = 0
 
     init {
         testDI.register { FooDeps(get(someConfigFlag), barDeps, defaultDeps) }
-        testDI.register { BarDeps(fooDeps) }
+        testDI.register { BarDeps(fooDeps, scope.apply { invokeOnCompletion { destroyedBar += 1 } }) }
     }
 
     private val defaultFlow = testDI.derived { get(defaultDeps) }
@@ -30,6 +35,7 @@ internal class DITest {
         assertSame(default, foo.defaultDeps)
         assertSame(foo, testDI.derived { get(fooDeps) }.value)
         assertSame(bar, testDI.derived { get(barDeps) }.value)
+        assertEquals(0, destroyedBar)
     }
 
     @Test
@@ -47,23 +53,33 @@ internal class DITest {
     }
 
     @Test
-    fun updateDIGraphOnRegister() {
+    fun updateDIGraphOnRegister() = runTest {
         // Replacing FooDeps invalidates the whole subgraph depending on FooDeps. So, BarDeps gets re-created.
         testDI.register { FooDeps(get(someConfigFlag), barDeps, defaultDeps) }
         assertNotSame(foo, testDI.derived { get(fooDeps) }.value)
         assertSame(default, testDI.derived { get(fooDeps) }.value.defaultDeps)
         val newBar = testDI.derived { get(barDeps) }.value
         assertNotSame(bar, newBar)
         assertTrue(foo.circularConfigFlag)
+        runCurrent()
+        assertEquals(1, destroyedBar)
 
         // Any flow also auto-updates
         assertSame(fooFlow.value, testDI.derived { get(fooDeps) }.value)
         assertSame(newBar, testDI.derived { get(barDeps) }.value)
         assertSame(barFlow.value, testDI.derived { get(barDeps) }.value)
+
+        runCurrent()
+        assertEquals(1, destroyedBar)
+
+        testDI.register { FooDeps(get(someConfigFlag), barDeps, defaultDeps) }
+        assertNotSame(newBar, testDI.derived { get(barDeps) }.value)
+        runCurrent()
+        assertEquals(2, destroyedBar)
     }
 
     @Test
-    fun updateDIGraphOnStateFlowChange() {
+    fun updateDIGraphOnStateFlowChange() = runTest {
         // Changing the StateFlow that FooDeps depends on also invalidates FooDeps and BarDeps
         someConfigFlag.value = false
         assertNotSame(foo, testDI.derived { get(fooDeps) }.value)
@@ -74,6 +90,15 @@ internal class DITest {
         assertFalse(fooFlow.value.circularConfigFlag)
         assertSame(fooFlow.value, testDI.derived { get(fooDeps) }.value)
         assertSame(barFlow.value, testDI.derived { get(barDeps) }.value)
+        runCurrent()
+        assertEquals(1, destroyedBar)
+
+        someConfigFlag.value = true
+        assertNotSame(bar, testDI.derived { get(barDeps) }.value)
+        assertSame(fooFlow.value, testDI.derived { get(fooDeps) }.value)
+        assertSame(barFlow.value, testDI.derived { get(barDeps) }.value)
+        runCurrent()
+        assertEquals(2, destroyedBar)
     }
 }
 
@@ -120,7 +145,7 @@ private class MyUseCase(val circularConfigFlag: Boolean)
 private val DIResolver.barDeps: LazyProperty<BarDeps> get() = DI.run { get() }
 
 // Circular dependency to Foo, so we have
-private class BarDeps(lazyFooDeps: LazyProperty<FooDeps>) {
+private class BarDeps(lazyFooDeps: LazyProperty<FooDeps>, val scope: CoroutineScope) {
     val fooDeps: FooDeps by lazyFooDeps
 
     val configFlag: Boolean by lazy { fooDeps.configFlag }