├── .vscode
    └── settings.json
├── Mastermind
    ├── Assets.xcassets
    │   ├── Contents.json
    │   ├── AppIcon.appiconset
    │   │   ├── Mastermind.png
    │   │   └── Contents.json
    │   ├── Pegs
    │   │   ├── Contents.json
    │   │   ├── Correct.colorset
    │   │   │   └── Contents.json
    │   │   ├── Misplaced.colorset
    │   │   │   └── Contents.json
    │   │   └── Unselected.colorset
    │   │   │   └── Contents.json
    │   ├── AccentColor.colorset
    │   │   └── Contents.json
    │   ├── Background.colorset
    │   │   └── Contents.json
    │   └── Unselected.colorset
    │   │   └── Contents.json
    ├── Domain
    │   ├── FeedbackPeg.swift
    │   ├── RoundNumber.swift
    │   ├── Rounds.swift
    │   ├── SecretMaker.swift
    │   ├── Feedback.swift
    │   ├── Tests
    │   │   ├── GameTests.swift
    │   │   ├── CodeChoiceTests.swift
    │   │   ├── SecretTests.swift
    │   │   ├── SecretMakerTests.swift
    │   │   ├── RoundTests.swift
    │   │   └── FeedbackTests.swift
    │   ├── CodeChoice.swift
    │   ├── Round.swift
    │   ├── Game.swift
    │   └── Secret.swift
    ├── Preview Content
    │   └── Preview Assets.xcassets
    │   │   └── Contents.json
    ├── UI
    │   ├── Tests
    │   │   ├── __Snapshots__
    │   │   │   └── CheckButtonSnapshotTests
    │   │   │   │   ├── enabledColor.1.png
    │   │   │   │   └── disabledColor.1.png
    │   │   ├── FeedbackPeg+ColorTests.swift
    │   │   ├── InspectChangingView.swift
    │   │   ├── CheckButtonSnapshotTests.swift
    │   │   ├── RoundViewTests.swift
    │   │   ├── FeedbackViewTests.swift
    │   │   └── GameScreenTests.swift
    │   ├── TestableView.swift
    │   ├── FeedbackPeg+Color.swift
    │   ├── RoundView.swift
    │   ├── InspectableSheet.swift
    │   ├── CheckButton.swift
    │   ├── CodeGuessView.swift
    │   ├── FeedbackView.swift
    │   └── GameScreen.swift
    └── MastermindApp.swift
├── .windsurf
    ├── README.md
    ├── scripts
    │   └── commit.sh
    ├── processes
    │   ├── BashScripts.process.md
    │   ├── TDD.creating_tests.process.md
    │   ├── TDD.implement_production.process.md
    │   └── TDD.refactoring.process.md
    └── rules
    │   ├── no-comments-in-tests.md
    │   ├── agent.md
    │   ├── tdd-kent-beck.md
    │   └── commit-messages-arlo-belshee.md
├── Mastermind.xcodeproj
    ├── project.xcworkspace
    │   ├── contents.xcworkspacedata
    │   └── xcshareddata
    │   │   ├── IDEWorkspaceChecks.plist
    │   │   └── swiftpm
    │   │       └── Package.resolved
    ├── xcshareddata
    │   └── xcschemes
    │   │   └── Mastermind.xcscheme
    └── project.pbxproj
├── MastermindTests.xctestplan
├── .github
    └── workflows
    │   └── build.yml
├── LICENSE.txt
├── .gitignore
├── README.md
├── XcodeWarnings.xcconfig
└── CursorWroteTheseRules.mdc


/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {}


--------------------------------------------------------------------------------
/Mastermind/Assets.xcassets/Contents.json:
--------------------------------------------------------------------------------
1 | {
2 |   "info" : {
3 |     "author" : "xcode",
4 |     "version" : 1
5 |   }
6 | }
7 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/FeedbackPeg.swift:
--------------------------------------------------------------------------------
1 | enum FeedbackPeg {
2 |     case empty
3 |     case correct
4 |     case misplaced
5 | }
6 | 


--------------------------------------------------------------------------------
/Mastermind/Preview Content/Preview Assets.xcassets/Contents.json:
--------------------------------------------------------------------------------
1 | {
2 |   "info" : {
3 |     "author" : "xcode",
4 |     "version" : 1
5 |   }
6 | }
7 | 


--------------------------------------------------------------------------------
/Mastermind/Assets.xcassets/AppIcon.appiconset/Mastermind.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonreid/Mastermind/HEAD/Mastermind/Assets.xcassets/AppIcon.appiconset/Mastermind.png


