finished refactor #2

Author: vokod

core/build.gradle.kts

@@ -45,13 +45,6 @@ kotlin {
 
             implementation(compose.runtime)
             implementation(libs.common.lifecycle.viewmodelCompose)
-
-
-            //implementation(project.dependencies.platform(libs.androidx.compose.bom))
-            //implementation(libs.androidx.lifecycle.viewmodel.ktx)
-            //implementation(libs.androidx.compose.ui)
-            //implementation(libs.androidx.lifecycle.viewmodel.ktx)
-            //implementation(libs.androidx.lifecycle.viewmodel.compose)
         }
         commonTest.dependencies {
             implementation(libs.kotlin.test)

core/src/commonMain/kotlin/com/bridge/ouroboros/compose/ExecutableEffect.kt

@@ -29,7 +29,6 @@ abstract class ExecutableEffect<EVENT, EFFECT_STATE> : CoroutineScope {
     }
 
     companion object {
-        @Volatile
         private var defaultDispatcher: CoroutineDispatcher = Dispatchers.Default
 
         fun setDefaultDispatcher(dispatcher: CoroutineDispatcher) {

core/src/commonMain/kotlin/com/bridge/ouroboros/compose/LoopState.kt

@@ -8,13 +8,15 @@ import androidx.compose.runtime.setValue
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.viewModelScope
+import androidx.lifecycle.viewmodel.CreationExtras
 import androidx.lifecycle.viewmodel.compose.viewModel
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.plus
 import kotlin.coroutines.cancellation.CancellationException
+import kotlin.reflect.KClass
 
 class LoopState<MODEL : Any, EVENT : ActionableEvent<MODEL, EFFECT>, EFFECT : ExecutableEffect<EVENT, EFFECT_STATE>, EFFECT_STATE>(
     initialModel: MODEL,
@@ -76,10 +78,7 @@ class LoopState<MODEL : Any, EVENT : ActionableEvent<MODEL, EFFECT>, EFFECT : Ex
     }
 
     companion object {
-
-        @Volatile
         var loopScopeCustomizer: CoroutineScopeCustomizer = { it }
-
     }
 }
 
@@ -113,7 +112,7 @@ class LoopStateViewModel<MODEL : Any, EVENT : ActionableEvent<MODEL, EFFECT>, EF
 
 @Composable
 inline fun <reified MODEL : Any, EVENT : ActionableEvent<MODEL, EFFECT>, EFFECT : ExecutableEffect<EVENT, EFFECT_STATE>, EFFECT_STATE> acquireLoop(
-    key: String? = MODEL::class.java.name,
+    key: String? = MODEL::class.qualifiedName,
     crossinline loopInitializer: LoopInitializer<MODEL, EFFECT>,
     crossinline effectStateFactory: EffectStateFactory<EFFECT_STATE>,
     noinline crashHandler: CrashHandler = {
@@ -127,7 +126,10 @@ inline fun <reified MODEL : Any, EVENT : ActionableEvent<MODEL, EFFECT>, EFFECT
             key = key,
             factory = remember {
                 object : ViewModelProvider.Factory {
-                    override fun <T : ViewModel> create(modelClass: Class<T>): T {
+                    override fun <T : ViewModel> create(
+                        modelClass: KClass<T>,
+                        extras: CreationExtras
+                    ): T {
                         val (model, effects) = loopInitializer()
                         val effectState = effectStateFactory()
 

gradle/libs.versions.toml

@@ -1,5 +1,5 @@
 [versions]
-agp = "8.6.0-alpha08"
+agp = "8.6.1"
 android-compileSdk = "34"
 android-minSdk = "24"
 android-targetSdk = "34"

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +1,7 @@
 #Wed Jul 31 08:39:04 CEST 2024
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
 networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

test/build.gradle

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2019 - present Instructure, Inc.
+ */
+
+import org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalWasmDsl
+import org.jetbrains.kotlin.gradle.targets.js.webpack.KotlinWebpackConfig
+
+plugins {
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.compose.compiler)
+    alias(libs.plugins.compose.multiplatform)
+    alias(libs.plugins.kotlin.multiplatform)
+}
+
+kotlin {
+    androidTarget {
+        compilations.all {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+
+    @OptIn(ExperimentalWasmDsl::class)
+            wasmJs {
+        browser {
+            val projectDirPath = project.projectDir.path
+            commonWebpackConfig {
+                outputFileName = "ouroboroscompose.js"
+                devServer = (devServer ?: KotlinWebpackConfig.DevServer()).apply {
+                    static = (static ?: mutableListOf()).apply {
+                        // Serve sources to debug inside browser
+                        add(projectDirPath)
+                    }
+                }
+            }
+        }
+        binaries.executable()
+    }
+
+    sourceSets {
+        commonMain.dependencies {
+            api(project(":core"))
+            implementation(libs.coroutines.core)
+            implementation(libs.coroutines.trest)
+            implementation(libs.junit)
+            implementation(libs.kotlin.test)
+        }
+        commonTest.dependencies {
+        }
+    }
+}
+
+android {
+    namespace = "com.bridge.ouroboros.compose.test"
+    compileSdk = 35
+
+    defaultConfig {
+        minSdk = 21
+        targetSdk = 35
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    buildFeatures {
+        compose = true
+    }
+}

test/build.gradle.kts

@@ -1,7 +1,8 @@
 package com.bridge.ouroboros.compose.test
 
-import kotlin.test.junit.JUnitAsserter.assertEquals
-import kotlin.test.junit.JUnitAsserter.assertTrue
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
 
 class EffectMatching<E>(
     capturedEvents: Set<E>,
@@ -15,11 +16,11 @@ class EffectMatching<E>(
         }
 
     fun expectEvents(vararg events: E) {
-        assertEquals("Expected events to be $events", events.toSet(), emittedEvents.toSet())
+        assertEquals(events.toSet(), emittedEvents.toSet(),"Expected events to be $events")
     }
 
     fun expectNoEvents() {
-        assertTrue("Expected events to be empty", emittedEvents.isEmpty())
+        assertTrue(emittedEvents.isEmpty(), "Expected events to be empty")
     }
 
     operator fun invoke(block: EffectMatching<E>.() -> Unit) {

test/src/main/kotlin/com/bridge/ouroboros/compose/test/EffectMatching.kt renamed to test/src/commonMain/kotlin/com/bridge/ouroboros/compose/test/EffectMatching.kt

@@ -1,9 +1,10 @@
 package com.bridge.ouroboros.compose.test
 
 import com.bridge.ouroboros.compose.Next
-import kotlin.test.junit.JUnitAsserter.assertEquals
-import kotlin.test.junit.JUnitAsserter.assertNull
-import kotlin.test.junit.JUnitAsserter.assertTrue
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
 
 class NextMatching<M, F>(private val next: Next<M, F>) {
 
@@ -23,33 +24,38 @@ class NextMatching<M, F>(private val next: Next<M, F>) {
             return next.effects
         }
 
-    val mustHaveModel: M get() {
-        modelAccessed = true
-        return checkNotNull(next.modelOrNull()) { "Expected model but there was none" }
-    }
+    val mustHaveModel: M
+        get() {
+            modelAccessed = true
+            return checkNotNull(next.modelOrNull()) { "Expected model but there was none" }
+        }
 
     fun shouldHaveModel(model: M) {
-        assertEquals("Expect new model to be $model", model, newModel)
+        assertEquals(expected = model, actual = newModel, message = "Expect new model to be $model")
     }
 
     fun shouldNotHaveModel() {
-        assertNull("Expected no new model", newModel)
+        assertNull(newModel, "Expected no new model")
     }
 
     fun shouldHaveEffects(vararg effects: F) {
         newEffects shouldEmit effects.toSet()
     }
 
     infix fun Set<F>.shouldEmit(effects: Set<F>) {
-        assertEquals("Expecting effects to be $effects", effects, newEffects)
+        assertEquals(
+            expected = effects,
+            actual = newEffects,
+            message = "Expecting effects to be $effects"
+        )
     }
 
     infix fun Set<F>.shouldEmit(effect: F) {
         shouldEmit(setOf(effect))
     }
 
     fun shouldNotHaveEffects() {
-        assertTrue("No effects should be emitted", newEffects.isEmpty())
+        assertTrue(newEffects.isEmpty(), "No effects should be emitted")
     }
 
     fun shouldNotChange() {