Gardening

Author: ra1028

Sources/Atoms/Context/AtomRelationContext.swift

@@ -189,7 +189,8 @@ public struct AtomRelationContext: AtomWatchableContext {
     /// - Parameter object: An object that to be retained.
     @inlinable
     public func keepUntilTermination<Object: AnyObject>(_ object: Object) {
-        _box.keepUntilTermination(object)
+        let retainer = ObjectRetainer(object)
+        addTermination(retainer.release)
     }
 }
 
@@ -200,23 +201,10 @@ internal protocol _AnyAtomRelationContextBox {
 
     func watch<Node: Atom>(_ atom: Node, shouldNotifyAfterUpdates: Bool) -> Node.State.Value
     func addTermination(_ termination: @MainActor @escaping () -> Void)
-    func keepUntilTermination<Object: AnyObject>(_ object: Object)
 }
 
 @usableFromInline
 internal struct _AtomRelationContextBox<Caller: Atom>: _AnyAtomRelationContextBox {
-    final class Retainer<Object: AnyObject> {
-        private var object: Object?
-
-        init(_ object: Object) {
-            self.object = object
-        }
-
-        func release() {
-            object = nil
-        }
-    }
-
     let caller: Caller
 
     @usableFromInline
@@ -235,10 +223,19 @@ internal struct _AtomRelationContextBox<Caller: Atom>: _AnyAtomRelationContextBo
     func addTermination(_ termination: @MainActor @escaping () -> Void) {
         store.addTermination(caller, termination: termination)
     }
+}
+
+@usableFromInline
+internal final class ObjectRetainer<Object: AnyObject> {
+    private var object: Object?
+
+    @usableFromInline
+    init(_ object: Object) {
+        self.object = object
+    }
 
     @usableFromInline
-    func keepUntilTermination<Object: AnyObject>(_ object: Object) {
-        let retainer = Retainer(object)
-        store.addTermination(caller, termination: retainer.release)
+    func release() {
+        object = nil
     }
 }

Sources/Atoms/Context/AtomTestContext.swift

@@ -25,6 +25,21 @@ public struct AtomTestContext: AtomWatchableContext {
     /// Waits until any of atoms watched through this context is updated for up to
     /// the specified timeout, and then return a boolean value indicating whether an update is done.
     ///
+    /// ```swift
+    /// func testAsyncUpdate() async {
+    ///     let context = AtomTestContext()
+    ///
+    ///     let initialPhase = context.watch(AsyncCalculationAtom().phase)
+    ///     XCTAssertEqual(initialPhase, .suspending)
+    ///
+    ///     let didUpdate = await context.waitUntilNextUpdate()
+    ///     let currentPhase = context.watch(AsyncCalculationAtom().phase)
+    ///
+    ///     XCTAssertTure(didUpdate)
+    ///     XCTAssertEqual(currentPhase, .success(123))
+    /// }
+    /// ```
+    ///
     /// - Parameter interval: The maximum timeout interval that this function can wait until
     ///                      the next update. The default timeout interval is `60`.
     /// - Returns: A boolean value indicating whether an update is done.

Sources/Atoms/Core/Internal/Store.swift

@@ -153,7 +153,7 @@ private extension Store {
         }
 
         // Notify the initial update to observers.
-        notifyObserversOfUpdate(of: atom, state: state)
+        notifyChangesToObservers(of: atom, state: state)
 
         return state
     }
@@ -180,7 +180,7 @@ private extension Store {
 
         host.onUpdate = { state in
             // Notify the update to observers.
-            notifyObserversOfUpdate(of: atom, state: state)
+            notifyChangesToObservers(of: atom, state: state)
         }
 
         guard let container = container else {
@@ -231,7 +231,7 @@ private extension Store {
         return host
     }
 
-    func notifyObserversOfUpdate<Node: Atom>(
+    func notifyChangesToObservers<Node: Atom>(
         of atom: Node,
         state: Node.State
     ) {

Sources/Atoms/Core/State/AsyncSequenceAtomState.swift

@@ -22,24 +22,24 @@ public final class AsyncSequenceAtomState<Sequence: AsyncSequence>: RefreshableA
             do {
                 for try await element in box.unboxed {
                     if !Task.isCancelled {
-                        self.phase = .success(element)
+                        phase = .success(element)
                         context.notifyUpdate()
                     }
                 }
             }
             catch {
                 if !Task.isCancelled {
-                    self.phase = .failure(error)
+                    phase = .failure(error)
                     context.notifyUpdate()
                 }
             }
         }
         context.addTermination(task.cancel)
 
-        let phase = Value.suspending
-        self.phase = phase
+        let initialPhase = Value.suspending
+        phase = initialPhase
 
-        return phase
+        return initialPhase
     }
 
     /// Overrides the value with an arbitrary value.

Sources/Atoms/Core/State/ModifiedAtomState.swift

@@ -1,6 +1,6 @@
 /// A state that is actual implementation of `ModifiedAtom`.
 public final class ModifiedAtomState<Node: Atom, Modifier: AtomModifier>: AtomState where Node.State.Value == Modifier.Value {
-    private var modified: Modifier.ModifiedValue?
+    private var modifiedValue: Modifier.ModifiedValue?
     private let atom: Node
     private let modifier: Modifier
 
@@ -11,21 +11,21 @@ public final class ModifiedAtomState<Node: Atom, Modifier: AtomModifier>: AtomSt
 
     /// Returns a value with initiating the update process and caches the value for the next access.
     public func value(context: Context) -> Modifier.ModifiedValue {
-        if let modified = modified {
-            return modified
+        if let modifiedValue = modifiedValue {
+            return modifiedValue
         }
 
         let value = context.atomContext.watch(atom)
-        let modified = modifier.value(context: context, with: value) { [weak self] modified in
-            self?.modified = modified
+        let modifiedValue = modifier.value(context: context, with: value) { [weak self] modifiedValue in
+            self?.modifiedValue = modifiedValue
         }
-        self.modified = modified
+        self.modifiedValue = modifiedValue
 
-        return modified
+        return modifiedValue
     }
 
     /// Overrides the value with an arbitrary value.
-    public func override(with modified: Modifier.ModifiedValue, context: Context) {
-        self.modified = modified
+    public func override(with modifiedValue: Modifier.ModifiedValue, context: Context) {
+        self.modifiedValue = modifiedValue
     }
 }

Sources/Atoms/Core/State/PublisherAtomState.swift

@@ -23,17 +23,17 @@ public final class PublisherAtomState<Publisher: Combine.Publisher>: Refreshable
         let task = Task {
             for await result in box.unboxed {
                 if !Task.isCancelled {
-                    self.phase = AsyncPhase(result)
+                    phase = AsyncPhase(result)
                     context.notifyUpdate()
                 }
             }
         }
         context.addTermination(task.cancel)
 
-        let phase = Value.suspending
-        self.phase = phase
+        let initialPhase = Value.suspending
+        phase = initialPhase
 
-        return phase
+        return initialPhase
     }
 
     /// Overrides the value with an arbitrary value.