aigroup-workflow 2.1.2 → 2.2.1

package/skills/swift/swift-expert/references/swiftui-patterns.md

@@ -0,0 +1,291 @@
+# SwiftUI Patterns
+
+## State Management
+
+```swift
+import SwiftUI
+
+// @State for local view state
+struct CounterView: View {
+    @State private var count = 0
+
+    var body: some View {
+        VStack {
+            Text("Count: \(count)")
+            Button("Increment") { count += 1 }
+        }
+    }
+}
+
+// @Binding for two-way data flow
+struct ToggleView: View {
+    @Binding var isOn: Bool
+
+    var body: some View {
+        Toggle("Enable Feature", isOn: $isOn)
+    }
+}
+
+// @StateObject for observable objects (view owns it)
+class ViewModel: ObservableObject {
+    @Published var items: [String] = []
+    @Published var isLoading = false
+}
+
+struct ContentView: View {
+    @StateObject private var viewModel = ViewModel()
+
+    var body: some View {
+        List(viewModel.items, id: \.self) { item in
+            Text(item)
+        }
+    }
+}
+
+// @ObservedObject for passed-in observable objects
+struct DetailView: View {
+    @ObservedObject var viewModel: ViewModel
+}
+
+// @EnvironmentObject for dependency injection
+struct AppView: View {
+    @EnvironmentObject var appState: AppState
+}
+```
+
+## Modern View Composition
+
+```swift
+// View builder for custom containers
+struct ConditionalView<Content: View>: View {
+    let condition: Bool
+    @ViewBuilder let content: () -> Content
+
+    var body: some View {
+        if condition {
+            content()
+        } else {
+            EmptyView()
+        }
+    }
+}
+
+// Custom ViewModifier
+struct CardModifier: ViewModifier {
+    func body(content: Content) -> some View {
+        content
+            .padding()
+            .background(Color.white)
+            .cornerRadius(12)
+            .shadow(radius: 4)
+    }
+}
+
+extension View {
+    func cardStyle() -> some View {
+        modifier(CardModifier())
+    }
+}
+
+// Usage
+Text("Hello")
+    .cardStyle()
+```
+
+## Environment Values
+
+```swift
+// Custom environment key
+private struct ThemeKey: EnvironmentKey {
+    static let defaultValue: Theme = .light
+}
+
+extension EnvironmentValues {
+    var theme: Theme {
+        get { self[ThemeKey.self] }
+        set { self[ThemeKey.self] = newValue }
+    }
+}
+
+extension View {
+    func theme(_ theme: Theme) -> some View {
+        environment(\.theme, theme)
+    }
+}
+
+// Usage
+struct ThemedView: View {
+    @Environment(\.theme) var theme
+
+    var body: some View {
+        Text("Themed")
+            .foregroundColor(theme.textColor)
+    }
+}
+```
+
+## Preference Keys
+
+```swift
+// Collecting data from child views
+struct SizePreferenceKey: PreferenceKey {
+    static var defaultValue: CGSize = .zero
+
+    static func reduce(value: inout CGSize, nextValue: () -> CGSize) {
+        value = nextValue()
+    }
+}
+
+struct MeasurableView: View {
+    @State private var size: CGSize = .zero
+
+    var body: some View {
+        Text("Measure me")
+            .background(
+                GeometryReader { geometry in
+                    Color.clear
+                        .preference(key: SizePreferenceKey.self, value: geometry.size)
+                }
+            )
+            .onPreferenceChange(SizePreferenceKey.self) { newSize in
+                size = newSize
+            }
+    }
+}
+```
+
+## Animations
+
+```swift
+// Implicit animations
+struct AnimatedView: View {
+    @State private var scale: CGFloat = 1.0
+
+    var body: some View {
+        Circle()
+            .scaleEffect(scale)
+            .animation(.spring(response: 0.5, dampingFraction: 0.6), value: scale)
+            .onTapGesture {
+                scale = scale == 1.0 ? 1.5 : 1.0
+            }
+    }
+}
+
+// Explicit animations
+struct ExplicitAnimationView: View {
+    @State private var offset: CGFloat = 0
+
+    var body: some View {
+        Text("Slide")
+            .offset(x: offset)
+            .onTapGesture {
+                withAnimation(.easeInOut(duration: 0.3)) {
+                    offset = offset == 0 ? 100 : 0
+                }
+            }
+    }
+}
+
+// Custom transitions
+extension AnyTransition {
+    static var slideAndFade: AnyTransition {
+        AnyTransition.slide.combined(with: .opacity)
+    }
+}
+```
+
+## Async/Await Integration
+
+```swift
+struct AsyncDataView: View {
+    @State private var data: [Item] = []
+    @State private var isLoading = false
+
+    var body: some View {
+        List(data) { item in
+            Text(item.title)
+        }
+        .task {
+            await loadData()
+        }
+        .refreshable {
+            await loadData()
+        }
+    }
+
+    private func loadData() async {
+        isLoading = true
+        defer { isLoading = false }
+
+        do {
+            data = try await API.fetchItems()
+        } catch {
+            print("Error: \(error)")
+        }
+    }
+}
+```
+
+## Custom Layouts (iOS 16+)
+
+```swift
+struct WaterfallLayout: Layout {
+    var columns: Int = 2
+    var spacing: CGFloat = 8
+
+    func sizeThatFits(
+        proposal: ProposedViewSize,
+        subviews: Subviews,
+        cache: inout ()
+    ) -> CGSize {
+        // Calculate total size needed
+        let columnWidth = (proposal.width! - spacing * CGFloat(columns - 1)) / CGFloat(columns)
+        var columnHeights = Array(repeating: CGFloat(0), count: columns)
+
+        for subview in subviews {
+            let column = columnHeights.enumerated().min(by: { $0.element < $1.element })!.offset
+            let size = subview.sizeThatFits(.init(width: columnWidth, height: nil))
+            columnHeights[column] += size.height + spacing
+        }
+
+        return CGSize(
+            width: proposal.width!,
+            height: columnHeights.max()! - spacing
+        )
+    }
+
+    func placeSubviews(
+        in bounds: CGRect,
+        proposal: ProposedViewSize,
+        subviews: Subviews,
+        cache: inout ()
+    ) {
+        let columnWidth = (bounds.width - spacing * CGFloat(columns - 1)) / CGFloat(columns)
+        var columnHeights = Array(repeating: CGFloat(0), count: columns)
+
+        for subview in subviews {
+            let column = columnHeights.enumerated().min(by: { $0.element < $1.element })!.offset
+            let x = bounds.minX + CGFloat(column) * (columnWidth + spacing)
+            let y = bounds.minY + columnHeights[column]
+
+            subview.place(
+                at: CGPoint(x: x, y: y),
+                proposal: .init(width: columnWidth, height: nil)
+            )
+
+            columnHeights[column] += subview.dimensions(in: .init(width: columnWidth, height: nil)).height + spacing
+        }
+    }
+}
+```
+
+## Performance Tips
+
+- Use `@State` for simple value types
+- Use `@StateObject` for reference types you create
+- Use `@ObservedObject` for reference types passed in
+- Prefer `@Environment` over prop drilling
+- Use `equatable()` modifier for expensive views
+- Leverage `id()` modifier to control view identity
+- Use `task(id:)` to cancel and restart async work
+- Avoid computing expensive values in body - use `@State` or computed properties