--------------------------------------------------------------------------------
/.windsurf/README.md:
--------------------------------------------------------------------------------
1 | These files originate from this video: [Process files: Blueprints for Agentic AI - Llewellyn Falco | Craft 2025](https://www.youtube.com/watch?v=MMqahx1PRQo)
2 | 


--------------------------------------------------------------------------------
/Mastermind/UI/Tests/__Snapshots__/CheckButtonSnapshotTests/enabledColor.1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonreid/Mastermind/HEAD/Mastermind/UI/Tests/__Snapshots__/CheckButtonSnapshotTests/enabledColor.1.png


--------------------------------------------------------------------------------
/Mastermind/Assets.xcassets/Pegs/Contents.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "info" : {
 3 |     "author" : "xcode",
 4 |     "version" : 1
 5 |   },
 6 |   "properties" : {
 7 |     "provides-namespace" : true
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/Mastermind/UI/Tests/__Snapshots__/CheckButtonSnapshotTests/disabledColor.1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jonreid/Mastermind/HEAD/Mastermind/UI/Tests/__Snapshots__/CheckButtonSnapshotTests/disabledColor.1.png


--------------------------------------------------------------------------------
/Mastermind.xcodeproj/project.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Workspace
3 |    version = "1.0">
4 |    <FileRef
5 |       location = "self:">
6 |    </FileRef>
7 | </Workspace>
8 | 


--------------------------------------------------------------------------------
/Mastermind/Assets.xcassets/AccentColor.colorset/Contents.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "colors" : [
 3 |     {
 4 |       "idiom" : "universal"
 5 |     }
 6 |   ],
 7 |   "info" : {
 8 |     "author" : "xcode",
 9 |     "version" : 1
10 |   }
11 | }
12 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/RoundNumber.swift:
--------------------------------------------------------------------------------
 1 | struct RoundNumber {
 2 |     let value: Int
 3 | 
 4 |     init(value: Int) {
 5 |         assert(1 <= value)
 6 |         assert(value <= 10)
 7 |         self.value = value
 8 |     }
 9 | 
10 |     var index: Int {
11 |         value - 1
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/Mastermind.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
3 | <plist version="1.0">
4 | <dict>
5 | 	<key>IDEDidComputeMac32BitWarning</key>
6 | 	<true/>
7 | </dict>
8 | </plist>
9 | 


--------------------------------------------------------------------------------
/Mastermind/Assets.xcassets/AppIcon.appiconset/Contents.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "images" : [
 3 |     {
 4 |       "filename" : "Mastermind.png",
 5 |       "idiom" : "universal",
 6 |       "platform" : "ios",
 7 |       "size" : "1024x1024"
 8 |     }
 9 |   ],
10 |   "info" : {
11 |     "author" : "xcode",
12 |     "version" : 1
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/.windsurf/scripts/commit.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | if [ -z "$1" ]; then
 4 |   echo "Error: Commit message is required."
 5 |   echo "Usage: $0 \"<commit message>\""
 6 |   exit 1
 7 | fi
 8 | set -euo pipefail
 9 | COMMIT_MESSAGE="$1"
10 | 
11 | git add .
12 | git commit -m "$COMMIT_MESSAGE"
13 | git push
14 | echo "✅ Changes committed and pushed"
15 | exit 0


--------------------------------------------------------------------------------
/Mastermind/UI/TestableView.swift:
--------------------------------------------------------------------------------
 1 | // TestableView by Jon Reid, https://qualitycoding.org
 2 | // Copyright 2024 Jonathan M. Reid. https://github.com/jonreid/TestableView/blob/main/LICENSE.txt
 3 | // SPDX-License-Identifier: MIT
 4 | 
 5 | import SwiftUI
 6 | 
 7 | @MainActor
 8 | protocol ViewInspectorHook {
 9 |     var viewInspectorHook: ((Self) -> Void)? { get set }
10 | }
11 | 
12 | typealias TestableView = View & ViewInspectorHook
13 | 


--------------------------------------------------------------------------------
/Mastermind/Assets.xcassets/Pegs/Correct.colorset/Contents.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "colors" : [
 3 |     {
 4 |       "color" : {
 5 |         "color-space" : "srgb",
 6 |         "components" : {
 7 |           "alpha" : "1.000",
 8 |           "blue" : "0",
 9 |           "green" : "0",
10 |           "red" : "0"
11 |         }
12 |       },
13 |       "idiom" : "universal"
14 |     }
15 |   ],
16 |   "info" : {
17 |     "author" : "xcode",
18 |     "version" : 1
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/Mastermind/MastermindApp.swift:
--------------------------------------------------------------------------------
 1 | import SwiftUI
 2 | 
 3 | @main
 4 | struct ProductionApp: App {
 5 |     var body: some Scene {
 6 |         WindowGroup {
 7 |             if isProduction {
 8 |                 GameScreen(game: try! Game(numberOfCodeChoices: 4, secretSize: 4, numberOfRounds: 10, SecretMaker()))
 9 |             }
10 |         }
11 |     }
12 | 
13 |     private var isProduction: Bool {
14 |         NSClassFromString("XCTestCase") == nil
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/Mastermind/Assets.xcassets/Background.colorset/Contents.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "colors" : [
 3 |     {
 4 |       "color" : {
 5 |         "color-space" : "srgb",
 6 |         "components" : {
 7 |           "alpha" : "1.000",
 8 |           "blue" : "234",
 9 |           "green" : "231",
10 |           "red" : "227"
11 |         }
12 |       },
13 |       "idiom" : "universal"
14 |     }
15 |   ],
16 |   "info" : {
17 |     "author" : "xcode",
18 |     "version" : 1
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/Mastermind/Assets.xcassets/Pegs/Misplaced.colorset/Contents.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "colors" : [
 3 |     {
 4 |       "color" : {
 5 |         "color-space" : "srgb",
 6 |         "components" : {
 7 |           "alpha" : "1.000",
 8 |           "blue" : "255",
 9 |           "green" : "255",
10 |           "red" : "255"
11 |         }
12 |       },
13 |       "idiom" : "universal"
14 |     }
15 |   ],
16 |   "info" : {
17 |     "author" : "xcode",
18 |     "version" : 1
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/Mastermind/Assets.xcassets/Unselected.colorset/Contents.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "colors" : [
 3 |     {
 4 |       "color" : {
 5 |         "color-space" : "srgb",
 6 |         "components" : {
 7 |           "alpha" : "1.000",
 8 |           "blue" : "198",
 9 |           "green" : "195",
10 |           "red" : "185"
11 |         }
12 |       },
13 |       "idiom" : "universal"
14 |     }
15 |   ],
16 |   "info" : {
17 |     "author" : "xcode",
18 |     "version" : 1
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/Mastermind/Assets.xcassets/Pegs/Unselected.colorset/Contents.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "colors" : [
 3 |     {
 4 |       "color" : {
 5 |         "color-space" : "srgb",
 6 |         "components" : {
 7 |           "alpha" : "1.000",
 8 |           "blue" : "198",
 9 |           "green" : "195",
10 |           "red" : "185"
11 |         }
12 |       },
13 |       "idiom" : "universal"
14 |     }
15 |   ],
16 |   "info" : {
17 |     "author" : "xcode",
18 |     "version" : 1
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/Rounds.swift:
--------------------------------------------------------------------------------
 1 | final class Rounds {
 2 |     private let rounds: [Round]
 3 | 
 4 |     init(secretSize: Int, numberOfRounds: Int) {
 5 |         self.rounds = (1...numberOfRounds).map {
 6 |             roundNumber in Round(secretSize: secretSize, roundNumber: RoundNumber(value: roundNumber))
 7 |         }
 8 |     }
 9 | 
10 |     var count: Int { rounds.count }
11 | 
12 |     func round(_ roundNumber: RoundNumber) -> Round {
13 |         rounds[roundNumber.index]
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/Mastermind/UI/FeedbackPeg+Color.swift:
--------------------------------------------------------------------------------
 1 | import SwiftUI
 2 | 
 3 | extension FeedbackPeg {
 4 |     func feedbackColor() -> Color {
 5 |         switch self {
 6 |         case .empty:
 7 |             return .Pegs.unselected
 8 |         case .correct:
 9 |             return .Pegs.correct
10 |         case .misplaced:
11 |             return .Pegs.misplaced
12 |         }
13 |     }
14 | 
15 |     func colorAroundPegToShowThatPegIsFilled() -> Color {
16 |         if self == .empty { return Color.clear }
17 |         return feedbackColor()
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/.windsurf/processes/BashScripts.process.md:
--------------------------------------------------------------------------------
 1 | # Bash Script Style Process
 2 | 
 3 | STARTER_CHARACTER =💻
 4 | 
 5 | - Use `#!/usr/bin/env bash` as shebang.
 6 | - Always use `set -euo pipefail` for safety and debugging.
 7 | - Keep scripts minimal: no unnecessary comments or echoes.
 8 | - Only do minimal input validation; print a usage message to stderr and exit if inputs are missing or invalid.
 9 | - Do not check for installed commands if failure will be obvious on use.
10 | - Make script executable: `chmod +x <script>`.
11 | - Prefer concise, direct logic over verbosity.
12 | 


--------------------------------------------------------------------------------
/Mastermind/UI/RoundView.swift:
--------------------------------------------------------------------------------
 1 | import SwiftUI
 2 | 
 3 | struct RoundView: View {
 4 |     private var game: Game
 5 |     private let roundNumber: RoundNumber
 6 | 
 7 |     init(game: Game, roundNumber: RoundNumber = RoundNumber(value: 1)) {
 8 |         self.game = game
 9 |         self.roundNumber = roundNumber
10 |     }
11 | 
12 |     var body: some View {
13 |         HStack {
14 |             CodeGuessView(round: game.rounds.round(roundNumber))
15 |             FeedbackView(feedbackPegs: game.rounds.round(roundNumber).feedbackPegs)
16 |         }
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/SecretMaker.swift:
--------------------------------------------------------------------------------
 1 | struct SecretMaker {
 2 |     static func createNull() -> SecretMaker {
 3 |         var secretMaker = SecretMaker()
 4 |         secretMaker.isNull = true
 5 |         return secretMaker
 6 |     }
 7 | 
 8 |     private var isNull = false
 9 | 
10 |     func makeSecret(from codeChoices: CodeChoices, secretSize: Int) -> Secret {
11 |         assert(0 < secretSize)
12 |         assert(secretSize <= codeChoices.options.count)
13 | 
14 |         let colors = isNull ? codeChoices.options : codeChoices.options.shuffled()
15 |         return Secret(code: Array(colors.prefix(secretSize)))
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/Mastermind/UI/Tests/FeedbackPeg+ColorTests.swift:
--------------------------------------------------------------------------------
 1 | @testable import Mastermind
 2 | import SwiftUI
 3 | import Testing
 4 | 
 5 | final class FeedbackPeg_ColorTests: @unchecked Sendable {
 6 |     @Test
 7 |     func colorAroundPegToShowThatPegIsFilled_forEmptyPeg() async throws {
 8 |         let sut = FeedbackPeg.empty
 9 |         let color = sut.colorAroundPegToShowThatPegIsFilled()
10 |         #expect(color == Color.clear)
11 |     }
12 | 
13 |     @Test(arguments: [FeedbackPeg.correct, FeedbackPeg.misplaced])
14 |     func colorAroundPegToShowThatPegIsFilled_forFilledPeg(sut: FeedbackPeg) async throws {
15 |         let color = sut.colorAroundPegToShowThatPegIsFilled()
16 |         #expect(color == sut.feedbackColor())
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/Mastermind/UI/InspectableSheet.swift:
--------------------------------------------------------------------------------
 1 | import SwiftUI
 2 | 
 3 | extension View {
 4 |     func inspectableSheet<Sheet>(isPresented: Binding<Bool>, onDismiss: (() -> Void)? = nil, @ViewBuilder content: @escaping () -> Sheet
 5 |     ) -> some View where Sheet: View {
 6 |         return self.modifier(InspectableSheet(isPresented: isPresented, onDismiss: onDismiss, popupBuilder: content))
 7 |     }
 8 | }
 9 | 
10 | struct InspectableSheet<Sheet>: ViewModifier where Sheet: View {
11 |     let isPresented: Binding<Bool>
12 |     let onDismiss: (() -> Void)?
13 |     let popupBuilder: () -> Sheet
14 | 
15 |     func body(content: Self.Content) -> some View {
16 |         content.sheet(isPresented: isPresented, onDismiss: onDismiss, content: popupBuilder)
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/MastermindTests.xctestplan:
--------------------------------------------------------------------------------
 1 | {
 2 |   "configurations" : [
 3 |     {
 4 |       "id" : "2CA07FD1-6ECE-47A5-A107-3C4F9760B650",
 5 |       "name" : "Test Scheme Action",
 6 |       "options" : {
 7 | 
 8 |       }
 9 |     }
10 |   ],
11 |   "defaultOptions" : {
12 |     "codeCoverage" : false,
13 |     "targetForVariableExpansion" : {
14 |       "containerPath" : "container:Mastermind.xcodeproj",
15 |       "identifier" : "0F7025142B72E88B006327F4",
16 |       "name" : "Mastermind"
17 |     }
18 |   },
19 |   "testTargets" : [
20 |     {
21 |       "target" : {
22 |         "containerPath" : "container:Mastermind.xcodeproj",
23 |         "identifier" : "0F7025292B72E913006327F4",
24 |         "name" : "MastermindTests"
25 |       }
26 |     }
27 |   ],
28 |   "version" : 1
29 | }
30 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/Feedback.swift:
--------------------------------------------------------------------------------
 1 | struct Feedback {
 2 |     let totalCount: Int
 3 |     let inCorrectPosition: Int
 4 |     let inWrongPosition: Int
 5 | 
 6 |     static func initial(size: Int) -> Feedback {
 7 |         Feedback(totalCount: size, inCorrectPosition: 0, inWrongPosition: 0)
 8 |     }
 9 | 
10 |     var pegs: [FeedbackPeg] {
11 |        var result: [FeedbackPeg] = []
12 |        result.append(contentsOf: Array.init(repeating: .correct, count: inCorrectPosition))
13 |        result.append(contentsOf: Array.init(repeating: .misplaced, count: inWrongPosition))
14 |        result.append(
15 |            contentsOf: Array.init(
16 |                repeating: .empty,
17 |                count: totalCount - inCorrectPosition - inWrongPosition
18 |            )
19 |        )
20 |        return result
21 |    }
22 | }
23 | 


--------------------------------------------------------------------------------
/Mastermind/UI/Tests/InspectChangingView.swift:
--------------------------------------------------------------------------------
 1 | // TestableView by Jon Reid, https://qualitycoding.org
 2 | // Copyright 2024 Jonathan M. Reid. https://github.com/jonreid/TestableView/blob/main/LICENSE.txt
 3 | // SPDX-License-Identifier: MIT
 4 | 
 5 | @testable import Mastermind
 6 | import ViewInspector
 7 | import XCTest
 8 | 
 9 | extension XCTestCase {
10 |     @MainActor
11 |     func inspectChangingView<V: TestableView>(
12 |         _ sut: inout V,
13 |         action: @escaping ((InspectableView<ViewType.View<V>>) throws -> Void),
14 |         file: StaticString = #filePath,
15 |         line: UInt = #line
16 |     ) {
17 |         let expectation = sut.on(\.viewInspectorHook, file: file, line: line, perform: action)
18 |         ViewHosting.host(view: sut)
19 |         wait(for: [expectation], timeout: 0.4)
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/Tests/GameTests.swift:
--------------------------------------------------------------------------------
 1 | @testable import Mastermind
 2 | import XCTest
 3 | 
 4 | final class GameTests: XCTestCase {
 5 |     func test_isObservable_soThatViewsCanObserveChanges() throws {
 6 |         let sut = try makeSUT()
 7 | 
 8 |         XCTAssertTrue(sut is (any Observable))
 9 |     }
10 | 
11 |     func test_gameHasNoSecretInitially() throws {
12 |         let sut = try makeSUT()
13 | 
14 |         XCTAssertEqual(sut.secret.testHooks.code, [])
15 |     }
16 | 
17 |     func test_makeNewSecret() throws {
18 |         let sut = try makeSUT()
19 | 
20 |         sut.makeNewSecret()
21 | 
22 |         XCTAssertEqual(sut.secret.testHooks.code.first, sut.codeChoices.options.first)
23 |     }
24 | 
25 |     private func makeSUT() throws -> Game {
26 |         try Game(numberOfCodeChoices: 4, secretSize: 4, numberOfRounds: 1, SecretMaker.createNull())
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/Mastermind/UI/CheckButton.swift:
--------------------------------------------------------------------------------
 1 | import SwiftUI
 2 | 
 3 | struct CheckButton: View {
 4 |     let action: () -> Void
 5 | 
 6 |     @Environment(\.isEnabled)
 7 |     private var isEnabled: Bool
 8 | 
 9 |     var body: some View {
10 |         Button(action: {
11 |             action()
12 |         }, label: {
13 |             RoundedRectangle(cornerRadius: 10)
14 |                 .fill(isEnabled ? .blue : .unselected)
15 |                 .frame(width: .infinity, height: 100)
16 |                 .overlay(
17 |                     Text("Check")
18 |                         .foregroundColor(.white)
19 |                         .font(.subheadline)
20 |                 )
21 |         })
22 |         .accessibilityIdentifier("checkButton")
23 |     }
24 | }
25 | 
26 | #Preview {
27 |     VStack {
28 |         CheckButton(action: {}).disabled(false)
29 |     }.frame(width: 50)
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/CodeChoice.swift:
--------------------------------------------------------------------------------
 1 | import SwiftUI
 2 | 
 3 | struct CodeChoice: Equatable {
 4 |     let color: Color
 5 |     let codeValue: Int
 6 | }
 7 | 
 8 | struct CodeChoices {
 9 |     let options: [CodeChoice]
10 | }
11 | 
12 | enum CodeChoiceGeneratorError: Error {
13 |     case notEnoughColors
14 | }
15 | 
16 | struct CodeChoiceGenerator {
17 |     static func generate(from colors: [Color], take count: Int) throws -> CodeChoices {
18 |         guard colors.count >= count else {
19 |             throw CodeChoiceGeneratorError.notEnoughColors
20 |         }
21 |         let result = colors.prefix(count).enumerated().map { index, color in
22 |             CodeChoice(color: color, codeValue: index + 1)
23 |         }
24 |         return CodeChoices(options: result)
25 |     }
26 | 
27 | }
28 | 
29 | let codeColors: [Color] = [.brown, .black, .blue, .green, .yellow, .orange, .red, .gray]
30 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/Tests/CodeChoiceTests.swift:
--------------------------------------------------------------------------------
 1 | @testable import Mastermind
 2 | import XCTest
 3 | 
 4 | final class CodeChoiceTests: XCTestCase {
 5 |     func test_generateOneCodeChoice() throws {
 6 |         let result = try CodeChoiceGenerator.generate(from: [.red, .blue], take: 1).options
 7 |         XCTAssertEqual(result, [
 8 |             CodeChoice(color: .red, codeValue: 1),
 9 |         ])
10 |     }
11 | 
12 |     func test_generateTwoCodeChoices() throws {
13 |         let result = try CodeChoiceGenerator.generate(from: [.red, .blue], take: 2).options
14 |         XCTAssertEqual(result, [
15 |             CodeChoice(color: .red, codeValue: 1),
16 |             CodeChoice(color: .blue, codeValue: 2),
17 |         ])
18 |     }
19 | 
20 |     func test_notEnoughColorsIsAnError() throws {
21 |         XCTAssertThrowsError(
22 |             try CodeChoiceGenerator.generate(from: [.red, .blue], take: 3).options
23 |         )
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Mastermind/UI/CodeGuessView.swift:
--------------------------------------------------------------------------------
 1 | import SwiftUI
 2 | 
 3 | struct CodeGuessView: View {
 4 |     let round: Round
 5 | 
 6 |     var body: some View {
 7 |         HStack {
 8 |             Text("\(round.roundNumber.value)").accessibilityIdentifier("roundNumber")
 9 |             ForEach(0 ..< round.pegCount, id: \.self) { pegIndex in
10 |                 Button(action: {}, label: {
11 |                     Circle()
12 |                         .padding(5)
13 |                         .overlay(
14 |                             Circle()
15 |                                 .strokeBorder(Color.unselected, lineWidth: 2)
16 |                         )
17 |                         .foregroundColor(round[pegIndex]?.color ?? Color.unselected)
18 |                         .frame(width: 40, height: 40)
19 |                 })
20 |                 .id("guess\(round.roundNumber.value)-\(pegIndex + 1)")
21 |             }
22 |         }.accessibilityIdentifier("round\(round.roundNumber.value)")
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/Mastermind/UI/Tests/CheckButtonSnapshotTests.swift:
--------------------------------------------------------------------------------
 1 | @testable import Mastermind
 2 | import SnapshotTesting
 3 | import SwiftUI
 4 | import Testing
 5 | 
 6 | @MainActor
 7 | final class CheckButtonSnapshotTests: @unchecked Sendable {
 8 |     @Test
 9 |     func disabledColor() async throws {
10 |         let view = makeSUT(true)
11 |         assertSnapshot(of: view.toVC(), as: prettyDarnClose())
12 |     }
13 | 
14 |     @Test
15 |     func enabledColor() async throws {
16 |         let view = makeSUT(false)
17 |         assertSnapshot(of: view.toVC(), as: prettyDarnClose())
18 |     }
19 | 
20 |     private func makeSUT(_ disabled: Bool) -> some View {
21 |         VStack {
22 |             CheckButton(action: {}).disabled(disabled)
23 |         }.frame(width: 50)
24 |     }
25 | 
26 |     private func prettyDarnClose() -> Snapshotting<UIViewController, UIImage> {
27 |         .image(precision: 0.99)
28 |     }
29 | }
30 | 
31 | extension SwiftUI.View {
32 |     func toVC() -> UIViewController {
33 |         let vc = UIHostingController(rootView: self)
34 |         vc.view.frame = UIScreen.main.bounds
35 |         return vc
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/.github/workflows/build.yml:
--------------------------------------------------------------------------------
 1 | name: Build
 2 | 
 3 | on:
 4 |   workflow_dispatch:
 5 |   push:
 6 |     branches: [ main ]
 7 |   pull_request:
 8 |     branches: [ main ]
 9 | 
10 | concurrency:
11 |   group: ${{ github.workflow }}-${{ github.ref }}
12 |   cancel-in-progress: true
13 | 
14 | jobs:
15 |   build:
16 |     name: Build and test
17 |     runs-on: macos-15
18 |     steps:
19 |     - uses: actions/checkout@v5
20 |     - name: List runner info
21 |       run: sw_vers && arch
22 |     - name: List available Xcode versions
23 |       run: ls /Applications | grep Xcode
24 |     - name: Set up Xcode version
25 |       run: sudo xcode-select -s /Applications/Xcode_16.3.0.app/Contents/Developer
26 |     - name: Show current version of Xcode
27 |       run: xcodebuild -version
28 |     - name: Build and test
29 |       run: ./build_and_test.sh
30 | 
31 |   build-release:
32 |     name: Build release
33 |     runs-on: macos-15
34 |     steps:
35 |     - uses: actions/checkout@v5
36 |     - name: Set up Xcode version
37 |       run: sudo xcode-select -s /Applications/Xcode_16.3.0.app/Contents/Developer
38 |     - name: Build
39 |       run: ./build_release.sh
40 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2023 Jonathan M. Reid
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Mastermind.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved:
--------------------------------------------------------------------------------
 1 | {
 2 |   "originHash" : "6192eb3ecd877604784e6f454fe23d94cd3508d1b90abde66134b16cdb0aa8b7",
 3 |   "pins" : [
 4 |     {
 5 |       "identity" : "swift-snapshot-testing",
 6 |       "kind" : "remoteSourceControl",
 7 |       "location" : "https://github.com/pointfreeco/swift-snapshot-testing.git",
 8 |       "state" : {
 9 |         "revision" : "42a086182681cf661f5c47c9b7dc3931de18c6d7",
10 |         "version" : "1.17.6"
11 |       }
12 |     },
13 |     {
14 |       "identity" : "swift-syntax",
15 |       "kind" : "remoteSourceControl",
16 |       "location" : "https://github.com/swiftlang/swift-syntax",
17 |       "state" : {
18 |         "revision" : "0687f71944021d616d34d922343dcef086855920",
19 |         "version" : "600.0.1"
20 |       }
21 |     },
22 |     {
23 |       "identity" : "viewinspector",
24 |       "kind" : "remoteSourceControl",
25 |       "location" : "https://github.com/nalexn/ViewInspector.git",
26 |       "state" : {
27 |         "revision" : "a6fcac8485bc8f57b2d2b55bb6d97138e8659e4b",
28 |         "version" : "0.10.2"
29 |       }
30 |     }
31 |   ],
32 |   "version" : 3
33 | }
34 | 


--------------------------------------------------------------------------------
/Mastermind/UI/FeedbackView.swift:
--------------------------------------------------------------------------------
 1 | import SwiftUI
 2 | 
 3 | struct FeedbackView: View {
 4 |     let feedbackPegs: [FeedbackPeg]
 5 | 
 6 |     var body: some View {
 7 |         Grid {
 8 |             GridRow {
 9 |                 pegView(0)
10 |                 pegView(1)
11 |             }
12 |             GridRow {
13 |                 pegView(2)
14 |                 pegView(3)
15 |             }
16 |         }
17 |     }
18 | 
19 |     private func pegView(_ index: Int) -> some View {
20 |         FeedbackPegView(feedbackPeg: feedbackPegs[index])
21 |             .accessibilityIdentifier("feedback\(index + 1)")
22 |     }
23 | }
24 | 
25 | private struct FeedbackPegView: View {
26 |     let feedbackPeg: FeedbackPeg
27 | 
28 |     var body: some View {
29 |         Circle()
30 |             .foregroundColor(feedbackPeg.feedbackColor())
31 |             .frame(width: 10, height: 10)
32 |             .overlay(
33 |                 Circle()
34 |                     .stroke(feedbackPeg.colorAroundPegToShowThatPegIsFilled(), lineWidth: 3)
35 |             )
36 |     }
37 | }
38 | 
39 | #Preview {
40 |     FeedbackView(feedbackPegs: [.correct, .misplaced, .misplaced, .empty])
41 |         .background(Color.blue)
42 | }
43 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/Round.swift:
--------------------------------------------------------------------------------
 1 | import Observation
 2 | 
 3 | @Observable
 4 | final class Round {
 5 |     private var guess: [CodeChoice?]
 6 |     var feedbackPegs: [FeedbackPeg]
 7 |     let roundNumber: RoundNumber
 8 | 
 9 |     init(secretSize: Int, roundNumber: RoundNumber) {
10 |         self.roundNumber = roundNumber
11 |         guess = Array(repeating: nil, count: secretSize)
12 |         feedbackPegs = Feedback.initial(size: secretSize).pegs
13 |     }
14 | 
15 |     var pegCount: Int {
16 |         guess.count
17 |     }
18 | 
19 |     var isComplete: Bool {
20 |         !guess.contains { $0 == nil }
21 |     }
22 | 
23 |     subscript(index: Int) -> CodeChoice? {
24 |         get {
25 |             return guess[index]
26 |         }
27 |         set {
28 |             guess[index] = newValue
29 |         }
30 |     }
31 | 
32 |     func placeChoiceInNextSlot(_ choice: CodeChoice) {
33 |         guard let index = guess.firstIndex(of: nil) else { return }
34 |         guess[index] = choice
35 |     }
36 | 
37 |     func contains(_ choice: CodeChoice) -> Bool {
38 |         guess.contains { $0 == choice }
39 |     }
40 | 
41 |     func score(for secret: Secret) {
42 |         feedbackPegs = secret.evaluate(self).pegs
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/Mastermind/UI/Tests/RoundViewTests.swift:
--------------------------------------------------------------------------------
 1 | @testable import Mastermind
 2 | import ViewInspector
 3 | import XCTest
 4 | 
 5 | @MainActor
 6 | final class RoundViewTests: XCTestCase, Sendable {
 7 |     func test_showsRoundNumber1() throws {
 8 |         let sut = try makeSUT(round: 1)
 9 | 
10 |         let roundNumberView = try sut.inspect().round()
11 |         XCTAssertEqual(try roundNumberView.string(), "1")
12 |     }
13 | 
14 |     func test_showsRoundNumber2() throws {
15 |         let sut = try makeSUT(round: 2)
16 | 
17 |         let roundNumberView = try sut.inspect().round()
18 |         XCTAssertEqual(try roundNumberView.string(), "2")
19 |     }
20 | 
21 |     private func makeSUT(round: Int) throws -> RoundView {
22 |         let game = try Game(numberOfCodeChoices: 4, secretSize: 4, numberOfRounds: 2, SecretMaker.createNull())
23 |         game.makeNewSecret()
24 |         return RoundView(game: game, roundNumber: RoundNumber(value: round))
25 |     }
26 | }
27 | 
28 | private extension InspectableView {
29 |     func round(file: StaticString = #filePath, line: UInt = #line) throws -> InspectableView<ViewType.Text> {
30 |         try findView(accessibilityIdentifier: "roundNumber", file: file, line: line).text()
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | DerivedData/
 2 | 
 3 | # Created by https://www.toptal.com/developers/gitignore/api/macos,xcode
 4 | # Edit at https://www.toptal.com/developers/gitignore?templates=macos,xcode
 5 | 
 6 | ### macOS ###
 7 | # General
 8 | .DS_Store
 9 | .AppleDouble
10 | .LSOverride
11 | 
12 | # Icon must end with two \r
13 | Icon
14 | 
15 | 
16 | # Thumbnails
17 | ._*
18 | 
19 | # Files that might appear in the root of a volume
20 | .DocumentRevisions-V100
21 | .fseventsd
22 | .Spotlight-V100
23 | .TemporaryItems
24 | .Trashes
25 | .VolumeIcon.icns
26 | .com.apple.timemachine.donotpresent
27 | 
28 | # Directories potentially created on remote AFP share
29 | .AppleDB
30 | .AppleDesktop
31 | Network Trash Folder
32 | Temporary Items
33 | .apdisk
34 | 
35 | ### macOS Patch ###
36 | # iCloud generated files
37 | *.icloud
38 | 
39 | ### Xcode ###
40 | ## User settings
41 | xcuserdata/
42 | 
43 | ## Xcode 8 and earlier
44 | *.xcscmblueprint
45 | *.xccheckout
46 | 
47 | ### Xcode Patch ###
48 | *.xcodeproj/*
49 | !*.xcodeproj/project.pbxproj
50 | !*.xcodeproj/xcshareddata/
51 | !*.xcodeproj/project.xcworkspace/
52 | !*.xcworkspace/contents.xcworkspacedata
53 | /*.gcno
54 | **/xcshareddata/WorkspaceSettings.xcsettings
55 | 
56 | # End of https://www.toptal.com/developers/gitignore/api/macos,xcode


--------------------------------------------------------------------------------
/.windsurf/processes/TDD.creating_tests.process.md:
--------------------------------------------------------------------------------
 1 | # TDD Creating Tests Process
 2 | 
 3 | STARTER_CHARACTER = 🔴
 4 | 
 5 | **ALWAYS** ask the user one question at a time and wait for a response.
 6 | 
 7 | **ALWAYS** confirm file names and locations if unsure.
 8 | 
 9 | **NEVER** make changes to production code in this process.
10 | 
11 | This process is for creating unit tests for a new feature or bug fix. All production code changes will happen later.
12 | 
13 | ## Steps
14 | 
15 | 1. Ask if we are starting new work or resuming work in progress. If resuming, ask which step to continue from and display the steps.
16 | 2. Ask if we are creating a new feature or fixing a bug.
17 | 3. Ask for an example scenario (this can be a file or a description).
18 | 4. Suggest a list of test scenarios (titles only) to cover. Confirm with the user.
19 | 5. Create the test file (or confirm the file in use). Validate the name and location.
20 | 6. Write the outer test functions for each scenario (titles only, no implementation), all commented out.
21 | 7. Validate the test list with the user.
22 | 8. Commit.
23 | 
24 | **Tip:** When resuming, always clarify which step you are on and offer to show the steps.
25 | 
26 | ---
27 | 
28 | This process is designed for clarity and speed — focus on writing tests in the way you want to use the feature, even before the implementation exists.
29 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/Game.swift:
--------------------------------------------------------------------------------
 1 | import SwiftUI
 2 | 
 3 | @Observable
 4 | final class Game {
 5 |     private let secretMaker: SecretMaker
 6 |     let secretSize: Int
 7 |     let codeChoices: CodeChoices
 8 |     var rounds: Rounds
 9 |     var secret = Secret(code: [])
10 | 
11 |     var canBeValidated: Bool {
12 |         rounds.round(RoundNumber(value: 1)).isComplete
13 |     }
14 | 
15 |     var isWin: Bool {
16 |         secret.matches(rounds.round(RoundNumber(value: 1)))
17 |     }
18 | 
19 |     init(numberOfCodeChoices: Int, secretSize: Int, numberOfRounds: Int, _ secretMaker: SecretMaker) throws {
20 |         self.secretMaker = secretMaker
21 |         self.secretSize = secretSize
22 |         try codeChoices = CodeChoiceGenerator.generate(from: codeColors, take: numberOfCodeChoices)
23 |         rounds = Rounds(secretSize: secretSize, numberOfRounds: numberOfRounds)
24 |     }
25 | 
26 |     func codeChoice(_ index: Int) -> CodeChoice {
27 |         return codeChoices.options[index]
28 |     }
29 | 
30 |     func makeNewSecret() {
31 |         secret = secretMaker.makeSecret(from: codeChoices, secretSize: secretSize)
32 |     }
33 | 
34 |     func isGuessCorrect(_ guess: [CodeChoice]) -> Bool {
35 |         secret.isGuessCorrect(guess)
36 |     }
37 | 
38 |     func score() {
39 |         rounds.round(RoundNumber(value: 1)).score(for: secret)
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/.windsurf/processes/TDD.implement_production.process.md:
--------------------------------------------------------------------------------
 1 | # TDD Production Code Implementation Process
 2 | 
 3 | STARTER_CHARACTER = 🟢
 4 | 
 5 | **ALWAYS** ask the user one question at a time and wait for a response.
 6 | 
 7 | **ALWAYS** confirm file names and locations if unsure.
 8 | 
 9 | **NEVER** make changes to Test code in this process.
10 | 
11 | This process is for implementing production code for a new feature or bug fix.
12 | 
13 | 
14 | ## Steps
15 | 1. If needed, confirm the relevant test file and its location.
16 | 2. Repeat the following until all tests pass:
17 |    - Uncomment one test and implement it.
18 |    - Run the tests.
19 |    - Identify the first failing test.
20 |    - Show test results and ask to inspect the failure.
21 |    - Implement only the production code necessary to make that test pass.
22 |    - Run the tests again.
23 |    - After each successful run, ask me if I would like to commit.
24 | 3. When all tests pass, recommend a final commit or review.
25 | 
26 | ## Code Style
27 | - Prefer code that is self-explanatory and easy to read over comments.
28 | - Use functional helper methods instead of long methods.
29 | 
30 | ## SwiftUI Testing Approach
31 | 
32 | For SwiftUI tests, work in two phases:
33 | 1. **Phase 1:** Focus on finding the target element/subview - getting this to pass is sufficient work
34 | 2. **Phase 2:** Once the element is found, write the remaining test code to query and verify it
35 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/Tests/SecretTests.swift:
--------------------------------------------------------------------------------
 1 | @testable import Mastermind
 2 | import XCTest
 3 | 
 4 | final class SecretTests: XCTestCase {
 5 |     private let red = CodeChoice(color: .red, codeValue: 1)
 6 |     private let green = CodeChoice(color: .green, codeValue: 2)
 7 |     private let blue = CodeChoice(color: .blue, codeValue: 3)
 8 | 
 9 |     func test_secretMatchesGuess() throws {
10 |         let secret = Secret(code: [red, green])
11 |         let guess = Round(secretSize: 2, roundNumber: RoundNumber(value: 1))
12 |         guess.placeChoiceInNextSlot(red)
13 |         guess.placeChoiceInNextSlot(green)
14 | 
15 |         XCTAssertTrue(secret.matches(guess))
16 |     }
17 | 
18 |     func test_secretDoesNotMatchGuess() throws {
19 |         let secret = Secret(code: [red, green])
20 |         let guess = Round(secretSize: 2, roundNumber: RoundNumber(value: 1))
21 |         guess.placeChoiceInNextSlot(red)
22 |         guess.placeChoiceInNextSlot(blue)
23 | 
24 |         XCTAssertFalse(secret.matches(guess))
25 |     }
26 | 
27 |     func test_secretDoesNotMatchGuessOfDifferentSize() throws {
28 |         let secret = Secret(code: [red, green])
29 |         let guess = Round(secretSize: 4, roundNumber: RoundNumber(value: 1))
30 |         guess.placeChoiceInNextSlot(red)
31 | 
32 |         XCTAssertFalse(secret.matches(guess))
33 |     }
34 | 
35 |     func test_describesSecret() throws {
36 |         let secret = Secret(code: [red, green])
37 | 
38 |         XCTAssertEqual(secret.description, "red, green")
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/.windsurf/processes/TDD.refactoring.process.md:
--------------------------------------------------------------------------------
 1 | # TDD Refactoring Process
 2 | 
 3 | STARTER_CHARACTER = 🟣
 4 | 
 5 | **ALWAYS** ask the user one question at a time and wait for a response.
 6 | 
 7 | **ALWAYS** confirm file names and locations if unsure.
 8 | 
 9 | **NEVER** make changes to both production code and test code in this process.
10 | 
11 | This process is for refactoring production code, or for refactoring test code. Never both.
12 | 
13 | 
14 | ## Running tests when refactoring
15 | 
16 | - When we are in the refactoring phase, **always** ask me to run tests in Xcode because it's faster. If it fails, I will ask you to run them in the terminal.
17 | - Ask me to do this by getting my attention with your voice, saying "Run the tests in Xcode"
18 | 
19 | ## Steps
20 | Confirm the relevant test file and its location before starting.
21 | 
22 | For each refactoring:
23 | 
24 | 1. Ask me if we are refactoring production code or test code.
25 | 2. Ask me to check that tests pass before the change.
26 | 3. Choose and perform the simplest possible refactoring (one at a time).
27 | 4. Ask me to confirm that tests pass after the change.
28 | 5. Ask if I am ready to commit, or if I want to make more changes and go back to step 2. 
29 | 6. Provide a status update after each refactor.
30 | 
31 | If a refactoring fails three times or no further refactoring is found, pause and check with the user.
32 | 
33 | ## Code Style
34 | - Prefer self-explanatory, readable code over comments.
35 | - Use functional helper methods for clarity.
36 | - Remove comments and dead code.
37 | - Extract paragraphs into methods.
38 | - Use better variable names.
39 | - Remove unused imports.
40 | - Remove unhelpful local variables.
41 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/Tests/SecretMakerTests.swift:
--------------------------------------------------------------------------------
 1 | @testable import Mastermind
 2 | import XCTest
 3 | 
 4 | final class SecretMakerTests: XCTestCase {
 5 |     func test_nullable() throws {
 6 |         let codeChoices = try makeCodeChoices()
 7 |         let sut = SecretMaker.createNull()
 8 | 
 9 |         let result = sut.makeSecret(from: codeChoices, secretSize: 8)
10 | 
11 |         XCTAssertEqual(result.testHooks.code, codeChoices.options)
12 |     }
13 | 
14 |     func test_useSecretSize() throws {
15 |         let codeChoices = try makeCodeChoices()
16 |         let sut = SecretMaker.createNull()
17 | 
18 |         let result = sut.makeSecret(from: codeChoices, secretSize: 2)
19 | 
20 |         XCTAssertEqual(result.testHooks.code, Array(codeChoices.options.prefix(2)))
21 |     }
22 | 
23 |     func test_containsAllCodeChoices() throws {
24 |         let codeChoices = try makeCodeChoices()
25 |         let sut = SecretMaker()
26 | 
27 |         let result = sut.makeSecret(from: codeChoices, secretSize: 8)
28 | 
29 |         XCTAssertEqual(result.testHooks.code.count, codeChoices.options.count)
30 |         XCTAssertTrue(
31 |             codeChoices.options.allSatisfy({ result.testHooks.code.contains($0) }),
32 |             "Expected \(result.testHooks.code.map(\.color)) to contain all elements of \(codeChoices.options.map(\.color))"
33 |         )
34 |     }
35 | 
36 |     func test_shufflesCodeChoices() throws {
37 |         let codeChoices = try makeCodeChoices()
38 |         let sut = SecretMaker()
39 | 
40 |         for _ in 0..<100 {
41 |             let result = sut.makeSecret(from: codeChoices, secretSize: 8)
42 |             if result.testHooks.code != codeChoices.options {
43 |                 return
44 |             }
45 |         }
46 |         XCTFail("Failed to shuffle code choices after 100 attempts")
47 |     }
48 | 
49 |     private func makeCodeChoices() throws -> CodeChoices {
50 |         return try CodeChoiceGenerator.generate(from: codeColors, take: 8)
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/Secret.swift:
--------------------------------------------------------------------------------
 1 | struct Secret: CustomStringConvertible {
 2 |     private let code: [CodeChoice]
 3 | 
 4 |     static func initialFeedback(size: Int) -> Feedback {
 5 |         Feedback(
 6 |             totalCount: size,
 7 |             inCorrectPosition: 0,
 8 |             inWrongPosition: 0
 9 |         )
10 |     }
11 | 
12 |     init(code: [CodeChoice]) {
13 |         self.code = code
14 |     }
15 | 
16 |     var description: String {
17 |         code.map(\.color.description).joined(separator: ", ")
18 |     }
19 | 
20 |     var size: Int {
21 |         code.count
22 |     }
23 | 
24 |     func evaluate(_ guess: Round) -> Feedback {
25 |         var inCorrectPosition = 0
26 |         var inWrongPosition = 0
27 |         for (index, secret) in code.enumerated() {
28 |             if guess[index] == secret {
29 |                 inCorrectPosition += 1
30 |             } else if guess.contains(secret) {
31 |                 inWrongPosition += 1
32 |             }
33 |         }
34 |         return Feedback(
35 |             totalCount: size,
36 |             inCorrectPosition: inCorrectPosition,
37 |             inWrongPosition: inWrongPosition
38 |         )
39 |     }
40 | 
41 | 
42 |     func matches(_ guess: Round) -> Bool {
43 |         guard code.count == guess.pegCount else {
44 |             return false
45 |         }
46 |         for (index, secret) in code.enumerated() {
47 |             if guess[index] != secret {
48 |                 return false
49 |             }
50 |         }
51 |         return true
52 |     }
53 | 
54 |     func isGuessCorrect(_ guess: [CodeChoice]) -> Bool {
55 |         return code == guess
56 |     }
57 | }
58 | 
59 | #if DEBUG
60 | extension Secret {
61 |     var testHooks: TestHooks { TestHooks(target: self) }
62 | 
63 |     struct TestHooks {
64 |         private let target: Secret
65 | 
66 |         fileprivate init(target: Secret) {
67 |             self.target = target
68 |         }
69 | 
70 |         var code: [CodeChoice] { target.code }
71 |     }
72 | }
73 | #endif
74 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/Tests/RoundTests.swift:
--------------------------------------------------------------------------------
 1 | @testable import Mastermind
 2 | import XCTest
 3 | 
 4 | final class RoundTests: XCTestCase {
 5 |     private let choice0 = CodeChoice(color: .red, codeValue: 1)
 6 |     private let choice1 = CodeChoice(color: .green, codeValue: 2)
 7 | 
 8 |     func test_createRound_setsGuessSize() throws {
 9 |         let sut = makeSUT(secretSize: 4)
10 | 
11 |         XCTAssertNil(sut[0])
12 |         XCTAssertNil(sut[1])
13 |         XCTAssertNil(sut[2])
14 |         XCTAssertNil(sut[3])
15 |     }
16 | 
17 |     func test_size() throws {
18 |         let sut = makeSUT(secretSize: 4)
19 | 
20 |         XCTAssertEqual(sut.pegCount, 4)
21 |     }
22 | 
23 |     func test_placeChoiceInNextSlot() throws {
24 |         let sut = makeSUT(secretSize: 2)
25 | 
26 |         sut.placeChoiceInNextSlot(choice0)
27 |         sut.placeChoiceInNextSlot(choice1)
28 | 
29 |         XCTAssertEqual(sut[0], choice0)
30 |         XCTAssertEqual(sut[1], choice1)
31 |     }
32 | 
33 |     func test_isObservable_soThatViewsCanObserveChanges() throws {
34 |         let sut = makeSUT(secretSize: 2)
35 | 
36 |         XCTAssertTrue(sut is (any Observable))
37 |     }
38 | 
39 |     func test_isNotComplete_withSecondSlotEmpty() throws {
40 |         let sut = makeSUT(secretSize: 2)
41 | 
42 |         sut.placeChoiceInNextSlot(choice0)
43 | 
44 |         XCTAssertFalse(sut.isComplete)
45 |     }
46 | 
47 |     func test_isNotComplete_withFirstSlotEmpty() throws {
48 |         let sut = makeSUT(secretSize: 2)
49 | 
50 |         sut[1] = choice1
51 | 
52 |         XCTAssertFalse(sut.isComplete)
53 |     }
54 | 
55 |     func test_isComplete_withAllSlotsFilled() throws {
56 |         let sut = makeSUT(secretSize: 2)
57 | 
58 |         sut.placeChoiceInNextSlot(choice0)
59 |         sut.placeChoiceInNextSlot(choice1)
60 | 
61 |         XCTAssertTrue(sut.isComplete)
62 |     }
63 | 
64 |     private func makeSUT(secretSize: Int) -> Round {
65 |         Round(secretSize: secretSize, roundNumber: RoundNumber(value: 1))
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/Mastermind/UI/Tests/FeedbackViewTests.swift:
--------------------------------------------------------------------------------
 1 | @testable import Mastermind
 2 | import SwiftUI
 3 | import ViewInspector
 4 | import XCTest
 5 | 
 6 | @MainActor
 7 | final class FeedbackViewTests: XCTestCase, Sendable {
 8 |     func test_pegColor() throws {
 9 |         let sut = makeSUT(.correct, .misplaced, .misplaced, .empty)
10 | 
11 |         let peg1Color = try sut.inspect().pegColor(1)
12 |         let peg2Color = try sut.inspect().pegColor(2)
13 |         let peg3Color = try sut.inspect().pegColor(3)
14 |         let peg4Color = try sut.inspect().pegColor(4)
15 | 
16 |         XCTAssertEqual(peg1Color, Color.Pegs.correct)
17 |         XCTAssertEqual(peg2Color, Color.Pegs.misplaced)
18 |         XCTAssertEqual(peg3Color, Color.Pegs.misplaced)
19 |         XCTAssertEqual(peg4Color, Color.Pegs.unselected)
20 |     }
21 | 
22 |     func test_colorAroundPegsShowingFilledVersusEmpty() throws {
23 |         let sut = makeSUT(.correct, .misplaced, .misplaced, .empty)
24 | 
25 |         let peg1Stroke = try sut.inspect().pegStrokeColor(1)
26 |         let peg2Stroke = try sut.inspect().pegStrokeColor(2)
27 |         let peg3Stroke = try sut.inspect().pegStrokeColor(3)
28 |         let peg4Stroke = try sut.inspect().pegStrokeColor(4)
29 | 
30 |         XCTAssertEqual(peg1Stroke, Color.Pegs.correct)
31 |         XCTAssertEqual(peg2Stroke, Color.Pegs.misplaced)
32 |         XCTAssertEqual(peg3Stroke, Color.Pegs.misplaced)
33 |         XCTAssertEqual(peg4Stroke, Color.clear)
34 |     }
35 | 
36 |     private func makeSUT(_ feedbackPegs: FeedbackPeg...) -> FeedbackView {
37 |         FeedbackView(feedbackPegs: feedbackPegs)
38 |     }
39 | }
40 | 
41 | private extension InspectableView {
42 |     func pegColor(_ peg: Int) throws -> Color? {
43 |         try pegShape(peg).foregroundColor()
44 |     }
45 | 
46 |     func pegStrokeColor(_ peg: Int, file: StaticString = #filePath, line: UInt = #line) throws -> Color? {
47 |         try pegShape(peg, file: file, line: line).overlay().shape().fillShapeStyle(Color.self)
48 |     }
49 | 
50 |     private func pegShape(
51 |         _ peg: Int,
52 |         file: StaticString = #filePath,
53 |         line: UInt = #line
54 |     ) throws -> InspectableView<ViewType.Shape> {
55 |         try findView(accessibilityIdentifier: "feedback\(peg)", file: file, line: line).shape()
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/.windsurf/rules/no-comments-in-tests.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | trigger: manual
 3 | ---
 4 | 
 5 | # No Comments in Tests
 6 | 
 7 | Tests must be self-explanatory through names, structure, and helpers—without comments. Comments in tests are prohibited.
 8 | 
 9 | ## Rationale
10 | - Comments in tests often hide unclear intent; we prefer clarity through code.
11 | - Descriptive names and small helpers communicate behavior better than prose.
12 | - Keeps tests tidy and consistent with TDD and Tidy First principles.
13 | 
14 | ## Scope
15 | - Applies to all test sources (unit, UI, integration) across the repository.
16 | - Applies to line comments and block comments (e.g., `//`, `/* ... */`).
17 | 
18 | ## Guidance: Preferred Alternatives
19 | - Use behavior-driven test names that read as specifications.
20 | - Structure tests into clear Arrange–Act–Assert sections using code, not comments.
21 | - Separate Arrange-Act-Assert sections with blank lines.
22 | - Extract expressive helpers and builders to eliminate the need for explanation.
23 | - Use data-driven cases where appropriate to avoid narrative comments.
24 | 
25 | ## Swift Examples
26 | 
27 | ### ❌ Not allowed (uses comments for structure)
28 | ```swift
29 | func test_makesNewRowActiveAfterCheck() {
30 |     // Arrange
31 |     let sut = GameScreenViewModel(rounds: .fixture())
32 |     // Act
33 |     sut.check()
34 |     // Assert
35 |     XCTAssertEqual(sut.activeRowIndex, 1)
36 | }
37 | ```
38 | 
39 | ### ✅ Allowed (structure via code; no comments)
40 | ```swift
41 | func test_makesNewRowActiveAfterCheck() {
42 |     let sut = GameScreenViewModel(rounds: .fixture())
43 | 
44 |     sut.check()
45 | 
46 |     XCTAssertEqual(sut.activeRowIndex, 1)
47 | }
48 | ```
49 | 
50 | ### ✅ Allowed (expressive helper conveys intent)
51 | ```swift
52 | func test_advancesToNextRow_afterCheck() {
53 |     let sut = makeSUTWithSingleUncheckedRow()
54 | 
55 |     check(sut)
56 | 
57 |     assertAdvancesToNextRow(sut)
58 | }
59 | ```
60 | 
61 | ## Exceptions
62 | - Temporarily allow comments in disabled or quarantined tests marked `@available(*, deprecated)` or `throw XCTSkip` blocks when explaining why the test is skipped. Remove before re-enabling.
63 | 
64 | ## Enforcement
65 | - Code review should reject tests containing comments.
66 | - Linters or scripts may check for comment tokens within test directories.
67 | 
68 | ## Migration
69 | - When encountering commented tests, replace comments by:
70 |   - Renaming tests to describe behavior.
71 |   - Extracting well-named helpers/builders.
72 |   - Reordering code to make Arrange–Act–Assert obvious.


--------------------------------------------------------------------------------
/Mastermind/UI/GameScreen.swift:
--------------------------------------------------------------------------------
 1 | import SwiftUI
 2 | 
 3 | struct GameScreen: TestableView {
 4 |     @State private var game: Game
 5 | 
 6 |     var viewInspectorHook: ((Self) -> Void)?
 7 | 
 8 |     init(game: Game) {
 9 |         self.game = game
10 |         game.makeNewSecret()
11 |     }
12 | 
13 |     var body: some View {
14 |         Color.background.ignoresSafeArea().overlay {
15 |             HStack {
16 |                 VStack() {
17 |                     ForEach(1...game.rounds.count, id: \.self) { roundNumber in
18 |                         RoundView(game: game, roundNumber: RoundNumber(value: roundNumber))
19 |                     }
20 |                 }
21 |                 .accessibilityIdentifier("roundsContainer")
22 |                 VStack {
23 |                     CodeChoicesView(game: game)
24 |                     CheckButton(action: { game.score() })
25 |                         .disabled(!game.canBeValidated)
26 |                 }
27 |                 .frame(width: 50)
28 |             }
29 |         }
30 |         .inspectableSheet(isPresented: .constant(false), content: {
31 |             if (game.isWin) {
32 |                 Text("You win!")
33 |             } else {
34 |                 Text("You lose! The secret was \(game.secret)")
35 |             }
36 |         })
37 |         .onAppear { self.viewInspectorHook?(self) }
38 |     }
39 | }
40 | 
41 | private struct CodeChoicesView: View {
42 |     var game: Game
43 | 
44 |     var body: some View {
45 |         VStack {
46 |             ForEach(game.codeChoices.lastToFirst, id: \.codeValue) { codeChoice in
47 |                 CodeChoiceView(codePeg: codeChoice, codeChoiceId: codeChoice.codeValue, guess: game.rounds.round(RoundNumber(value: 1)))
48 |             }
49 |         }
50 |         .accessibilityIdentifier("codeChoices")
51 |     }
52 | }
53 | 
54 | private struct CodeChoiceView: View {
55 |     var codePeg: CodeChoice
56 |     var codeChoiceId: Int
57 |     var guess: Round
58 | 
59 |     var body: some View {
60 |         Button(action: {
61 |             guess.placeChoiceInNextSlot(codePeg)
62 |         }, label: {
63 |             RoundedRectangle(cornerRadius: 10)
64 |                 .fill(Color.white)
65 |                 .frame(width: .infinity)
66 |                 .aspectRatio(contentMode: .fit)
67 |                 .overlay(
68 |                     Circle()
69 |                         .foregroundColor(codePeg.color)
70 |                         .padding(10)
71 |                 )
72 |         })
73 |         .id(codeChoiceId)
74 |     }
75 | }
76 | 
77 | private extension CodeChoices {
78 |     var lastToFirst: [CodeChoice] {
79 |         return options.reversed()
80 |     }
81 | }
82 | 
83 | #Preview {
84 |     let game = try! Game(numberOfCodeChoices: 4, secretSize: 4, numberOfRounds: 1, SecretMaker.createNull())
85 |     return GameScreen(game: game)
86 | }
87 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Build](https://github.com/jonreid/Mastermind/actions/workflows/build.yml/badge.svg)](https://github.com/jonreid/Mastermind/actions/workflows/build.yml)
 2 | [![Bluesky](https://img.shields.io/bluesky/followers/qualitycoding.org)](https://bsky.app/profile/qualitycoding.org)
 3 | [![Mastodon](https://img.shields.io/mastodon/follow/109765011064804734?domain=https%3A%2F%2Fiosdev.space
 4 | )](https://iosdev.space/@qcoding)
 5 | [![YouTube](https://img.shields.io/youtube/channel/subscribers/UC69XtVGLRydpG7o1nkdQs8Q)](https://www.youtube.com/@QualityCoding)
 6 | [![GitHub](https://img.shields.io/github/stars/jonreid)](https://github.com/jonreid)
 7 | 
 8 | # Mastermind (exploring TDD with SwiftUI)
 9 | 
10 | I'm writing a Mastermind game to explore [TDD with SwiftUI](https://qualitycoding.org/tdd-swiftui-series/). Read [the first article](https://qualitycoding.org/tdd-for-swiftui-lets-begin) to learn about my goals.
11 | 
12 | There will be Xcode project configuration. There will be architecture, design, and refactoring. There will be test-driven development (TDD). And how will I approach SwiftUI?
13 | 
14 | Stick around to find out.
15 | 
16 | My plan is to live-code this project on Twitch, post the recordings on YouTube, and then turn what we discover into articles.
17 | 
18 | You can see [the Discovery Tree I'm using on Miro](https://miro.com/app/board/uXjVNNVlS6k=/?share_link_id=500104344113).
19 | 
20 | **Running Tests:** The project now includes a few snapshot tests. For these tests to pass, you must use:
21 | 
22 | - Simulator: iPhone 16 
23 | 
24 | The snapshots use slightly-less-than exact precision, so that may be enough. If they fail for you, let me know.
25 | 
26 | ## Live-Coding on Twitch
27 | 
28 | I’ll be streaming Sundays at 9:00 am Pacific (17:00 UTC) for roughly 60 minutes. Join so you can **chat with me live.** Chances are, you know more about SwiftUI than I do, and I’ll need your help. But I’ll be trying to apply the interesting practices listed in the [introductory article](https://qualitycoding.org/tdd-for-swiftui-lets-begin). This will be real, warts and all!
29 | 
30 | [Follow on Twitch](https://www.twitch.tv/qcoding)
31 | 
32 | _Consider subscribing to support my stream_
33 | 
34 | ## Recorded Sessions on YouTube
35 | 
36 | The following day, I’ll put the recording onto my YouTube channel. Your comments there will also be helpful.
37 | 
38 | [Subscribe on YouTube](https://www.youtube.com/@qualitycoding)
39 | 
40 | ## Articles on QualityCoding.org
41 | 
42 | Then I’ll refine what we discover into articles which I’ll post on my blog.
43 | 
44 | These articles will span a variety of topics. I expect they will cover the main categories of my blog: unit testing, TDD, refactoring, and tools. To make things easier to find, I’ve made a dedicated [TDD in a SwiftUI World](https://qualitycoding.org/tdd-swiftui-series/) page to collect the articles that come from this project, as I start from an empty GitHub repo.
45 | 
46 | Make sure you don’t miss a single post in this series. **Subscribe to my newsletter,** and I’ll notify you about new posts by email.
47 | 
48 | [Subscribe to Newsletter](https://qualitycoding.org/subscribe-swiftui-tdd/)
49 | 


--------------------------------------------------------------------------------
/Mastermind/Domain/Tests/FeedbackTests.swift:
--------------------------------------------------------------------------------
 1 | @testable import Mastermind
 2 | import Testing
 3 | 
 4 | private let red = CodeChoice(color: .red, codeValue: 1)
 5 | private let green = CodeChoice(color: .green, codeValue: 2)
 6 | private let blue = CodeChoice(color: .blue, codeValue: 3)
 7 | 
 8 | struct FeedbackTests {
 9 |     @Test(arguments: [([red, green], 2), ([red, green, blue], 3)])
10 |     func initialCountIsSecretSize(code: [CodeChoice], expectedCount: Int) async throws {
11 |         let feedback = Feedback.initial(size: code.count)
12 | 
13 |         #expect(feedback.totalCount == expectedCount)
14 |     }
15 | 
16 |     @Test
17 |     func correctPositionInFirstPeg() async throws {
18 |         let sut = makeSUT(code: [red, green])
19 | 
20 |         let correctColorsFeedback = sut.evaluate(makeGuess(code: [red, red]))
21 | 
22 |         #expect(correctColorsFeedback.totalCount == 2)
23 |         #expect(correctColorsFeedback.inCorrectPosition == 1)
24 |         #expect(correctColorsFeedback.inWrongPosition == 0)
25 |     }
26 | 
27 |     @Test
28 |     func correctPositionInSecondPeg() async throws {
29 |         let sut = makeSUT(code: [red, green])
30 | 
31 |         let correctColorsFeedback = sut.evaluate(makeGuess(code: [green, green]))
32 | 
33 |         #expect(correctColorsFeedback.totalCount == 2)
34 |         #expect(correctColorsFeedback.inCorrectPosition == 1)
35 |         #expect(correctColorsFeedback.inWrongPosition == 0)
36 |     }
37 | 
38 |     @Test
39 |     func wrongPosition() async throws {
40 |         let sut = makeSUT(code: [red, green])
41 | 
42 |         let correctColorsFeedback = sut.evaluate(makeGuess(code: [green, red]))
43 | 
44 |         #expect(correctColorsFeedback.totalCount == 2)
45 |         #expect(correctColorsFeedback.inCorrectPosition == 0)
46 |         #expect(correctColorsFeedback.inWrongPosition == 2)
47 |     }
48 | 
49 |     @Test(arguments: [
50 |         (1, [FeedbackPeg.empty]),
51 |         (2, [FeedbackPeg.empty, FeedbackPeg.empty]),
52 |     ])
53 |     func nothingCorrectYet(totalCount: Int, expected: [FeedbackPeg]) async throws {
54 |         let feedback = Feedback(totalCount: totalCount, inCorrectPosition: 0, inWrongPosition: 0)
55 | 
56 |         #expect(feedback.pegs == expected)
57 |     }
58 | 
59 |     @Test
60 |     func pegs_perfectMatch() async throws {
61 |         let feedback = Feedback(totalCount: 2, inCorrectPosition: 2, inWrongPosition: 0)
62 | 
63 |         #expect(feedback.pegs == [.correct, .correct])
64 |     }
65 | 
66 |     @Test
67 |     func pegs_rightColorsInWrongPositions() async throws {
68 |         let feedback = Feedback(totalCount: 2, inCorrectPosition: 0, inWrongPosition: 2)
69 | 
70 |         #expect(feedback.pegs == [.misplaced, .misplaced])
71 |     }
72 | 
73 |     @Test
74 |     func pegs_mixtureOfAll() async throws {
75 |         let feedback = Feedback(totalCount: 4, inCorrectPosition: 1, inWrongPosition: 2)
76 | 
77 |         #expect(feedback.pegs == [.correct, .misplaced, .misplaced, .empty])
78 |     }
79 | 
80 |     private func makeSUT(code: [CodeChoice]) -> Secret {
81 |         Secret(code: code)
82 |     }
83 | 
84 |     private func makeGuess(code: [CodeChoice]) -> Round {
85 |         let guess = Round(secretSize: code.count, roundNumber: RoundNumber(value: 1))
86 |         for choice in code {
87 |             guess.placeChoiceInNextSlot(choice)
88 |         }
89 |         return guess
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/.windsurf/rules/agent.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | trigger: always_on
 3 | ---
 4 | 
 5 | # Interaction
 6 | 
 7 | **ALWAYS** start replies with STARTER_CHARACTER + space (default: 🍀). Stack emojis when requested, don't replace.  
 8 | 
 9 | **ALWAYS** re-read these instructions after every large chunk of work you complete. When you re-read this file, say `♻️ Main rules re-read`  
10 | 
11 | Important: DO NOT COMMENT CODE, even if comments are already present. Communicate meaning by writing clean, expressive code.
12 | 
13 | # AI & Human Collaboration Guidelines
14 | 
15 | ## Core Partnership
16 | - I'm Jon. Call and think of me as Jon, not "the user"
17 | - We're friends and colleagues working together.
18 | - Take me with you on the thinking journey, don't just do the work. We work together to form mental models alongside the code we're writing. It's important that I also understand.
19 | 
20 | ## Communication Style
21 | - Be concise.
22 | - Keep details minimal unless I ask.
23 | - Light humor welcome, don't force it.
24 | 
25 | ## Using Voice
26 | You can draw my attention via voice.
27 | **ALWAYS** start any voice notification with the `say '<THING YOU WANT TO SAY>'` command. You will have to run that command via the terminal.
28 | Use `say` to let me know when you:
29 | - Complete a task
30 | - Pick up a new task
31 | - Run into problems or have a question and need my input
32 | - Finish what I asked you to do (so I know to come back)
33 | Avoid it for routine responses due to latency. Text is preferred for quick interactions.
34 | Voice is best when the auditory experience is worth the wait.
35 | 
36 | ## Structure
37 | - I like ASCII diagrams on a high level to talk about the architecture of existing code or the code we're planning to write. It helps me build high-level understanding.
38 | - When you need to ask me several questions or give me a list of things, show me that list and then ask me about each item one at a time.
39 | 
40 | ## Running commands in the terminal
41 | **Always** wait for terminal commands to finish before continuing, unless I explicitly say otherwise.
42 | 
43 | ## Mutual Support and Proactivity
44 | - Don't flatter me. Be charming and nice, but very honest. Tell me something I need to know, even if I don't want to hear it.
45 | - I'll help you not make mistakes, and you'll help me.
46 | - Push back when something seems wrong — don't just agree with mistakes.
47 | - Flag unclear but important points before they become problems. Be proactive in letting me know so we can discuss it and avoid the problem.
48 | - Call out potential misses.
49 | - Ask questions if something is not clear and you need to make a choice. Don't choose randomly if it's important for what we're doing.
50 | - When you show me a potential error or miss, start your response with the ❗️ emoji.
51 | 
52 | ## Code Principles
53 | - We prefer simple, clean, maintainable solutions over clever or complex ones, even if the latter are more concise or performant.
54 | - Readability and maintainability are primary concerns.
55 | - Self-documenting names and code
56 | - Small functions
57 | - Follow the single responsibility principle in classes and functions
58 | - Minimal changes only
59 | - Try to avoid rewriting — if unsure, ask permission first.
60 | 
61 | # Project specifics
62 | 
63 | ## Running tests
64 | 
65 | Run tests using the `build_and_test.sh` script.
66 | 
67 | ## Committing
68 | 
69 | - Draft a commit message following .windsurf/rules/commit-messages-arlo-belshee.md
70 | - **ALWAYS** ask me to approve the commit message.
71 | - Once I approve, run .windsurf/scripts/commit.sh
72 | 


--------------------------------------------------------------------------------
/.windsurf/rules/tdd-kent-beck.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | trigger: manual
  3 | ---
  4 | 
  5 | # ROLE AND EXPERTISE
  6 | 
  7 | You are a senior software engineer who follows Kent Beck's Test-Driven Development (TDD) and Tidy First principles. Your purpose is to guide development following these methodologies precisely.
  8 | 
  9 | # CORE DEVELOPMENT PRINCIPLES
 10 | 
 11 | - Always follow the TDD cycle: Red → Green → Refactor
 12 | 
 13 | - Write the simplest failing test first
 14 | 
 15 | - Implement the minimum code needed to make tests pass
 16 | 
 17 | - Refactor only after tests are passing
 18 | 
 19 | - Follow Beck's "Tidy First" approach by separating structural changes from behavioral changes
 20 | 
 21 | - Maintain high code quality throughout development
 22 | 
 23 | # TDD METHODOLOGY GUIDANCE
 24 | 
 25 | - Start by writing a failing test that defines a small increment of functionality
 26 | 
 27 | - Use meaningful test names that describe behavior (e.g., "sumsTwoPositiveNumbers")
 28 | 
 29 | - Make test failures clear and informative
 30 | 
 31 | - Write just enough code to make the test pass - no more
 32 | 
 33 | - Once tests pass, consider if refactoring is needed
 34 | 
 35 | - Repeat the cycle for new functionality
 36 | 
 37 | # TIDY FIRST APPROACH
 38 | 
 39 | - Separate all changes into two distinct types:
 40 | 
 41 | 1. STRUCTURAL CHANGES: Rearranging code without changing behavior (renaming, extracting methods, moving code)
 42 | 
 43 | 2. BEHAVIORAL CHANGES: Adding or modifying actual functionality
 44 | 
 45 | - Never mix structural and behavioral changes in the same commit
 46 | 
 47 | - Always make structural changes first when both are needed
 48 | 
 49 | - Validate structural changes do not alter behavior by running tests before and after
 50 | 
 51 | # COMMIT DISCIPLINE
 52 | 
 53 | - Only commit when:
 54 | 
 55 | 1. ALL tests are passing
 56 | 
 57 | 2. ALL compiler/linter warnings have been resolved
 58 | 
 59 | 3. The change represents a single logical unit of work
 60 | 
 61 | 4. Commit messages clearly state whether the commit contains structural or behavioral changes
 62 | 
 63 | - Use small, frequent commits rather than large, infrequent ones
 64 | 
 65 | # CODE QUALITY STANDARDS
 66 | 
 67 | - Eliminate duplication ruthlessly
 68 | 
 69 | - Express intent clearly through naming and structure
 70 | 
 71 | - Make dependencies explicit
 72 | 
 73 | - Keep methods small and focused on a single responsibility
 74 | 
 75 | - Minimize state and side effects
 76 | 
 77 | - Use the simplest solution that could possibly work
 78 | 
 79 | # REFACTORING GUIDELINES
 80 | 
 81 | - Refactor only when tests are passing (in the "Green" phase)
 82 | 
 83 | - Use established refactoring patterns with their proper names
 84 | 
 85 | - Make one refactoring change at a time
 86 | 
 87 | - Run tests after each refactoring step
 88 | 
 89 | - Prioritize refactorings that remove duplication or improve clarity
 90 | 
 91 | # EXAMPLE WORKFLOW
 92 | 
 93 | When approaching a new feature:
 94 | 
 95 | 1. Write a simple failing test for a small part of the feature
 96 | 
 97 | 2. Implement the bare minimum to make it pass
 98 | 
 99 | 3. Run tests to confirm they pass (Green)
100 | 
101 | 4. Make any necessary structural changes (Tidy First), running tests after each change
102 | 
103 | 5. Commit structural changes separately
104 | 
105 | 6. Add another test for the next small increment of functionality
106 | 
107 | 7. Repeat until the feature is complete, committing behavioral changes separately from structural ones
108 | 
109 | Follow this process precisely, always prioritizing clean, well-tested code over quick implementation.
110 | 
111 | Always write one test at a time, make it run, then improve structure. Always run all the tests (except long-running tests) each time.


--------------------------------------------------------------------------------
/Mastermind.xcodeproj/xcshareddata/xcschemes/Mastermind.xcscheme:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Scheme
 3 |    LastUpgradeVersion = "1520"
 4 |    version = "1.7">
 5 |    <BuildAction
 6 |       parallelizeBuildables = "YES"
 7 |       buildImplicitDependencies = "YES">
 8 |       <BuildActionEntries>
 9 |          <BuildActionEntry
10 |             buildForTesting = "YES"
11 |             buildForRunning = "YES"
12 |             buildForProfiling = "YES"
13 |             buildForArchiving = "YES"
14 |             buildForAnalyzing = "YES">
15 |             <BuildableReference
16 |                BuildableIdentifier = "primary"
17 |                BlueprintIdentifier = "0F7025142B72E88B006327F4"
18 |                BuildableName = "Mastermind.app"
19 |                BlueprintName = "Mastermind"
20 |                ReferencedContainer = "container:Mastermind.xcodeproj">
21 |             </BuildableReference>
22 |          </BuildActionEntry>
23 |       </BuildActionEntries>
24 |    </BuildAction>
25 |    <TestAction
26 |       buildConfiguration = "Debug"
27 |       selectedDebuggerIdentifier = ""
28 |       selectedLauncherIdentifier = "Xcode.IDEFoundation.Launcher.PosixSpawn"
29 |       shouldUseLaunchSchemeArgsEnv = "YES">
30 |       <TestPlans>
31 |          <TestPlanReference
32 |             reference = "container:MastermindTests.xctestplan"
33 |             default = "YES">
34 |          </TestPlanReference>
35 |       </TestPlans>
36 |       <Testables>
37 |          <TestableReference
38 |             skipped = "NO">
39 |             <BuildableReference
40 |                BuildableIdentifier = "primary"
41 |                BlueprintIdentifier = "0F7025292B72E913006327F4"
42 |                BuildableName = "MastermindTests.xctest"
43 |                BlueprintName = "MastermindTests"
44 |                ReferencedContainer = "container:Mastermind.xcodeproj">
45 |             </BuildableReference>
46 |          </TestableReference>
47 |       </Testables>
48 |    </TestAction>
49 |    <LaunchAction
50 |       buildConfiguration = "Debug"
51 |       selectedDebuggerIdentifier = ""
52 |       selectedLauncherIdentifier = "Xcode.IDEFoundation.Launcher.PosixSpawn"
53 |       launchStyle = "0"
54 |       useCustomWorkingDirectory = "NO"
55 |       ignoresPersistentStateOnLaunch = "NO"
56 |       debugDocumentVersioning = "YES"
57 |       debugServiceExtension = "internal"
58 |       allowLocationSimulation = "YES">
59 |       <BuildableProductRunnable
60 |          runnableDebuggingMode = "0">
61 |          <BuildableReference
62 |             BuildableIdentifier = "primary"
63 |             BlueprintIdentifier = "0F7025142B72E88B006327F4"
64 |             BuildableName = "Mastermind.app"
65 |             BlueprintName = "Mastermind"
66 |             ReferencedContainer = "container:Mastermind.xcodeproj">
67 |          </BuildableReference>
68 |       </BuildableProductRunnable>
69 |    </LaunchAction>
70 |    <ProfileAction
71 |       buildConfiguration = "Release"
72 |       shouldUseLaunchSchemeArgsEnv = "YES"
73 |       savedToolIdentifier = ""
74 |       useCustomWorkingDirectory = "NO"
75 |       debugDocumentVersioning = "YES">
76 |       <BuildableProductRunnable
77 |          runnableDebuggingMode = "0">
78 |          <BuildableReference
79 |             BuildableIdentifier = "primary"
80 |             BlueprintIdentifier = "0F7025142B72E88B006327F4"
81 |             BuildableName = "Mastermind.app"
82 |             BlueprintName = "Mastermind"
83 |             ReferencedContainer = "container:Mastermind.xcodeproj">
84 |          </BuildableReference>
85 |       </BuildableProductRunnable>
86 |    </ProfileAction>
87 |    <AnalyzeAction
88 |       buildConfiguration = "Debug">
89 |    </AnalyzeAction>
90 |    <ArchiveAction
91 |       buildConfiguration = "Release"
92 |       revealArchiveInOrganizer = "YES">
93 |    </ArchiveAction>
94 | </Scheme>
95 | 


--------------------------------------------------------------------------------
/.windsurf/rules/commit-messages-arlo-belshee.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | trigger: model_decision
  3 | description: Commit messages
  4 | ---
  5 | 
  6 | # Commit Message Guidelines
  7 | 
  8 | ## Arlo Belshee's Commit Notation
  9 | 
 10 | ### Risk Identifiers
 11 | - **.** (Safe) - Proven safe, addresses all known and unknown risks
 12 | - **^** (Validated) - Addresses all known risks with validation
 13 | - **!** (Risky) - Some known risks remain unverified
 14 | - **@** (Probably Broken) - No risk attestation
 15 | 
 16 | ### Change Types
 17 | - **f** feature
 18 | - **b** bug fix
 19 | - **r** refactoring
 20 | - **d** documentation
 21 | - **a** automated formatting
 22 | - **e** environment
 23 | - **t** test-only
 24 | 
 25 | ## Complete Commit Notation Reference
 26 | 
 27 | ### Features
 28 | | Risk | Type | Description | Criteria |
 29 | |------|------|-------------|----------|
 30 | | ! f | Feature (> 8 LoC) | Large feature changes |
 31 | | ^ f | Feature (<= 8 LoC) | Small feature changes with validation |
 32 | | . f | Feature (proven safe) | Automated or tool-generated changes |
 33 | | @ f | Feature (no validation) | Unfinished or untested features |
 34 | 
 35 | ### Bug Fixes
 36 | | Risk | Type | Description | Criteria |
 37 | |------|------|-------------|----------|
 38 | | ! b | Bug fix (> 8 LoC) | Large bug fixes |
 39 | | ^ b | Bug fix (<= 8 LoC) | Requires: customer review, <= 8 LoC, unit tests for old and new behavior |
 40 | | . b | Bug fix (proven safe) | Developer-only functionality, build tooling, debug logging |
 41 | | @ b | Bug fix (no validation) | No automatic tests or unfinished implementation |
 42 | 
 43 | ### Refactoring
 44 | | Risk | Type | Description | Criteria |
 45 | |------|------|-------------|----------|
 46 | | ! r | Manual refactoring | Identified single, named refactoring, but executed by editing code or without whole-project test coverage |
 47 | | ^ r | Test-supported refactoring | Test-supported procedural refactoring with full-suite test runs |
 48 | | . r | Proven refactoring | One of: automated refactoring via tool, scripted manual refactoring, formal methods, or entirely within test code |
 49 | | @ r | Unverified refactoring | Remodeled by editing code, even in small chunks |
 50 | 
 51 | ### Documentation
 52 | | Risk | Type | Description | Criteria |
 53 | |------|------|-------------|----------|
 54 | | ! d | Process-altering docs | Alters an important process |
 55 | | ^ d | Dev-impacting docs | Dev-impacting only, but changes compilation or process |
 56 | | . d | Safe documentation | Developer-visible documentation that does not change a process |
 57 | | @ d | Unverified docs | Not verified or trying out process changes |
 58 | 
 59 | ### Other Types
 60 | | Risk | Type | Description |
 61 | |------|------|-------------|
 62 | | . a | Automatic formatting/generation |
 63 | | . e | Environment (non-code) changes, including .windsurf directory changes |
 64 | | . t | Test-only changes |
 65 | 
 66 | ## Key Concepts
 67 | 
 68 | ### Size Guidelines
 69 | - **8 LoC Rule**: Features/bug fixes > 8 lines of code are automatically high risk (!)
 70 | - **Small Changes**: Changes <= 8 LoC can be medium risk (^) with proper validation
 71 | - **Test Changes**: Include test code in the line count
 72 | 
 73 | ### Risk Level Definitions
 74 | - **Safe (.)**: Addresses all known and unknown risks through proven methods
 75 | - **Validated (^)**: Addresses all known risks through testing and validation
 76 | - **Risky (!)**: Some known risks remain unverified
 77 | - **Probably Broken (@)**: No risk attestation or validation
 78 | 
 79 | ### Refactoring Types
 80 | - **Provable Refactoring**: Automated tools, scripted manual steps, or formal methods
 81 | - **Test-Supported Procedural Refactoring**: Named refactoring with full test coverage
 82 | - **Manual Refactoring**: Hand-edited code without comprehensive test coverage
 83 | 
 84 | ## Examples
 85 | 
 86 | ### Features
 87 | ```
 88 | ^ f Add user authentication system (<= 8 LoC with tests)
 89 | ! f Implement complete payment processing workflow (> 8 LoC)
 90 | . f Apply automated code generation for API endpoints
 91 | @ f Start implementing user dashboard (unfinished)
 92 | ```
 93 | 
 94 | ### Bug Fixes
 95 | ```
 96 | ^ b Fix login validation error (<= 8 LoC, customer reviewed, tested)
 97 | ! b Resolve memory leak in image processing (> 8 LoC)
 98 | . b Fix debug logging format (developer-only)
 99 | @ b Attempt to fix calculation error (no tests)
100 | ```
101 | 
102 | ### Refactoring
103 | ```
104 | ^ r Extract TDD methodology to dedicated rule file (test-supported)
105 | ! r Restructure entire authentication module (manual, large scope)
106 | . r Apply automated code formatting to all Swift files
107 | @ r Start extracting method with no name (unfinished)
108 | ```
109 | 
110 | ### Documentation
111 | ```
112 | . d Update README with new installation steps
113 | ^ d Update code review checklist (process change)
114 | ! d Change deployment process documentation
115 | @ d Try new commit message format (experimental)
116 | ```
117 | 
118 | ## Guidelines
119 | 
120 | ### When to Use Each Risk Level
121 | - **.** (Safe): Automated, proven, or tool-generated changes
122 | - **^** (Validated): Manual changes with comprehensive test coverage
123 | - **!** (Risky): Large changes or changes without full validation
124 | - **@** (Probably Broken): Unfinished, untested, or experimental changes
125 | 
126 | ### Best Practices
127 | - Keep commit messages concise and descriptive
128 | - Use present tense, imperative mood
129 | - Focus on what the change accomplishes
130 | - Include context when necessary
131 | - Separate risk and type with a space
132 | - Count all lines changed, including tests
133 | 
134 | ### Commit Message Format
135 | ```
136 | [risk][space][type][space][description]
137 | ```
138 | 
139 | Follow this notation for all commits to maintain consistency and provide clear risk assessment. The goal is to enable safe, rapid deployment through risk-aware commit history.


--------------------------------------------------------------------------------
/XcodeWarnings.xcconfig:
--------------------------------------------------------------------------------
  1 | // XcodeWarnings by Jon Reid, https://qualitycoding.org
  2 | // Copyright 2014 Jonathan M. Reid. https://github.com/jonreid/XcodeWarnings/blob/main/LICENSE.txt
  3 | // SPDX-License-Identifier: MIT
  4 | 
  5 | // Apple Clang - Address Sanitizer
  6 | CLANG_ADDRESS_SANITIZER_CONTAINER_OVERFLOW = YES
  7 | 
  8 | // Apple Clang - Code Generation
  9 | GCC_STRICT_ALIASING = YES
 10 | GCC_REUSE_STRINGS = YES
 11 | GCC_NO_COMMON_BLOCKS = YES
 12 | GCC_THREADSAFE_STATICS = YES
 13 | 
 14 | // Apple Clang - Language
 15 | GCC_ENABLE_TRIGRAPHS = NO
 16 | 
 17 | // Apple Clang - Preprocessing
 18 | ENABLE_STRICT_OBJC_MSGSEND = YES
 19 | 
 20 | // Apple Clang - Undefined Behavior Sanitizer
 21 | CLANG_UNDEFINED_BEHAVIOR_SANITIZER_INTEGER = YES
 22 | CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY = YES
 23 | 
 24 | // Apple Clang - Warning Policies
 25 | //GCC_WARN_PEDANTIC = YES
 26 | //GCC_TREAT_WARNINGS_AS_ERRORS = YES
 27 | 
 28 | // Apple Clang - Warnings - All languages
 29 | CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES
 30 | GCC_WARN_CHECK_SWITCH_STATEMENTS = YES
 31 | CLANG_WARN_COMPLETION_HANDLER_MISUSE = YES
 32 | GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS = YES
 33 | CLANG_WARN_DOCUMENTATION_COMMENTS = YES
 34 | CLANG_WARN_EMPTY_BODY = YES
 35 | GCC_WARN_FOUR_CHARACTER_CONSTANTS = YES
 36 | GCC_WARN_SHADOW = YES
 37 | CLANG_WARN_BOOL_CONVERSION = YES
 38 | CLANG_WARN_CONSTANT_CONVERSION = YES
 39 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES
 40 | CLANG_WARN_ENUM_CONVERSION = YES
 41 | CLANG_WARN_IMPLICIT_FALLTHROUGH = YES
 42 | CLANG_WARN_FLOAT_CONVERSION = YES
 43 | CLANG_WARN_INT_CONVERSION = YES
 44 | CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES
 45 | CLANG_WARN_IMPLICIT_SIGN_CONVERSION = YES
 46 | CLANG_WARN_INFINITE_RECURSION = YES
 47 | GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES
 48 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR
 49 | GCC_WARN_MISSING_PARENTHESES = YES
 50 | GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS = YES
 51 | GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES
 52 | GCC_WARN_ABOUT_MISSING_NEWLINE = YES
 53 | CLANG_WARN_ASSIGN_ENUM = YES
 54 | CLANG_WARN_PRIVATE_MODULE = YES
 55 | GCC_WARN_ABOUT_POINTER_SIGNEDNESS = YES
 56 | CLANG_WARN_FRAMEWORK_INCLUDE_PRIVATE_FROM_PUBLIC = YES
 57 | CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES
 58 | CLANG_WARN_SEMICOLON_BEFORE_METHOD_BODY = YES
 59 | GCC_WARN_SIGN_COMPARE = YES
 60 | CLANG_WARN_STRICT_PROTOTYPES = YES
 61 | CLANG_WARN_COMMA = YES
 62 | CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION = YES
 63 | CLANG_WARN_PRAGMA_PACK = YES
 64 | GCC_TREAT_INCOMPATIBLE_POINTER_TYPE_WARNINGS_AS_ERRORS = YES
 65 | GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS = YES
 66 | GCC_WARN_TYPECHECK_CALLS_TO_PRINTF = YES
 67 | CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE
 68 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE
 69 | GCC_WARN_UNKNOWN_PRAGMAS = YES
 70 | CLANG_WARN_UNREACHABLE_CODE = YES_AGGRESSIVE
 71 | GCC_WARN_UNUSED_FUNCTION = YES
 72 | GCC_WARN_UNUSED_LABEL = YES
 73 | //GCC_WARN_UNUSED_PARAMETER = YES
 74 | GCC_WARN_UNUSED_VALUE = YES
 75 | GCC_WARN_UNUSED_VARIABLE = YES
 76 | 
 77 | // Apple Clang - Warnings - C++
 78 | CLANG_WARN_VEXING_PARSE = YES
 79 | CLANG_WARN_DELETE_NON_VIRTUAL_DTOR = YES
 80 | CLANG_WARN__EXIT_TIME_DESTRUCTORS = YES
 81 | GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES
 82 | GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS = YES
 83 | CLANG_WARN_RANGE_LOOP_ANALYSIS = YES
 84 | CLANG_WARN_SUSPICIOUS_MOVE = YES
 85 | GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO = YES
 86 | CLANG_WARN_ATOMIC_IMPLICIT_SEQ_CST = YES
 87 | CLANG_WARN_CXX0X_EXTENSIONS = YES
 88 | 
 89 | // Apple Clang - Warnings - Objective-C
 90 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR
 91 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES
 92 | CLANG_WARN_OBJC_IMPLICIT_ATOMIC_PROPERTIES = YES
 93 | CLANG_WARN_OBJC_LITERAL_CONVERSION = YES
 94 | GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL = YES
 95 | CLANG_WARN_OBJC_INTERFACE_IVARS = YES
 96 | CLANG_WARN_MISSING_NOESCAPE = YES
 97 | CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES
 98 | GCC_WARN_STRICT_SELECTOR_MATCH = YES
 99 | GCC_WARN_UNDECLARED_SELECTOR = YES
100 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR
101 | 
102 | // Apple Clang - Warnings - Objective-C and ARC
103 | CLANG_WARN_OBJC_EXPLICIT_OWNERSHIP_TYPE = YES
104 | CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES
105 | CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK = YES_AGGRESSIVE
106 | CLANG_WARN__ARC_BRIDGE_CAST_NONARC = YES
107 | 
108 | // Static Analysis - Analysis Policy
109 | RUN_CLANG_STATIC_ANALYZER = YES
110 | CLANG_STATIC_ANALYZER_MODE_ON_ANALYZE_ACTION = Deep
111 | CLANG_STATIC_ANALYZER_MODE = Deep
112 | 
113 | // Static Analysis - Generic Issues
114 | CLANG_ANALYZER_NULL_DEREFERENCE = YES
115 | CLANG_ANALYZER_DIVIDE_BY_ZERO = YES
116 | CLANG_ANALYZER_MEMORY_MANAGEMENT = YES
117 | CLANG_TIDY_BUGPRONE_INFINITE_LOOP = YES
118 | CLANG_ANALYZER_NONNULL = YES
119 | CLANG_TIDY_BUGPRONE_ASSERT_SIDE_EFFECT = YES
120 | 
121 | // Static Analysis - Issues - Apple APIs
122 | CLANG_ANALYZER_OSOBJECT_C_STYLE_CAST = YES
123 | CLANG_ANALYZER_OBJC_NSCFERROR = YES
124 | CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES
125 | CLANG_ANALYZER_LOCALIZABILITY_EMPTY_CONTEXT = YES
126 | CLANG_ANALYZER_OBJC_COLLECTIONS = YES
127 | CLANG_ANALYZER_GCD = YES
128 | CLANG_ANALYZER_GCD_PERFORMANCE = YES
129 | CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE
130 | CLANG_ANALYZER_LIBKERN_RETAIN_COUNT = YES
131 | CLANG_ANALYZER_MIG_CONVENTIONS = YES
132 | 
133 | // Static Analysis - Issues - C++
134 | CLANG_TIDY_BUGPRONE_MOVE_FORWARDING_REFERENCE = YES
135 | CLANG_ANALYZER_USE_AFTER_MOVE = YES_AGGRESSIVE
136 | 
137 | // Static Analysis - Issues - Objective-C
138 | CLANG_ANALYZER_OBJC_ATSYNC = YES
139 | CLANG_ANALYZER_OBJC_DEALLOC = YES
140 | CLANG_ANALYZER_OBJC_INCOMP_METHOD_TYPES = YES
141 | CLANG_ANALYZER_OBJC_GENERICS = YES
142 | CLANG_ANALYZER_OBJC_UNUSED_IVARS = YES
143 | CLANG_ANALYZER_OBJC_SELF_INIT = YES
144 | CLANG_ANALYZER_OBJC_RETAIN_COUNT = YES
145 | 
146 | // Static Analysis - Issues - Security
147 | CLANG_ANALYZER_SECURITY_FLOATLOOPCOUNTER = YES
148 | CLANG_ANALYZER_SECURITY_KEYCHAIN_API = YES
149 | CLANG_ANALYZER_SECURITY_INSECUREAPI_UNCHECKEDRETURN = YES
150 | CLANG_ANALYZER_SECURITY_INSECUREAPI_GETPW_GETS = YES
151 | CLANG_ANALYZER_SECURITY_INSECUREAPI_MKSTEMP = YES
152 | CLANG_ANALYZER_SECURITY_INSECUREAPI_RAND = YES
153 | CLANG_ANALYZER_SECURITY_INSECUREAPI_STRCPY = YES
154 | CLANG_ANALYZER_SECURITY_INSECUREAPI_VFORK = YES
155 | 
156 | // Static Analysis - Issues - Unused Code
157 | CLANG_ANALYZER_DEADCODE_DEADSTORES = YES
158 | CLANG_TIDY_MISC_REDUNDANT_EXPRESSION = YES
159 | CLANG_TIDY_BUGPRONE_REDUNDANT_BRANCH_CONDITION = YES
160 | 
161 | // Swift Compiler - Custom Flags (for Xcode 15)
162 | OTHER_SWIFT_FLAGS = -enable-upcoming-feature DisableOutwardActorInference -enable-upcoming-feature GlobalConcurrency -enable-upcoming-feature InferSendableFromCaptures
163 | 
164 | // Swift Compiler - Upcoming Features (for Xcode 16)
165 | SWIFT_ENABLE_BARE_SLASH_REGEX = YES
166 | SWIFT_UPCOMING_FEATURE_CONCISE_MAGIC_FILE = YES
167 | SWIFT_UPCOMING_FEATURE_INTERNAL_IMPORTS_BY_DEFAULT = YES
168 | SWIFT_UPCOMING_FEATURE_DEPRECATE_APPLICATION_MAIN = YES
169 | SWIFT_UPCOMING_FEATURE_DISABLE_OUTWARD_ACTOR_ISOLATION = YES
170 | SWIFT_UPCOMING_FEATURE_FORWARD_TRAILING_CLOSURES = YES
171 | SWIFT_UPCOMING_FEATURE_IMPLICIT_OPEN_EXISTENTIALS = YES
172 | SWIFT_UPCOMING_FEATURE_IMPORT_OBJC_FORWARD_DECLS = YES
173 | SWIFT_UPCOMING_FEATURE_INFER_SENDABLE_FROM_CAPTURES = YES
174 | SWIFT_UPCOMING_FEATURE_ISOLATED_DEFAULT_VALUES = YES
175 | SWIFT_UPCOMING_FEATURE_GLOBAL_CONCURRENCY = YES
176 | SWIFT_UPCOMING_FEATURE_REGION_BASED_ISOLATION = YES
177 | SWIFT_UPCOMING_FEATURE_EXISTENTIAL_ANY = YES
178 | SWIFT_STRICT_CONCURRENCY = complete
179 | 
180 | // Swift Compiler - Warning Policies
181 | //SWIFT_TREAT_WARNINGS_AS_ERRORS = YES
182 | 


--------------------------------------------------------------------------------
/CursorWroteTheseRules.mdc:
--------------------------------------------------------------------------------
  1 | ---
  2 | description: 
  3 | globs: 
  4 | alwaysApply: false
  5 | ---
  6 | # Swift Coding Style Guide
  7 | 
  8 | ## Common Suggestions
  9 | 
 10 | ### Code Quality
 11 | - Use meaningful variable names that describe their purpose
 12 | - Keep functions small and focused on a single responsibility
 13 | - Prefer immutable values (`let`) over mutable ones (`var`)
 14 | - Use `guard` statements for early returns and validation
 15 | - Leverage Swift's type system to prevent runtime errors
 16 | 
 17 | ### Swift Best Practices
 18 | - Use `map`, `filter`, `reduce` for functional programming patterns
 19 | - Prefer `switch` statements over multiple `if-else` chains
 20 | - Use `lazy` properties for expensive computations
 21 | - Leverage protocol extensions for shared functionality
 22 | - Use `@available` for API compatibility
 23 | 
 24 | #### Swift Preferences in Practice
 25 | ```swift
 26 | // ✅ Good: Using if let shorthand
 27 | func processUser(_ user: User?) {
 28 |     if let user {  // Shorthand instead of if let user = user
 29 |         user.handleNotification(service: notificationService)
 30 |     }
 31 | }
 32 | 
 33 | // ✅ Good: Avoiding -er in type names
 34 | struct Cash {  // Good: simple, descriptive
 35 |     let amount: Decimal
 36 |     let currency: Currency
 37 | }
 38 | 
 39 | struct USDCash {  // Good: specific currency
 40 |     let amount: Decimal
 41 | }
 42 | 
 43 | // ❌ Bad: Using -er suffix
 44 | struct CashFormatter {  // Bad: -er suffix
 45 |     func format(_ amount: Decimal) -> String {
 46 |         // formatting logic
 47 |     }
 48 | }
 49 | ```
 50 | 
 51 | #### Construction Builder Pattern for Test Data
 52 | ```swift
 53 | // ✅ Good: Construction Builder for nested structs
 54 | struct UserBuilder {
 55 |     private var id: UserId = UserId("test-123")
 56 |     private var name: String = "Test User"
 57 |     private var email: EmailAddress = try! EmailAddress("test@example.com")
 58 |     private var age: Age = try! Age(25)
 59 |     private var preferences: UserPreferences = UserPreferencesBuilder().build()
 60 |     
 61 |     func id(_ id: UserId) -> Self {
 62 |         self.id = id
 63 |         return self
 64 |     }
 65 |     
 66 |     func name(_ name: String) -> Self {
 67 |         self.name = name
 68 |         return self
 69 |     }
 70 |     
 71 |     func email(_ email: EmailAddress) -> Self {
 72 |         self.email = email
 73 |         return self
 74 |     }
 75 |     
 76 |     func age(_ age: Age) -> Self {
 77 |         self.age = age
 78 |         return self
 79 |     }
 80 |     
 81 |     func preferences(_ preferences: UserPreferences) -> Self {
 82 |         self.preferences = preferences
 83 |         return self
 84 |     }
 85 |     
 86 |     func build() -> User {
 87 |         User(
 88 |             id: id,
 89 |             name: name,
 90 |             email: email,
 91 |             age: age,
 92 |             preferences: preferences
 93 |         )
 94 |     }
 95 | }
 96 | 
 97 | struct UserPreferencesBuilder {
 98 |     private var theme: Theme = .light
 99 |     private var notifications: Bool = true
100 |     private var language: Language = .english
101 |     
102 |     func theme(_ theme: Theme) -> Self {
103 |         self.theme = theme
104 |         return self
105 |     }
106 |     
107 |     func notifications(_ enabled: Bool) -> Self {
108 |         self.notifications = enabled
109 |         return self
110 |     }
111 |     
112 |     func language(_ language: Language) -> Self {
113 |         self.language = language
114 |         return self
115 |     }
116 |     
117 |     func build() -> UserPreferences {
118 |         UserPreferences(
119 |             theme: theme,
120 |             notifications: notifications,
121 |             language: language
122 |         )
123 |     }
124 | }
125 | 
126 | // Usage in tests
127 | func test_user_hasCorrectPreferences() throws {
128 |     let sut = UserBuilder()
129 |         .name("John Doe")
130 |         .age(try! Age(30))
131 |         .preferences(
132 |             UserPreferencesBuilder()
133 |                 .theme(.dark)
134 |                 .notifications(false)
135 |                 .build()
136 |         )
137 |         .build()
138 |     
139 |     XCTAssertEqual(sut.name(), "John Doe")
140 |     XCTAssertEqual(sut.age().years(), 30)
141 |     XCTAssertEqual(sut.preferences.theme, .dark)
142 |     XCTAssertFalse(sut.preferences.notifications)
143 | }
144 | ```
145 | 
146 | ### Testing Best Practices
147 | - Write tests that describe behavior, not implementation
148 | - Use descriptive test names that read like specifications
149 | - Test edge cases and error conditions
150 | - Keep tests independent and isolated
151 | - Use setup/teardown methods for common test data
152 | 
153 | ### Error Handling
154 | - Create specific error types for different failure scenarios
155 | - Use `do-catch` blocks for comprehensive error handling
156 | - Consider using `Result` types for operations that can fail
157 | - Provide meaningful error messages for debugging
158 | 
159 | ---
160 | 
161 | ## Advanced Suggestions for Growth
162 | 
163 | ### Architecture Patterns
164 | - **Clean Architecture**: Separate concerns into layers (Domain, Use Cases, Presentation)
165 | - **SOLID Principles**: Apply Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
166 | - **Composition over Inheritance**: Use protocols and composition for flexibility
167 | - **Repository Pattern**: Abstract data access behind protocols
168 | 
169 | ### Swift Advanced Features
170 | - **Property Wrappers**: Create custom property wrappers for common patterns
171 | - **Result Builders**: Use for DSL-like APIs (like SwiftUI's ViewBuilder)
172 | - **Key Paths**: Use for type-safe property access and transformations
173 | - **Combine Framework**: For reactive programming and data flow
174 | - **Concurrency**: Use async/await for modern asynchronous code
175 | 
176 | ### Performance Optimization
177 | - **Value Semantics**: Understand when to use structs vs classes
178 | - **Copy-on-Write**: Implement for custom value types
179 | - **Memory Management**: Use Instruments to profile memory usage
180 | - **Algorithm Complexity**: Choose appropriate data structures and algorithms
181 | 
182 | ### Testing Advanced Patterns
183 | - **Property-Based Testing**: Use frameworks like SwiftCheck for generative testing
184 | - **Integration Testing**: Test complete workflows and system interactions
185 | - **Performance Testing**: Measure and track performance regressions
186 | 
187 | ### Code Organization
188 | - **Feature-Based Structure**: Organize by features rather than technical layers
189 | - **Dependency Injection**: Use protocols for testability and flexibility
190 | - **Modular Architecture**: Break large apps into modules/frameworks
191 | - **API Design**: Design APIs that are easy to use correctly and hard to use incorrectly
192 | 
193 | ### Swift Ecosystem
194 | - **Package Manager**: Use Swift Package Manager for dependencies
195 | - **Documentation**: Generate documentation with DocC
196 | - **Linting**: Use SwiftLint for consistent code style
197 | - **Continuous Integration**: Automate testing and code quality checks
198 | 
199 | ### Advanced Swift Concepts
200 | - **Generics**: Use for type-safe, reusable code
201 | - **Protocols with Associated Types**: For flexible, generic protocols
202 | - **Opaque Types**: Use `some` and `any` for type abstraction
203 | - **Macros**: Create compile-time code generation (Swift 5.9+)
204 | - **Custom Operators**: Define operators for domain-specific operations
205 | 
206 | ### Debugging and Profiling
207 | - **LLDB**: Master command-line debugging
208 | - **Instruments**: Profile performance, memory, and other metrics
209 | - **Symbolication**: Understand crash reports and stack traces
210 | - **Network Debugging**: Use tools like Charles Proxy or Network Link Conditioner
211 | 
212 | ### Code Review Practices
213 | - **Pair Programming**: Collaborate on complex problems
214 | - **Code Reviews**: Focus on design, not just syntax
215 | - **Refactoring**: Continuously improve code quality
216 | - **Technical Debt**: Balance new features with code maintenance
217 | 
218 | ---
219 | 
220 | ## Tools and Resources
221 | 
222 | ### Recommended Tools
223 | - **Xcode**: Latest version for best Swift support
224 | - **SwiftLint**: Code style enforcement
225 | - **SwiftFormat**: Automatic code formatting
226 | - **Instruments**: Performance profiling
227 | - **Git**: Version control with meaningful commit messages
228 | 
229 | ### Learning Resources
230 | - **Swift.org**: Official documentation and guides
231 | - **WWDC Sessions**: Apple's annual developer conference
232 | - **Swift Forums**: Community discussions and Q&A
233 | - **Open Source Projects**: Study well-written Swift codebases
234 | - **Books**: "Swift Programming Language", "Advanced Swift"
235 | 
236 | ### Community
237 | - **Swift Evolution**: Follow language evolution proposals
238 | - **Local Meetups**: Connect with other Swift developers
239 | - **Open Source Contributions**: Contribute to Swift projects
240 | - **Blogs and Podcasts**: Stay updated with Swift ecosystem
241 | 
242 | ---
243 | 
244 | ## Quick Reference
245 | 
246 | ### Naming Conventions
247 | ```swift
248 | // Variables and functions
249 | let userName = "John"
250 | func calculateTotal() -> Double
251 | 
252 | // Constants
253 | let maxRetryCount = 3
254 | 
255 | // Types
256 | struct UserProfile { }
257 | class NetworkManager { }
258 | enum NetworkError { }
259 | 
260 | // Test methods
261 | func test_shouldReturnUser_whenValidIdProvided() { }
262 | ```
263 | 
264 | ### Common Patterns
265 | ```swift
266 | // Guard for early returns
267 | guard let user = currentUser else {
268 |     return
269 | }
270 | 
271 | // Result type for operations that can fail
272 | func fetchUser(id: String) -> Result<User, NetworkError>
273 | 
274 | // Protocol-oriented programming
275 | protocol UserRepository {
276 |     func getUser(id: String) async throws -> User
277 | }
278 | 
279 | // Dependency injection
280 | class UserService {
281 |     private let repository: UserRepository
282 |     
283 |     init(repository: UserRepository) {
284 |         self.repository = repository
285 |     }
286 | }
287 | ```
288 | 
289 | ### Modern Swift Quick Reference
290 | - **Async/Await**: Use `async throws` → Result types → custom errors
291 | - **Concurrency**: Prefer actors, then structured concurrency
292 | - **Property Wrappers**: Create custom wrappers for common patterns
293 | - **Result Builders**: Use for DSL-like APIs
294 | - **Testing**: Swift Testing for domain logic, XCTest + ViewInspector for SwiftUI
295 | - **Test Data**: Use Construction Builder pattern for nested structs
296 | - **Test Variables**: Use `sut` for system under test
297 | - **Classes**: Declare classes `final` unless they need subclassing
298 | 
299 | Remember: This guide should evolve with your experience and the Swift ecosystem. Regularly review and update your practices based on new learnings and project requirements.
300 | 


--------------------------------------------------------------------------------
/Mastermind/UI/Tests/GameScreenTests.swift:
--------------------------------------------------------------------------------
  1 | @testable import Mastermind
  2 | import SwiftUI
  3 | import ViewInspector
  4 | import XCTest
  5 | 
  6 | extension InspectableSheet: @retroactive PopupPresenter {}
  7 | 
  8 | @MainActor
  9 | final class GameScreenTests: XCTestCase, Sendable {
 10 |     private var game: Game!
 11 | 
 12 |     override func setUp() async throws {
 13 |         try await super.setUp()
 14 |         game = try makeGame()
 15 |     }
 16 | 
 17 |     override func tearDown() async throws {
 18 |         game = nil
 19 |         try await super.tearDown()
 20 |     }
 21 | 
 22 |     func test_displaysCodeChoicesBottomUp() throws {
 23 |         let sut = makeSUT(game)
 24 | 
 25 |         let choice1 = try sut.inspect().codeChoiceColor(0)
 26 |         let choice2 = try sut.inspect().codeChoiceColor(1)
 27 |         let choice3 = try sut.inspect().codeChoiceColor(2)
 28 |         let choice4 = try sut.inspect().codeChoiceColor(3)
 29 | 
 30 |         XCTAssertEqual(choice1, game.codeChoice(3).color)
 31 |         XCTAssertEqual(choice2, game.codeChoice(2).color)
 32 |         XCTAssertEqual(choice3, game.codeChoice(1).color)
 33 |         XCTAssertEqual(choice4, game.codeChoice(0).color)
 34 |     }
 35 | 
 36 |     func test_showingGameScreen_setsGameSecret() throws {
 37 |         _ = makeSUT(game)
 38 | 
 39 |         XCTAssertFalse(game.secret.testHooks.code.isEmpty)
 40 |     }
 41 | 
 42 |     func test_initialColorGuessIsUnselected() throws {
 43 |         let sut = makeSUT(game)
 44 | 
 45 |         let color1 = try sut.inspect().colorOfGuess(id: "guess1-1")
 46 |         let color2 = try sut.inspect().colorOfGuess(id: "guess1-2")
 47 |         let color3 = try sut.inspect().colorOfGuess(id: "guess1-3")
 48 |         let color4 = try sut.inspect().colorOfGuess(id: "guess1-4")
 49 | 
 50 |         XCTAssertEqual(color1, Color.unselected)
 51 |         XCTAssertEqual(color2, Color.unselected)
 52 |         XCTAssertEqual(color3, Color.unselected)
 53 |         XCTAssertEqual(color4, Color.unselected)
 54 |     }
 55 | 
 56 |     func test_tappingCodeChoicesSetsGuessColors() throws {
 57 |         var sut = makeSUT(game)
 58 |         let codeChoice1 = game.codeChoice(0)
 59 |         let codeChoice2 = game.codeChoice(1)
 60 |         let codeChoice3 = game.codeChoice(2)
 61 |         let codeChoice4 = game.codeChoice(3)
 62 |         var color1: Color?
 63 |         var color2: Color?
 64 |         var color3: Color?
 65 |         var color4: Color?
 66 | 
 67 |         inspectChangingView(&sut) { inspectableView in
 68 |             try inspectableView.findView(id: codeChoice1.codeValue).button().tap()
 69 |             try inspectableView.findView(id: codeChoice2.codeValue).button().tap()
 70 |             try inspectableView.findView(id: codeChoice3.codeValue).button().tap()
 71 |             try inspectableView.findView(id: codeChoice4.codeValue).button().tap()
 72 |             color1 = try inspectableView.colorOfGuess(id: "guess1-1")
 73 |             color2 = try inspectableView.colorOfGuess(id: "guess1-2")
 74 |             color3 = try inspectableView.colorOfGuess(id: "guess1-3")
 75 |             color4 = try inspectableView.colorOfGuess(id: "guess1-4")
 76 |         }
 77 | 
 78 |         XCTAssertEqual(color1, codeChoice1.color)
 79 |         XCTAssertEqual(color2, codeChoice2.color)
 80 |         XCTAssertEqual(color3, codeChoice3.color)
 81 |         XCTAssertEqual(color4, codeChoice4.color)
 82 |     }
 83 | 
 84 |     func test_checkButtonIsInitiallyDisabled() throws {
 85 |         let sut = makeSUT(game)
 86 | 
 87 |         let isEnabled = try sut.inspect().findView(accessibilityIdentifier: "checkButton").button().isResponsive()
 88 | 
 89 |         XCTAssertFalse(isEnabled)
 90 |     }
 91 | 
 92 |     func test_enablesCheckButtonWhenGuessIsFilled() throws {
 93 |         var sut = makeSUT(game)
 94 |         let codeChoice1 = game.codeChoice(0)
 95 |         let codeChoice2 = game.codeChoice(1)
 96 |         let codeChoice3 = game.codeChoice(2)
 97 |         let codeChoice4 = game.codeChoice(3)
 98 | 
 99 |         var isEnabled = false
100 |         inspectChangingView(&sut) { inspectableView in
101 |             try inspectableView.findView(id: codeChoice1.codeValue).button().tap()
102 |             try inspectableView.findView(id: codeChoice2.codeValue).button().tap()
103 |             try inspectableView.findView(id: codeChoice3.codeValue).button().tap()
104 |             try inspectableView.findView(id: codeChoice4.codeValue).button().tap()
105 | 
106 |             isEnabled = try inspectableView.checkButton().isResponsive()
107 |         }
108 | 
109 |         XCTAssertTrue(isEnabled)
110 |     }
111 | 
112 |     func test_initialFeedbackPegsAreEmpty() throws {
113 |         let sut = makeSUT(game)
114 | 
115 |         let feedbackPegColor = try sut.inspect().feedbackPegColor(1)
116 | 
117 |         XCTAssertEqual(feedbackPegColor, Color.Pegs.unselected)
118 |     }
119 | 
120 |     func test_tappingCheckButtonUpdatesFeedback() throws {
121 |         var sut = makeSUT(game)
122 |         let codeChoice1 = game.codeChoice(0)
123 |         let codeChoice2 = game.codeChoice(1)
124 |         let codeChoice3 = game.codeChoice(2)
125 |         let codeChoice4 = game.codeChoice(3)
126 |         var feedbackPegColor: Color?
127 | 
128 |         inspectChangingView(&sut) { inspectableView in
129 |             try inspectableView.findView(id: codeChoice1.codeValue).button().tap()
130 |             try inspectableView.findView(id: codeChoice2.codeValue).button().tap()
131 |             try inspectableView.findView(id: codeChoice3.codeValue).button().tap()
132 |             try inspectableView.findView(id: codeChoice4.codeValue).button().tap()
133 |             try inspectableView.checkButton().tap()
134 |             feedbackPegColor = try inspectableView.feedbackPegColor(1)
135 |         }
136 | 
137 |         XCTAssertEqual(feedbackPegColor, Color.Pegs.correct)
138 |     }
139 | 
140 |     func test_showsGameOverWhenCodeChoiceIsFilled() throws {
141 |         try XCTSkipIf(true, "Disabled")
142 |         var sut = makeSUT(game)
143 |         let codeChoice = game.codeChoice(0)
144 | 
145 |         inspectChangingView(&sut) { inspectableView in
146 |             try inspectableView.findView(id: codeChoice.codeValue).button().tap()
147 |             XCTAssertNoThrow(try inspectableView.find(ViewType.Sheet.self))
148 |         }
149 |     }
150 | 
151 |     func test_doesNotShowGameOverWhenGuessIsNotFilled() throws {
152 |         var sut = makeSUT(game)
153 |         let firstCodeChoice = game.codeChoice(0)
154 |         let secondCodeChoice = game.codeChoice(1)
155 |         let thirdCodeChoice = game.codeChoice(2)
156 | 
157 |         inspectChangingView(&sut) { inspectableView in
158 |             try inspectableView.findView(id: firstCodeChoice.codeValue).button().tap()
159 |             try inspectableView.findView(id: secondCodeChoice.codeValue).button().tap()
160 |             try inspectableView.findView(id: thirdCodeChoice.codeValue).button().tap()
161 |             XCTAssertThrowsError(try inspectableView.find(ViewType.Sheet.self))
162 |         }
163 |     }
164 | 
165 |     func test_showsYouWinWhenGuessMatchesSecret() throws {
166 |         try XCTSkipIf(true, "Disabled")
167 |         var sut = makeSUT(game)
168 |         let firstCodeChoice = game.codeChoice(0)
169 |         let secondCodeChoice = game.codeChoice(1)
170 |         var gameOverText: String?
171 | 
172 |         inspectChangingView(&sut) { inspectableView in
173 |             try inspectableView.findView(id: firstCodeChoice.codeValue).button().tap()
174 |             try inspectableView.findView(id: secondCodeChoice.codeValue).button().tap()
175 |             gameOverText = try inspectableView.find(ViewType.Sheet.self).text().string()
176 |         }
177 | 
178 |         XCTAssertEqual(gameOverText, "You win!")
179 |     }
180 | 
181 |     func test_showsYouLoseWhenGuessDoesNotMatchSecret() throws {
182 |         try XCTSkipIf(true, "Disabled")
183 |         let game = try makeGame(numberOfCodeChoices: 2, secretSize: 2)
184 |         var sut = makeSUT(game)
185 |         let firstCodeChoice = game.codeChoice(0)
186 |         let secondCodeChoice = game.codeChoice(1)
187 |         var gameOverText: String?
188 | 
189 |         inspectChangingView(&sut) { inspectableView in
190 |             try inspectableView.findView(id: secondCodeChoice.codeValue).button().tap()
191 |             try inspectableView.findView(id: firstCodeChoice.codeValue).button().tap()
192 |             gameOverText = try inspectableView.find(ViewType.Sheet.self).text().string()
193 |         }
194 | 
195 |         XCTAssertEqual(gameOverText, "You lose! The secret was brown, black")
196 |     }
197 | 
198 |     func test_displaysTwoRounds() throws {
199 |         let game = try makeGame(numberOfRounds: 2)
200 |         let sut = makeSUT(game)
201 |         let inspectable = try sut.inspect()
202 | 
203 |         _ = try inspectable.findView(accessibilityIdentifier: "round1")
204 |         _ = try inspectable.findView(accessibilityIdentifier: "round2")
205 |         XCTAssertThrowsError(try inspectable.find(viewWithAccessibilityLabel: "round3"))
206 |         _ = try inspectable.findView(id: "guess1-1")
207 |         _ = try inspectable.findView(id: "guess2-1")
208 |         XCTAssertThrowsError(try inspectable.find(viewWithId: "guess3-1"))
209 |     }
210 |     
211 |     func test_displaysThreeRounds() throws {
212 |         let game = try makeGame(numberOfRounds: 3)
213 |         let sut = makeSUT(game)
214 |         let inspectable = try sut.inspect()
215 | 
216 |         _ = try inspectable.findView(id: "guess1-1")
217 |         _ = try inspectable.findView(id: "guess2-1")
218 |         _ = try inspectable.findView(id: "guess3-1")
219 |         XCTAssertThrowsError(try inspectable.find(viewWithId: "guess4-1"))
220 |     }
221 | 
222 |     func testRoundsDisplayInDescendingOrder() throws {
223 |         let game = try makeGame(numberOfRounds: 3)
224 |         let sut = makeSUT(game)
225 |         let inspectable = try sut.inspect()
226 |         
227 |         // Phase 1: Find the VStack that contains all rounds
228 |         let roundsVStack = try inspectable.findView(accessibilityIdentifier: "roundsContainer")
229 |     }
230 | 
231 |     private func makeGame(numberOfCodeChoices: Int = 4, secretSize: Int = 4, numberOfRounds: Int = 2) throws -> Game {
232 |         try Game(numberOfCodeChoices: numberOfCodeChoices, secretSize: secretSize, numberOfRounds: numberOfRounds, SecretMaker.createNull())
233 |     }
234 | 
235 |     private func makeSUT(_ game: Game) -> GameScreen {
236 |         GameScreen(game: game)
237 |     }
238 | }
239 | 
240 | private extension InspectableView {
241 |     func checkButton(file: StaticString = #filePath, line: UInt = #line) throws -> InspectableView<ViewType.Button> {
242 |         try findView(accessibilityIdentifier: "checkButton", file: file, line: line).button()
243 |     }
244 | 
245 |     func colorOfGuess(id: String, file: StaticString = #filePath, line: UInt = #line) throws -> Color? {
246 |         try findView(id: id, file: file, line: line).button().labelView().shape().foregroundColor()
247 |     }
248 | 
249 |     func codeChoiceColor(_ index: Int, file: StaticString = #filePath, line: UInt = #line) throws -> Color? {
250 |         let codeChoice = try findView(accessibilityIdentifier: "codeChoices", file: file, line: line).vStack(0).forEach(0)[index]
251 |         return try codeChoice.find(ViewType.Button.self).labelView().shape().overlay().shape().foregroundColor()
252 |     }
253 | 
254 |     func feedbackPegColor(_ peg: Int, file: StaticString = #filePath, line: UInt = #line) throws -> Color? {
255 |         try findView(accessibilityIdentifier: "feedback\(peg)", file: file, line: line).shape().foregroundColor()
256 |     }
257 | }
258 | 
259 | extension InspectableView {
260 |     func findView(
261 |         accessibilityIdentifier: String,
262 |         file: StaticString = #filePath,
263 |         line: UInt = #line
264 |     ) throws -> InspectableView<ViewType.ClassifiedView> {
265 |         do {
266 |             return try find(viewWithAccessibilityIdentifier: accessibilityIdentifier)
267 |         } catch {
268 |             XCTFail(
269 |                 "view with accessibility identifier \"\(accessibilityIdentifier)\" not found: \(error)",
270 |                 file: file,
271 |                 line: line
272 |             )
273 |             throw error
274 |         }
275 |     }
276 | 
277 |     func findView(
278 |         id: AnyHashable,
279 |         file: StaticString = #filePath,
280 |         line: UInt = #line
281 |     ) throws -> InspectableView<ViewType.ClassifiedView> {
282 |         do {
283 |             return try find(viewWithId: id)
284 |         } catch {
285 |             XCTFail(
286 |                 "view with id \"\(id)\" not found: \(error)",
287 |                 file: file,
288 |                 line: line
289 |             )
290 |             throw error
291 |         }
292 |     }
293 | }
294 | 


--------------------------------------------------------------------------------
/Mastermind.xcodeproj/project.pbxproj:
--------------------------------------------------------------------------------
  1 | // !$*UTF8*$!
  2 | {
  3 | 	archiveVersion = 1;
  4 | 	classes = {
  5 | 	};
  6 | 	objectVersion = 70;
  7 | 	objects = {
  8 | 
  9 | /* Begin PBXBuildFile section */
 10 | 		0F1F6ED12BA759C7001611A4 /* ViewInspector in Frameworks */ = {isa = PBXBuildFile; productRef = 0F1F6ED02BA759C7001611A4 /* ViewInspector */; };
 11 | 		0F69490A2D2AFD1100CC5211 /* SnapshotTesting in Frameworks */ = {isa = PBXBuildFile; productRef = 0F6949092D2AFD1100CC5211 /* SnapshotTesting */; };
 12 | /* End PBXBuildFile section */
 13 | 
 14 | /* Begin PBXContainerItemProxy section */
 15 | 		0F70252E2B72E913006327F4 /* PBXContainerItemProxy */ = {
 16 | 			isa = PBXContainerItemProxy;
 17 | 			containerPortal = 0F70250D2B72E88B006327F4 /* Project object */;
 18 | 			proxyType = 1;
 19 | 			remoteGlobalIDString = 0F7025142B72E88B006327F4;
 20 | 			remoteInfo = Mastermind;
 21 | 		};
 22 | /* End PBXContainerItemProxy section */
 23 | 
 24 | /* Begin PBXFileReference section */
 25 | 		0F7025152B72E88B006327F4 /* Mastermind.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Mastermind.app; sourceTree = BUILT_PRODUCTS_DIR; };
 26 | 		0F70252A2B72E913006327F4 /* MastermindTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = MastermindTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
 27 | 		0F7025332B72EB4B006327F4 /* MastermindTests.xctestplan */ = {isa = PBXFileReference; lastKnownFileType = text; path = MastermindTests.xctestplan; sourceTree = "<group>"; };
 28 | 		0F92CB1D2B9E56DF001F8E20 /* XcodeWarnings.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = XcodeWarnings.xcconfig; sourceTree = "<group>"; };
 29 | /* End PBXFileReference section */
 30 | 
 31 | /* Begin PBXFileSystemSynchronizedBuildFileExceptionSet section */
 32 | 		0FA0B6962CEA68B80094D7AD /* PBXFileSystemSynchronizedBuildFileExceptionSet */ = {
 33 | 			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
 34 | 			membershipExceptions = (
 35 | 				Domain/Tests/CodeChoiceTests.swift,
 36 | 				Domain/Tests/FeedbackTests.swift,
 37 | 				Domain/Tests/GameTests.swift,
 38 | 				Domain/Tests/RoundTests.swift,
 39 | 				Domain/Tests/SecretMakerTests.swift,
 40 | 				Domain/Tests/SecretTests.swift,
 41 | 				UI/Tests/__Snapshots__/CheckButtonSnapshotTests/enabledColor.1.png,
 42 | 				UI/Tests/CheckButtonSnapshotTests.swift,
 43 | 				"UI/Tests/FeedbackPeg+ColorTests.swift",
 44 | 				UI/Tests/FeedbackViewTests.swift,
 45 | 				UI/Tests/GameScreenTests.swift,
 46 | 				UI/Tests/InspectChangingView.swift,
 47 | 				UI/Tests/RoundViewTests.swift,
 48 | 			);
 49 | 			target = 0F7025142B72E88B006327F4 /* Mastermind */;
 50 | 		};
 51 | 		0FA0B6972CEA68B80094D7AD /* PBXFileSystemSynchronizedBuildFileExceptionSet */ = {
 52 | 			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
 53 | 			membershipExceptions = (
 54 | 				Domain/Tests/CodeChoiceTests.swift,
 55 | 				Domain/Tests/FeedbackTests.swift,
 56 | 				Domain/Tests/GameTests.swift,
 57 | 				Domain/Tests/RoundTests.swift,
 58 | 				Domain/Tests/SecretMakerTests.swift,
 59 | 				Domain/Tests/SecretTests.swift,
 60 | 				UI/Tests/CheckButtonSnapshotTests.swift,
 61 | 				"UI/Tests/FeedbackPeg+ColorTests.swift",
 62 | 				UI/Tests/FeedbackViewTests.swift,
 63 | 				UI/Tests/GameScreenTests.swift,
 64 | 				UI/Tests/InspectChangingView.swift,
 65 | 				UI/Tests/RoundViewTests.swift,
 66 | 			);
 67 | 			target = 0F7025292B72E913006327F4 /* MastermindTests */;
 68 | 		};
 69 | /* End PBXFileSystemSynchronizedBuildFileExceptionSet section */
 70 | 
 71 | /* Begin PBXFileSystemSynchronizedRootGroup section */
 72 | 		0FA0B6782CEA65E50094D7AD /* Mastermind */ = {isa = PBXFileSystemSynchronizedRootGroup; exceptions = (0FA0B6962CEA68B80094D7AD /* PBXFileSystemSynchronizedBuildFileExceptionSet */, 0FA0B6972CEA68B80094D7AD /* PBXFileSystemSynchronizedBuildFileExceptionSet */, ); explicitFileTypes = {}; explicitFolders = (); path = Mastermind; sourceTree = "<group>"; };
 73 | /* End PBXFileSystemSynchronizedRootGroup section */
 74 | 
 75 | /* Begin PBXFrameworksBuildPhase section */
 76 | 		0F7025122B72E88B006327F4 /* Frameworks */ = {
 77 | 			isa = PBXFrameworksBuildPhase;
 78 | 			buildActionMask = 2147483647;
 79 | 			files = (
 80 | 			);
 81 | 			runOnlyForDeploymentPostprocessing = 0;
 82 | 		};
 83 | 		0F7025272B72E913006327F4 /* Frameworks */ = {
 84 | 			isa = PBXFrameworksBuildPhase;
 85 | 			buildActionMask = 2147483647;
 86 | 			files = (
 87 | 				0F1F6ED12BA759C7001611A4 /* ViewInspector in Frameworks */,
 88 | 				0F69490A2D2AFD1100CC5211 /* SnapshotTesting in Frameworks */,
 89 | 			);
 90 | 			runOnlyForDeploymentPostprocessing = 0;
 91 | 		};
 92 | /* End PBXFrameworksBuildPhase section */
 93 | 
 94 | /* Begin PBXGroup section */
 95 | 		0F70250C2B72E88B006327F4 = {
 96 | 			isa = PBXGroup;
 97 | 			children = (
 98 | 				0F92CB1D2B9E56DF001F8E20 /* XcodeWarnings.xcconfig */,
 99 | 				0F7025332B72EB4B006327F4 /* MastermindTests.xctestplan */,
100 | 				0FA0B6782CEA65E50094D7AD /* Mastermind */,
101 | 				0F7025162B72E88B006327F4 /* Products */,
102 | 			);
103 | 			sourceTree = "<group>";
104 | 		};
105 | 		0F7025162B72E88B006327F4 /* Products */ = {
106 | 			isa = PBXGroup;
107 | 			children = (
108 | 				0F7025152B72E88B006327F4 /* Mastermind.app */,
109 | 				0F70252A2B72E913006327F4 /* MastermindTests.xctest */,
110 | 			);
111 | 			name = Products;
112 | 			sourceTree = "<group>";
113 | 		};
114 | /* End PBXGroup section */
115 | 
116 | /* Begin PBXNativeTarget section */
117 | 		0F7025142B72E88B006327F4 /* Mastermind */ = {
118 | 			isa = PBXNativeTarget;
119 | 			buildConfigurationList = 0F7025232B72E88C006327F4 /* Build configuration list for PBXNativeTarget "Mastermind" */;
120 | 			buildPhases = (
121 | 				0F7025112B72E88B006327F4 /* Sources */,
122 | 				0F7025122B72E88B006327F4 /* Frameworks */,
123 | 				0F7025132B72E88B006327F4 /* Resources */,
124 | 			);
125 | 			buildRules = (
126 | 			);
127 | 			dependencies = (
128 | 			);
129 | 			fileSystemSynchronizedGroups = (
130 | 				0FA0B6782CEA65E50094D7AD /* Mastermind */,
131 | 			);
132 | 			name = Mastermind;
133 | 			productName = Mastermind;
134 | 			productReference = 0F7025152B72E88B006327F4 /* Mastermind.app */;
135 | 			productType = "com.apple.product-type.application";
136 | 		};
137 | 		0F7025292B72E913006327F4 /* MastermindTests */ = {
138 | 			isa = PBXNativeTarget;
139 | 			buildConfigurationList = 0F7025322B72E913006327F4 /* Build configuration list for PBXNativeTarget "MastermindTests" */;
140 | 			buildPhases = (
141 | 				0F7025262B72E913006327F4 /* Sources */,
142 | 				0F7025272B72E913006327F4 /* Frameworks */,
143 | 				0F7025282B72E913006327F4 /* Resources */,
144 | 			);
145 | 			buildRules = (
146 | 			);
147 | 			dependencies = (
148 | 				0F70252F2B72E913006327F4 /* PBXTargetDependency */,
149 | 			);
150 | 			name = MastermindTests;
151 | 			packageProductDependencies = (
152 | 				0F1F6ED02BA759C7001611A4 /* ViewInspector */,
153 | 				0F6949092D2AFD1100CC5211 /* SnapshotTesting */,
154 | 			);
155 | 			productName = MastermindTests;
156 | 			productReference = 0F70252A2B72E913006327F4 /* MastermindTests.xctest */;
157 | 			productType = "com.apple.product-type.bundle.unit-test";
158 | 		};
159 | /* End PBXNativeTarget section */
160 | 
161 | /* Begin PBXProject section */
162 | 		0F70250D2B72E88B006327F4 /* Project object */ = {
163 | 			isa = PBXProject;
164 | 			attributes = {
165 | 				BuildIndependentTargetsInParallel = 1;
166 | 				LastSwiftUpdateCheck = 1520;
167 | 				LastUpgradeCheck = 1520;
168 | 				TargetAttributes = {
169 | 					0F7025142B72E88B006327F4 = {
170 | 						CreatedOnToolsVersion = 15.2;
171 | 					};
172 | 					0F7025292B72E913006327F4 = {
173 | 						CreatedOnToolsVersion = 15.2;
174 | 						TestTargetID = 0F7025142B72E88B006327F4;
175 | 					};
176 | 				};
177 | 			};
178 | 			buildConfigurationList = 0F7025102B72E88B006327F4 /* Build configuration list for PBXProject "Mastermind" */;
179 | 			compatibilityVersion = "Xcode 14.0";
180 | 			developmentRegion = en;
181 | 			hasScannedForEncodings = 0;
182 | 			knownRegions = (
183 | 				en,
184 | 				Base,
185 | 			);
186 | 			mainGroup = 0F70250C2B72E88B006327F4;
187 | 			packageReferences = (
188 | 				0F1F6ECF2BA759C7001611A4 /* XCRemoteSwiftPackageReference "ViewInspector" */,
189 | 				0F6949082D2AFD1100CC5211 /* XCRemoteSwiftPackageReference "swift-snapshot-testing" */,
190 | 			);
191 | 			productRefGroup = 0F7025162B72E88B006327F4 /* Products */;
192 | 			projectDirPath = "";
193 | 			projectRoot = "";
194 | 			targets = (
195 | 				0F7025142B72E88B006327F4 /* Mastermind */,
196 | 				0F7025292B72E913006327F4 /* MastermindTests */,
197 | 			);
198 | 		};
199 | /* End PBXProject section */
200 | 
201 | /* Begin PBXResourcesBuildPhase section */
202 | 		0F7025132B72E88B006327F4 /* Resources */ = {
203 | 			isa = PBXResourcesBuildPhase;
204 | 			buildActionMask = 2147483647;
205 | 			files = (
206 | 			);
207 | 			runOnlyForDeploymentPostprocessing = 0;
208 | 		};
209 | 		0F7025282B72E913006327F4 /* Resources */ = {
210 | 			isa = PBXResourcesBuildPhase;
211 | 			buildActionMask = 2147483647;
212 | 			files = (
213 | 			);
214 | 			runOnlyForDeploymentPostprocessing = 0;
215 | 		};
216 | /* End PBXResourcesBuildPhase section */
217 | 
218 | /* Begin PBXSourcesBuildPhase section */
219 | 		0F7025112B72E88B006327F4 /* Sources */ = {
220 | 			isa = PBXSourcesBuildPhase;
221 | 			buildActionMask = 2147483647;
222 | 			files = (
223 | 			);
224 | 			runOnlyForDeploymentPostprocessing = 0;
225 | 		};
226 | 		0F7025262B72E913006327F4 /* Sources */ = {
227 | 			isa = PBXSourcesBuildPhase;
228 | 			buildActionMask = 2147483647;
229 | 			files = (
230 | 			);
231 | 			runOnlyForDeploymentPostprocessing = 0;
232 | 		};
233 | /* End PBXSourcesBuildPhase section */
234 | 
235 | /* Begin PBXTargetDependency section */
236 | 		0F70252F2B72E913006327F4 /* PBXTargetDependency */ = {
237 | 			isa = PBXTargetDependency;
238 | 			target = 0F7025142B72E88B006327F4 /* Mastermind */;
239 | 			targetProxy = 0F70252E2B72E913006327F4 /* PBXContainerItemProxy */;
240 | 		};
241 | /* End PBXTargetDependency section */
242 | 
243 | /* Begin XCBuildConfiguration section */
244 | 		0F7025212B72E88C006327F4 /* Debug */ = {
245 | 			isa = XCBuildConfiguration;
246 | 			baseConfigurationReference = 0F92CB1D2B9E56DF001F8E20 /* XcodeWarnings.xcconfig */;
247 | 			buildSettings = {
248 | 				ALWAYS_SEARCH_USER_PATHS = NO;
249 | 				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
250 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
251 | 				CLANG_ENABLE_MODULES = YES;
252 | 				CLANG_ENABLE_OBJC_ARC = YES;
253 | 				CLANG_ENABLE_OBJC_WEAK = YES;
254 | 				COPY_PHASE_STRIP = NO;
255 | 				DEBUG_INFORMATION_FORMAT = dwarf;
256 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
257 | 				ENABLE_TESTABILITY = YES;
258 | 				ENABLE_USER_SCRIPT_SANDBOXING = YES;
259 | 				GCC_C_LANGUAGE_STANDARD = gnu17;
260 | 				GCC_DYNAMIC_NO_PIC = NO;
261 | 				GCC_NO_COMMON_BLOCKS = YES;
262 | 				GCC_OPTIMIZATION_LEVEL = 0;
263 | 				GCC_PREPROCESSOR_DEFINITIONS = (
264 | 					"DEBUG=1",
265 | 					"$(inherited)",
266 | 				);
267 | 				IPHONEOS_DEPLOYMENT_TARGET = 17.2;
268 | 				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
269 | 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
270 | 				MTL_FAST_MATH = YES;
271 | 				ONLY_ACTIVE_ARCH = YES;
272 | 				SDKROOT = iphoneos;
273 | 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = "DEBUG $(inherited)";
274 | 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
275 | 				SWIFT_VERSION = 5.0;
276 | 			};
277 | 			name = Debug;
278 | 		};
279 | 		0F7025222B72E88C006327F4 /* Release */ = {
280 | 			isa = XCBuildConfiguration;
281 | 			baseConfigurationReference = 0F92CB1D2B9E56DF001F8E20 /* XcodeWarnings.xcconfig */;
282 | 			buildSettings = {
283 | 				ALWAYS_SEARCH_USER_PATHS = NO;
284 | 				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
285 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
286 | 				CLANG_ENABLE_MODULES = YES;
287 | 				CLANG_ENABLE_OBJC_ARC = YES;
288 | 				CLANG_ENABLE_OBJC_WEAK = YES;
289 | 				COPY_PHASE_STRIP = NO;
290 | 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
291 | 				ENABLE_NS_ASSERTIONS = NO;
292 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
293 | 				ENABLE_USER_SCRIPT_SANDBOXING = YES;
294 | 				GCC_C_LANGUAGE_STANDARD = gnu17;
295 | 				GCC_NO_COMMON_BLOCKS = YES;
296 | 				IPHONEOS_DEPLOYMENT_TARGET = 17.2;
297 | 				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
298 | 				MTL_ENABLE_DEBUG_INFO = NO;
299 | 				MTL_FAST_MATH = YES;
300 | 				SDKROOT = iphoneos;
301 | 				SWIFT_COMPILATION_MODE = wholemodule;
302 | 				SWIFT_VERSION = 5.0;
303 | 				VALIDATE_PRODUCT = YES;
304 | 			};
305 | 			name = Release;
306 | 		};
307 | 		0F7025242B72E88C006327F4 /* Debug */ = {
308 | 			isa = XCBuildConfiguration;
309 | 			buildSettings = {
310 | 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
311 | 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
312 | 				CODE_SIGN_STYLE = Automatic;
313 | 				CURRENT_PROJECT_VERSION = 1;
314 | 				DEVELOPMENT_ASSET_PATHS = "\"Mastermind/Preview Content\"";
315 | 				DEVELOPMENT_TEAM = EH4R632375;
316 | 				ENABLE_PREVIEWS = YES;
317 | 				GENERATE_INFOPLIST_FILE = YES;
318 | 				INFOPLIST_KEY_UIApplicationSceneManifest_Generation = YES;
319 | 				INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES;
320 | 				INFOPLIST_KEY_UILaunchScreen_Generation = YES;
321 | 				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad = "UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
322 | 				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPhone = "UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
323 | 				LD_RUNPATH_SEARCH_PATHS = (
324 | 					"$(inherited)",
325 | 					"@executable_path/Frameworks",
326 | 				);
327 | 				MARKETING_VERSION = 0.1;
328 | 				PRODUCT_BUNDLE_IDENTIFIER = org.qualitycoding.Mastermind;
329 | 				PRODUCT_NAME = "$(TARGET_NAME)";
330 | 				SWIFT_EMIT_LOC_STRINGS = YES;
331 | 				TARGETED_DEVICE_FAMILY = "1,2";
332 | 			};
333 | 			name = Debug;
334 | 		};
335 | 		0F7025252B72E88C006327F4 /* Release */ = {
336 | 			isa = XCBuildConfiguration;
337 | 			buildSettings = {
338 | 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
339 | 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
340 | 				CODE_SIGN_STYLE = Automatic;
341 | 				CURRENT_PROJECT_VERSION = 1;
342 | 				DEVELOPMENT_ASSET_PATHS = "\"Mastermind/Preview Content\"";
343 | 				DEVELOPMENT_TEAM = EH4R632375;
344 | 				ENABLE_PREVIEWS = YES;
345 | 				GENERATE_INFOPLIST_FILE = YES;
346 | 				INFOPLIST_KEY_UIApplicationSceneManifest_Generation = YES;
347 | 				INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES;
348 | 				INFOPLIST_KEY_UILaunchScreen_Generation = YES;
349 | 				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad = "UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
350 | 				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPhone = "UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
351 | 				LD_RUNPATH_SEARCH_PATHS = (
352 | 					"$(inherited)",
353 | 					"@executable_path/Frameworks",
354 | 				);
355 | 				MARKETING_VERSION = 0.1;
356 | 				PRODUCT_BUNDLE_IDENTIFIER = org.qualitycoding.Mastermind;
357 | 				PRODUCT_NAME = "$(TARGET_NAME)";
358 | 				SWIFT_EMIT_LOC_STRINGS = YES;
359 | 				TARGETED_DEVICE_FAMILY = "1,2";
360 | 			};
361 | 			name = Release;
362 | 		};
363 | 		0F7025302B72E913006327F4 /* Debug */ = {
364 | 			isa = XCBuildConfiguration;
365 | 			buildSettings = {
366 | 				BUNDLE_LOADER = "$(TEST_HOST)";
367 | 				CODE_SIGN_STYLE = Automatic;
368 | 				CURRENT_PROJECT_VERSION = 1;
369 | 				DEVELOPMENT_TEAM = EH4R632375;
370 | 				GENERATE_INFOPLIST_FILE = YES;
371 | 				MARKETING_VERSION = 1.0;
372 | 				PRODUCT_BUNDLE_IDENTIFIER = org.qualitycoding.MastermindTests;
373 | 				PRODUCT_NAME = "$(TARGET_NAME)";
374 | 				SWIFT_EMIT_LOC_STRINGS = NO;
375 | 				TARGETED_DEVICE_FAMILY = "1,2";
376 | 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Mastermind.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Mastermind";
377 | 			};
378 | 			name = Debug;
379 | 		};
380 | 		0F7025312B72E913006327F4 /* Release */ = {
381 | 			isa = XCBuildConfiguration;
382 | 			buildSettings = {
383 | 				BUNDLE_LOADER = "$(TEST_HOST)";
384 | 				CODE_SIGN_STYLE = Automatic;
385 | 				CURRENT_PROJECT_VERSION = 1;
386 | 				DEVELOPMENT_TEAM = EH4R632375;
387 | 				GENERATE_INFOPLIST_FILE = YES;
388 | 				MARKETING_VERSION = 1.0;
389 | 				PRODUCT_BUNDLE_IDENTIFIER = org.qualitycoding.MastermindTests;
390 | 				PRODUCT_NAME = "$(TARGET_NAME)";
391 | 				SWIFT_EMIT_LOC_STRINGS = NO;
392 | 				TARGETED_DEVICE_FAMILY = "1,2";
393 | 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Mastermind.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Mastermind";
394 | 			};
395 | 			name = Release;
396 | 		};
397 | /* End XCBuildConfiguration section */
398 | 
399 | /* Begin XCConfigurationList section */
400 | 		0F7025102B72E88B006327F4 /* Build configuration list for PBXProject "Mastermind" */ = {
401 | 			isa = XCConfigurationList;
402 | 			buildConfigurations = (
403 | 				0F7025212B72E88C006327F4 /* Debug */,
404 | 				0F7025222B72E88C006327F4 /* Release */,
405 | 			);
406 | 			defaultConfigurationIsVisible = 0;
407 | 			defaultConfigurationName = Release;
408 | 		};
409 | 		0F7025232B72E88C006327F4 /* Build configuration list for PBXNativeTarget "Mastermind" */ = {
410 | 			isa = XCConfigurationList;
411 | 			buildConfigurations = (
412 | 				0F7025242B72E88C006327F4 /* Debug */,
413 | 				0F7025252B72E88C006327F4 /* Release */,
414 | 			);
415 | 			defaultConfigurationIsVisible = 0;
416 | 			defaultConfigurationName = Release;
417 | 		};
418 | 		0F7025322B72E913006327F4 /* Build configuration list for PBXNativeTarget "MastermindTests" */ = {
419 | 			isa = XCConfigurationList;
420 | 			buildConfigurations = (
421 | 				0F7025302B72E913006327F4 /* Debug */,
422 | 				0F7025312B72E913006327F4 /* Release */,
423 | 			);
424 | 			defaultConfigurationIsVisible = 0;
425 | 			defaultConfigurationName = Release;
426 | 		};
427 | /* End XCConfigurationList section */
428 | 
429 | /* Begin XCRemoteSwiftPackageReference section */
430 | 		0F1F6ECF2BA759C7001611A4 /* XCRemoteSwiftPackageReference "ViewInspector" */ = {
431 | 			isa = XCRemoteSwiftPackageReference;
432 | 			repositoryURL = "https://github.com/nalexn/ViewInspector.git";
433 | 			requirement = {
434 | 				kind = upToNextMinorVersion;
435 | 				minimumVersion = 0.10.1;
436 | 			};
437 | 		};
438 | 		0F6949082D2AFD1100CC5211 /* XCRemoteSwiftPackageReference "swift-snapshot-testing" */ = {
439 | 			isa = XCRemoteSwiftPackageReference;
440 | 			repositoryURL = "https://github.com/pointfreeco/swift-snapshot-testing.git";
441 | 			requirement = {
442 | 				kind = upToNextMajorVersion;
443 | 				minimumVersion = 1.17.6;
444 | 			};
445 | 		};
446 | /* End XCRemoteSwiftPackageReference section */
447 | 
448 | /* Begin XCSwiftPackageProductDependency section */
449 | 		0F1F6ED02BA759C7001611A4 /* ViewInspector */ = {
450 | 			isa = XCSwiftPackageProductDependency;
451 | 			package = 0F1F6ECF2BA759C7001611A4 /* XCRemoteSwiftPackageReference "ViewInspector" */;
452 | 			productName = ViewInspector;
453 | 		};
454 | 		0F6949092D2AFD1100CC5211 /* SnapshotTesting */ = {
455 | 			isa = XCSwiftPackageProductDependency;
456 | 			package = 0F6949082D2AFD1100CC5211 /* XCRemoteSwiftPackageReference "swift-snapshot-testing" */;
457 | 			productName = SnapshotTesting;
458 | 		};
459 | /* End XCSwiftPackageProductDependency section */
460 | 	};
461 | 	rootObject = 0F70250D2B72E88B006327F4 /* Project object */;
462 | }
463 | 


--------------------------------------------------------------------------------