LUCA: SwiftUI に適したモダンアーキテクチャ

┌───────────────────┐
│   UserInterface   │  ← UIの提供とイベントハンドリング
├───────────────────┤
│       Model       │  ← ビジネスロジックと状態管理
├───────────────────┤
│    DataSource     │  ← データアクセスとインフラ抽象化
└───────────────────┘

ファイル構成

.
├── LocalPackage
│   ├── Package.swift
│   ├── Sources
│   │   ├── DataSource
│   │   │   ├── Dependencies
│   │   │   │   └── AppStateClient.swift
│   │   │   ├── Entities
│   │   │   │   └── AppState.swift
│   │   │   ├── Extensions
│   │   │   ├── Repositories
│   │   │   └── DependencyClient.swift
│   │   ├── Model
│   │   │   ├── Extensions
│   │   │   ├── Services
│   │   │   ├── Stores
│   │   │   ├── AppDelegate.swift (任意)
│   │   │   └── AppDependencies.swift
│   │   └── UserInterface
│   │       ├── Extensions
│   │       ├── Resources
│   │       ├── Scenes
│   │       └── Views
│   └── Tests
│       └── ModelTests
│           ├── ServiceTests
│           └── StoreTests
├── ProjectName
│   └── ProjectNameApp.swift
└── ProjectName.xcodeproj

LocalPackage/Sources/DataSource/Entities/Person.swift

import Foundation

public struct Person: Codable, Sendable, Equatable {
    public var name: String
    public var weight: Double 
    public var height: Double 

    public init(name: String, weight: Double, height: Double) {
        self.name = name
        self.weight = weight
        self.height = height
    }

    public static let empty = Person(name: "", weight: .zero, height: .zero)
}

LocalPackage/Sources/DataSource/DependencyClient.swift

public protocol DependencyClient: Sendable {
    static var liveValue: Self { get }
    static var testValue: Self { get }
}

public func testDependencyD: DependencyClient>(of type: D.Type, injection: (inout D) -> Void) -> D {
    var dependencyClient = type.testValue
    injection(&dependencyClient)
    return dependencyClient
}

LocalPackage/Sources/DataSource/Dependencies/UserDefaultsClient.swift

import Foundation

public struct UserDefaultsClient: DependencyClient {
    var data: @Sendable (String) -> Data?
    var setData: @Sendable (Data?, String) -> Void

    public static let liveValue = Self(
        data: { UserDefaults.standard.data(forKey: $0) },
        setData: { UserDefaults.standard.set($0, forKey: $1) }
    )

    public static let testValue = Self(
        data: { _ in nil },
        setData: { _, _ in }
    )
}

LocalPackage/Sources/DataSource/Repositories/UserDefaultsRepository.swift

import Foundation

public struct UserDefaultsRepository: Sendable {
    private var userDefaultsClient: UserDefaultsClient

    public var person: Person {
        get {
            guard let data = userDefaultsClient.data(.person) else { return Person.empty }
            return (try? JSONDecoder().decode(Person.self, from: data)) ?? Person.empty
        }
        nonmutating set {
            let data = try? JSONEncoder().encode(newValue)
            userDefaultsClient.setData(data, .person)
        }
    }

    public init(_ userDefaultsClient: UserDefaultsClient) {
        self.userDefaultsClient = userDefaultsClient
    }
}

LocalPackage/Sources/DataSource/Extensions/String+Extension.swift

extension String {
    static let person = "person"
}

LocalPackage/Sources/DataSource/Entities/AppState.swift

import Combine

public struct AppState: Sendable {
    public var hasAlreadyTutorial
}

LocalPackage/Sources/DataSource/Dependencies/AppStateClient.swift

import os

public struct AppStateClient: DependencyClient {
    var getAppState: @Sendable () -> AppState
    var setAppState: @Sendable (AppState) -> Void

    public func withLockR: Sendable>(_ body: @Sendable (inout AppState) throws -> R) rethrows -> R {
        var state = getAppState()
        let result = try body(&state)
        setAppState(state)
        return result
    }

    public static let liveValue: Self = {
        let state = OSAllocatedUnfairLockAppState>(initialState: .init())
        return Self(
            getAppState: { state.withLock(\.self) },
            setAppState: { value in state.withLock { $0 = value } }
        )
    }()

    public static let testValue = Self(
        getAppState: { .init() },
        setAppState: { _ in }
    )
}

LocalPackage/Sources/Model/AppDependencies.swift

import DataSource
import SwiftUI

public final class AppDependencies: Sendable {
    public let appStateClient: AppStateClient
    public let userDefaultsClient: UserDefaultsClient

    public nonisolated init(
        appStateClient: AppStateClient = .liveValue,
        userDefaultsClient: UserDefaultsClient = .liveValue
    ) {
        self.appStateClient = appStateClient
        self.userDefaultsClient = userDefaultsClient
    }

    
    static let shared = AppDependencies()
}

public extension EnvironmentValues {
    @Entry var appDependencies = AppDependencies.shared
}


