migrate interceptors to immutable lists and enhance id strategy

intuit · Oct 27, 2021 · 458ca6e · 458ca6e
1 parent ebfdb97
commit 458ca6e
Show file tree

Hide file tree

Showing 7 changed files with 74 additions and 44 deletions.
diff --git a/compiler-plugin/src/main/kotlin/com/intuit/hooks/plugin/CodeGeneration.kt b/compiler-plugin/src/main/kotlin/com/intuit/hooks/plugin/CodeGeneration.kt
@@ -13,8 +13,8 @@ internal data class HookCodeGen(
     private val zeroArity: Boolean
 ) {
     val tapMethod get() = if (!zeroArity) """
-        fun tap(name: String, f: ($hookSignature)): String = tap(name, randomId(), f)
-        fun tap(name: String, id: String, f: ($hookSignature)): String = super.tap(name, id) { _: HookContext, $paramsWithTypes -> f($paramsWithoutTypes) }
+        fun tap(name: String, f: ($hookSignature)): String? = tap(name, generateRandomId(), f)
+        fun tap(name: String, id: String, f: ($hookSignature)): String? = super.tap(name, id) { _: HookContext, $paramsWithTypes -> f($paramsWithoutTypes) }
     """.trimIndent() else ""
     val paramsWithTypes get() = params.joinToString(", ") { it.withType }
     val paramsWithoutTypes get() = params.joinToString(", ") { it.withoutType }

diff --git a/docs/src/test/kotlin/example/snippets.kt b/docs/src/test/kotlin/example/snippets.kt
@@ -19,8 +19,8 @@ fun typed() {
         fun call(value: Int) =
             super.call { f, context -> f(context, value) }
 
-        fun tap(name: String, id: String, f: ((Int) -> Unit)) =
-            super.tap(name, id) { _, newValue -> f(newValue) }
+        fun tap(name: String, f: ((Int) -> Unit)) =
+            super.tap(name) { _, newValue -> f(newValue) }
     }
 
     val myHook = MyHook()

diff --git a/hooks/api/hooks.api b/hooks/api/hooks.api
@@ -51,6 +51,7 @@ public final class com/intuit/hooks/BailResult$Continue : com/intuit/hooks/BailR
 
 public abstract class com/intuit/hooks/BaseHook {
 	public fun <init> (Ljava/lang/String;)V
+	protected fun generateRandomId ()Ljava/lang/String;
 	protected fun getInterceptors ()Lcom/intuit/hooks/Interceptors;
 	protected final fun getTaps ()Ljava/util/List;
 	public final fun interceptCall (Lkotlin/Function;)V
@@ -61,12 +62,11 @@ public abstract class com/intuit/hooks/BaseHook {
 	public final fun untap (Ljava/lang/String;)V
 }
 
-public final class com/intuit/hooks/BaseHookKt {
-	public static final fun randomId ()Ljava/lang/String;
-}
-
 public class com/intuit/hooks/Interceptors {
 	public fun <init> ()V
+	public final fun addCallInterceptor (Lkotlin/Function;)V
+	public final fun addRegisterInterceptor (Lkotlin/jvm/functions/Function1;)V
+	public final fun addTapInterceptor (Lkotlin/jvm/functions/Function2;)V
 	public final fun getCall ()Ljava/util/List;
 	public final fun getRegister ()Ljava/util/List;
 	public final fun getTap ()Ljava/util/List;
@@ -76,6 +76,7 @@ public class com/intuit/hooks/Interceptors {
 
 public final class com/intuit/hooks/LoopInterceptors : com/intuit/hooks/Interceptors {
 	public fun <init> ()V
+	public final fun addLoopInterceptor (Lkotlin/Function;)V
 	public final fun getLoop ()Ljava/util/List;
 }
 

diff --git a/hooks/src/main/kotlin/com/intuit/hooks/AsyncSeriesLoopHook.kt b/hooks/src/main/kotlin/com/intuit/hooks/AsyncSeriesLoopHook.kt
@@ -23,6 +23,6 @@ public abstract class AsyncSeriesLoopHook<F : Function<LoopResult>, FInterceptor
     }
 
     public fun interceptLoop(f: FInterceptor) {
-        interceptors.loop.add(f)
+        interceptors.addLoopInterceptor(f)
     }
 }
diff --git a/hooks/src/main/kotlin/com/intuit/hooks/BaseHook.kt b/hooks/src/main/kotlin/com/intuit/hooks/BaseHook.kt
@@ -6,22 +6,31 @@ import kotlin.collections.HashMap
 public typealias HookContext = HashMap<String, Any>
 
 public open class Interceptors<F : Function<*>> {
-    // TODO: I don't love that I've really only made [taps] immutable.. this screams inconsistency
-    public val register: MutableList<(TapInfo<F>) -> TapInfo<F>?> = mutableListOf()
-    public val tap: MutableList<(HookContext, TapInfo<F>) -> Unit> = mutableListOf()
-    public val call: MutableList<F> = mutableListOf()
-
-    public fun invokeRegisterInterceptors(info: TapInfo<F>?): TapInfo<F>? =
-        register.fold(info) { acc, interceptor ->
-            acc?.let(interceptor)
-        }
+    public var register: List<(TapInfo<F>) -> TapInfo<F>?> = emptyList(); private set
+    public var tap: List<(HookContext, TapInfo<F>) -> Unit> = emptyList(); private set
+    public var call: List<F> = emptyList(); private set
+
+    public fun addRegisterInterceptor(interceptor: (TapInfo<F>) -> TapInfo<F>?) {
+        register = register + interceptor
+    }
+
+    public fun invokeRegisterInterceptors(info: TapInfo<F>?): TapInfo<F>? = register.fold(info) { acc, interceptor ->
+        acc?.let(interceptor)
+    }
 
-    public fun invokeTapInterceptors(taps: List<TapInfo<F>>, context: HookContext): Unit =
-        tap.forEach { interceptor ->
-            taps.forEach { tap ->
-                interceptor.invoke(context, tap)
-            }
+    public fun addTapInterceptor(interceptor: (HookContext, TapInfo<F>) -> Unit) {
+        tap = tap + interceptor
+    }
+
+    public fun invokeTapInterceptors(taps: List<TapInfo<F>>, context: HookContext): Unit = tap.forEach { interceptor ->
+        taps.forEach { tap ->
+            interceptor.invoke(context, tap)
         }
+    }
+
+    public fun addCallInterceptor(interceptor: F) {
+        call = call + interceptor
+    }
 }
 
 public class TapInfo<FWithContext : Function<*>> internal constructor(
@@ -65,37 +74,53 @@ public abstract class BaseHook<F : Function<*>>(private val type: String) {
     protected var taps: List<TapInfo<F>> = emptyList(); private set
     protected open val interceptors: Interceptors<F> = Interceptors()
 
-    public fun tap(name: String, f: F): String = tap(name, randomId(), f)
-
-    public fun tap(name: String, id: String, f: F): String {
-        val filtered = taps.filter {
-            it.id != id
-        }
-
-        taps = TapInfo(name, id, type, f).let(interceptors::invokeRegisterInterceptors)?.let {
-            filtered + it
-        } ?: filtered
-
-        return id
+    /**
+     * Tap the hook with [f].
+     *
+     * @param name human-readable identifier to make debugging easier
+     *
+     * @return an auto generated identifier token that can be used to [untap], null if tap was
+     *         rejected by any of the register interceptors.
+     */
+    public fun tap(name: String, f: F): String? = tap(name, generateRandomId(), f)
+
+    /**
+     * Tap the hook with [f].
+     *
+     * @param name human-readable identifier to make debugging easier
+     * @param id identifier token to register the [f] callback with. If another tap exists with
+     *           the same [id], it will be overridden, which essentially shortcuts an [untap] call.
+     *
+     * @return identifier token that can be used to [untap], null if tap was rejected by any of the
+     *         register interceptors.
+     */
+    public fun tap(name: String, id: String, f: F): String? {
+        untap(id)
+
+        return TapInfo(name, id, type, f).let(interceptors::invokeRegisterInterceptors)?.also {
+            taps = taps + it
+        }?.id
     }
 
+    /** Remove tapped callback associated with the [id] returned from [tap] */
     public fun untap(id: String) {
         taps = taps.filter {
             it.id != id
         }
     }
 
     public fun interceptTap(f: (context: HookContext, tapInfo: TapInfo<F>) -> Unit) {
-        interceptors.tap.add(f)
+        interceptors.addTapInterceptor(f)
     }
 
     public fun interceptCall(f: F) {
-        interceptors.call.add(f)
+        interceptors.addCallInterceptor(f)
     }
 
     public fun interceptRegister(f: (TapInfo<F>) -> TapInfo<F>?) {
-        interceptors.register.add(f)
+        interceptors.addRegisterInterceptor(f)
     }
-}
 
-public fun randomId(): String = UUID.randomUUID().toString()
+    /** Method to generate a random identifier for managing `TapInfo`s */
+    protected open fun generateRandomId(): String = UUID.randomUUID().toString()
+}
diff --git a/hooks/src/main/kotlin/com/intuit/hooks/SyncLoopHook.kt b/hooks/src/main/kotlin/com/intuit/hooks/SyncLoopHook.kt
@@ -9,7 +9,11 @@ public enum class LoopResult {
 }
 
 public class LoopInterceptors<F : Function<*>, FInterceptor : Function<*>> : Interceptors<F>() {
-    public val loop: MutableList<FInterceptor> = mutableListOf()
+    public var loop: List<FInterceptor> = emptyList(); private set
+
+    public fun addLoopInterceptor(f: FInterceptor) {
+        loop = loop + f
+    }
 }
 
 public abstract class SyncLoopHook<F : Function<LoopResult>, FInterceptor : Function<*>> : SyncBaseHook<F>("SyncLoopHook") {
@@ -35,6 +39,6 @@ public abstract class SyncLoopHook<F : Function<LoopResult>, FInterceptor : Func
     }
 
     public fun interceptLoop(f: FInterceptor) {
-        interceptors.loop.add(f)
+        interceptors.addLoopInterceptor(f)
     }
 }
diff --git a/hooks/src/test/kotlin/com/intuit/hooks/SyncHookTests.kt b/hooks/src/test/kotlin/com/intuit/hooks/SyncHookTests.kt
@@ -77,7 +77,7 @@ class SyncHookTests {
         }
         val tap2 = hook.tap("second") {
             output.add(2)
-        }
+        }!!
         hook.tap("third") {
             output.add(3)
         }
@@ -99,7 +99,7 @@ class SyncHookTests {
         }
         val tap2 = hook.tap("second") {
             output.add(2)
-        }
+        }!!
         hook.tap("third") {
             output.add(3)
         }