Leviathan v3 (#4)

v3
---------

Co-authored-by: Yahor <[email protected]>

Author: vkatz

.github/workflows/verify.yml

@@ -31,7 +31,7 @@ jobs:
       - uses: actions/checkout@v5
       - uses: gradle/actions/setup-gradle@v5
       - name: Check ABI
-        run: ./gradlew checkLegacyAbi
+        run: ./gradlew checkAbi
 
   verify-libs:
     runs-on: ubuntu-latest

README.md

@@ -39,21 +39,23 @@ Base usage
 
 Create `Module` (recommend to use `object`) and extends from `Leviathan` class
 
-Create fields using one functions:
+Create fields using these functions:
 
-- Use `by instanceOf` to create single-object-delegate (same instance upon every access)
-- Use `by lateInitInstance` to create instance-based late-init dependency (ps: you need to call `provides` method before
-  access)
-- Use `by factoryOf` to create factory-delegate (new instance upon each access)
+- Use `by instanceOf(keepAlive){/**/}` to create instance dependency
+  - `keepAlive = true` : instance persists across different scopes
+  - `keepAlive = false`(default): instance is auto-closed when all scopes close
+- Use `by factoryOf(useCache)` to create factory dependency
+  - `useCache = true` (default): caches instances within the same scope
+  - `useCache = false`: creates new instance on each access
+- Use `by valueOf(value)` to create value dependency (returns the same value always)
 
-Both functions return a dependency provider instance and the type of field will be `Dependency<Type>`
+All functions return a `Dependency<Type>` instance.
 
-To retreive dependency use either `Module.dependency.get()` or define a property `val dep by Module.dependency`
 
-Simple case
+Example
 -----------
 
-Declare you dependencies
+Declare your dependencies
 
 ```kotlin
 class SampleRepository()
@@ -68,156 +70,45 @@ Create module
 
 ```kotlin
 object Module : Leviathan() {
-    val lazyRepository by instanceOf(::SampleRepository)
-    val nonLazyRepository by instanceOf(false, ::SampleRepository)
+    val autoCloseRepository by instanceOf { SampleRepository() }
+    val keepAliveRepository by instanceOf(keepAlive = true) { SampleRepository() }
     val repositoryWithParam by factoryOf { SampleRepositoryWithParam(1) }
-    val repositoryWithDependency by instanceOf { SampleRepositoryWithDependency(lazyRepository.get()) }
-    val interfaceRepo by instanceOf<SampleInterfaceRepo>(::SampleInterfaceRepoImpl)
+    val repositoryWithDependency by instanceOf { 
+        SampleRepositoryWithDependency(inject(autoCloseRepository)) 
+    }
+    val interfaceRepo by instanceOf<SampleInterfaceRepo> { SampleInterfaceRepoImpl() }
+    val constantValue by valueOf(42)
 }
 ```
 
 Dependencies usage:
 
 ```kotlin
-fun foo() {
-    val repo = Module.lazyRepository.get()
-    //...  
-}
-
-class Model(
-    val dep1: SampleRepository = Module.lazyRepository.get()
-) {
-    val dep2: SampleRepository by Module.nonLazyRepository
-    //...
-}
-
-```
-
-Mutli-module case
------------------
-
-Interface based approach
-
-```kotlin
-// ----------Module 1-------------
-//Dependency 
-class Dep {
-    fun foo() {}
-}
-
-// ----------Module 2-------------
-// Dependency provider interface
-interface ICore {
-    val dep: Dependency<Dep>
-}
-
-// Dependency provider implementation
-internal class CoreImpl : Leviathan(), ICore {
-    override val dep by instanceOf { Dep() }
-}
-// Dependency provider accessor
-val Core: ICore = CoreImpl()
-
-// ----------Module 3-------------    
-// Usage
-fun boo() {
-    val dep by Core.dep
-} 
-   ```
-
-Simple approach
-
-```kotlin
-// ----------Module 1-------------
-//Dependency
-class Dep {
-    fun foo() {}
-}
-
-// ----------Module 2-------------
-// Dependency provider & accessor
-object Core : Leviathan() {
-    val dep by instanceOf { Dep() }
-}
-
-// ----------Module 3-------------
-// Usage
-fun boo() {
-    val dep by Core.dep
-}
-```
-
-Advanced case
--------------
-
-In order to create good & testable classes recommend to use advanced scenario
-
-1) declare dependencies
-    ```kotlin
-    class DataRepository //...
-    class ApiRepository //...
-    ```
-2) declare module interface (data/domain modules)
-    ```kotlin
-    interface DataModule {
-        val dataRepository: Dependency<DataRepository>
-    }
-    
-    interface ApiModule {
-        val apiRepository: Dependency<ApiRepository>
-    }    
-    ```
-3) Create `AppModule` and inherit from interfaces(step #2) and `Leviathan`
-    ```kotlin
-    object AppModule : DataModule, ApiModule, Leviathan() {
-        override val dataRepository: Dependency<DataRepository> by instance(::DataRepository)
-        override val apiRepository: Dependency<ApiRepository> by instance(::ApiRepository)
+// view model
+class SomeVM(
+    dep1: Dependency<SampleRepository> = Module.autoCloseRepository,
+) : ViewModel() {
+    val dep1value = inject(dep1)
+
+    fun foo(){
+        val dep2 = inject(Module.interfaceRepo)
     }
-    ```
-4) Create Models (or any other classes) base on interfaces from step #2
-    ```kotlin
-    class Model(apiModule: ApiModule = AppModule){
-        val api: ApiRepository by apiModule.apiRepository
-   
-        fun foo(){/*...*/}
-    }
-    ```
-
-Now you can make tests and have easy way to mock your data:
-
-```kotlin
-@Test
-fun ModelTests() {
-    val model = Model(object : Leviathan(), ApiModule {
-        override val apiRepository by instanceOf { MyMockApiRepository() }
-    })
-    model.foo()
-
-    //-----or-----------
-
-    AppModule.apiRepository.overrideWith { MyMockApiRepository() }
-    val model = Model()
-    model.foo()
-}
-```
-
-Compose
--------------
-
-Dependencies access in compose code:
-```kotlin
-class Repository(){
-    fun foo(){}
 }
 
-object Module : Leviathan(){
-    val dependency by instanceOf { Repository() }
+// compose
+@Composable
+fun ComposeWithDI() {
+    val repo1 = inject(Module.autoCloseRepository)
+    val repo2 = inject { Module.repositoryWithParam }
+    /*..*/
 }
 
-@Composable
-fun SomeComposable(){
-    val dependency = leviathanInject { Module.dependency }
-    ///...
+// random access
+fun foo() {
+    val scope = DIScope()
+    val repo1 = Module.autoCloseRepository.injectedIn(scope)
+    /*..*/
+    scope.close()
 }
 ```
 

build.gradle.kts

@@ -1,9 +1,8 @@
 import io.gitlab.arturbosch.detekt.DetektPlugin
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-    alias(libs.plugins.android.library) apply false
-    alias(libs.plugins.compose.compiler)
+    alias(libs.plugins.android.kotlin.multiplatform.library) apply false
+    alias(libs.plugins.compose.compiler) apply false
     alias(libs.plugins.jetbrains.compose) apply false
     alias(libs.plugins.detekt)
     alias(libs.plugins.kotlin.multiplatform) apply false
@@ -42,19 +41,16 @@ allprojects {
     }
 }
 
-subprojects {
-    tasks.withType<KotlinCompile>().configureEach {
-        val outPath = layout.buildDirectory.dir("compose_compiler").get().asFile.absoluteFile
-
-        compilerOptions {
-            if (project.findProperty("composeCompilerReports") == "true") {
-                composeCompiler {
-                    reportsDestination = outPath
-                    metricsDestination = outPath
-                }
-            }
-        }
-    }
+// check ABI
+tasks.register("checkAbi") {
+    dependsOn(":leviathan:checkLegacyAbi")
+    dependsOn(":leviathan-compose:checkLegacyAbi")
+}
+
+// update ABI
+tasks.register("updateAbi") {
+    dependsOn(":leviathan:updateLegacyAbi")
+    dependsOn(":leviathan-compose:updateLegacyAbi")
 }
 
 createM2PTask()

gradle/leviathan.toml

@@ -1,2 +1,2 @@
 [versions]
-leviathan = "2.0.0"
+leviathan = "3.0.0"

gradle/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
 agp = "8.12.0"
-android-compileSdk = "35"
-android-minSdk = "21"
+minSdk = "21"
+compileSdk = "36"
 
 detekt = "1.23.8"
 jetbrains-compose = "1.9.0"
@@ -12,9 +12,10 @@ detekt-compose = "io.nlopez.compose.rules:detekt:0.4.27"
 detekt-formatting = { module = "io.gitlab.arturbosch.detekt:detekt-formatting", version.ref = "detekt" }
 
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
+lifecycle-viewmodel-compose = { module = "org.jetbrains.androidx.lifecycle:lifecycle-viewmodel-compose", version = "2.9.4" }
 
 [plugins]
-android-library = { id = "com.android.library", version.ref = "agp" }
+android-kotlin-multiplatform-library = { id = "com.android.kotlin.multiplatform.library", version.ref = "agp" }
 compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
 detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
 jetbrains-compose = { id = "org.jetbrains.compose", version.ref = "jetbrains-compose" }

leviathan-compose/api/android/leviathan-compose.api

@@ -1,4 +1,6 @@
 public final class com/composegears/leviathan/compose/LeviathanComposeKt {
-	public static final fun leviathanInject (Lkotlin/jvm/functions/Function0;Landroidx/compose/runtime/Composer;I)Ljava/lang/Object;
+	public static final fun inject (Landroidx/lifecycle/ViewModel;Lcom/composegears/leviathan/Dependency;)Ljava/lang/Object;
+	public static final fun inject (Lcom/composegears/leviathan/Dependency;Landroidx/compose/runtime/Composer;I)Ljava/lang/Object;
+	public static final fun inject (Lkotlin/jvm/functions/Function0;Landroidx/compose/runtime/Composer;I)Ljava/lang/Object;
 }
 

leviathan-compose/api/jvm/leviathan-compose.api

@@ -1,4 +1,6 @@
 public final class com/composegears/leviathan/compose/LeviathanComposeKt {
-	public static final fun leviathanInject (Lkotlin/jvm/functions/Function0;Landroidx/compose/runtime/Composer;I)Ljava/lang/Object;
+	public static final fun inject (Landroidx/lifecycle/ViewModel;Lcom/composegears/leviathan/Dependency;)Ljava/lang/Object;
+	public static final fun inject (Lcom/composegears/leviathan/Dependency;Landroidx/compose/runtime/Composer;I)Ljava/lang/Object;
+	public static final fun inject (Lkotlin/jvm/functions/Function0;Landroidx/compose/runtime/Composer;I)Ljava/lang/Object;
 }
 

leviathan-compose/api/leviathan-compose.klib.api

@@ -6,4 +6,6 @@
 // - Show declarations: true
 
 // Library unique name: <io.github.composegears:leviathan-compose>
-final fun <#A: kotlin/Any?> com.composegears.leviathan.compose/leviathanInject(kotlin/Function0<com.composegears.leviathan/Dependency<#A>>, androidx.compose.runtime/Composer?, kotlin/Int): #A // com.composegears.leviathan.compose/leviathanInject|leviathanInject(kotlin.Function0<com.composegears.leviathan.Dependency<0:0>>;androidx.compose.runtime.Composer?;kotlin.Int){0§<kotlin.Any?>}[0]
+final fun <#A: kotlin/Any?> (androidx.lifecycle/ViewModel).com.composegears.leviathan.compose/inject(com.composegears.leviathan/Dependency<#A>): #A // com.composegears.leviathan.compose/inject|[email protected](com.composegears.leviathan.Dependency<0:0>){0§<kotlin.Any?>}[0]
+final fun <#A: kotlin/Any?> com.composegears.leviathan.compose/inject(com.composegears.leviathan/Dependency<#A>, androidx.compose.runtime/Composer?, kotlin/Int): #A // com.composegears.leviathan.compose/inject|inject(com.composegears.leviathan.Dependency<0:0>;androidx.compose.runtime.Composer?;kotlin.Int){0§<kotlin.Any?>}[0]
+final fun <#A: kotlin/Any?> com.composegears.leviathan.compose/inject(kotlin/Function0<com.composegears.leviathan/Dependency<#A>>, androidx.compose.runtime/Composer?, kotlin/Int): #A // com.composegears.leviathan.compose/inject|inject(kotlin.Function0<com.composegears.leviathan.Dependency<0:0>>;androidx.compose.runtime.Composer?;kotlin.Int){0§<kotlin.Any?>}[0]

leviathan-compose/build.gradle.kts

@@ -1,11 +1,11 @@
-import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+import com.android.build.api.dsl.androidLibrary
 import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.dsl.abi.ExperimentalAbiValidation
 
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
-    alias(libs.plugins.android.library)
+    alias(libs.plugins.android.kotlin.multiplatform.library)
     alias(libs.plugins.compose.compiler)
     alias(libs.plugins.jetbrains.compose)
     alias(libs.plugins.m2p)
@@ -22,11 +22,15 @@ kotlin {
     }
 
     jvm()
-    androidTarget {
-        publishLibraryVariants("release")
-        @OptIn(ExperimentalKotlinGradlePluginApi::class)
-        compilerOptions {
-            jvmTarget = JvmTarget.JVM_1_8
+    androidLibrary {
+        namespace = "com.composegears.leviathan.compose"
+        compileSdk = libs.versions.compileSdk.get().toInt()
+        minSdk = libs.versions.minSdk.get().toInt()
+
+        compilations.configureEach {
+            compilerOptions.configure {
+                jvmTarget = JvmTarget.JVM_1_8
+            }
         }
     }
     iosX64()
@@ -35,28 +39,20 @@ kotlin {
 
     @OptIn(ExperimentalWasmDsl::class)
     wasmJs {
-        binaries.executable()
-        nodejs()
+        browser()
     }
 
     sourceSets {
         commonMain.dependencies {
-            implementation(projects.leviathan)
+            api(projects.leviathan)
 
             implementation(compose.foundation)
             implementation(compose.runtime)
+            implementation(libs.lifecycle.viewmodel.compose)
         }
     }
 }
 
-android {
-    namespace = "io.github.composegears.leviathan.compose"
-    compileSdk = libs.versions.android.compileSdk.get().toInt()
-    defaultConfig {
-        minSdk = libs.versions.android.minSdk.get().toInt()
-    }
-}
-
 m2p {
     description = "Leviathan Compose integration"
 }