extension AppDependencies {
    public static func testDependencies(
        appStateClient: AppStateClient = .testValue,
        userDefaultsClient: UserDefaultsClient = .testValue
    ) -> AppDependencies {
        AppDependencies(
            appStateClient: appStateClient,
            userDefaultsClient: userDefaultsClient
        )
    }
}

LocalPackage/Sources/Model/AppDelegate.swift

import DataSource
import SwiftUI

@MainActor public final class AppDelegate: NSObject, NSApplicationDelegate {
    private var appDependencies = AppDependencies.shared

    public func applicationDidFinishLaunching(_ notification: Notification) {
        
        
    }

    public func applicationWillTerminate(_ notification: Notification) {
        
    }
}

LocalPackage/Sources/Model/Services/BMIService.swift

import DataSource

public struct BMIService {
    private let appStateClient: AppStateClient

    public init(_ appDependencies: AppDependencies) {
        self.appStateClient = appDependencies.appStateClient
    }

    public func calculateBMI(weight: Double, height: Double) -> Double {
        guard height > 0 else { return 0 }
        let heightInMeters = height / 100
        return (100 * weight / (heightInMeters * heightInMeters)).rounded() / 100
    }
}

LocalPackage/Sources/Model/Stores/PersonBMI.swift

import Foundation
import DataSource
import Observation

@MainActor @Observable public final class PersonBMI {
    private let userDefaultsRepository: UserDefaultsRepository
    private let bmiService: BMIService
    private let appStateClient: AppStateClient

    public var person: Person
    public var calculatedBMI: Double
    public var isPresentedTutorial: Bool

    public init(
        _ appDependencies: AppDependencies,
        person: Person = .empty,
        calculatedBMI: Double = .zero,
        isPresentedTutorial: Bool = false
    ) {
        self.userDefaultsRepository = .init(appDependencies.userDefaultsClient)
        self.bmiService = .init(appDependencies)
        self.appStateClient = appDependencies.appStateClient
        self.person = person
        self.calculatedBMI = calculatedBMI
        self.isPresentedTutorial = isPresentedTutorial
    }

    public func send(_ action: Action) {
        switch action {
        case .onAppear:
            person = userDefaultsRepository.person
            calculatedBMI = bmiService.calculateBMI(weight: person.weight, height: person.height)
            isPresentedTutorial = appStateClient.withLock {
                if $0.hasAlreadyTutorial {
                    return false
                } else {
                    $0.hasAlreadyTutorial = true
                    return true
                }
            }

        case .calculateButtonTapped:
            calculatedBMI = bmiService.calculateBMI(weight: person.weight, height: person.height)

        case .saveButtonTapped:
            userDefaultsRepository.person = person
        }
    }

    public enum Action {
        case onAppear
        case calculateButtonTapped
        case saveButtonTapped
    }
}

LocalPackage/Sources/UserInterface/Views/PersonBMIView.swift

import DataSource
import Model
import SwiftUI

struct PersonBMIView: View {
    @State var store: PersonBMI

    var body: some View {
        Form {
            Section {
                LabeledContent("名前") {
                    TextField("名前を入力", text: $store.person.name)
                        .textFieldStyle(.roundedBorder)
                }
                LabeledContent("体重 (kg)") {
                    TextField("体重", value: $store.person.weight, format: .number)
                        .textFieldStyle(.roundedBorder)
                }
                LabeledContent("身長 (cm)") {
                    TextField("身長", value: $store.person.height, format: .number)
                        .textFieldStyle(.roundedBorder)
                }
            }
            Section {
                LabeledContent("BMI") {
                    Text(String(format: "%.1f", store.calculatedBMI))
                }
                Button("BMI算出") {
                    store.send(.calculateButtonTapped)
                }
                .buttonStyle(.borderedProminent)
                Button("保存") {
                    store.send(.saveButtonTapped)
                }
                .buttonStyle(.bordered)
            }
        }
        .onAppear {
            store.send(.onAppear)
        }
        .alert("チュートリアル", isPresented: $store.isPresentedTutorial) {
            Button("OK") {}
        }
    }
}

#Preview {
    PersonBMIView(store: .init(.testDependencies()))
}

LocalPackage/Sources/UserInterface/Scenes/PersonBMIScene.swift

import Model
import SwiftUI

public struct PersonBMIScene: Scene {
    @Environment(\.appDependencies) private var appDependencies

    public init() {}

    public var body: some Scene {
        WindowGroup {
            NavigationView {
                PersonBMIView(store: .init(appDependencies))
            }
        }
    }
}

BMI/BMIApp.swift

import UserInterface
import SwiftUI

@main
struct BMIApp: App {
    
    @NSApplicationDelegateAdaptor(AppDelegate.self) private var appDelegate

    var body: some Scene {
        PersonBMIScene()
    }
}

LocalPackage/Tests/ModelTests/ServiceTests/BMIServiceTests.swift

