feat: add reactions + mobk viewmodel wrapper

ThomasSalvetat · ThomasSalvetat · commit cc89a6c18b3f · 2023-09-22T13:36:17.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -1,7 +1,7 @@
 /secret.properties
 /local.properties
-/build/
 /.gradle/
 /.idea/
 /mobk-compose/build/
 /mobk-core/build/
+build/
diff --git a/mobk-core/build.gradle.kts b/mobk-core/build.gradle.kts
@@ -28,7 +28,7 @@ kotlin {
         iosSimulatorArm64()
     ).forEach {
         it.binaries.framework {
-            baseName = "shared"
+            baseName = "mobk-core"
         }
 
     }
diff --git a/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/api/Api.kt b/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/api/Api.kt
@@ -4,6 +4,7 @@ import io.monkeypatch.mobk.core.*
 import kotlin.properties.ReadOnlyProperty
 import kotlin.properties.ReadWriteProperty
 import kotlin.reflect.KProperty
+import kotlin.time.Duration
 
 
 public fun autorun(body: () -> Unit): ReactionDisposer =
@@ -13,6 +14,23 @@ public fun action(body: () -> Unit) {
     Action(body).runAction()
 }
 
+public fun <T> reaction(context: ReactiveContext = ReactiveContext.main,
+                        delay: Duration? = null,
+                        equals: ((T?, T?) -> Boolean)? = null,
+                        onError: ReactionErrorHandler? = null,trackingFn: (Reaction) -> T, effect: (T?) -> Unit): ReactionDisposer =
+    createReaction(
+        context = context,
+        delay = delay,
+        equals = equals,
+        onError = onError,
+        trackingFn = trackingFn, effect = effect)
+
+public fun whenReaction(context: ReactiveContext = ReactiveContext.main,
+                            timeout: Duration? = null,
+                            onError: ReactionErrorHandler? = null,
+                            predicate: (Reaction) -> Boolean,
+                            effect: () -> Unit) = createWhenReaction(context = context, timeout = timeout, onError = onError, predicate = predicate, effect = effect)
+
 public fun <T> observable(initialValue: T): ReadWriteProperty<Any?, T> = ObservableDelegate(initialValue)
 
 public fun <T> computed(body: () -> T): ReadOnlyProperty<Any?, T> = ComputedDelegate(body)
diff --git a/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/Autorun.kt b/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/Autorun.kt
@@ -1,14 +1,5 @@
 package io.monkeypatch.mobk.core
 
