aigroup-workflow 2.1.2 → 2.2.0

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

@@ -1,291 +0,0 @@
-# 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-expert/references/testing-patterns.md

@@ -1,399 +0,0 @@
-# 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)