import Testing
import DataSource
@testable import Model

@MainActor struct BMIServiceTests {
    @Test
    func calculateBMI_身長がゼロでない_正常な値が返される() {
        let sut = BMIService(.testDependencies())
        let actual = sut.calculateBMI(weight: 70, height: 175)
        #expect(actual == 22.86)
    }

    @Test
    func calculateBMI_身長がゼロ_ゼロが返される() {
        let sut = BMIService(.testDependencies())
        let actual = sut.calculateBMI(weight: 70, height: 0)
        #expect(actual == 0)
    }
}

LocalPackage/Tests/ModelTests/StoreTests/PersonBMITests.swift

import os
import Testing
@testable import DataSource
@testable import Model

struct PersonTests {
    @MainActor @Test
    func send_onAppear_保存されたデータが復元される() {
        let sut = Person(.testDependency(
            userDefaultsClient: testDependency(of: UserDefaultsClient.self) {
            $0$.data = { _ in
                return try! JSONEncoder().encode(Person(name: "テスト", weight: 70.0, height: 175.0))
            }
        }
        ))
        sut.send(.onAppear)
        #expect(sut.person == Person(name: "テスト", weight: 70.0, height: 175.0))
    }

    @MainActor @Test
    func send_calculateButtonTapped_BMIが計算される() {
        let sut = PersonBMI(
            .testDependency(),
            person: Person(name: "テスト", weight: 70.0, height: 175.0)
        )
        sut.send(.calculateButtonTapped)
        #expect(sut.calculatedBMI == 22.86)
    }

    @MainActor @Test
    func send_saveButtonTapped_データが保存される() {
        var savedData = OSAllocatedUnfairLockData?>(initialState: nil)
        let sut = PersonBMI(
            .testDependency(
                userDefaultsClient: testDependency(of: UserDefaultsClient.self) {
                    $0.setData = { data, _ in
                        savedData.withLock { $0 = data }
                    }
                }
            ),
            person: Person(name: "テスト", weight: 70.0, height: 175.0)
        )
        sut.send(.saveButtonTapped)
        #expect(savedData.withLock(\.self) != nil)
    }
}

@MainActor @Observable public final class Child {
    private let action: (Action) -> Void

    public init(
        _ appDependencies: AppDependencies,
        action: @escaping (Action) -> Void
    ) {
        self.action = action
    }

    public func send(_ action: Action) {
        self.action(action)

        switch action {
        case .closeButtonTapped:
            break
        }
    }

    public enum Action {
        case closeButtonTapped
    }
}

@MainActor @Observable public final class Parent {
    public var child: Child?

    public init(_ appDependencies: AppDependencies) {}

    public func send(_ action: Action) async {
        switch action {
        case .openChildButtonTapped(appDependencies):
            child = .init(appDependencies, action: { [weak self] in
                self?.send(.child($0))
            })

        
        case .child(.closeButtonTapped):
            child = nil

        case .child:
            break
        }
    }

    public enum Action {
        case openChildButtonTapped(AppDependencies) 
        case child(Child.Action)
    }
}

@MainActor @Observable public final class Fruits {
    public var path: [Path]
    public var bananas: [Banana]

    public init(_ appDependencies: AppDependencies, path: [Path] = [], bananas: [Banana] = []) {  }

    public func send(_ action: Action) async {
        switch action {
        case let .appleButtonTapped(appDependencies):
            path.append(.apple(.init(appDependencies, action: { [weak self] in
                self?.send(.settings($0))
            })))

        case let .bananaButtonTapped(store):
            path.append(.banana(store))

        case .banana:
            break

        case .apple:
            break
        }
    }

    public enum Action {
        case appleButtonTapped(AppDependencies) 
        case bananaButtonTapped(Banana) 
        case apple(Apple.Action)
        case banana(Banana.Action)
    }

    public enum Path: Hashable {
        case apple(Apple)
        case banana(Banana)

        public static func ==(lhs: Path, rhs: Path) -> Bool {
            lhs.id == rhs.id
        }

        public func hash(into hasher: inout Hasher) {
            hasher.combine(id)
        }

        
        var id: Int {
            switch self {
            case let .apple(value):
                Int(bitPattern: ObjectIdentifier(value))
            case let .banana(value):
                Int(bitPattern: ObjectIdentifier(value))
            }
        }
    }
}

struct FruitsView: View {
    @Environment(\.appDependencies) private var appDependencies
    @State var store: Fruits

    var body: some View {
        NavigationStack(path: $store.path) {
            VStack {
                Button("Apple") {
                    store.send(.appleButtonTapped(appDependencies))
                }
                ForEach(store.bananas) { store in
                    Button("Banana: \(store.id)") {
                        store.send(.bananaButtonTapped(store))
                    }
                }
            }
            .navigationDestination(for: Fruits.Path.self) { path in
                switch path {
                case let .apple(store):
                    AppleView(store: store)

                case let .banana(store):
                    BananaView(store: store)
                }
            }
        }
    }
}