package/skills/swift/swift-expert/references/testing-patterns.md

@@ -0,0 +1,399 @@
+# Testing Patterns
+
+## XCTest Basics
+
+```swift
+import XCTest
+@testable import MyApp
+
+final class UserTests: XCTestCase {
+    var sut: UserManager!
+
+    override func setUp() {
+        super.setUp()
+        sut = UserManager()
+    }
+
+    override func tearDown() {
+        sut = nil
+        super.tearDown()
+    }
+
+    func testUserCreation() {
+        // Given
+        let name = "John Doe"
+        let email = "john@example.com"
+
+        // When
+        let user = sut.createUser(name: name, email: email)
+
+        // Then
+        XCTAssertEqual(user.name, name)
+        XCTAssertEqual(user.email, email)
+        XCTAssertNotNil(user.id)
+    }
+
+    func testValidation() throws {
+        // Unwrapping optionals in tests
+        let user = try XCTUnwrap(sut.findUser(id: 123))
+        XCTAssertEqual(user.name, "Test User")
+    }
+}
+```
+
+## Async Testing
+
+```swift
+final class AsyncTests: XCTestCase {
+    func testAsyncFunction() async throws {
+        // Test async/await code directly
+        let result = try await fetchData()
+        XCTAssertEqual(result.count, 10)
+    }
+
+    func testAsyncSequence() async throws {
+        var results: [Int] = []
+
+        for try await value in numberStream() {
+            results.append(value)
+            if results.count >= 5 {
+                break
+            }
+        }
+
+        XCTAssertEqual(results.count, 5)
+    }
+
+    func testWithTimeout() async throws {
+        // Test with timeout
+        try await withTimeout(seconds: 5) {
+            try await longRunningOperation()
+        }
+    }
+
+    func testConcurrentOperations() async throws {
+        async let result1 = fetchData(id: 1)
+        async let result2 = fetchData(id: 2)
+
+        let (data1, data2) = try await (result1, result2)
+
+        XCTAssertNotNil(data1)
+        XCTAssertNotNil(data2)
+    }
+}
+
+// Helper for timeout
+func withTimeout<T>(
+    seconds: TimeInterval,
+    operation: @escaping () async throws -> T
+) async throws -> T {
+    try await withThrowingTaskGroup(of: T.self) { group in
+        group.addTask {
+            try await operation()
+        }
+
+        group.addTask {
+            try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
+            throw TimeoutError()
+        }
+
+        let result = try await group.next()!
+        group.cancelAll()
+        return result
+    }
+}
+```
+
+## Mocking
+
+```swift
+// Protocol for dependency injection
+protocol DataService {
+    func fetch(id: Int) async throws -> Data
+    func save(_ data: Data) async throws
+}
+
+// Production implementation
+class APIDataService: DataService {
+    func fetch(id: Int) async throws -> Data {
+        // Real API call
+    }
+
+    func save(_ data: Data) async throws {
+        // Real save operation
+    }
+}
+
+// Mock for testing
+class MockDataService: DataService {
+    var fetchCalled = false
+    var fetchID: Int?
+    var fetchResult: Data?
+    var fetchError: Error?
+
+    var saveCalled = false
+    var savedData: Data?
+    var saveError: Error?
+
+    func fetch(id: Int) async throws -> Data {
+        fetchCalled = true
+        fetchID = id
+
+        if let error = fetchError {
+            throw error
+        }
+
+        return fetchResult ?? Data()
+    }
+
+    func save(_ data: Data) async throws {
+        saveCalled = true
+        savedData = data
+
+        if let error = saveError {
+            throw error
+        }
+    }
+}
+
+// Using mock in tests
+final class DataManagerTests: XCTestCase {
+    func testDataFetch() async throws {
+        // Given
+        let mockService = MockDataService()
+        mockService.fetchResult = "test data".data(using: .utf8)
+        let manager = DataManager(service: mockService)
+
+        // When
+        let result = try await manager.loadData(id: 123)
+
+        // Then
+        XCTAssertTrue(mockService.fetchCalled)
+        XCTAssertEqual(mockService.fetchID, 123)
+        XCTAssertNotNil(result)
+    }
+}
+```
+
+## Test Doubles
+
+```swift
+// Spy - records interactions
+class SpyDelegate: UserManagerDelegate {
+    private(set) var didUpdateUserCalled = false
+    private(set) var updatedUser: User?
+    private(set) var callCount = 0
+
+    func didUpdateUser(_ user: User) {
+        didUpdateUserCalled = true
+        updatedUser = user
+        callCount += 1
+    }
+}
+
+// Stub - provides predetermined responses
+class StubNetworkService: NetworkService {
+    var stubbedResponse: Result<Data, Error> = .success(Data())
+
+    func fetch(url: URL) async throws -> Data {
+        try stubbedResponse.get()
+    }
+}
+
+// Fake - working implementation with shortcuts
+class FakeDatabase: Database {
+    private var storage: [String: Data] = [:]
+
+    func save(key: String, value: Data) {
+        storage[key] = value
+    }
+
+    func load(key: String) -> Data? {
+        storage[key]
+    }
+
+    func clear() {
+        storage.removeAll()
+    }
+}
+```
+
+## Performance Testing
+
+```swift
+final class PerformanceTests: XCTestCase {
+    func testSortingPerformance() {
+        let numbers = (0..<10000).shuffled()
+
+        measure {
+            _ = numbers.sorted()
+        }
+    }
+
+    func testCustomMetrics() {
+        let metrics: [XCTMetric] = [
+            XCTClockMetric(),
+            XCTCPUMetric(),
+            XCTMemoryMetric(),
+            XCTStorageMetric()
+        ]
+
+        let options = XCTMeasureOptions()
+        options.iterationCount = 10
+
+        measure(metrics: metrics, options: options) {
+            performExpensiveOperation()
+        }
+    }
+}
+```
+
+## UI Testing
+
+```swift
+final class AppUITests: XCTestCase {
+    var app: XCUIApplication!
+
+    override func setUp() {
+        super.setUp()
+        continueAfterFailure = false
+        app = XCUIApplication()
+        app.launch()
+    }
+
+    func testLoginFlow() {
+        // Test UI interactions
+        let emailField = app.textFields["Email"]
+        emailField.tap()
+        emailField.typeText("test@example.com")
+
+        let passwordField = app.secureTextFields["Password"]
+        passwordField.tap()
+        passwordField.typeText("password123")
+
+        app.buttons["Login"].tap()
+
+        // Verify navigation
+        XCTAssertTrue(app.navigationBars["Dashboard"].exists)
+    }
+
+    func testButtonEnabled() {
+        let button = app.buttons["Submit"]
+        XCTAssertFalse(button.isEnabled)
+
+        app.textFields["Username"].tap()
+        app.textFields["Username"].typeText("testuser")
+
+        XCTAssertTrue(button.isEnabled)
+    }
+}
+```
+
+## Testing Actors
+
+```swift
+final class ActorTests: XCTestCase {
+    func testActorIsolation() async throws {
+        actor Counter {
+            private var value = 0
+
+            func increment() -> Int {
+                value += 1
+                return value
+            }
+
+            func reset() {
+                value = 0
+            }
+        }
+
+        let counter = Counter()
+
+        // Test concurrent access
+        await withTaskGroup(of: Int.self) { group in
+            for _ in 0..<100 {
+                group.addTask {
+                    await counter.increment()
+                }
+            }
+        }
+
+        let finalValue = await counter.increment()
+        XCTAssertEqual(finalValue, 101)
+    }
+}
+```
+
+## Snapshot Testing
+
+```swift
+import SnapshotTesting
+
+final class ViewSnapshotTests: XCTestCase {
+    func testButtonAppearance() {
+        let button = UIButton()
+        button.setTitle("Tap Me", for: .normal)
+        button.backgroundColor = .blue
+        button.frame = CGRect(x: 0, y: 0, width: 200, height: 50)
+
+        assertSnapshot(matching: button, as: .image)
+    }
+
+    func testViewControllerLayout() {
+        let vc = MyViewController()
+        assertSnapshot(matching: vc, as: .image(on: .iPhone13))
+    }
+
+    func testDarkMode() {
+        let view = MyView()
+        assertSnapshot(matching: view, as: .image(traits: .init(userInterfaceStyle: .dark)))
+    }
+}
+```
+
+## Test Organization
+
+```swift
+// MARK: - Test Cases
+extension UserManagerTests {
+    // MARK: Creation Tests
+    func testUserCreation() { }
+    func testUserCreationWithInvalidData() { }
+
+    // MARK: Validation Tests
+    func testEmailValidation() { }
+    func testPasswordValidation() { }
+
+    // MARK: Persistence Tests
+    func testUserSave() { }
+    func testUserLoad() { }
+}
+
+// MARK: - Test Helpers
+extension UserManagerTests {
+    func makeTestUser() -> User {
+        User(name: "Test", email: "test@example.com")
+    }
+
+    func setupMockData() {
+        // Common test setup
+    }
+}
+```
+
+## Best Practices
+
+- Use `@testable import` to test internal types
+- One assertion concept per test (can have multiple XCTAssert calls)
+- Use Given-When-Then pattern for clarity
+- Name tests descriptively: `test_methodName_condition_expectedResult`
+- Use setUp/tearDown for common test setup
+- Prefer dependency injection for testability
+- Use protocols to enable mocking
+- Test edge cases and error conditions
+- Use async/await for testing async code
+- Measure performance with XCTest metrics
+- Use UI testing for critical user flows
+- Mock external dependencies
+- Keep tests fast and independent
+- Use test doubles appropriately (mock, stub, spy, fake)