Fix dependency reset on capsule inheritance

lib/build.gradle.kts

@@ -19,6 +19,11 @@ dependencies {
     // Use the Kotlin JDK 8 standard library.
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
 
+    // Logging
+    implementation("io.github.microutils:kotlin-logging-jvm:3.0.5")
+    testImplementation("net.logstash.logback:logstash-logback-encoder:7.3")
+    testImplementation("ch.qos.logback:logback-classic:1.4.6")
+
     // Use the Kotlin test library.
     testImplementation("org.jetbrains.kotlin:kotlin-test")
 

lib/src/main/kotlin/io/nexure/capsule/Capsule.kt

@@ -1,26 +1,33 @@
 package io.nexure.capsule
 
+import mu.KotlinLogging
 import java.lang.reflect.Constructor
 import java.util.LinkedList
 
 private const val DEFAULT_PRIORITY: Int = Int.MAX_VALUE
 
+private val log = KotlinLogging.logger {}
+
+interface DependencyProvider {
+    fun <T : Any> tryGet(clazz: Class<T>): T?
+    fun <T : Any> get(clazz: Class<T>): T = tryGet(clazz) ?: throw DependencyException(clazz)
+    fun <T : Any> getMany(clazz: Class<T>): List<T>
+}
+
+inline fun <reified T : Any> DependencyProvider.get(): T = get(T::class.java)
+inline fun <reified T : Any> DependencyProvider.tryGet(): T? = tryGet(T::class.java)
+inline fun <reified T : Any> DependencyProvider.getMany(): List<T> = getMany(T::class.java)
+
 @Suppress("UNCHECKED_CAST")
 open class Capsule
 private constructor(
     private val priority: Int = DEFAULT_PRIORITY,
     private val dependencies: List<Dependency> = LinkedList()
-) {
+) : DependencyProvider {
     constructor(): this(Int.MAX_VALUE, LinkedList())
 
-    inline fun <reified T : Any> get(): T = get(T::class.java)
-    inline fun <reified T : Any> tryGet(): T? = tryGet(T::class.java)
-
-    fun <T : Any> tryGet(clazz: Class<T>): T? =
-        getDependencies(clazz).firstOrNull()?.let { it.getInstance() as T } ?: resolveImplicit(clazz)
-
-    fun <T : Any> get(clazz: Class<T>): T =
-        tryGet(clazz) ?: throw DependencyException(clazz)
+    override fun <T : Any> tryGet(clazz: Class<T>): T? =
+        getDependencies(clazz).firstOrNull()?.let { it.getInstance(this) as T } ?: resolveImplicit(clazz)
 
     private fun <T : Any> resolveImplicit(clazz: Class<T>): T? {
         if (clazz in forbiddenImplicit) {
@@ -36,9 +43,7 @@ private constructor(
         return constructor.newInstance(*parameters) as? T
     }
 
-    inline fun <reified T : Any> getMany(): List<T> = getMany(T::class.java)
-
-    fun <T : Any> getMany(clazz: Class<T>): List<T> = getDependencies(clazz).map { it.getInstance() as T }
+    override fun <T : Any> getMany(clazz: Class<T>): List<T> = getDependencies(clazz).map { it.getInstance(this) as T }
 
     private fun <T: Any> getDependencies(clazz: Class<T>): List<Dependency> {
         val key: String = classKey(clazz)
@@ -50,15 +55,15 @@ private constructor(
         private val priority: Int,
         internal val dependencies: LinkedList<Dependency>,
     ) : Capsule(priority, dependencies) {
-        inline fun <reified T : Any> register(noinline setup: () -> T) {
+        inline fun <reified T : Any> register(noinline setup: DependencyProvider.() -> T) {
             val clazz: Class<T> = T::class.java
             register(clazz, setup)
             clazz.interfaces.forEach {
                 register(it, setup)
             }
         }
 
-        fun <T : Any> register(clazz: Class<out T>, setup: () -> T) {
+        fun <T : Any> register(clazz: Class<out T>, setup: DependencyProvider.() -> T) {
             val dependency = Dependency.fromClass(clazz, priority, setup)
             dependencies.push(dependency)
         }
@@ -82,12 +87,13 @@ private constructor(
             val dependencies: LinkedList<Dependency> = parents
                 .map { it.dependencies }
                 .flatten()
-                .map { it.reset() }
+                .map { it.copy() }
                 .let { LinkedList(it) }
 
             val parentsPriority: Int = parents.minOfOrNull { it.priority } ?: DEFAULT_PRIORITY
             val priority: Int = parentsPriority - 1
             val moduleConfig = Configuration(priority, dependencies).apply(config)
+            log.debug { "Capsule created with dependencies: ${moduleConfig.dependencies}" }
             return Capsule(priority, moduleConfig.dependencies)
         }
     }
@@ -97,26 +103,28 @@ internal class Dependency
 private constructor(
     val key: String,
     val priority: Int,
-    private val constructor: () -> Any,
+    private val constructor: DependencyProvider.() -> Any,
 ): Comparable<Dependency> {
-    private val instance: Lazy<Any> = lazy(initializer = constructor)
+    private val instance: Memoized<Any> = Memoized()
 
-    fun getInstance(): Any {
+    fun getInstance(provider: DependencyProvider): Any {
         return try {
-            instance.value
+            instance.getOnce {
+                provider.constructor()
+            }
         } catch (e: Exception) {
             throw DependencyException(key, e)
         }
     }
 
-    fun reset(): Dependency = Dependency(key, priority, constructor)
+    fun copy(): Dependency = Dependency(key, priority, constructor)
 
     override fun toString(): String = key
 
     override fun compareTo(other: Dependency): Int = this.priority.compareTo(other.priority)
 
     companion object {
-        fun fromClass(clazz: Class<*>, priority: Int, constructor: () -> Any): Dependency {
+        fun fromClass(clazz: Class<*>, priority: Int, constructor: DependencyProvider.() -> Any): Dependency {
             return Dependency(key = classKey(clazz), priority = priority, constructor = constructor)
         }
     }

lib/src/main/kotlin/io/nexure/capsule/Memoized.kt

@@ -0,0 +1,16 @@
+package io.nexure.capsule
+
+import java.util.concurrent.Semaphore
+
+class Memoized<T> {
+    private val semaphore = Semaphore(1)
+    private var value: T? = null
+
+    fun getOnce(creation: () -> T): T {
+        if (semaphore.tryAcquire()) {
+            this.value = creation()
+        }
+        return this.value!!
+    }
+}
+

lib/src/test/kotlin/io/nexure/capsule/CapsuleTest.kt

@@ -184,6 +184,22 @@ class CapsuleTest {
         assertEquals("foo", greeter.hello())
     }
 
+    @Test
+    fun `adding new dependency of same interface should invoke a reset`() {
+        val parent = Capsule {
+            register<Greeter> { FirstImpl() }
+            register { GreeterService(get()) }
+        }
+
+        assertEquals("first", parent.get<GreeterService>().greet())
+
+        val child = Capsule(parent) {
+            register<Greeter> { SecondImpl() }
+        }
+
+        assertEquals("second", child.get<GreeterService>().greet())
+    }
+
     @Test
     fun `DependencyException should provide context on which class creation that failed`() {
         try {
@@ -235,3 +251,15 @@ class GrandParent(val parent: Parent)
 interface Greeter {
     fun hello(): String
 }
+
+class GreeterService(private val greeter: Greeter) {
+    fun greet(): String = greeter.hello()
+}
+
+class FirstImpl : Greeter {
+    override fun hello(): String = "first"
+}
+
+class SecondImpl : Greeter {
+    override fun hello(): String = "second"
+}