Add solution for late-init dependencies (#23)

Add late initialization providers: FactoryDependency
Add option to update ValueDependency's value

Author: vkatz

README.md

@@ -41,13 +41,14 @@ Create `Module` (recommend to use `object`) and extends from `Leviathan` class
 
 Create fields using these functions:
 
-- Use `by instanceOf(keepAlive){/**/}` to create instance dependency
+- Use `by instanceOf(keepAlive){ value }` 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)
+- Use `by valueOf(value)` to create value dependency (the value may be updated later)
+- Use `by providableOf { value }` to create a providable dependency (provider may be updated later)
 
 All functions return a `Dependency<Type>` instance.
 
@@ -78,6 +79,7 @@ object Module : Leviathan() {
     }
     val interfaceRepo by instanceOf<SampleInterfaceRepo> { SampleInterfaceRepoImpl() }
     val constantValue by valueOf(42)
+    val providable by providableOf { 34 }
 }
 ```
 
@@ -107,6 +109,8 @@ fun ComposeWithDI() {
 fun foo() {
     val scope = DIScope()
     val repo1 = Module.autoCloseRepository.injectedIn(scope)
+    // update providable value
+    (Module.providable as? ProvidableDependency<Int>)?.provides { 21 }
     /*..*/
     scope.close()
 }

gradle/leviathan.toml

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

leviathan/api/android/leviathan.api

@@ -16,6 +16,14 @@ public final class com/composegears/leviathan/DependencyInitializationScope {
 	public final fun inject (Lcom/composegears/leviathan/Dependency;)Ljava/lang/Object;
 }
 
+public final class com/composegears/leviathan/FactoryDependency : com/composegears/leviathan/Dependency {
+	public fun injectedIn (Lcom/composegears/leviathan/DIScope;)Ljava/lang/Object;
+}
+
+public final class com/composegears/leviathan/InstanceDependency : com/composegears/leviathan/Dependency {
+	public fun injectedIn (Lcom/composegears/leviathan/DIScope;)Ljava/lang/Object;
+}
+
 public abstract class com/composegears/leviathan/Leviathan {
 	public static final field Companion Lcom/composegears/leviathan/Leviathan$Companion;
 	public fun <init> ()V
@@ -24,14 +32,20 @@ public abstract class com/composegears/leviathan/Leviathan {
 	protected static final fun getValue (Lcom/composegears/leviathan/Dependency;Lcom/composegears/leviathan/Leviathan;Lkotlin/reflect/KProperty;)Lcom/composegears/leviathan/Dependency;
 	protected final fun instanceOf (ZLkotlin/jvm/functions/Function1;)Lcom/composegears/leviathan/Dependency;
 	public static synthetic fun instanceOf$default (Lcom/composegears/leviathan/Leviathan;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lcom/composegears/leviathan/Dependency;
+	protected final fun providableOf (Lkotlin/jvm/functions/Function0;)Lcom/composegears/leviathan/ProvidableDependency;
 	protected final fun valueOf (Ljava/lang/Object;)Lcom/composegears/leviathan/Dependency;
 }
 
 public final class com/composegears/leviathan/Leviathan$Companion {
 }
 
+public final class com/composegears/leviathan/ProvidableDependency : com/composegears/leviathan/Dependency {
+	public fun injectedIn (Lcom/composegears/leviathan/DIScope;)Ljava/lang/Object;
+	public final fun provides (Lkotlin/jvm/functions/Function0;)V
+}
+
 public final class com/composegears/leviathan/ValueDependency : com/composegears/leviathan/Dependency {
-	public fun <init> (Ljava/lang/Object;)V
 	public fun injectedIn (Lcom/composegears/leviathan/DIScope;)Ljava/lang/Object;
+	public final fun provides (Ljava/lang/Object;)V
 }
 

leviathan/api/jvm/leviathan.api

@@ -16,6 +16,14 @@ public final class com/composegears/leviathan/DependencyInitializationScope {
 	public final fun inject (Lcom/composegears/leviathan/Dependency;)Ljava/lang/Object;
 }
 
+public final class com/composegears/leviathan/FactoryDependency : com/composegears/leviathan/Dependency {
+	public fun injectedIn (Lcom/composegears/leviathan/DIScope;)Ljava/lang/Object;
+}
+
+public final class com/composegears/leviathan/InstanceDependency : com/composegears/leviathan/Dependency {
+	public fun injectedIn (Lcom/composegears/leviathan/DIScope;)Ljava/lang/Object;
+}
+
 public abstract class com/composegears/leviathan/Leviathan {
 	public static final field Companion Lcom/composegears/leviathan/Leviathan$Companion;
 	public fun <init> ()V
@@ -24,14 +32,20 @@ public abstract class com/composegears/leviathan/Leviathan {
 	protected static final fun getValue (Lcom/composegears/leviathan/Dependency;Lcom/composegears/leviathan/Leviathan;Lkotlin/reflect/KProperty;)Lcom/composegears/leviathan/Dependency;
 	protected final fun instanceOf (ZLkotlin/jvm/functions/Function1;)Lcom/composegears/leviathan/Dependency;
 	public static synthetic fun instanceOf$default (Lcom/composegears/leviathan/Leviathan;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lcom/composegears/leviathan/Dependency;
+	protected final fun providableOf (Lkotlin/jvm/functions/Function0;)Lcom/composegears/leviathan/ProvidableDependency;
 	protected final fun valueOf (Ljava/lang/Object;)Lcom/composegears/leviathan/Dependency;
 }
 
 public final class com/composegears/leviathan/Leviathan$Companion {
 }
 
+public final class com/composegears/leviathan/ProvidableDependency : com/composegears/leviathan/Dependency {
+	public fun injectedIn (Lcom/composegears/leviathan/DIScope;)Ljava/lang/Object;
+	public final fun provides (Lkotlin/jvm/functions/Function0;)V
+}
+
 public final class com/composegears/leviathan/ValueDependency : com/composegears/leviathan/Dependency {
-	public fun <init> (Ljava/lang/Object;)V
 	public fun injectedIn (Lcom/composegears/leviathan/DIScope;)Ljava/lang/Object;
+	public final fun provides (Ljava/lang/Object;)V
 }
 

leviathan/api/leviathan.klib.api

@@ -15,15 +15,28 @@ abstract class com.composegears.leviathan/Leviathan { // com.composegears.leviat
 
     final fun <#A1: kotlin/Any?> factoryOf(kotlin/Boolean = ..., kotlin/Function1<com.composegears.leviathan/DependencyInitializationScope, #A1>): com.composegears.leviathan/Dependency<#A1> // com.composegears.leviathan/Leviathan.factoryOf|factoryOf(kotlin.Boolean;kotlin.Function1<com.composegears.leviathan.DependencyInitializationScope,0:0>){0§<kotlin.Any?>}[0]
     final fun <#A1: kotlin/Any?> instanceOf(kotlin/Boolean = ..., kotlin/Function1<com.composegears.leviathan/DependencyInitializationScope, #A1>): com.composegears.leviathan/Dependency<#A1> // com.composegears.leviathan/Leviathan.instanceOf|instanceOf(kotlin.Boolean;kotlin.Function1<com.composegears.leviathan.DependencyInitializationScope,0:0>){0§<kotlin.Any?>}[0]
+    final fun <#A1: kotlin/Any?> providableOf(kotlin/Function0<#A1>): com.composegears.leviathan/ProvidableDependency<#A1> // com.composegears.leviathan/Leviathan.providableOf|providableOf(kotlin.Function0<0:0>){0§<kotlin.Any?>}[0]
     final fun <#A1: kotlin/Any?> valueOf(#A1): com.composegears.leviathan/Dependency<#A1> // com.composegears.leviathan/Leviathan.valueOf|valueOf(0:0){0§<kotlin.Any?>}[0]
 
     final object Companion // com.composegears.leviathan/Leviathan.Companion|null[0]
 }
 
-final class <#A: kotlin/Any?> com.composegears.leviathan/ValueDependency : com.composegears.leviathan/Dependency<#A> { // com.composegears.leviathan/ValueDependency|null[0]
-    constructor <init>(#A) // com.composegears.leviathan/ValueDependency.<init>|<init>(1:0){}[0]
+final class <#A: kotlin/Any?> com.composegears.leviathan/FactoryDependency : com.composegears.leviathan/Dependency<#A> { // com.composegears.leviathan/FactoryDependency|null[0]
+    final fun injectedIn(com.composegears.leviathan/DIScope): #A // com.composegears.leviathan/FactoryDependency.injectedIn|injectedIn(com.composegears.leviathan.DIScope){}[0]
+}
+
+final class <#A: kotlin/Any?> com.composegears.leviathan/InstanceDependency : com.composegears.leviathan/Dependency<#A> { // com.composegears.leviathan/InstanceDependency|null[0]
+    final fun injectedIn(com.composegears.leviathan/DIScope): #A // com.composegears.leviathan/InstanceDependency.injectedIn|injectedIn(com.composegears.leviathan.DIScope){}[0]
+}
 
+final class <#A: kotlin/Any?> com.composegears.leviathan/ProvidableDependency : com.composegears.leviathan/Dependency<#A> { // com.composegears.leviathan/ProvidableDependency|null[0]
+    final fun injectedIn(com.composegears.leviathan/DIScope): #A // com.composegears.leviathan/ProvidableDependency.injectedIn|injectedIn(com.composegears.leviathan.DIScope){}[0]
+    final fun provides(kotlin/Function0<#A>) // com.composegears.leviathan/ProvidableDependency.provides|provides(kotlin.Function0<1:0>){}[0]
+}
+
+final class <#A: kotlin/Any?> com.composegears.leviathan/ValueDependency : com.composegears.leviathan/Dependency<#A> { // com.composegears.leviathan/ValueDependency|null[0]
     final fun injectedIn(com.composegears.leviathan/DIScope): #A // com.composegears.leviathan/ValueDependency.injectedIn|injectedIn(com.composegears.leviathan.DIScope){}[0]
+    final fun provides(#A) // com.composegears.leviathan/ValueDependency.provides|provides(1:0){}[0]
 }
 
 final class com.composegears.leviathan/DependencyInitializationScope { // com.composegears.leviathan/DependencyInitializationScope|null[0]

leviathan/src/commonMain/kotlin/com/composegears/leviathan/Leviathan.kt

@@ -43,15 +43,45 @@ public interface Dependency<T> {
 }
 
 /**
- * A dependency that always provides the same constant value.
+ * A dependency that always provides the same value.
+ * The value can be updated using the [provides] method.
  */
-public class ValueDependency<T>(
-    private val value: T
+public class ValueDependency<T> internal constructor(
+    private var value: T
 ) : Dependency<T> {
     override fun injectedIn(scope: DIScope): T = value
+
+    /**
+     * Updates the value of the dependency.
+     */
+    public fun provides(newValue: T) {
+        value = newValue
+    }
 }
 
-internal class FactoryDependency<T>(
+/**
+ * A dependency that provides a value using a provider function.
+ * The provider function can be updated to supply a new value.
+ */
+public class ProvidableDependency<T> internal constructor(
+    private var provider: () -> T
+) : Dependency<T> {
+    override fun injectedIn(scope: DIScope): T = provider()
+
+    /**
+     * Updates the provider function to supply a new value.
+     */
+    public fun provides(valueProvider: () -> T) {
+        provider = valueProvider
+    }
+}
+
+/**
+ * A dependency that provides a new instance using a factory function.
+ * If [useCache] is true, the same instance will be provided every time the dependency
+ * is injected within the same [DIScope]. If false, a new instance will be created every time.
+ */
+public class FactoryDependency<T> internal constructor(
     private val useCache: Boolean,
     private val factory: DependencyInitializationScope.() -> T
 ) : Dependency<T> {
@@ -69,7 +99,12 @@ internal class FactoryDependency<T>(
         } else factory(DependencyInitializationScope(scope))
 }
 
-internal class InstanceDependency<T>(
+/**
+ * A dependency that provides a singleton instance using a factory function.
+ * If [keepAlive] is true, the instance will be kept alive after being injected at least once.
+ * If false, the instance will be destroyed as soon as the last [DIScope] using it is closed.
+ */
+public class InstanceDependency<T> internal constructor(
     private val keepAlive: Boolean,
     private val factory: DependencyInitializationScope.() -> T
 ) : Dependency<T> {
@@ -98,7 +133,7 @@ internal class InstanceDependency<T>(
 
 /**
  * Base class for defining a module of dependencies.
- * Extend this class and use [valueOf], [factoryOf] and [instanceOf] to define dependencies.
+ * Extend this class and use [valueOf], [providableOf], [factoryOf] and [instanceOf] to define dependencies.
  *
  * Example:
  * ```
