Refactoring

Author: ra1028

README.md

@@ -909,7 +909,7 @@ The context also provides a flexible solution for passing dynamic parameters to
 
 ### Context
 
-Context is a context structure for using and interacting with atom values from a view or an another atom.  
+Context is a structure for using and interacting with atom values from views or other atoms.  
 
 |API|Use|
 |:--|:--|
@@ -992,7 +992,7 @@ struct BooksView: View {
 
 </details>
 
-Context available through the `@ViewContext` property wrapper when using atoms from a view.
+A context available through the `@ViewContext` property wrapper when using atoms from a view.
 
 #### [AtomTransactionContext](https://ra1028.github.io/swiftui-atom-properties/documentation/atoms/atomtransactioncontext)
 
@@ -1023,7 +1023,7 @@ struct CoordinateAtom: ValueAtom, Hashable {
 
 </details>
 
-Context passed as a parameter to the primary function of an atom type.  
+A context passed as a parameter to the primary function of each atom type.  
 This context type has a `coordinator` property that preserves an instance from the time an atom is used and initialized until it is unused and cleaned up, so it can be used to cache values or as a lifecycle for an atom.  
 
 |API|Use|
@@ -1073,7 +1073,7 @@ class FetchMusicsTests: XCTestCase {
 
 </details>
 
-Context that can simulate any scenarios in which atoms are used from a view or another atom and provides a comprehensive means of testing.
+A context that can simulate any scenarios in which atoms are used from a view or another atom and provides a comprehensive means of testing.
 
 |API|Use|
 |:--|:--|

Sources/Atoms/Core/AtomCache.swift

@@ -1,13 +1,13 @@
 @MainActor
-internal protocol AtomCache {
+internal protocol AtomCacheBase {
     var shouldKeepAlive: Bool { get }
 
     func reset(with store: StoreContext)
     func notifyUnassigned(to observers: [AtomObserver])
 }
 
 @MainActor
-internal struct ConcreteAtomCache<Node: Atom>: AtomCache {
+internal struct AtomCache<Node: Atom>: AtomCacheBase {
     var atom: Node
     var value: Node.Loader.Value?
 

Sources/Atoms/Core/AtomState.swift

@@ -1,10 +1,10 @@
 @MainActor
-internal protocol AtomState {
+internal protocol AtomStateBase {
     var transaction: Transaction? { get nonmutating set }
     var subscriptions: [SubscriptionKey: Subscription] { get nonmutating set }
 }
 
-internal final class ConcreteAtomState<Coordinator>: AtomState {
+internal final class AtomState<Coordinator>: AtomStateBase {
     let coordinator: Coordinator
     var transaction: Transaction?
     var subscriptions = [SubscriptionKey: Subscription]()

Sources/Atoms/Core/StoreContext.swift

@@ -210,14 +210,14 @@ private extension StoreContext {
         }
     }
 
-    func getCache<Node: Atom>(of atom: Node, for key: AtomKey) -> ConcreteAtomCache<Node> {
+    func getCache<Node: Atom>(of atom: Node, for key: AtomKey) -> AtomCache<Node> {
         let store = getStore()
 
         if let cache = peekCache(of: atom, for: key) {
             return cache
         }
         else {
-            let cache = ConcreteAtomCache(atom: atom)
+            let cache = AtomCache(atom: atom)
             store.state.atomCaches[key] = cache
 
             for observer in observers {
@@ -228,14 +228,14 @@ private extension StoreContext {
         }
     }
 
-    func peekCache<Node: Atom>(of atom: Node, for key: AtomKey) -> ConcreteAtomCache<Node>? {
+    func peekCache<Node: Atom>(of atom: Node, for key: AtomKey) -> AtomCache<Node>? {
         let store = getStore()
 
         guard let baseCache = store.state.atomCaches[key] else {
             return nil
         }
 
-        guard let cache = baseCache as? ConcreteAtomCache<Node> else {
+        guard let cache = baseCache as? AtomCache<Node> else {
             assertionFailure(
                 """
                 [Atoms]
@@ -257,12 +257,12 @@ private extension StoreContext {
         return cache
     }
 
-    func getState<Node: Atom>(of atom: Node, for key: AtomKey) -> ConcreteAtomState<Node.Coordinator> {
+    func getState<Node: Atom>(of atom: Node, for key: AtomKey) -> AtomState<Node.Coordinator> {
         let store = getStore()
 
-        func makeState() -> ConcreteAtomState<Node.Coordinator> {
+        func makeState() -> AtomState<Node.Coordinator> {
             let coordinator = atom.makeCoordinator()
-            let state = ConcreteAtomState(coordinator: coordinator)
+            let state = AtomState(coordinator: coordinator)
             store.state.atomStates[key] = state
             return state
         }
@@ -271,7 +271,7 @@ private extension StoreContext {
             return makeState()
         }
 
-        guard let state = baseState as? ConcreteAtomState<Node.Coordinator> else {
+        guard let state = baseState as? AtomState<Node.Coordinator> else {
             assertionFailure(
                 """
                 [Atoms]

Sources/Atoms/Core/StoreState.swift

@@ -1,7 +1,7 @@
 @MainActor
 internal struct StoreState {
-    var atomCaches = [AtomKey: AtomCache]()
-    var atomStates = [AtomKey: AtomState]()
+    var atomCaches = [AtomKey: AtomCacheBase]()
+    var atomStates = [AtomKey: AtomStateBase]()
 
     nonisolated init() {}
 }

Tests/AtomsTests/Core/AtomCacheTests.swift

@@ -11,8 +11,8 @@ final class AtomCacheTests: XCTestCase {
             }
         }
 
-        let state0 = ConcreteAtomCache(atom: TestValueAtom(value: 0))
-        let state1 = ConcreteAtomCache(atom: KeepAliveAtom())
+        let state0 = AtomCache(atom: TestValueAtom(value: 0))
+        let state1 = AtomCache(atom: KeepAliveAtom())
 
         XCTAssertFalse(state0.shouldKeepAlive)
         XCTAssertTrue(state1.shouldKeepAlive)
@@ -24,7 +24,7 @@ final class AtomCacheTests: XCTestCase {
         let atom = TestValueAtom(value: 0)
         let dependency = TestStateAtom(defaultValue: 0)
         let transaction = Transaction(key: AtomKey(atom)) {}
-        let state = ConcreteAtomCache(atom: atom)
+        let state = AtomCache(atom: atom)
 
         XCTAssertEqual(context.watch(dependency, in: transaction), 0)
 
@@ -38,7 +38,7 @@ final class AtomCacheTests: XCTestCase {
 
     func testNotifyUnassigned() {
         let atom = TestStateAtom(defaultValue: 0)
-        let state = ConcreteAtomCache(atom: atom)
+        let state = AtomCache(atom: atom)
         let observer = TestObserver()
 
         XCTAssertTrue(observer.assignedAtomKeys.isEmpty)

Tests/AtomsTests/Core/EnvironmentTests.swift

@@ -10,7 +10,7 @@ final class EnvironmentTests: XCTestCase {
         let atom = TestValueAtom(value: 0)
         var environment = EnvironmentValues()
 
-        store.state.atomCaches = [AtomKey(atom): ConcreteAtomCache(atom: atom, value: 100)]
+        store.state.atomCaches = [AtomKey(atom): AtomCache(atom: atom, value: 100)]
         environment.store = StoreContext(store)
 
         XCTAssertEqual(environment.store.read(atom), 100)

Tests/AtomsTests/Core/StoreContextTests.swift

@@ -17,7 +17,7 @@ final class StoreContextTests: XCTestCase {
         XCTAssertEqual(observer.changedAtomKeys, [AtomKey(atom)])
         XCTAssertEqual(observer.unassignedAtomKeys, [AtomKey(atom)])
 
-        store.state.atomCaches[key] = ConcreteAtomCache(atom: atom, value: 1)
+        store.state.atomCaches[key] = AtomCache(atom: atom, value: 1)
 
         XCTAssertEqual(context.read(atom), 1)
         XCTAssertNil(store.state.atomCaches[key])
@@ -55,7 +55,7 @@ final class StoreContextTests: XCTestCase {
         XCTAssertNil(store.state.atomStates[key])
         XCTAssertNil(store.state.atomCaches[key])
 
-        let atomState = ConcreteAtomState(coordinator: atom.makeCoordinator())
+        let atomState = AtomState(coordinator: atom.makeCoordinator())
         store.state.atomStates[key] = atomState
         atomState.subscriptions[subscriptionKey] = Subscription(
             notifyUpdate: { updateCount += 1 },
@@ -74,7 +74,7 @@ final class StoreContextTests: XCTestCase {
         XCTAssertNil(store.state.atomStates[key]?.transaction)
         XCTAssertNil(store.state.atomCaches[key])
 
-        store.state.atomCaches[key] = ConcreteAtomCache(atom: atom, value: 2)
+        store.state.atomCaches[key] = AtomCache(atom: atom, value: 2)
         context.set(3, for: atom)
 
         XCTAssertEqual(updateCount, 1)
@@ -85,7 +85,7 @@ final class StoreContextTests: XCTestCase {
         XCTAssertTrue(observer.unassignedAtomKeys.isEmpty)
         XCTAssertNotNil(store.state.atomStates[key])
         XCTAssertNil(store.state.atomStates[key]?.transaction)
-        XCTAssertEqual((store.state.atomCaches[key] as? ConcreteAtomCache<TestStateAtom<Int>>)?.value, 3)
+        XCTAssertEqual((store.state.atomCaches[key] as? AtomCache<TestStateAtom<Int>>)?.value, 3)
     }
 
     func testWatch() {
@@ -103,7 +103,7 @@ final class StoreContextTests: XCTestCase {
         XCTAssertEqual(context.watch(dependency0, in: transaction), 0)
         XCTAssertEqual(store.graph.dependencies, [key: [dependency0Key]])
         XCTAssertEqual(store.graph.children, [dependency0Key: [key]])
-        XCTAssertEqual((store.state.atomCaches[dependency0Key] as? ConcreteAtomCache<TestStateAtom<Int>>)?.value, 0)
+        XCTAssertEqual((store.state.atomCaches[dependency0Key] as? AtomCache<TestStateAtom<Int>>)?.value, 0)
         XCTAssertNotNil(store.state.atomStates[dependency0Key])
         XCTAssertEqual(observer.assignedAtomKeys, [dependency0Key])
         XCTAssertEqual(observer.changedAtomKeys, [dependency0Key])
@@ -151,8 +151,8 @@ final class StoreContextTests: XCTestCase {
         XCTAssertEqual(initialValue, 0)
         XCTAssertNotNil(container.wrapper.subscriptions[key])
         XCTAssertNotNil(store.state.atomStates[key]?.subscriptions[subscriptionKey])
-        XCTAssertEqual((store.state.atomCaches[key] as? ConcreteAtomCache<TestAtom>)?.value, 0)
-        XCTAssertEqual((store.state.atomCaches[dependencyKey] as? ConcreteAtomCache<DependencyAtom>)?.value, 0)
+        XCTAssertEqual((store.state.atomCaches[key] as? AtomCache<TestAtom>)?.value, 0)
+        XCTAssertEqual((store.state.atomCaches[dependencyKey] as? AtomCache<DependencyAtom>)?.value, 0)
         XCTAssertEqual(observer.assignedAtomKeys, [key, dependencyKey])
         XCTAssertEqual(observer.changedAtomKeys, [dependencyKey, key])
         XCTAssertTrue(observer.unassignedAtomKeys.isEmpty)
@@ -194,7 +194,7 @@ final class StoreContextTests: XCTestCase {
         }
 
         let value1 = await context.refresh(atom).value
-        let cachedValue = await (store.state.atomCaches[key] as? ConcreteAtomCache<TestTaskAtom<Int>>)?.value?.value
+        let cachedValue = await (store.state.atomCaches[key] as? AtomCache<TestTaskAtom<Int>>)?.value?.value
 
         XCTAssertEqual(value1, 0)
         XCTAssertNotNil(store.state.atomCaches[key])
@@ -270,13 +270,13 @@ final class StoreContextTests: XCTestCase {
 
         _ = context.watch(atom, container: container.wrapper) {}
 
-        let state = store.state.atomStates[key] as? ConcreteAtomState<TestAtom.Coordinator>
+        let state = store.state.atomStates[key] as? AtomState<TestAtom.Coordinator>
 
         XCTAssertNotNil(state?.coordinator)
 
         context.reset(atom)
 
-        let newState = store.state.atomStates[key] as? ConcreteAtomState<TestAtom.Coordinator>
+        let newState = store.state.atomStates[key] as? AtomState<TestAtom.Coordinator>
 
         XCTAssertTrue(state?.coordinator === newState?.coordinator)
     }