241 lines
12 KiB
Swift
241 lines
12 KiB
Swift
import SwiftUI
|
|
|
|
// MARK: - The git-mode section's state
|
|
|
|
/// **What the popover's git section shows on a git-mode board** — a pure function of four facts, so
|
|
/// the surface 06-history-undo.md describes is assertable without a popover on screen.
|
|
///
|
|
/// It exists for the same reason `BoardGitSection.resolve` does one level up: the *posture* is the
|
|
/// part worth pinning, and the SwiftUI that renders it is not. Three rules live here —
|
|
///
|
|
/// - **A paused repository names its state and disables the controls** (06 ▸ Rules ▸ Abnormal repo
|
|
/// states: "Undo/Redo and the branch controls disable … the popover's git section names the state
|
|
/// plainly … and says resolving it belongs to the tool that created it").
|
|
/// - **A read-only board disables them too** (02-architecture.md ▸ The lock's scope, which names "the
|
|
/// popover's git controls" outright).
|
|
/// - **A switch in flight disables them**, so a second click cannot start a second checkout.
|
|
/// - **An unreadable repository reads as broken, never as still loading** (06 ▸ Rules, the
|
|
/// corrupt-`.git` loud failure, ruled 2026-07-31: "Never a silent placeholder discovered only in
|
|
/// the popover").
|
|
struct BoardGitBranchSurface: Equatable {
|
|
|
|
/// What the branch line reads — the branch name, the short hash on a detached HEAD
|
|
/// (`GitRepository.branchName` decides which), the placeholder while the first read is in
|
|
/// flight, or `unavailableLabel` when there is no readable repository for it to name.
|
|
let branchLabel: String
|
|
|
|
/// Whether that label is the placeholder rather than an answer.
|
|
let isReadingBranch: Bool
|
|
|
|
/// The pause's own sentence (`GitRepositoryPause.explanation`), or `nil` when the surface is live.
|
|
let pauseExplanation: String?
|
|
|
|
/// **Whether the pause is the unopenable repository** — the one pause whose surface is not the
|
|
/// pause note: nothing is in progress and no tool is coming to finish it, so the section says
|
|
/// its own sentence instead (`unreadableNote`), and the branch line has no answer to wait for.
|
|
let isRepositoryUnreadable: Bool
|
|
|
|
/// Whether the branch controls accept a click — the popover's switch picker, and the settings
|
|
/// sheet's create field (`BoardSettingsSheet`), which resolves this same surface so that a
|
|
/// paused repository, a read-only board and a switch in flight close both by one rule.
|
|
let controlsEnabled: Bool
|
|
|
|
/// The line the branch display is read as by VoiceOver.
|
|
///
|
|
/// The broken case is spelled out rather than left to fall through "Branch \(label)": the label
|
|
/// is a *state* there, not a name, and "Branch Unavailable" would read as a branch somebody
|
|
/// called Unavailable.
|
|
var accessibilityLabel: String {
|
|
if isRepositoryUnreadable { return "Branch unavailable" }
|
|
return isReadingBranch ? "Reading branch" : "Branch \(branchLabel)"
|
|
}
|
|
|
|
static let placeholder = "…"
|
|
|
|
/// **What the branch line reads when the repository will not open** — an answer, not a
|
|
/// placeholder, which is the whole of the ruling's "fails loudly" at this one control: the
|
|
/// placeholder means "still reading" and would go on meaning it forever here.
|
|
static let unavailableLabel = "Unavailable"
|
|
|
|
/// The second half of the paused sentence — 06's "says resolving it belongs to the tool that
|
|
/// created it", said in the app's own voice and paired with the promise that makes it safe to
|
|
/// wait: the app is not going to touch the repository behind the user's back.
|
|
static let pauseCaption =
|
|
"Finishing it belongs to the tool that started it; Lanework leaves the repository untouched."
|
|
|
|
/// **The popover's own sentence for an unreadable repository** (06 ▸ Rules, the corrupt-`.git`
|
|
/// loud failure, ruled 2026-07-31: "with the whole git surface paused … and the popover's git
|
|
/// section naming the state").
|
|
///
|
|
/// A sibling of the nested and unverifiable notes (`BoardInfoPopover`) and written in their
|
|
/// register — one sentence, the state first and the consequence after — rather than the pause
|
|
/// note's two lines, because both of *those* lines would be wrong here: nothing is "in
|
|
/// progress", and there is no tool whose job it is to finish it. What it keeps from the pause
|
|
/// note is the promise that matters most on a repository the app cannot read, in the ruling's
|
|
/// own words.
|
|
///
|
|
/// It is deliberately **not** the banner's sentence (`BannerCenter.repositoryUnreadableMessage`)
|
|
/// re-used: the strip announces a condition to somebody who has not asked, and this answers
|
|
/// somebody looking straight at the git section — the register the neighbouring notes set.
|
|
static let unreadableNote =
|
|
"Lanework can't read this board's git repository, so history is paused; the repository is left untouched."
|
|
|
|
static func resolve(
|
|
branch: String?,
|
|
pause: GitRepositoryPause?,
|
|
isSwitching: Bool,
|
|
isWritable: Bool
|
|
) -> BoardGitBranchSurface {
|
|
// Derived from the pause rather than passed in beside it: the pause *is* how this state is
|
|
// carried everywhere else (`GitRepositoryPause.unreadable`, seeded by the detection-time
|
|
// probe and refreshed by every later read), so a second parameter would be a second answer
|
|
// to one question — and a caller could hold them apart.
|
|
let unreadable = pause == .unreadable
|
|
return BoardGitBranchSurface(
|
|
branchLabel: unreadable ? unavailableLabel : (branch ?? placeholder),
|
|
// Never "reading" on an unreadable repository: there is nothing in flight, and the line
|
|
// the ruling forbids is exactly the one that says otherwise forever.
|
|
isReadingBranch: !unreadable && branch == nil,
|
|
pauseExplanation: pause?.explanation,
|
|
isRepositoryUnreadable: unreadable,
|
|
controlsEnabled: pause == nil && isWritable && !isSwitching
|
|
)
|
|
}
|
|
}
|
|
|
|
// MARK: - The git-mode section
|
|
|
|
/// **The popover's git section on a board that has a repository** (03-board-ui.md ▸ Board popover;
|
|
/// 06-history-undo.md ▸ Branch switching).
|
|
///
|
|
/// **The daily face, and only that** (the 2026-07-31 popover/sheet split): the branch display with
|
|
/// its **switch** picker, and the pause explanation when the surface is held. Branch *creation* and
|
|
/// the commit-identity fields left with the split — they are setup, and setup's home is the board
|
|
/// settings sheet (`BoardSettingsSheet`), which the section's Board Settings… row opens.
|
|
///
|
|
/// **Shaped for the half that is not here yet.** Remote tracking, Pull/Push and the status badges are
|
|
/// 07-sync-collab.md's own cards, and this section is arranged so they join as one more block under
|
|
/// the branch controls — nothing here is nested inside anything they would have to be pulled out of,
|
|
/// and nothing about the branch controls assumes there is no upstream to show beside them.
|
|
struct BoardGitControls: View {
|
|
|
|
let git: HistoryStore
|
|
|
|
/// The read-only lock's reach (02-architecture.md ▸ The lock's scope): a board that refuses writes
|
|
/// refuses a checkout most of all — it rewrites the tree the lock exists to stop describing.
|
|
let isEnabled: Bool
|
|
|
|
private var surface: BoardGitBranchSurface {
|
|
BoardGitBranchSurface.resolve(
|
|
branch: git.branch,
|
|
pause: git.committer?.pause,
|
|
isSwitching: git.switcher?.isSwitching ?? false,
|
|
isWritable: isEnabled
|
|
)
|
|
}
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
branchRow
|
|
|
|
// **The unreadable repository names itself in its own sentence** (06 ▸ Rules, the
|
|
// corrupt-`.git` loud failure) — checked before the pause note because it *is* a pause,
|
|
// and the pause note's second line ("finishing it belongs to the tool that started it")
|
|
// would be advice about an operation nobody started.
|
|
if surface.isRepositoryUnreadable {
|
|
caption(BoardGitBranchSurface.unreadableNote, tone: .primary)
|
|
} else if let explanation = surface.pauseExplanation {
|
|
pauseNote(explanation)
|
|
}
|
|
|
|
if let failure = git.switcher?.lastFailure {
|
|
caption(failure.message, tone: .red)
|
|
}
|
|
}
|
|
// Every read the section needs, taken when it appears rather than held live: the popover is
|
|
// built fresh on each open (`BoardInfoWidget`), and none of these is a fact the board's
|
|
// watcher could deliver — `.git` is filtered out of the watch by design.
|
|
.task {
|
|
await git.refreshBranch()
|
|
await git.committer?.refreshPause()
|
|
await git.switcher?.refreshBranches()
|
|
}
|
|
}
|
|
|
|
// MARK: The branch line
|
|
|
|
/// The branch display and the switch, as one control: the line *is* the picker, which is what
|
|
/// makes "branch/source display and switching" one affordance rather than a label with a button
|
|
/// beside it.
|
|
///
|
|
/// **Switch entries and nothing else** since the 2026-07-31 split — the "New Branch…" entry that
|
|
/// used to close the menu is the settings sheet's standing Create field now. On a board with one
|
|
/// branch the menu is therefore *empty*, and that is left honest rather than papered over: the
|
|
/// label still reads the current branch and still disables with the rest of the git surface, so
|
|
/// the line goes on saying the one thing it is here to say.
|
|
private var branchRow: some View {
|
|
HStack(spacing: 6) {
|
|
Image(systemName: "arrow.triangle.branch")
|
|
.imageScale(.small)
|
|
.foregroundStyle(.secondary)
|
|
|
|
Menu {
|
|
ForEach(otherBranches, id: \.self) { name in
|
|
Button(name) {
|
|
Task { await git.switcher?.switchTo(name) }
|
|
}
|
|
}
|
|
} label: {
|
|
Text(surface.branchLabel)
|
|
.font(.callout)
|
|
.foregroundStyle(surface.isReadingBranch ? .secondary : .primary)
|
|
}
|
|
.menuStyle(.borderlessButton)
|
|
.fixedSize()
|
|
.disabled(!surface.controlsEnabled)
|
|
.accessibilityLabel(surface.accessibilityLabel)
|
|
.accessibilityHint("Switch branches")
|
|
|
|
if git.switcher?.isSwitching == true {
|
|
ProgressView()
|
|
.controlSize(.small)
|
|
.accessibilityLabel("Switching branches")
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Every local branch except the one already checked out — a picker offering the current branch
|
|
/// would be offering a no-op, and the switch refuses one anyway.
|
|
private var otherBranches: [String] {
|
|
(git.switcher?.branches ?? []).filter { $0 != git.branch }
|
|
}
|
|
|
|
// MARK: The pause
|
|
|
|
/// **The abnormal-state surface** (06 ▸ Rules ▸ Abnormal repo states) — deferred here from the
|
|
/// auto-commit card, which built the hold this explains.
|
|
///
|
|
/// Two sentences, both of them the design's: what the repository is doing, and whose job it is to
|
|
/// finish. Never a Repair button — "the app never mutates repo state it didn't create".
|
|
private func pauseNote(_ explanation: String) -> some View {
|
|
VStack(alignment: .leading, spacing: 2) {
|
|
Text(explanation)
|
|
.font(.caption)
|
|
.foregroundStyle(.primary)
|
|
.fixedSize(horizontal: false, vertical: true)
|
|
Text(BoardGitBranchSurface.pauseCaption)
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
.fixedSize(horizontal: false, vertical: true)
|
|
}
|
|
.accessibilityElement(children: .combine)
|
|
}
|
|
|
|
private func caption(_ text: String, tone: Color) -> some View {
|
|
Text(text)
|
|
.font(.caption)
|
|
.foregroundStyle(tone)
|
|
.fixedSize(horizontal: false, vertical: true)
|
|
}
|
|
}
|