@@ -113,6 +148,7 @@ internal class InstanceDependency<T>(
  *     }
  *     val interfaceRepo by instanceOf<SampleInterfaceRepo> { SampleInterfaceRepoImpl() }
  *     val constantValue by valueOf(42)
+ *     val providable by providableOf { 34 }
  * }
  *
  * // ----- Usage -----
@@ -140,6 +176,8 @@ internal class InstanceDependency<T>(
  * fun foo() {
  *     val scope = DIScope()
  *     val repo1 = Module.autoCloseRepository.injectedIn(scope)
+ *     // update providable value
+ *     (Module.providable as? ProvidableDependency<Int>)?.provides { 21 }
  *     ...
  *     scope.close()
  * }
@@ -154,16 +192,28 @@ public abstract class Leviathan {
         ): Dependency<T> = this
     }
 
-    /** Defines a dependency as a constant value.
-     *
-     * The same instance will be provided every time the dependency is injected.
+    /**
+     * Defines a dependency as a value.
+     * The value can be updated using the [ValueDependency.provides] method.
+     * The value will be provided every time the dependency is injected.
      */
     protected fun <T> valueOf(
         value: T
     ): Dependency<T> =
         ValueDependency(value)
 
-    /** Defines a dependency as a factory function.
+    /**
+     * Defines a dependency as a providable function.
+     * The provider function can be updated using [ProvidableDependency.provides] method.
+     * The instance from the provider will be provided every time the dependency is injected.
+     */
+    protected fun <T> providableOf(
+        provider: () -> T
+    ): ProvidableDependency<T> =
+        ProvidableDependency(provider)
+
+    /**
+     * Defines a dependency as a factory function.
      * If [useCache] is true (default), the same instance will be provided every time the dependency
      * is injected within the same [DIScope]. If false, a new instance will be created every time.
      */
