diff --git a/.claude/docs/technology-stack.md b/.claude/docs/technology-stack.md index b5e4b9e94..d93bc3a86 100644 --- a/.claude/docs/technology-stack.md +++ b/.claude/docs/technology-stack.md @@ -4,6 +4,22 @@ Open `Code.xcodeproj` in Xcode 16.x. Swift packages resolve automatically on first open. Build and run the `Flipcash` scheme. +## Commit stamp + +`Scripts/write_commit_xcconfig` writes `GIT_COMMIT_SHA` into the gitignored +`Configurations/commit.local.xcconfig`; Info.plist exposes it as `FCGitCommit`, read by +`AppMeta.commit` and parsed by `BuildCommit`. It runs from the Flipcash scheme's build +pre-action (pre-actions run before build settings are read, so the value lands in the same +build; a Run Script phase would be one build stale and can't reach `.git` under +`ENABLE_USER_SCRIPT_SANDBOXING`) and from `ci_scripts/ci_pre_xcodebuild.sh`, which prefers +`CI_COMMIT` and never marks the build dirty. Locally, `*` marks uncommitted changes to tracked +files (`git diff --quiet HEAD`, excluding the generated `GoogleService-Info.plist`), the same rule +Android uses. `base.xcconfig` defaults it to `unknown`. The footer format is shared with Android: +keep `AppMeta.versionFooter` and Android's `VersionInfo.commitLabel` in step. The track after +the hash comes from `ReleaseTrack`: `development` under `#if DEBUG`, `beta` when StoreKit's +`AppTransaction` environment is `.sandbox` (TestFlight), none on the App Store. Don't +change `CFBundleVersion` for this: `SessionAuthenticator.requiresUpgrade` parses it. + ## Protos: consumed, not generated here This repo no longer vendors `.proto` files or runs protoc. The generated Swift ships from two diff --git a/.gitignore b/.gitignore index 0df4412c2..cd6ffae28 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ ## Private assets Configurations/secrets.local.xcconfig +Configurations/commit.local.xcconfig ci_scripts/ci_post_xcodebuild.sh .env .env.local diff --git a/Code.xcodeproj/xcshareddata/xcschemes/Flipcash.xcscheme b/Code.xcodeproj/xcshareddata/xcschemes/Flipcash.xcscheme index 695064917..9fce46577 100644 --- a/Code.xcodeproj/xcshareddata/xcschemes/Flipcash.xcscheme +++ b/Code.xcodeproj/xcshareddata/xcschemes/Flipcash.xcscheme @@ -23,6 +23,22 @@ + + + + + + + + UIColorName background + FCGitCommit + $(GIT_COMMIT_SHA) bugsnag apiKey diff --git a/Flipcash/Utilities/ErrorReporting.swift b/Flipcash/Utilities/ErrorReporting.swift index 40ff1e3eb..2774005ea 100644 --- a/Flipcash/Utilities/ErrorReporting.swift +++ b/Flipcash/Utilities/ErrorReporting.swift @@ -38,6 +38,9 @@ enum ErrorReporting { static func initialize() { let config = BugsnagConfiguration.loadConfig() config.maxStringValueLength = 50_000 + // The raw stamp, `*` dirty marker included: CFBundleVersion is Xcode Cloud's run + // counter and maps to no commit on its own. + config.addMetadata(AppMeta.commit, key: "commit", section: "app") Bugsnag.start(with: config) isEnabled = true } diff --git a/Flipcash/Utilities/ReleaseTrack.swift b/Flipcash/Utilities/ReleaseTrack.swift new file mode 100644 index 000000000..14adf3612 --- /dev/null +++ b/Flipcash/Utilities/ReleaseTrack.swift @@ -0,0 +1,36 @@ +// +// ReleaseTrack.swift +// Flipcash +// + +import StoreKit + +/// The distribution channel shown after the commit in the version footer, named as Android names it. +nonisolated enum ReleaseTrack { + + /// The track for this build: `development` for a DEBUG build, `beta` on TestFlight, and + /// `nil` on the App Store or when StoreKit can't say. + /// + /// TestFlight and the App Store run the same Release binary, so only StoreKit's + /// `AppTransaction` environment tells them apart. + static func current() async -> String? { + #if DEBUG + return name(isDebug: true, environment: nil) + #else + let environment = try? await AppTransaction.shared.payloadValue.environment + return name(isDebug: false, environment: environment) + #endif + } + + /// Maps a build to its track name; `nil` means no track is shown. + static func name(isDebug: Bool, environment: AppStore.Environment?) -> String? { + if isDebug { + return "development" + } + // AppStore.Environment is a struct, so this can't be an exhaustive switch. + if environment == .sandbox { + return "beta" + } + return nil + } +} diff --git a/FlipcashCore/Sources/FlipcashCore/Clients/AppMeta.swift b/FlipcashCore/Sources/FlipcashCore/Clients/AppMeta.swift index baea44565..93cd6a54b 100644 --- a/FlipcashCore/Sources/FlipcashCore/Clients/AppMeta.swift +++ b/FlipcashCore/Sources/FlipcashCore/Clients/AppMeta.swift @@ -23,4 +23,29 @@ public enum AppMeta { public static var build: String { Bundle.main.object(forInfoDictionaryKey: "CFBundleVersion") as? String ?? unknown } + + /// The git commit stamp the app was built from, or ``unknown`` when the host bundle doesn't + /// declare one. Parse it with ``BuildCommit`` for display. + public static var commit: String { + Bundle.main.object(forInfoDictionaryKey: "FCGitCommit") as? String ?? unknown + } + + /// The You screen's version footer, in the format Android's footer uses. + /// + /// Two lines, `Version • Build ` over the commit label followed by + /// ` • ` when there is one. Without a commit it falls back to the single line + /// `Version • Build `, with the track appended the same way. + public static func versionFooter( + version: String = version, + build: String = build, + commit: BuildCommit, + track: String? = nil + ) -> String { + let trackSuffix = track.map { " • \($0)" } ?? "" + let versionLine = "Version \(version) • Build \(build)" + guard let label = commit.label else { + return versionLine + trackSuffix + } + return versionLine + "\n" + label + trackSuffix + } } diff --git a/FlipcashCore/Sources/FlipcashCore/Clients/BuildCommit.swift b/FlipcashCore/Sources/FlipcashCore/Clients/BuildCommit.swift new file mode 100644 index 000000000..416b3f5d8 --- /dev/null +++ b/FlipcashCore/Sources/FlipcashCore/Clients/BuildCommit.swift @@ -0,0 +1,45 @@ +// +// BuildCommit.swift +// FlipcashCore +// + +import Foundation + +/// The git commit a build was made from, parsed from the stamp in ``AppMeta/commit``. +/// +/// The stamp is a 40-character SHA, suffixed `*` when a local build had uncommitted changes to +/// tracked files. Anything else, including ``AppMeta/unknown``, parses as no commit. +public struct BuildCommit: Equatable, Sendable { + + /// Characters of the SHA shown in ``label``, matched by Android's version footer. + public static let labelLength = 10 + + private static let dirtyMarker = "*" + + /// The full 40-character SHA, or `nil` when the build carried no usable stamp. + public let sha: String? + + /// Whether the build was made with uncommitted changes to tracked files. + public let isDirty: Bool + + /// Parses a stamp as written by `Scripts/write_commit_xcconfig`. + public init(_ stamp: String) { + let dirty = stamp.hasSuffix(Self.dirtyMarker) + let candidate = dirty ? String(stamp.dropLast(Self.dirtyMarker.count)) : stamp + + if candidate.count == 40, candidate.allSatisfy(\.isHexDigit) { + sha = candidate.lowercased() + isDirty = dirty + } else { + sha = nil + isDirty = false + } + } + + /// The commit as the version footer shows it: the first ``labelLength`` characters of the + /// SHA with `*` appended for a dirty build, or `nil` when there is no commit. + public var label: String? { + guard let sha else { return nil } + return String(sha.prefix(Self.labelLength)) + (isDirty ? Self.dirtyMarker : "") + } +} diff --git a/FlipcashCore/Tests/FlipcashCoreTests/AppMetaTests.swift b/FlipcashCore/Tests/FlipcashCoreTests/AppMetaTests.swift index 2f0cd434f..029ef9461 100644 --- a/FlipcashCore/Tests/FlipcashCoreTests/AppMetaTests.swift +++ b/FlipcashCore/Tests/FlipcashCoreTests/AppMetaTests.swift @@ -22,6 +22,11 @@ struct AppMetaTests { #expect(!AppMeta.build.isEmpty) } + @Test("Commit reads without trapping and is never empty") + func commitDegrades() { + #expect(!AppMeta.commit.isEmpty) + } + @Test("The build stand-in stays unparseable, so requiresUpgrade allows access") func buildStandInIsNotNumeric() { #expect(UInt32(AppMeta.unknown) == nil) diff --git a/FlipcashCore/Tests/FlipcashCoreTests/BuildCommitTests.swift b/FlipcashCore/Tests/FlipcashCoreTests/BuildCommitTests.swift new file mode 100644 index 000000000..6e69fb04b --- /dev/null +++ b/FlipcashCore/Tests/FlipcashCoreTests/BuildCommitTests.swift @@ -0,0 +1,81 @@ +// +// BuildCommitTests.swift +// FlipcashCoreTests +// + +import Testing +@testable import FlipcashCore + +@Suite("BuildCommit — parsing the build's commit stamp and formatting the version footer") +struct BuildCommitTests { + + private static let sha = "2acfecffeb4d1c3b8e0f9a7d6c5b4a3928170615" + + @Test("A clean stamp keeps the full SHA and labels it with the first 10 characters") + func cleanStamp() { + let commit = BuildCommit(Self.sha) + #expect(commit.sha == Self.sha) + #expect(commit.isDirty == false) + #expect(commit.label == "2acfecffeb") + } + + @Test("A dirty stamp keeps the full SHA and appends an asterisk to the label") + func dirtyStamp() { + let commit = BuildCommit(Self.sha + "*") + #expect(commit.sha == Self.sha) + #expect(commit.isDirty) + #expect(commit.label == "2acfecffeb*") + } + + @Test("An uppercase SHA is normalized to git's lowercase") + func uppercaseStamp() { + #expect(BuildCommit(Self.sha.uppercased()).sha == Self.sha) + } + + @Test( + "Anything that isn't a 40-character SHA has no label", + arguments: [ + AppMeta.unknown, + "", + "$(GIT_COMMIT_SHA)", + "*", + "2acfecffeb", + "2acfecffeb*", + "2acfecffeb4d1c3b8e0f9a7d6c5b4a3928170615-dirty", + "2acfecffeb4d1c3b8e0f9a7d6c5b4a39281706150", + "zacfecffeb4d1c3b8e0f9a7d6c5b4a3928170615", + ] + ) + func unusableStamp(stamp: String) { + let commit = BuildCommit(stamp) + #expect(commit.sha == nil) + #expect(commit.isDirty == false) + #expect(commit.label == nil) + } + + // MARK: - Footer - + + @Test("The footer puts the commit on its own line") + func footerWithCommit() { + let footer = AppMeta.versionFooter(version: "2026.9.3", build: "272", commit: BuildCommit(Self.sha)) + #expect(footer == "Version 2026.9.3 • Build 272\n2acfecffeb") + } + + @Test("A track follows the commit on the second line") + func footerWithCommitAndTrack() { + let footer = AppMeta.versionFooter(version: "2026.9.3", build: "272", commit: BuildCommit(Self.sha + "*"), track: "beta") + #expect(footer == "Version 2026.9.3 • Build 272\n2acfecffeb* • beta") + } + + @Test("Without a commit the footer is the old single line") + func footerWithoutCommit() { + let footer = AppMeta.versionFooter(version: "2026.9.3", build: "272", commit: BuildCommit(AppMeta.unknown)) + #expect(footer == "Version 2026.9.3 • Build 272") + } + + @Test("Without a commit a track stays on the single line") + func footerWithoutCommitWithTrack() { + let footer = AppMeta.versionFooter(version: "2026.9.3", build: "272", commit: BuildCommit(AppMeta.unknown), track: "beta") + #expect(footer == "Version 2026.9.3 • Build 272 • beta") + } +} diff --git a/FlipcashTests/ReleaseTrackTests.swift b/FlipcashTests/ReleaseTrackTests.swift new file mode 100644 index 000000000..e61ec12b2 --- /dev/null +++ b/FlipcashTests/ReleaseTrackTests.swift @@ -0,0 +1,27 @@ +// +// ReleaseTrackTests.swift +// FlipcashTests +// + +import StoreKit +import Testing +@testable import Flipcash + +@Suite("Release track shown in the version footer") +struct ReleaseTrackTests { + + @Test("A debug build is development, whatever StoreKit says", arguments: [nil, .sandbox, .production, .xcode] as [AppStore.Environment?]) + func debugIsDevelopment(environment: AppStore.Environment?) { + #expect(ReleaseTrack.name(isDebug: true, environment: environment) == "development") + } + + @Test("TestFlight is beta") + func testFlightIsBeta() { + #expect(ReleaseTrack.name(isDebug: false, environment: .sandbox) == "beta") + } + + @Test("The App Store, an Xcode install, and an unknown environment show no track", arguments: [nil, .production, .xcode] as [AppStore.Environment?]) + func otherwiseNoTrack(environment: AppStore.Environment?) { + #expect(ReleaseTrack.name(isDebug: false, environment: environment) == nil) + } +} diff --git a/Scripts/write_commit_xcconfig b/Scripts/write_commit_xcconfig new file mode 100755 index 000000000..128482beb --- /dev/null +++ b/Scripts/write_commit_xcconfig @@ -0,0 +1,57 @@ +#!/usr/bin/env bash + +# Writes the commit being built into Configurations/commit.local.xcconfig as +# GIT_COMMIT_SHA, suffixed `*` for a local build with uncommitted changes to +# tracked files. The Flipcash Info.plist reads it as FCGitCommit. +# +# Runs as a scheme pre-action (before build settings are read, so the value +# lands in the same build) and from ci_scripts/ci_pre_xcodebuild.sh. It never +# fails the build: when the commit can't be determined any stale file is +# removed and base.xcconfig's `unknown` default applies. +# +# Usage: write_commit_xcconfig + +SOURCE_ROOT="$1" + +if [ ! -d "$SOURCE_ROOT" ]; then + echo "warning: No source directory provided: $SOURCE_ROOT. Skipping commit stamp." + exit 0 +fi + +OUTPUT="$SOURCE_ROOT/Configurations/commit.local.xcconfig" + +# Xcode Cloud names the commit it checked out. Its clone is never dirty, so the +# dirty check is skipped there rather than trusted to a working tree CI may +# have touched (package resolution, generated plists). +if [ -n "$CI_COMMIT" ]; then + COMMIT="$CI_COMMIT" + DIRTY="" +else + COMMIT=$(git -C "$SOURCE_ROOT" rev-parse HEAD 2>/dev/null) + # Tracked changes only, matching Android: untracked files never mark a build + # dirty. GoogleService-Info.plist is tracked but rewritten from secrets by the + # "Generate Google" phase on every build, so it doesn't count either. + if git -C "$SOURCE_ROOT" diff --quiet HEAD -- . \ + ':(exclude)Flipcash/Supporting Files/GoogleService-Info.plist' 2>/dev/null; then + DIRTY="" + else + DIRTY="*" + fi +fi + +if ! [[ "$COMMIT" =~ ^[0-9a-f]{40}$ ]]; then + echo "warning: Could not determine the git commit. The build will report 'unknown'." + rm -f "$OUTPUT" + exit 0 +fi + +CONTENT="GIT_COMMIT_SHA = $COMMIT$DIRTY" + +# Rewriting an unchanged file would still bump its timestamp and invalidate +# the Info.plist step on every build. +if [ -f "$OUTPUT" ] && [ "$(cat "$OUTPUT")" = "$CONTENT" ]; then + exit 0 +fi + +echo "$CONTENT" > "$OUTPUT" +echo "Stamped $COMMIT$DIRTY" diff --git a/ci_scripts/ci_pre_xcodebuild.sh b/ci_scripts/ci_pre_xcodebuild.sh new file mode 100755 index 000000000..4690d00d7 --- /dev/null +++ b/ci_scripts/ci_pre_xcodebuild.sh @@ -0,0 +1,6 @@ +#!/bin/sh + +# Stamp CI_COMMIT into the build. The scheme pre-action does the same, but it +# runs only for scheme-driven actions; this covers every xcodebuild Xcode Cloud +# runs, and it never fails the build. +"$CI_PRIMARY_REPOSITORY_PATH/Scripts/write_commit_xcconfig" "$CI_PRIMARY_REPOSITORY_PATH"