wip

Author: Ryu0118

Sources/SimplexArchitecture/Reducer/DependenciesOverrideModifier.swift

@@ -0,0 +1,39 @@
+import Dependencies
+
+public struct _DependenciesOverrideModifier<Base: ReducerProtocol>: _ReducerModifier {
+    public let base: Base
+    public let override: (inout DependencyValues) -> Void
+
+    public func reduce(into state: StateContainer<Base.Target>, action: Base.Action) -> SideEffect<Base> {
+        withDependencies(override) {
+            base.reduce(into: state, action: action)
+        }
+    }
+
+    public func reduce(into state: StateContainer<Base.Target>, action: Base.ReducerAction) -> SideEffect<Base> {
+        withDependencies(override) {
+            base.reduce(into: state, action: action)
+        }
+    }
+
+    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 {
+    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,31 @@
+import Foundation
+import Dependencies
+
+public protocol _ReducerModifier<Base> {
+    associatedtype Base: ReducerProtocol
+    var base: Base { get }
+    func reduce(into state: StateContainer<Base.Target>, action: Base.Action) -> SideEffect<Base>
+    /// Evolve the current state of ActionSendable to the next state.
+    ///
+    /// - Parameters:
+    ///   - state: Current state of ActionSendable and ReducerState. ReducerState can be accessed from the `reducerState` property of State..
+    ///   - 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<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/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
     }
 

Tests/SimplexArchitectureTests/ReducerTests.swift

@@ -1,6 +1,7 @@
 @testable import SimplexArchitecture
 import SwiftUI
 import XCTest
+import Dependencies
 
 @MainActor
 final class ReducerTests: XCTestCase {
@@ -94,6 +95,39 @@ final class ReducerTests: XCTestCase {
             $0.count = 0
         }
     }
+
+    func testDependencies() async {
+        let testStore = TestView(
+            store: .init(
+                reducer: TestReducer()
+                    .dependency(\.test, value: .init {})
+                ,
+                initialReducerState: .init()
+            )
+        ).testStore(states: .init())
+        await testStore.send(.testDependencies)
+        await testStore.receive(.increment) {
+            $0.count = 1
+        }
+    }
+}
+
+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 {
@@ -118,8 +152,11 @@ private struct TestReducer: ReducerProtocol {
         case invokeIncrement
         case invokeDecrement
         case send
+        case testDependencies
     }
 
+    @Dependency(\.test) var test
+
     func reduce(into state: StateContainer<TestView>, action: ReducerAction) -> SideEffect<Self> {
         switch action {
         case .incrementFromReducerAction:
@@ -171,6 +208,12 @@ private struct TestReducer: ReducerProtocol {
 
         case .send:
             return .send(.increment)
+
+        case .testDependencies:
+            return .run { send in
+                try await test.asyncThrows()
+                await send(.increment)
+            }
         }
     }
 }