Enable context.key to handle all use cases. (#275)

* Enable nested scopes fully.

* Rename to createScopedKey.

Author: Laimiux

.circleci/config.yml

@@ -155,7 +155,9 @@ jobs:
     executor: android
     steps:
       - prepare
-      - run: bundle exec danger --verbose
+# Disabled because the token for posting Danger comments has been revoked
+# Will fix this issue a bit later
+#      - run: bundle exec danger --verbose
 
 workflows:
   version: 2

.gitignore

@@ -14,3 +14,6 @@
 
 # Site
 /site
+
+# Jenv
+.java-version

CHANGELOG.md

@@ -14,6 +14,8 @@
 - Add `action.runAgain()` extension function
 - Add `action.cancelPrevious(previousAction)` extension function
 - Add `DelegateAction` abstract class
+- Add child formula support for `context.key` scopes.
+- Add support for nested `context.key` calls.
 
 ## [0.7.0] - June 30, 2021
 - **Breaking**: Remove `events(observable) { }` utility function.

formula/src/main/java/com/instacart/formula/FormulaContext.kt

@@ -1,17 +1,17 @@
 package com.instacart.formula
 
-import com.instacart.formula.internal.JoinedKey
-import com.instacart.formula.internal.ScopedListeners
+import com.instacart.formula.internal.Listeners
 import com.instacart.formula.internal.TransitionDispatcher
 import com.instacart.formula.internal.UnitListener
+import kotlin.reflect.KClass
 
 /**
  * Provides functionality within [evaluate][Formula.evaluate] function to [compose][child]
  * child formulas, handle events [FormulaContext.onEvent], and [respond][FormulaContext.actions]
  * to arbitrary asynchronous events.
  */
 abstract class FormulaContext<out Input, State> internal constructor(
-    @PublishedApi internal val listeners: ScopedListeners,
+    @PublishedApi internal val listeners: Listeners,
     internal val transitionDispatcher: TransitionDispatcher<Input, State>,
 ) {
 
@@ -24,7 +24,7 @@ abstract class FormulaContext<out Input, State> internal constructor(
         transition: Transition<Input, State, Event>,
     ): Listener<Event> {
         return eventListener(
-            key = transition.type(),
+            key = createScopedKey(transition.type()),
             transition = transition
         )
     }
@@ -39,7 +39,7 @@ abstract class FormulaContext<out Input, State> internal constructor(
         transition: Transition<Input, State, Event>,
     ): Listener<Event> {
         return eventListener(
-            key = JoinedKey(key, transition.type()),
+            key = createScopedKey(transition.type(), key),
             transition = transition
         )
     }
@@ -129,19 +129,30 @@ abstract class FormulaContext<out Input, State> internal constructor(
      * @param key Unique identifier that will be used for this block.
      */
     inline fun <Value> key(key: Any, create: () -> Value): Value {
-        listeners.enterScope(key)
+        ensureNotRunning()
+
+        enterScope(key)
         val value = create()
-        listeners.endScope()
+        endScope()
         return value
     }
 
     internal fun <Event> eventListener(
         key: Any,
         transition: Transition<Input, State, Event>
     ): Listener<Event> {
+        ensureNotRunning()
         val listener = listeners.initOrFindListener<Input, State, Event>(key)
         listener.transitionDispatcher = transitionDispatcher
         listener.transition = transition
         return listener
     }
+
+    // Internal key scope management
+    @PublishedApi internal abstract fun enterScope(key: Any)
+    @PublishedApi internal abstract fun endScope()
+    @PublishedApi internal abstract fun createScopedKey(type: KClass<*>, key: Any? = null): Any
+
+    // Internal validation
+    @PublishedApi internal abstract fun ensureNotRunning()
 }

formula/src/main/java/com/instacart/formula/Transition.kt

@@ -1,5 +1,7 @@
 package com.instacart.formula
 
+import kotlin.reflect.KClass
+
 /**
  * Transition is a function that is called when an [Event] happens and produces a [Result] which
  * indicates what [Formula] should do in response to this event. It can contain a new [state][State]
@@ -67,7 +69,7 @@ fun interface Transition<in Input, State, in Event> {
     /**
      * Transition type is used as part of the key to distinguish different transitions.
      */
-    fun type(): Any {
+    fun type(): KClass<*> {
         return this::class
     }
 }

formula/src/main/java/com/instacart/formula/internal/ActionBuilderImpl.kt

@@ -51,7 +51,7 @@ internal class ActionBuilderImpl<out Input, State> internal constructor(
         stream: Action<Event>,
         transition: Transition<Input, State, Event>,
     ): DeferredAction<Event> {
-        val key = JoinedKey(stream.key(), transition.type())
+        val key = snapshot.context.createScopedKey(transition.type(), stream.key())
         val listener = snapshot.context.eventListener(key, transition)
         return DeferredAction(
             key = key,

formula/src/main/java/com/instacart/formula/internal/FormulaKey.kt

@@ -3,6 +3,7 @@ package com.instacart.formula.internal
 import kotlin.reflect.KClass
 
 internal data class FormulaKey(
+    val scopeKey: Any?,
     val type: KClass<*>,
     val key: Any?
 )

formula/src/main/java/com/instacart/formula/internal/FormulaManagerImpl.kt

@@ -17,15 +17,15 @@ import com.instacart.formula.Transition
 internal class FormulaManagerImpl<Input, State, Output>(
     private val formula: Formula<Input, State, Output>,
     initialInput: Input,
-    private val listeners: ScopedListeners,
+    private val listeners: Listeners,
     private val transitionListener: TransitionListener
-) : SnapshotImpl.Delegate, FormulaManager<Input, Output> {
+) : FormulaManager<Input, Output> {
 
     constructor(
         formula: Formula<Input, State, Output>,
         input: Input,
         transitionListener: TransitionListener
-    ): this(formula, input, ScopedListeners(formula), transitionListener)
+    ): this(formula, input, Listeners(), transitionListener)
 
     private val actionManager = ActionManager()
 
@@ -80,7 +80,6 @@ internal class FormulaManagerImpl<Input, State, Output>(
             state = formula.onInputChanged(prevInput, input, state)
         }
 
-        listeners.evaluationStarted()
         val transitionDispatcher = TransitionDispatcher(input, state, this::handleTransitionResult, transitionId)
         val snapshot = SnapshotImpl(transitionId, listeners, this, transitionDispatcher)
         val result = snapshot.run { formula.run { evaluate() } }
@@ -147,27 +146,27 @@ internal class FormulaManagerImpl<Input, State, Output>(
         return false
     }
 
-    override fun <ChildInput, ChildOutput> child(
+    fun <ChildInput, ChildOutput> child(
+        key: Any,
         formula: IFormula<ChildInput, ChildOutput>,
         input: ChildInput,
         transitionId: TransitionId
     ): ChildOutput {
         @Suppress("UNCHECKED_CAST")
         val children = children ?: run {
-            val initialized: SingleRequestMap<Any, FormulaManager<*, *>> = mutableMapOf()
+            val initialized: SingleRequestMap<Any, FormulaManager<*, *>> = LinkedHashMap()
             this.children = initialized
             initialized
         }
 
-        val compositeKey = constructKey(formula, input)
         val manager = children
-            .findOrInit(compositeKey) {
+            .findOrInit(key) {
                 val childTransitionListener = getOrInitChildTransitionListener()
                 val implementation = formula.implementation()
                 FormulaManagerImpl(implementation, input, childTransitionListener)
             }
             .requestAccess {
-                throw IllegalStateException("There already is a child with same key: $compositeKey. Override [Formula.key] function.")
+                throw IllegalStateException("There already is a child with same key: $key. Override [Formula.key] function.")
             } as FormulaManager<ChildInput, ChildOutput>
 
         return manager.evaluate(input, transitionId).output
@@ -185,16 +184,6 @@ internal class FormulaManagerImpl<Input, State, Output>(
         listeners.disableAll()
     }
 
-    private fun <ChildInput, ChildOutput> constructKey(
-        formula: IFormula<ChildInput, ChildOutput>,
-        input: ChildInput
-    ): Any {
-        return FormulaKey(
-            type = formula.type(),
-            key = formula.key(input)
-        )
-    }
-
     private fun getOrInitChildTransitionListener(): TransitionListener {
         return childTransitionListener ?: run {
             TransitionListener { result, isChildValid ->

formula/src/main/java/com/instacart/formula/internal/JoinedKey.kt

@@ -1,6 +1,6 @@
 package com.instacart.formula.internal
 
-data class JoinedKey(
+internal data class JoinedKey(
     val left: Any?,
     val right: Any?
 )

formula/src/main/java/com/instacart/formula/internal/Listeners.kt

@@ -12,7 +12,7 @@ internal class Listeners {
         return "Listener $key is already defined. Are you calling it in a loop or reusing a method? You can wrap the call with FormulaContext.key"
     }
 
-    fun <Input, State, Event> initOrFindCallback(key: Any): ListenerImpl<Input, State, Event> {
+    fun <Input, State, Event> initOrFindListener(key: Any): ListenerImpl<Input, State, Event> {
         val listeners = listeners ?: run {
             val initialized: SingleRequestMap<Any, ListenerImpl<*, *, *>> = mutableMapOf()
             this.listeners = initialized