@@ -173,7 +223,8 @@ public abstract class Leviathan {
     ): Dependency<T> =
         FactoryDependency(useCache, factory)
 
-    /** Defines a dependency as a singleton instance.
+    /**
+     * Defines a dependency as a singleton instance.
      * If [keepAlive] is true, the instance will be kept alive after being injected at least once.
      * If false (default), the instance will be destroyed as soon as the last [DIScope] using it is closed.
      */

leviathan/src/commonTest/kotlin/com/composegears/leviathan/Test.kt

@@ -41,6 +41,12 @@ class ServiceLocator(externalServices: ExternalServices) : Leviathan() {
     // cyclic
     val cyclicDep1: Dependency<CyclicService> by instanceOf { CyclicService { inject(cyclicDep2) } }
     val cyclicDep2: Dependency<CyclicService> by instanceOf { CyclicService { inject(cyclicDep1) } }
+
+    // value
+    val valueDep by valueOf(Service())
+
+    // providable
+    val providableDep by providableOf { Service() }
 }
 
 //------------Code------------
@@ -281,6 +287,46 @@ class Tests {
         assertNotEquals(external1, external2, "External dependencies should be independent")
     }
 
+    // ValueDependency tests
+    @Test
+    fun `valueDep - provides consistent value instance`() {
+        val externalServices = ExternalServices()
+        val serviceLocator = ServiceLocator(externalServices)
+        val scope1 = DIScope()
+        val scope2 = DIScope()
+        val value1 = serviceLocator.valueDep.injectedIn(scope1)
+        val value2 = serviceLocator.valueDep.injectedIn(scope1)
+        val value3 = serviceLocator.valueDep.injectedIn(scope2)
+        assertEquals(value1, value2, "Value dependency should provide consistent instance")
+        assertEquals(value2, value3, "Value dependency should provide consistent instance")
+    }
+
+    @Test
+    fun `valueDep - reflects changes to the value`() {
+        val externalServices = ExternalServices()
+        val serviceLocator = ServiceLocator(externalServices)
+        val scope = DIScope()
+        val value1 = serviceLocator.valueDep.injectedIn(scope)
+        val newValue = Service()
+        (serviceLocator.valueDep as? ValueDependency<Service>)?.provides(newValue)
+        val value2 = serviceLocator.valueDep.injectedIn(scope)
+        assertNotEquals(newValue, value1, "Updated value should not match old instance")
+        assertEquals(newValue, value2, "Updated value should match new instance")
+    }
+
+    // ProvidableDependency tests
+
+    @Test
+    fun `providableDep - reflect changes to provider`() {
+        val externalServices = ExternalServices()
+        val serviceLocator = ServiceLocator(externalServices)
+        val scope = DIScope()
+        val providedInstance = Service()
+        (serviceLocator.providableDep as? ProvidableDependency<Service>)?.provides { providedInstance }
+        val instance = serviceLocator.providableDep.injectedIn(scope)
+        assertEquals(providedInstance, instance, "Providable dependency should return provided instance")
+    }
+
     // Scope behavior combination tests
     @Test
     fun `mixed dependencies - behave correctly in same scope`() {