Merge pull request #34 from Ryu0118/feature/dependency

Add Utilitis of Dependencies

Author: Ryu0118

Sources/SimplexArchitecture/Effect/CombineAction.swift

@@ -28,6 +28,7 @@ public extension CombineAction {
         .init(kind: .viewAction(action: action))
     }
 
+    @_disfavoredOverload
     @inlinable
     static func action(
         _ action: Reducer.ReducerAction

Sources/SimplexArchitecture/Effect/SideEffect.swift

@@ -17,6 +17,7 @@ public struct SideEffect<Reducer: ReducerProtocol>: Sendable {
         case concurrentReducerAction([Reducer.ReducerAction])
         case serialCombineAction([CombineAction<Reducer>])
         case concurrentCombineAction([CombineAction<Reducer>])
+        case runEffects([SideEffect<Reducer>])
     }
 
     let kind: EffectKind
@@ -86,4 +87,9 @@ public extension SideEffect {
     static func serial(_ actions: CombineAction<Reducer>...) -> Self {
         .init(effectKind: .serialCombineAction(actions))
     }
+
+    @inlinable
+    static func runEffects(_ effects: [SideEffect<Reducer>]) -> Self {
+        .init(effectKind: .runEffects(effects))
+    }
 }

Sources/SimplexArchitecture/Reducer/DependenciesOverrideModifier.swift

@@ -0,0 +1,49 @@
+import Dependencies
+
+public struct _DependenciesOverrideModifier<Base: ReducerProtocol>: ReducerModifier {
+    public let base: Base
+    public let override: (inout DependencyValues) -> Void
+
+    @usableFromInline
+    init(base: Base, override: @escaping (inout DependencyValues) -> Void) {
+        self.base = base
+        self.override = override
+    }
+
+    @inlinable
+    public func reduce(into state: StateContainer<Base.Target>, action: Base.Action) -> SideEffect<Base> {
+        withDependencies(override) {
+            base.reduce(into: state, action: action)
+        }
+    }
+
+    @inlinable
+    public func reduce(into state: StateContainer<Base.Target>, action: Base.ReducerAction) -> SideEffect<Base> {
+        withDependencies(override) {
+            base.reduce(into: state, action: action)
+        }
+    }
+
+    @inlinable
+    public func dependency<Value>(
+        _ keyPath: WritableKeyPath<DependencyValues, Value>,
+        value: Value
+    ) -> Self {
+        Self(base: self.base) { values in
+            values[keyPath: keyPath] = value
+            override(&values)
+        }
+    }
+}
+
+public extension ReducerProtocol {
+    @inlinable
+    func dependency<Value>(
+        _ keyPath: WritableKeyPath<DependencyValues, Value>,
+        value: Value
+    ) -> _DependenciesOverrideModifier<Self> {
+        .init(base: self) { values in
+            values[keyPath: keyPath] = value
+        }
+    }
+}

Sources/SimplexArchitecture/Reducer/ReducerModifier.swift

@@ -0,0 +1,24 @@
+import Foundation
+import Dependencies
+
+public protocol ReducerModifier<Base> {
+    associatedtype Base: ReducerProtocol
+    func reduce(into state: StateContainer<Base.Target>, action: Base.Action) -> SideEffect<Base>
+    func reduce(into state: StateContainer<Base.Target>, action: Base.ReducerAction) -> SideEffect<Base>
+}
+
+public extension ReducerModifier {
+    @inlinable
+    func reduce(
+        into state: StateContainer<Base.Target>,
+        action: CombineAction<Base>
+    ) -> SideEffect<Base> {
+        switch action.kind {
+        case let .viewAction(action):
+            reduce(into: state, action: action)
+
+        case let .reducerAction(action):
+            reduce(into: state, action: action)
+        }
+    }
+}

Sources/SimplexArchitecture/Reducer/ReducerProtocol.swift

@@ -114,6 +114,8 @@ public protocol ReducerProtocol<Target> {
     ///   - action: A ReducerAction that can change the state of View and ReducerState.
     /// - Returns: An `SideEffect` representing the side effects generated by the reducer.
     func reduce(into state: StateContainer<Target>, action: ReducerAction) -> SideEffect<Self>
+
+    associatedtype Children = Never
 }
 
 public extension ReducerProtocol where ReducerAction == Never {

Sources/SimplexArchitecture/Store/Store+send.swift

@@ -74,7 +74,7 @@ extension Store {
         if _XCTIsTesting, let effectContext = EffectContext.id {
             let before = container.copy()
             sideEffect = withLock {
-                reducer.reduce(into: container, action: action)
+                reduce(container, action)
             }
             sentFromEffectActions.append(
                 ActionTransition(
@@ -86,7 +86,7 @@ extension Store {
                 )
             )
         } else {
-            sideEffect = withLock { reducer.reduce(into: container, action: action) }
+            sideEffect = withLock { reduce(container, action) }
         }
 
         if case .none = sideEffect.kind {

Sources/SimplexArchitecture/Store/Store.swift

@@ -20,20 +20,35 @@ public final class Store<Reducer: ReducerProtocol> {
     @usableFromInline var pullbackAction: ((Reducer.Action) -> Void)?
     @usableFromInline var pullbackReducerAction: ((Reducer.ReducerAction) -> Void)?
 
-    let reducer: Reducer
+    let reduce: (StateContainer<Reducer.Target>, CombineAction<Reducer>) -> SideEffect<Reducer>
     var initialReducerState: (() -> Reducer.ReducerState)?
 
     /// Initialize  `Store` with the given reducer when the `ReducerState` is `Never`.
     public init(reducer: Reducer) where Reducer.ReducerState == Never {
-        self.reducer = reducer
+        self.reduce = reducer.reduce
     }
 
     /// Initialize `Store` with the given `Reducer` and initial `ReducerState`.
     public init(
         reducer: Reducer,
         initialReducerState: @autoclosure @escaping () -> Reducer.ReducerState
     ) {
-        self.reducer = reducer
+        self.reduce = reducer.reduce
+        self.initialReducerState = initialReducerState
+    }
+
+    public init<R: ReducerModifier<Reducer>>(
+        reducer: R
+    ) where Reducer.ReducerState == Never {
+        self.reduce = reducer.reduce
+    }
+
+    /// Initialize `Store` with the given `Reducer` and initial `ReducerState`.
+    public init<R: ReducerModifier<Reducer>>(
+        reducer: R,
+        initialReducerState: @autoclosure @escaping () -> Reducer.ReducerState
+    ) {
+        self.reduce = reducer.reduce
         self.initialReducerState = initialReducerState
     }
 
@@ -198,6 +213,11 @@ extension Store {
             }
             return [SendTask(task: task)]
 
+        case let .runEffects(effects):
+            return effects.reduce(into: [SendTask]()) { partialResult, effect in
+                partialResult += runEffect(effect, send: send)
+            }
+
         case .none:
             return []
         }

Tests/SimplexArchitectureTests/DependenciesOverrideModifierTests.swift

@@ -0,0 +1,53 @@
+@testable import SimplexArchitecture
+import SwiftUI
+import Dependencies
+import XCTest
+
+final class DependenciesOverrideModifierTests: XCTestCase {
+    func testModifier() async {
+        let base = BaseView(
+            store: Store(
+                reducer: _DependenciesOverrideModifier(base: BaseReducer()) {
+                    $0.test = .init(asyncThrows: {})
+                }
+            )
+        )
+        let container = base.store.setContainerIfNeeded(for: base, states: .init())
+        await base.send(.test).wait()
+        XCTAssertEqual(container.count, 1)
+    }
+}
+
+struct BaseReducer: ReducerProtocol {
+    enum Action {
+        case test
+        case callback
+    }
+
+    @Dependency(\.test) var test
+
+    func reduce(into state: StateContainer<BaseView>, action: Action) -> SideEffect<BaseReducer> {
+        switch action {
+        case .test:
+            return .run { send in
+                try await test.asyncThrows()
+                await send(.callback)
+            }
+        case .callback:
+            state.count += 1
+            return .none
+        }
+    }
+}
+
+@ScopeState
+struct BaseView: View {
+    @State var count: Int = 0
+    let store: Store<BaseReducer>
+
+    init(store: Store<BaseReducer> = .init(reducer: BaseReducer())) {
+        self.store = store
+    }
+
+    var body: some View { EmptyView() }
+}

Tests/SimplexArchitectureTests/ReducerTests.swift

@@ -98,17 +98,12 @@ final class ReducerTests: XCTestCase {
 
     func testDependencies() async {
         let testStore = TestView(
-            store: Store(
-                reducer: withDependencies {
-                    $0.continuousClock = ImmediateClock()
-                } operation: {
-                    TestReducer()
-                },
+            store: .init(
+                reducer: TestReducer().dependency(\.test, value: .init {}),
                 initialReducerState: .init()
             )
         ).testStore(states: .init())
-
-        await testStore.send(.runEffectWithDependencies)
+        await testStore.send(.testDependencies)
         await testStore.receive(.increment) {
             $0.count = 1
         }
@@ -134,6 +129,24 @@ final class ReducerTests: XCTestCase {
     }
 }
 
+struct TestDependency: DependencyKey {
+    public var asyncThrows: @Sendable () async throws -> Void
+
+    public init(asyncThrows: @Sendable @escaping () async throws -> Void) {
+        self.asyncThrows = asyncThrows
+    }
+
+    public static let liveValue: TestDependency = .init(asyncThrows: { throw CancellationError() })
+    public static let testValue: TestDependency = .init(asyncThrows: {})
+}
+
+extension DependencyValues {
+    var test: TestDependency {
+        get { self[TestDependency.self] }
+        set { self[TestDependency.self] = newValue }
+    }
+}
+
 private struct TestReducer: ReducerProtocol {
     struct ReducerState: Equatable {
         var count = 0
@@ -157,9 +170,11 @@ private struct TestReducer: ReducerProtocol {
         case invokeDecrement
         case send
         case runEffectWithDependencies
+        case testDependencies
     }
 
     @Dependency(\.continuousClock) private var clock
+    @Dependency(\.test) var test
 
     func reduce(into state: StateContainer<TestView>, action: ReducerAction) -> SideEffect<Self> {
         switch action {
@@ -218,6 +233,12 @@ private struct TestReducer: ReducerProtocol {
                 try await clock.sleep(for: .seconds(1))
                 await send(.increment)
             }
+
+        case .testDependencies:
+            return .run { send in
+                try await test.asyncThrows()
+                await send(.increment)
+            }
         }
     }
 }
@@ -235,3 +256,27 @@ private struct TestView: View {
         EmptyView()
     }
 }
+
+private struct MyReducer: ReducerProtocol {
+    enum Action {
+        case hoge
+    }
+
+    func reduce(into state: StateContainer<MyView>, action: Action) -> SideEffect<MyReducer> {
+        .none
+    }
+}
+
+@ScopeState
+private struct MyView: View {
+    @State var count = 0
+    let store: Store<MyReducer>
+
+    init(store: Store<MyReducer> = Store(reducer: MyReducer())) {
+        self.store = store
+    }
+
+    var body: some View {
+        EmptyView()
+    }
+}

Tests/SimplexArchitectureTests/TestUtilities.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+typealias Original = @convention(thin) (UnownedJob) -> Void
+typealias Hook = @convention(thin) (UnownedJob, Original) -> Void
+
+private let _swift_task_enqueueGlobal_hook = dlsym(
+    dlopen(nil, 0), "swift_task_enqueueGlobal_hook"
+).assumingMemoryBound(to: Hook?.self)
+
+var swift_task_enqueueGlobal_hook: Hook? {
+    get { _swift_task_enqueueGlobal_hook.pointee }
+    set { _swift_task_enqueueGlobal_hook.pointee = newValue }
+}