-public interface ReactionDisposer {
-    public operator fun invoke()
-}
-
-internal data class ReactionDisposerImpl(private val reaction: Reaction): ReactionDisposer {
-    override operator fun invoke() {
-        reaction.dispose()
-    }
-}
 
 internal fun createAutorun(
     context: ReactiveContext = ReactiveContext.main,
diff --git a/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/Derivation.kt b/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/Derivation.kt
@@ -7,7 +7,7 @@ public enum class DerivationState {
     STALE
 }
 
-internal interface Derivation {
+ interface Derivation {
     val name: String
     var observables: Set<Atom>
     var newObservables: MutableSet<Atom>
diff --git a/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/Exception.kt b/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/Exception.kt
@@ -8,4 +8,6 @@ public sealed class MobXException(message: String): Exception(message) {
 
     /// This captures the stack trace when user-land code throws an exception
     public class MobXCaughtException(public val exception: Throwable): MobXException("MobXCaughtException: $exception")
+
+    public class MobXTimeoutException(message: String): MobXException(message)
 }
diff --git a/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/Reaction.kt b/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/Reaction.kt
@@ -1,8 +1,8 @@
 package io.monkeypatch.mobk.core
 
-internal typealias ReactionErrorHandler = (error: Throwable, reaction: Reaction) -> Unit
+ typealias ReactionErrorHandler = (error: Throwable, reaction: Reaction) -> Unit
 
-internal interface Reaction : Derivation {
+ interface Reaction : Derivation {
     val isDisposed: Boolean
 
     fun dispose()
diff --git a/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/ReactionDisposers.kt b/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/ReactionDisposers.kt
@@ -0,0 +1,14 @@
+package io.monkeypatch.mobk.core
+
+ class ReactionDisposers {
+    private val disposers = mutableListOf<ReactionDisposer>()
+
+     fun add(disposer: ReactionDisposer) {
+        disposers.add(disposer)
+    }
+
+     fun clear() {
+        disposers.forEach { it() }
+        disposers.clear()
+    }
+}
diff --git a/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/ReactionHelper.kt b/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/ReactionHelper.kt
@@ -0,0 +1,133 @@
+package io.monkeypatch.mobk.core
+
+import kotlinx.coroutines.Delay
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
+import kotlin.time.Duration
+
+public interface ReactionDisposer {
+    public operator fun invoke()
+}
+
+internal data class ReactionDisposerImpl(private val reaction: Reaction): ReactionDisposer {
+    override operator fun invoke() {
+        reaction.dispose()
+    }
+}
+
+internal fun <T> createReaction(
+    context: ReactiveContext = ReactiveContext.main,
+    name: String = context.nameFor("Reaction"),
+    delay: Duration? = null,
+    equals: ((T?, T?) -> Boolean)? = null,
+    onError: ReactionErrorHandler? = null,
+    trackingFn: (Reaction) -> T,
+    effect: (T?) -> Unit
+): ReactionDisposer {
+    var lastValue: T? = null
+    var firstTime = true
+    var runSync = delay == null
+    var  rxn: ReactionImpl? = null
+    val effectAction = effect
+
+    val reactionRunner: () -> Unit = {
+        val reaction = rxn
+        if (reaction == null || !reaction.isDisposed) {
+            var changed = false
+
+            reaction?.run {
+                track {
+                    val nextValue = trackingFn(reaction)
+                    val isEqual = if (equals != null) equals(nextValue, lastValue) else  lastValue == nextValue
+
+                    changed = firstTime || !isEqual
+                    lastValue = nextValue
+                }
+            }
+
+            val canInvokeEffect = !firstTime && changed
+
+            if (canInvokeEffect) {
+                effectAction(lastValue)
+            }
+
+            if (firstTime) {
+                firstTime = false
+            }
+        }
+    }
+
+    var isScheduled = false
+     rxn = ReactionImpl(
+        context, name, onError
+    ) {
+        if (firstTime || runSync) {
+            reactionRunner()
+        } else if(!isScheduled) {
+            isScheduled = true
+
+            context.config.reactionCoroutineScope.launch {
+              if (delay != null) {
+                    delay(delay)
+                }
+
+                isScheduled = false
+
+                withContext(Dispatchers.Main) {
+                reactionRunner()
+                }
+            }
+        }
+    }
+    rxn.schedule()
+    return ReactionDisposerImpl(rxn)
+}
+
+internal fun createWhenReaction(
+    context: ReactiveContext = ReactiveContext.main,
+    name: String = context.nameFor("Reaction"),
+    timeout: Duration? = null,
+    onError: ReactionErrorHandler? = null,
+    predicate: (Reaction) -> Boolean,
+    effect: () -> Unit
+): ReactionDisposer {
+    val effectAction = effect
+    var dispose: ReactionDisposer? = null
+    val rxn: ReactionImpl? = null
+
+    if (timeout != null) {
+        context.config.reactionCoroutineScope.launch {
+            withTimeout(timeout) {
+                val d = dispose
+                val r = rxn
+                if (d != null && r != null) {
+                    if (!r.isDisposed) {
+                        d()
+
+                        val error = MobXException.MobXTimeoutException("WHEN_TIMEOUT")
+                        if (onError != null) {
+                            onError(error, r)
+                        } else {
+                            throw error
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+     dispose = createAutorun(
+        context = context,
+        name = name,
+        onError = onError
+    ) { reaction ->
+        if (predicate(reaction)) {
+            reaction.dispose()
+            effectAction()
+        }
+    }
+    return dispose
+}
diff --git a/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/ReactiveContext.kt b/mobk-core/src/commonMain/kotlin/io/monkeypatch/mobk/core/ReactiveContext.kt
@@ -1,6 +1,8 @@
 package io.monkeypatch.mobk.core
 
 import io.monkeypatch.mobk.utils.isMainThread
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlin.native.concurrent.ThreadLocal
 import kotlin.properties.Delegates
 
@@ -59,7 +61,8 @@ public data class ReactiveConfig(
     val writePolicy: ReactiveWritePolicy,
     val readPolicy: ReactiveReadPolicy,
     val maxIterations: Int = 100,
-    val enforceWriteOnMainThread: Boolean = true
+    val enforceWriteOnMainThread: Boolean = true,
+    val reactionCoroutineScope: CoroutineScope = CoroutineScope(Dispatchers.Default)
 ) {
     internal val reactionErrorHandlers: MutableSet<ReactionErrorHandler> = mutableSetOf()
 
diff --git a/mobk-core/src/commonTest/kotlin/io/monkeypatch/mobk/core/TestReactiveContext.kt b/mobk-core/src/commonTest/kotlin/io/monkeypatch/mobk/core/TestReactiveContext.kt
@@ -96,4 +96,63 @@ class TestReactiveContext {
         assertEquals(listOf(10, 11, 12, 20), xHistory)
         assertEquals(listOf(true, false, true), isPairHistory)
     }
+
+    @Test
+    fun testReaction() {
+        val x = Observable(10)
+        val isPair = Computed { x.value % 2 == 0 }
+
+        val xHistory = mutableListOf<Int>()
+        var pairCounter = 1
+
+        createAutorun {
+            xHistory.add(x.value)
+        }
+
+        createReaction (
+            trackingFn = {
+                isPair.value
+            }
+        ) { value ->
+            value?.let {
+                pairCounter++
+            }
+        }
+
+        x.value = 11
+        x.value = 12
+        x.value = 20
+
+        assertEquals(listOf(10, 11, 12, 20), xHistory)
+        assertEquals(3, pairCounter)
+    }
+
+    @Test
+    fun testWhenReaction() {
+        val x = Observable(10)
+
+        val xHistory = mutableListOf<Int>()
+        var isTwelve = 0
+
+        createAutorun {
+            xHistory.add(x.value)
+        }
+
+        createWhenReaction (
+            predicate = {
+                x.value == 12
+            }
+        ) {
+                isTwelve++
+        }
+
+        x.value = 11
+        x.value = 12
+        x.value = 20
+        x.value= 12
+        x.value = 24
+
+        assertEquals(listOf(10, 11, 12, 20,12,24), xHistory)
+        assertEquals(1, isTwelve)
+    }
 }
diff --git a/mobk-viewmodel/build.gradle.kts b/mobk-viewmodel/build.gradle.kts
@@ -0,0 +1,58 @@
+plugins {
+    kotlin("multiplatform")
+    id("com.android.library")
+    id("maven-publish")
+}
+
+
+group = "io.monkeypatch"
+version = "0.0.11"
+
+@OptIn(org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi::class)
+kotlin {
+    targetHierarchy.default()
+
+    androidTarget {
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "1.8"
+            }
+        }
+
+        publishLibraryVariants("release")
+    }
+    
+    listOf(
+        iosX64(),
+        iosArm64(),
+        iosSimulatorArm64()
+    ).forEach {
+        it.binaries.framework {
+            baseName = "mobk-viewmodel"
+
+            export("dev.icerock.moko:mvvm-core:0.16.1")
+        }
+    }
+
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                api(project(":mobk-core"))
+                api("dev.icerock.moko:mvvm-core:0.16.1")
+            }
+        }
+        val commonTest by getting {
+            dependencies {
+                implementation(kotlin("test"))
+            }
+        }
+    }
+}
+
+android {
+    namespace = "io.monkeypatch.mobk.viewmodel"
+    compileSdk = 33
+    defaultConfig {
+        minSdk = 24
+    }
+}
diff --git a/mobk-viewmodel/src/commonMain/kotlin/io/monkeypatch/mobk/viewmodel/MobkViewModel.kt b/mobk-viewmodel/src/commonMain/kotlin/io/monkeypatch/mobk/viewmodel/MobkViewModel.kt
diff --git a/settings.gradle.kts b/settings.gradle.kts

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ kotlin {`
`28`	`28`	`iosSimulatorArm64()`
`29`	`29`	`).forEach {`
`30`	`30`	`it.binaries.framework {`
`31`		`- baseName = "shared"`
	`31`	`+ baseName = "mobk-core"`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ public enum class DerivationState {`
`7`	`7`	`STALE`
`8`	`8`	`}`
`9`	`9`
`10`		`-internal interface Derivation {`
	`10`	`+ interface Derivation {`
`11`	`11`	`val name: String`
`12`	`12`	`var observables: Set<Atom>`
`13`	`13`	`var newObservables: MutableSet<Atom>`
Original file line number	Diff line number	Diff line change
`@@ -8,4 +8,6 @@ public sealed class MobXException(message: String): Exception(message) {`
`8`	`8`
`9`	`9`	`/// This captures the stack trace when user-land code throws an exception`
`10`	`10`	`public class MobXCaughtException(public val exception: Throwable): MobXException("MobXCaughtException: $exception")`
	`11`	`+`
	`12`	`+ public class MobXTimeoutException(message: String): MobXException(message)`
`11`	`13`	`}`