SwiftLee方式のDIをすることでTCAのEnvironmentバケツリレーをやめたい話

// MARK: - InjectionKey

/// DIする対象に対してのKeyを抽象化する。
/// TestDoubleなものに切り替えられればそれをstaticに保存しており、切り替えられたものを利用する。
/// 例えば次のような準拠構造になる。
/// InjectionKey
///   - NetworkProviderKey
///   - DBProviderKey
///   - SchedulerProviderKey
public protocol InjectionKey {

    /// Valueの型。準拠する側で決めてくれよな！
    associatedtype Value

    /// このInjectionKeyは現在の唯一の値(Value型)をstaticに返す。
    /// デフォルト値とも言えるが、書き換えられるのでcurrentValueとしているんだろうか（書き換えられたら元のデフォルトに戻せない）。
    static var currentValue: Self.Value { get set }
}

// MARK: - InjectedValues

/// 注入された依存物のアクセスを抽象化する。
/// 基本的にはこれがkeyで管理されたグローバル変数のDictionaryのように振る舞うだけの話。
/// SwiftのpropertyWrapperアノテーションはgetterとsetterによってそれを隠蔽化できる。
struct InjectedValues {

    /// This is only used as an accessor to the computed properties within extensions of `InjectedValues`.
    /// staticなメソッドを理容師た場合にこのインスタンスを利用する。
    private static var current = InjectedValues()

    /// プロパティcurrentValueを持つKey型を引数にし、currentValueのgetter, setterとして振る舞いをさせる。
    /// extension InjectedValuesのプロパティから利用する。
    static subscript<K>(key: K.Type) -> K.Value where K : InjectionKey {
        get { key.currentValue }
        set { key.currentValue = newValue }
    }

    /// A static subscript accessor for updating and references dependencies directly.
    /// [KeyPath]でアクセスする際にsetterとgetterが利用される。
    /// つまりDIする際と、利用する際の2つ。
    static subscript<T>(_ keyPath: WritableKeyPath<InjectedValues, T>) -> T {
        get { current[keyPath: keyPath] }
        set { current[keyPath: keyPath] = newValue }
    }
}

// MARK: - Property Wrapper

@propertyWrapper
public struct Injected<T> {

    /// StaticなInjectedValuesにアクセスするためのkeyPathを定義する
    private let keyPath: WritableKeyPath<InjectedValues, T>

    /// @propertyWrapperの必須プロパティ。
    /// StaticにInjectedValuesにアクセスする。
    public var wrappedValue: T {
        get { InjectedValues[keyPath] }
        set { InjectedValues[keyPath] = newValue }
    }

    init(_ keyPath: WritableKeyPath<InjectedValues, T>) {
        self.keyPath = keyPath
    }
}

import Combine

// MARK: - MainScheduler

public struct SchedulerKey: InjectionKey {
    public typealias Value = Scheduler
    public static var currentValue: Scheduler = ProductionScheduler()
}

public protocol Scheduler {
    var main: AnySchedulerOf<DispatchQueue> { get }
}

public struct ProductionScheduler: Scheduler {
    public var main: AnySchedulerOf<DispatchQueue>  {
        DispatchQueue.main.eraseToAnyScheduler()
    }
}

// MARK: - network providing

protocol NetworkProviding {
    var fetch: (Int) -> Effect<String, Error> { get }
}

struct NetworkProvider: NetworkProviding {
    var fetch: (Int) -> Effect<String, Swift.Error>

    static let live = Self(
        fetch: { number in
            return Effect.task {
                await Self.fetch(number)
            }
            .setFailureType(to: Error.self)
            .eraseToEffect()
        }
    )

    static func fetch(_ number: Int) async -> String {
        do {
          let (data, _) = try await URLSession.shared
            .data(from: URL(string: "https://numbersapi.com/\(number)/trivia")!)
          return String(decoding: data, as: UTF8.self)
        } catch {
          try? await Task.sleep(nanoseconds: NSEC_PER_SEC)
          return "\(number) is a good number Brent"
        }
    }
}

import SwiftUI
import ComposableArchitecture

enum MainFeature {
    struct State {
        var detail: DetailFeature.State
    }

    enum Action {
        case detailAction(DetailFeature.Action)
    }

    struct Environment {}

    static let reducer = Reducer<State, Action, Environment>.combine(
        DetailFeature.reducer.pullback(
            state: \.detail,
            action: /MainFeature.Action.detailAction,
            environment: { _ in
                DetailFeature.Environment()
            }
        ),
        Reducer { state, action, environment in
            return .none
        }
    )

