Internal refactoring (#119)

* Refactor internal

* Refactoring

Author: ra1028

Sources/Atoms/Core/StoreContext.swift

@@ -71,12 +71,7 @@ internal struct StoreContext {
         }
         else {
             let cache = makeCache(of: atom, for: key, override: override)
-            notifyUpdateToObservers()
-
-            if checkAndRelease(for: key) {
-                notifyUpdateToObservers()
-            }
-
+            checkAndRelease(for: key)
             return cache.value
         }
     }
@@ -152,8 +147,7 @@ internal struct StoreContext {
         let override = lookupOverride(of: atom)
         let scopeKey = lookupScopeKey(of: atom, isScopedOverriden: override?.isScoped ?? false)
         let key = AtomKey(atom, scopeKey: scopeKey)
-        let state = lookupState(of: atom, for: key) ?? makeEphemeralState(of: atom)
-        let context = prepareForTransaction(of: atom, for: key, state: state)
+        let context = prepareForTransaction(of: atom, for: key)
         let value: Node.Loader.Value
 
         if let override {
@@ -164,6 +158,7 @@ internal struct StoreContext {
         }
 
         guard let cache = lookupCache(of: atom, for: key) else {
+            checkAndRelease(for: key)
             return value
         }
 
@@ -180,11 +175,12 @@ internal struct StoreContext {
         let override = lookupOverride(of: atom)
         let scopeKey = lookupScopeKey(of: atom, isScopedOverriden: override?.isScoped ?? false)
         let key = AtomKey(atom, scopeKey: scopeKey)
-        let state = lookupState(of: atom, for: key) ?? makeEphemeralState(of: atom)
+        let state = getState(of: atom, for: key)
         let context = AtomCurrentContext(store: self, coordinator: state.coordinator)
         let value = await atom.refresh(context: context)
 
         guard let transaction = state.transaction, let cache = lookupCache(of: atom, for: key) else {
+            checkAndRelease(for: key)
             return value
         }
 
@@ -214,10 +210,11 @@ internal struct StoreContext {
         let override = lookupOverride(of: atom)
         let scopeKey = lookupScopeKey(of: atom, isScopedOverriden: override?.isScoped ?? false)
         let key = AtomKey(atom, scopeKey: scopeKey)
-        let state = lookupState(of: atom, for: key) ?? makeEphemeralState(of: atom)
-        let context = AtomCurrentContext(store: self, coordinator: state.coordinator)
 
-        atom.reset(context: context)
+        if let state = lookupState(of: atom, for: key) {
+            let context = AtomCurrentContext(store: self, coordinator: state.coordinator)
+            atom.reset(context: context)
+        }
     }
 
     @usableFromInline
@@ -292,9 +289,10 @@ internal struct StoreContext {
 private extension StoreContext {
     func prepareForTransaction<Node: Atom>(
         of atom: Node,
-        for key: AtomKey,
-        state: AtomState<Node.Coordinator>
+        for key: AtomKey
     ) -> AtomLoaderContext<Node.Loader.Value, Node.Loader.Coordinator> {
+        let state = getState(of: atom, for: key)
+
         // Terminate the ongoing transaction first.
         state.transaction?.terminate()
 
@@ -386,8 +384,7 @@ private extension StoreContext {
         notifyUpdateToObservers()
     }
 
-    @discardableResult
-    func checkAndRelease(for key: AtomKey) -> Bool {
+    func checkAndRelease(for key: AtomKey) {
         // The condition under which an atom may be released are as follows:
         //     1. It's not marked as `KeepAlive`, is marked as `Scoped`, or is scoped by override.
         //     2. It has no downstream atoms.
@@ -398,11 +395,10 @@ private extension StoreContext {
         lazy var shouldRelease = !shouldKeepAlive && isChildrenEmpty && isSubscriptionEmpty
 
         guard shouldRelease else {
-            return false
+            return
         }
 
         release(for: key)
-        return true
     }
 
     func release(for key: AtomKey) {
@@ -427,16 +423,12 @@ private extension StoreContext {
             return state
         }
 
-        let state = makeEphemeralState(of: atom)
+        let coordinator = atom.makeCoordinator()
+        let state = AtomState(coordinator: coordinator)
         store.state.states[key] = state
         return state
     }
 
-    func makeEphemeralState<Node: Atom>(of atom: Node) -> AtomState<Node.Coordinator> {
-        let coordinator = atom.makeCoordinator()
-        return AtomState(coordinator: coordinator)
-    }
-
     func lookupState<Node: Atom>(of atom: Node, for key: AtomKey) -> AtomState<Node.Coordinator>? {
         guard let baseState = store.state.states[key] else {
             return nil
@@ -477,8 +469,7 @@ private extension StoreContext {
         for key: AtomKey,
         override: AtomOverride<Node>?
     ) -> AtomCache<Node> {
-        let state = getState(of: atom, for: key)
-        let context = prepareForTransaction(of: atom, for: key, state: state)
+        let context = prepareForTransaction(of: atom, for: key)
         let value: Node.Loader.Value
 
         if let override {

Tests/AtomsTests/Core/StoreContextTests.swift

@@ -142,23 +142,12 @@ final class StoreContextTests: XCTestCase {
 
         XCTAssertEqual(context.read(atom), 0)
         XCTAssertNil(store.state.caches[key])
-        XCTAssertEqual(
-            snapshots.map { $0.caches.mapValues { $0.value as? Int } },
-            [
-                [key: 0],
-                [:],
-            ]
-        )
+        XCTAssertTrue(snapshots.isEmpty)
 
         snapshots.removeAll()
         store.graph.children[key] = [AtomKey(TestAtom(value: 1))]
         XCTAssertEqual(context.read(atom), 0)
-        XCTAssertEqual(
-            snapshots.map { $0.caches.mapValues { $0.value as? Int } },
-            [
-                [key: 0]
-            ]
-        )
+        XCTAssertTrue(snapshots.isEmpty)
 
         snapshots.removeAll()
         store.state.caches[key] = AtomCache(atom: atom, value: 1)
@@ -279,20 +268,14 @@ final class StoreContextTests: XCTestCase {
         XCTAssertNotNil(store.state.states[dependency0Key])
         XCTAssertTrue(snapshots.flatMap(\.caches).isEmpty)
 
-        snapshots.removeAll()
         transaction.terminate()
+
         XCTAssertEqual(context.watch(dependency1, in: transaction), 1)
         XCTAssertEqual(store.graph.dependencies, [key: [dependency0Key]])
         XCTAssertEqual(store.graph.children, [dependency0Key: [key]])
         XCTAssertNil(store.state.caches[dependency1Key])
         XCTAssertNil(store.state.states[dependency1Key])
-        XCTAssertEqual(
-            snapshots.map { $0.caches.mapValues { $0.value as? Int } },
-            [
-                [dependency0Key: 0, dependency1Key: 1],
-                [dependency0Key: 0],
-            ]
-        )
+        XCTAssertTrue(snapshots.isEmpty)
     }
 
     @MainActor