    struct View: SwiftUI.View {
        let store: Store<State, Action>

        var body: some SwiftUI.View {
            NavigationView {
                NavigationLink(
                    destination: DetailFeature.View(
                        store: store.scope(
                            state: \.detail,
                            action: {
                                MainFeature.Action.detailAction($0)
                            }
                        )
                    )
                ) {
                    Text("tap me!")
                }
            }
        }
    }
}

enum DetailFeature {
    struct State: Equatable {
        var modal: ModalFeature.State
    }

    enum Action {
        case modalAction(ModalFeature.Action)
        case onTapDetail
    }

    struct Environment {}

    static let reducer = Reducer<State, Action, Environment>.combine(
        ModalFeature.reducer.pullback(
            state: \.modal,
            action: /DetailFeature.Action.modalAction,
            environment: { _ in ModalFeature.Environment() }
        ),
        Reducer { state, action, environment in
            switch action {
            case .onTapDetail:
                state.modal.isPresented.toggle()
                return .none
            case .modalAction:
                return .none
            }
        }
    )

    struct View: SwiftUI.View {
        @SwiftUI.Environment(\.presentationMode) var presentationMode

        let store: Store<State, Action>

        var body: some SwiftUI.View {
            WithViewStore(store) { viewStore in
                Button {
                    viewStore.send(.onTapDetail)
                } label: {
                    Text("Detail")
                }
                .sheet(
                    isPresented: viewStore.binding(
                        get: { $0.modal.isPresented },
                        send: Action.modalAction(ModalFeature.Action.togglePresent)
                    )
                ) {
                    ModalFeature.View(
                        store: store.scope(
                            state: \.modal,
                            action: {
                                DetailFeature.Action.modalAction($0)
                            }
                        )
                    )
                }
            }
        }
    }
}

enum ModalFeature {

    struct State: Equatable {
        var isPresented = false
        var number = 0
        var fact = ""
    }

    enum Action: Equatable {
        case togglePresent
        case onTapNumberFactButton
        case numberFactResponse(Result<String, NSError>)
    }

    struct Environment {
        @Injected(\.scheduler) var scheduler: Scheduler
        @Injected(\.networkProvider) var networkProvider: NetworkProviding
    }

    static let reducer = Reducer<State, Action, Environment> { state, action, environment in
        switch action {
        case .togglePresent:
            state.isPresented.toggle()
            return .none

        case .onTapNumberFactButton:
            struct FetchID: Hashable {}

            return environment.networkProvider.fetch(state.number)
                .debounce(id: FetchID(), for: 0.3, scheduler: environment.scheduler.main)
                .mapError { $0 as NSError }
                .receive(on: environment.scheduler.main)
                .catchToEffect(Action.numberFactResponse)

        case .numberFactResponse(let result):
            switch result {
            case .failure(let error):
                state.fact = error.localizedDescription
            case .success(let fact):
                state.fact = fact
            }

            return .none
        }
    }

    struct View: SwiftUI.View {
        let store: Store<State, Action>

        var body: some SwiftUI.View {
            WithViewStore(store) { viewStore in
                VStack {
                    Text(viewStore.fact)
                    Text("Number fact API")
                        .onTapGesture {

                        }
                        .onAppear {
                            viewStore.send(.onTapNumberFactButton)
                        }

                }
            }
        }
    }
}

// テキストにしたら紛らわしくて申し訳ないけども、このSchedulerは自前のprotocol Scheduler
struct MockedScheduler: Scheduler {
    var main: AnySchedulerOf<DispatchQueue>
}
struct MockedNetworkProvider: NetworkProviding {
    var fetch: (Int) -> Effect<String, Swift.Error>
}

import XCTest
import ComposableArchitecture

@testable import TCALeeDemo

class ModalFeatureTests: XCTestCase {
    let scheduler = DispatchQueue.test

    func testExample() {
        InjectedValues[\.scheduler] = MockedScheduler(main: scheduler.eraseToAnyScheduler() )
        InjectedValues[\.networkProvider] = MockedNetworkProvider(fetch: { n in
            Effect(value: "\(n)!!")
        })

        let store = TestStore(
            initialState: ModalFeature.State(
                number: 0
            ),
            reducer: ModalFeature.reducer,
            environment: ModalFeature.Environment()
        )

        store.send(.onTapNumberFactButton)

        scheduler.advance(by: 0.3)

        store.receive(.numberFactResponse(.success("0!!"))) {
            $0.fact = "0!!"
        }
    }
}