rzen
bec75e4282
The trash sorts by modified descending — the arrival rank mint retires (Ranks.isOrderedForTrash one comparator, loader + merged order agree; the legacy deleted: migration stamps modified from the tombstone timestamp where parseable; delete undo steps validate existence-only; agent guide v8). Trash selection goes kind-blind — ranges, marquee, Select All, and the successor walk sweep both kinds; the guard moves to the exits (mixed-payload drop refusal, copy/cut validation). The copy stamping preflight widens back to comment depth (load-scoped posture — the board always loads, the gesture refuses whole). Fixes a latent no-op: trashed-lane drag restore never fired (DragSession.beginLanes hard-coded the board container). 2403 tests in 413 suites green. Claude-Session: https://claude.ai/code/session_01CqjXB7ASoWtbyoGod68k97
733 lines
34 KiB
Swift
733 lines
34 KiB
Swift
import CoreGraphics
|
|
import Foundation
|
|
import Testing
|
|
@testable import Kanban
|
|
|
|
/// 04-interactions.md § Selection's pointer grammar and § The trash's extensions to it, branch by
|
|
/// branch — plus the anchor that makes ⇧-click mean anything, and the rubber band's arithmetic.
|
|
///
|
|
/// The grammar is written as a pure function precisely so it can be tested like one: a click, a
|
|
/// selection, an anchor and a snapshot in, a selection and an anchor out — no window, no gesture, no
|
|
/// modifier flags. The boards underneath are **real loads off real temp trees**, because the rules
|
|
/// read card ordering and the trash container, and a hand-built `BoardModel` would let both drift
|
|
/// from what the loader actually produces.
|
|
///
|
|
/// **One container axis, and a kind axis that stops at it** (resettled 2026-07-28; kind-blind trash
|
|
/// re-ruled 2026-07-31): a selection never mixes trash rows with board items, and *on the board* it
|
|
/// is cards XOR lanes — but inside the trash "cards and lane rows select together", so the kind axis
|
|
/// does not reach into the second container. The guard that used to live there moved to the exits
|
|
/// (⌘C/⌘X validation and the mixed-payload drop refusal).
|
|
///
|
|
/// `WriterFixture`, `Ident` and `Item` live in `WriterTestSupport.swift`.
|
|
|
|
// MARK: - Fixtures
|
|
|
|
/// More literal identities than `Ident` offers: a three-lane range needs five cards.
|
|
private enum More {
|
|
static let card5 = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"
|
|
static let card6 = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb"
|
|
}
|
|
|
|
/// Three lanes and five cards — enough that a flatten-order range crosses two lane boundaries.
|
|
///
|
|
/// Flatten order is `[card1, card2, card3, card4, card5]`.
|
|
@MainActor
|
|
private func makeLiveBoard() throws -> WriterFixture {
|
|
let fixture = try WriterFixture()
|
|
try fixture.item("", Item.board)
|
|
try fixture.item(Ident.lane1, Item.rich(order: "1024", title: "Todo"))
|
|
try fixture.item("\(Ident.lane1)/\(Ident.card1)", Item.rich(order: "1024", title: "First"))
|
|
try fixture.item("\(Ident.lane1)/\(Ident.card2)", Item.rich(order: "2048", title: "Second"))
|
|
try fixture.item(Ident.lane2, Item.rich(order: "2048", title: "Doing"))
|
|
try fixture.item("\(Ident.lane2)/\(Ident.card3)", Item.rich(order: "1024", title: "Third"))
|
|
try fixture.item("\(Ident.lane2)/\(Ident.card4)", Item.rich(order: "2048", title: "Fourth"))
|
|
try fixture.item(Ident.lane3, Item.rich(order: "3072", title: "Done"))
|
|
try fixture.item("\(Ident.lane3)/\(More.card5)", Item.rich(order: "1024", title: "Fifth"))
|
|
return fixture
|
|
}
|
|
|
|
/// A board with one lane and three cards in its `.trash/` — the container the trash-side grammar
|
|
/// walks, newest first by `modified` (`[card1, card2, card3]`).
|
|
@MainActor
|
|
private func makeTrashBoard() throws -> WriterFixture {
|
|
let fixture = try WriterFixture()
|
|
try fixture.item("", Item.board)
|
|
try fixture.item(Ident.lane1, Item.rich(order: "1024", title: "Todo"))
|
|
try fixture.item("\(Ident.lane1)/\(More.card6)", Item.rich(order: "1024", title: "Live"))
|
|
// **The trash's order is `modified` descending** (01-storage-format.md § Deletion, re-ruled
|
|
// 2026-07-31), so the stamps are what these fixtures state their sequence in; the `order` values
|
|
// ride along and are deliberately in the *opposite* direction, so nothing here can pass by
|
|
// accident of the retired rank rule.
|
|
try fixture.item(".trash/\(Ident.card1)", trashItem(order: "1024", title: "First", modified: "2026-05-05T09:00:00Z"))
|
|
try fixture.item(".trash/\(Ident.card2)", trashItem(order: "512", title: "Second", modified: "2026-05-03T09:00:00Z"))
|
|
try fixture.item(".trash/\(Ident.card3)", trashItem(order: "256", title: "Third", modified: "2026-05-01T09:00:00Z"))
|
|
return fixture
|
|
}
|
|
|
|
/// One trash entry, stated in the key the container actually sorts by.
|
|
private func trashItem(order: String, title: String, modified: String, kind: String? = nil) -> String {
|
|
"""
|
|
---
|
|
schema: 1
|
|
title: \(title)
|
|
order: \(order)
|
|
modified: \(modified)
|
|
\(kind.map { "kind: \($0)\n" } ?? "")---
|
|
\(title) body.
|
|
|
|
"""
|
|
}
|
|
|
|
/// The same trash with **two lane rows interleaved among its cards** (03-board-ui.md § Trash, lanes
|
|
/// rejoined 2026-07-29): the column order is `[card1, lane2, card2, lane3, card3]`, so every
|
|
/// kind-crossing claim below has a row of the other kind sitting inside the span it asks about.
|
|
@MainActor
|
|
private func makeMixedTrashBoard() throws -> WriterFixture {
|
|
let fixture = try makeTrashBoard()
|
|
try fixture.item(
|
|
".trash/\(Ident.lane2)",
|
|
trashItem(order: "384", title: "Doing", modified: "2026-05-04T09:00:00Z", kind: "lane")
|
|
)
|
|
try fixture.item(
|
|
".trash/\(Ident.lane3)",
|
|
trashItem(order: "768", title: "Done", modified: "2026-05-02T09:00:00Z", kind: "lane")
|
|
)
|
|
return fixture
|
|
}
|
|
|
|
private let lane1 = ItemID(rawValue: Ident.lane1)
|
|
private let lane2 = ItemID(rawValue: Ident.lane2)
|
|
private let lane3 = ItemID(rawValue: Ident.lane3)
|
|
private let card1 = ItemID(rawValue: Ident.card1)
|
|
private let card2 = ItemID(rawValue: Ident.card2)
|
|
private let card3 = ItemID(rawValue: Ident.card3)
|
|
private let card4 = ItemID(rawValue: Ident.card4)
|
|
private let card5 = ItemID(rawValue: More.card5)
|
|
private let card6 = ItemID(rawValue: More.card6)
|
|
|
|
private func load(_ fixture: WriterFixture) throws -> BoardModel {
|
|
try BoardLoader.load(boardRoot: fixture.root).model
|
|
}
|
|
|
|
private func target(_ id: ItemID, _ kind: SelectionKind, _ container: ItemContainer = .board) -> SelectionTarget {
|
|
SelectionTarget(id: id, kind: kind, container: container)
|
|
}
|
|
|
|
private func set(_ ids: Set<ItemID>, _ container: ItemContainer = .board) -> ItemReferenceSet {
|
|
ItemReferenceSet(ids: ids, container: container)
|
|
}
|
|
|
|
/// One click, with the grammar's own defaults filled in.
|
|
private func click(
|
|
_ target: SelectionTarget,
|
|
_ modifier: ClickModifier,
|
|
selection: ItemReferenceSet = .empty,
|
|
anchor: ItemID? = nil,
|
|
in snapshot: BoardModel,
|
|
togglesOnRepeat: Bool = false
|
|
) -> SelectionGrammar.Outcome {
|
|
SelectionGrammar.click(
|
|
target,
|
|
modifier: modifier,
|
|
selection: selection,
|
|
anchor: anchor,
|
|
snapshot: snapshot,
|
|
togglesOnRepeat: togglesOnRepeat
|
|
)
|
|
}
|
|
|
|
// MARK: - The order lists
|
|
|
|
@MainActor
|
|
@Suite("SelectionGrammar ▸ order")
|
|
struct SelectionOrderTests {
|
|
|
|
@Test("Board cards flatten lane order first, then card order")
|
|
func flattenOrder() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
// "Lane `order` first, then card `order` (a cross-lane selection flattens left-to-right,
|
|
// top-to-bottom)" — the multi-drag order (04-interactions.md ▸ Drag and drop).
|
|
#expect(SelectionGrammar.boardCards(in: snapshot) == [card1, card2, card3, card4, card5])
|
|
#expect(SelectionGrammar.lanes(in: snapshot) == [lane1, lane2, lane3])
|
|
}
|
|
|
|
@Test("The trash's list is its rows, newest first; a trash with no lane rows is all cards")
|
|
func trashOrder() throws {
|
|
let fixture = try makeTrashBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
#expect(SelectionGrammar.trashCards(in: snapshot) == [card1, card2, card3])
|
|
#expect(SelectionGrammar.order(of: .card, in: .trash, snapshot: snapshot) == [card1, card2, card3])
|
|
// Kind-blind: with no lane rows in the container the two lists coincide, which is the point —
|
|
// there is only ever *one* trash list to walk (04 ▸ The trash, re-ruled 2026-07-31).
|
|
#expect(SelectionGrammar.order(of: .lane, in: .trash, snapshot: snapshot) == [card1, card2, card3])
|
|
#expect(SelectionGrammar.trashLanes(in: snapshot).isEmpty)
|
|
}
|
|
|
|
/// **The column has one list, and the kind argument does not narrow it** (04-interactions.md ▸
|
|
/// The trash, re-ruled 2026-07-31 — kind-blind trash selection): navigation and ranging read the
|
|
/// same merged sequence, so a ⇧-range sweeps the rows of the other kind rather than skipping
|
|
/// them. The kind-scoped slices survive as `trashCards`/`trashLanes` for the consumers that
|
|
/// genuinely mean one kind, and they are still slices of the same order.
|
|
@Test("The trash's rows interleave by stamp, and `order(of:in:)` returns them whatever the kind")
|
|
func trashRowsInterleave() throws {
|
|
let fixture = try makeMixedTrashBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
let rows = [card1, lane2, card2, lane3, card3]
|
|
#expect(SelectionGrammar.trashRows(in: snapshot) == rows)
|
|
#expect(SelectionGrammar.order(of: .card, in: .trash, snapshot: snapshot) == rows)
|
|
#expect(SelectionGrammar.order(of: .lane, in: .trash, snapshot: snapshot) == rows)
|
|
// The kind-scoped slices are still slices of it.
|
|
#expect(SelectionGrammar.trashCards(in: snapshot) == [card1, card2, card3])
|
|
#expect(SelectionGrammar.trashLanes(in: snapshot) == [lane2, lane3])
|
|
// One merge, one order: the path resolver batches in exactly the order the column draws.
|
|
#expect(ItemPath.resolve([card2, lane2, lane3], in: .trash, snapshot: snapshot)
|
|
== [.trashLane(lane2), .trashCard(card2), .trashLane(lane3)])
|
|
}
|
|
|
|
@Test("The trash's kind is derived from the snapshot for both kinds")
|
|
func trashKindDerivation() throws {
|
|
let fixture = try makeMixedTrashBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
#expect(SelectionGrammar.kind(of: set([card1, card2], .trash), in: snapshot) == .card)
|
|
#expect(SelectionGrammar.kind(of: set([lane2, lane3], .trash), in: snapshot) == .lane)
|
|
// A board id claimed on the trash side names nothing there — the container is the question.
|
|
#expect(SelectionGrammar.kind(of: set([card6], .trash), in: snapshot) == nil)
|
|
#expect(SelectionGrammar.kind(of: set([lane2]), in: snapshot) == nil, "and the reverse")
|
|
}
|
|
|
|
@Test("A selection's kind is derived from the snapshot, and a ghost selection has none")
|
|
func kindDerivation() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
#expect(SelectionGrammar.kind(of: set([card1, card3]), in: snapshot) == .card)
|
|
#expect(SelectionGrammar.kind(of: set([lane2]), in: snapshot) == .lane)
|
|
#expect(SelectionGrammar.kind(of: .empty, in: snapshot) == nil)
|
|
// A set claiming a container that does not hold its members answers nothing.
|
|
#expect(SelectionGrammar.kind(of: set([card1], .trash), in: snapshot) == nil)
|
|
// Members that name nothing are ignored; one that names something still answers.
|
|
#expect(SelectionGrammar.kind(of: set([ItemID(rawValue: Ident.indexless), card1]), in: snapshot) == .card)
|
|
}
|
|
}
|
|
|
|
// MARK: - Plain
|
|
|
|
@MainActor
|
|
@Suite("SelectionGrammar ▸ plain click")
|
|
struct PlainClickTests {
|
|
|
|
@Test("A plain click replaces the selection and becomes the anchor")
|
|
func replacesAndAnchors() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
let outcome = click(target(card3, .card), .plain, selection: set([card1, card2]), anchor: card1, in: snapshot)
|
|
#expect(outcome.selection == set([card3]))
|
|
#expect(outcome.anchor == card3)
|
|
}
|
|
|
|
@Test("Click again unselects — but only where the design gives that behaviour, and only on a sole selection")
|
|
func toggleOffIsSoleMembershipOnly() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
// "Single click selects the lane (click again to unselect)", and the header "toggles like
|
|
// empty space (settled)".
|
|
let off = click(target(lane1, .lane), .plain, selection: set([lane1]), anchor: lane1, in: snapshot, togglesOnRepeat: true)
|
|
#expect(off.selection.isEmpty)
|
|
#expect(off.anchor == nil)
|
|
|
|
// A multi-lane selection containing this lane is *narrowed*, not wiped: the toggle is about
|
|
// the lane the user already had alone, not about a set they built with ⌘.
|
|
let narrowed = click(target(lane1, .lane), .plain, selection: set([lane1, lane2]), anchor: lane2, in: snapshot, togglesOnRepeat: true)
|
|
#expect(narrowed.selection == set([lane1]))
|
|
#expect(narrowed.anchor == lane1)
|
|
|
|
// A card face never toggles off — Finder does not deselect a file by clicking it twice.
|
|
let card = click(target(card1, .card), .plain, selection: set([card1]), anchor: card1, in: snapshot)
|
|
#expect(card.selection == set([card1]))
|
|
#expect(card.anchor == card1)
|
|
|
|
// Nor does the toggle reach across the boundary: a board click on a trash-side sole
|
|
// selection of the same id is a replace.
|
|
let crossed = click(target(lane1, .lane), .plain, selection: set([lane1], .trash), anchor: lane1, in: snapshot, togglesOnRepeat: true)
|
|
#expect(crossed.selection == set([lane1]))
|
|
}
|
|
}
|
|
|
|
// MARK: - Command
|
|
|
|
@MainActor
|
|
@Suite("SelectionGrammar ▸ ⌘-click")
|
|
struct CommandClickTests {
|
|
|
|
@Test("⌘-click toggles within one kind, and the click is the new anchor either way")
|
|
func togglesWithinKind() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
let added = click(target(card3, .card), .command, selection: set([card1]), anchor: card1, in: snapshot)
|
|
#expect(added.selection == set([card1, card3]))
|
|
#expect(added.anchor == card3)
|
|
|
|
let removed = click(target(card1, .card), .command, selection: set([card1, card3]), anchor: card3, in: snapshot)
|
|
#expect(removed.selection == set([card3]))
|
|
#expect(removed.anchor == card1)
|
|
}
|
|
|
|
@Test("Toggling the last member out leaves nothing selected and nothing to range from")
|
|
func emptyingClearsTheAnchor() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
let outcome = click(target(card1, .card), .command, selection: set([card1]), anchor: card1, in: snapshot)
|
|
#expect(outcome.selection.isEmpty)
|
|
#expect(outcome.anchor == nil)
|
|
}
|
|
|
|
@Test("⌘-click across the kind boundary replaces — a selection is never mixed")
|
|
func acrossKindReplaces() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
// "Selection is homogeneous: cards XOR lanes" (04-interactions.md § Selection).
|
|
let ontoLane = click(target(lane2, .lane), .command, selection: set([card1, card2]), anchor: card2, in: snapshot)
|
|
#expect(ontoLane.selection == set([lane2]))
|
|
#expect(ontoLane.anchor == lane2)
|
|
|
|
let ontoCard = click(target(card1, .card), .command, selection: set([lane1, lane2]), anchor: lane2, in: snapshot)
|
|
#expect(ontoCard.selection == set([card1]))
|
|
#expect(ontoCard.anchor == card1)
|
|
}
|
|
|
|
/// **Inside the trash there is no kind boundary to cross** (04-interactions.md ▸ The trash,
|
|
/// re-ruled 2026-07-31, superseding the kind-homogeneous trash grammar): "within the trash cards
|
|
/// and lane rows select together — clicks, ⇧-click ranges, ⇧-arrow extension, and the rubber
|
|
/// band all sweep every row". So a ⌘-click that used to replace now *extends*.
|
|
@Test("⌘-click adds a lane row to a card selection inside the trash")
|
|
func acrossKindInTheTrashExtends() throws {
|
|
let fixture = try makeMixedTrashBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
let ontoRow = click(target(lane2, .lane, .trash), .command, selection: set([card1], .trash), anchor: card1, in: snapshot)
|
|
#expect(ontoRow.selection == set([card1, lane2], .trash))
|
|
|
|
let ontoCard = click(target(card1, .card, .trash), .command, selection: set([lane2, lane3], .trash), anchor: lane3, in: snapshot)
|
|
#expect(ontoCard.selection == set([lane2, lane3, card1], .trash))
|
|
|
|
// Within one kind it still toggles, which is what makes the branch above a rule rather than
|
|
// a refusal of ⌘ in the trash.
|
|
let added = click(target(lane3, .lane, .trash), .command, selection: set([lane2], .trash), anchor: lane2, in: snapshot)
|
|
#expect(added.selection == set([lane2, lane3], .trash))
|
|
}
|
|
|
|
@Test("⌘-click across the container boundary replaces too")
|
|
func acrossContainerReplaces() throws {
|
|
let fixture = try makeTrashBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
// "A selection never mixes trash cards with board cards — a single container rule replacing
|
|
// the old liveness law" (04 ▸ The trash, resettled 2026-07-28).
|
|
let intoTrash = click(target(card1, .card, .trash), .command, selection: set([card6]), anchor: card6, in: snapshot)
|
|
#expect(intoTrash.selection == set([card1], .trash))
|
|
|
|
let backOut = click(target(card6, .card), .command, selection: set([card1, card2], .trash), anchor: card2, in: snapshot)
|
|
#expect(backOut.selection == set([card6]))
|
|
}
|
|
|
|
@Test("⌘-click with nothing — or nothing real — selected replaces")
|
|
func emptyOrGhostSelectionReplaces() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
let fromEmpty = click(target(card1, .card), .command, in: snapshot)
|
|
#expect(fromEmpty.selection == set([card1]))
|
|
#expect(fromEmpty.anchor == card1)
|
|
|
|
// A selection whose members all name nothing the board renders counts as empty: a ⌘-click
|
|
// after a foreign delete starts a fresh set rather than extending a ghost.
|
|
let ghost = ItemID(rawValue: Ident.indexless)
|
|
let fromGhost = click(target(card1, .card), .command, selection: set([ghost]), anchor: ghost, in: snapshot)
|
|
#expect(fromGhost.selection == set([card1]))
|
|
}
|
|
}
|
|
|
|
// MARK: - Shift
|
|
|
|
@MainActor
|
|
@Suite("SelectionGrammar ▸ ⇧-click")
|
|
struct ShiftClickTests {
|
|
|
|
@Test("A ⇧-range spans the flatten order across lanes and leaves the anchor put")
|
|
func rangeAcrossLanes() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
let outcome = click(target(card5, .card), .shift, selection: set([card1]), anchor: card1, in: snapshot)
|
|
#expect(outcome.selection == set([card1, card2, card3, card4, card5]))
|
|
// Finder-list style: the anchor is unchanged, so successive ⇧-clicks sweep from one origin.
|
|
#expect(outcome.anchor == card1)
|
|
}
|
|
|
|
@Test("Direction does not matter — the range is the span between anchor and target")
|
|
func rangeIsDirectionless() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
let backwards = click(target(card1, .card), .shift, selection: set([card5]), anchor: card5, in: snapshot)
|
|
#expect(backwards.selection == set([card1, card2, card3, card4, card5]))
|
|
#expect(backwards.anchor == card5)
|
|
}
|
|
|
|
@Test("Lanes range in their own order list")
|
|
func laneRange() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
let outcome = click(target(lane3, .lane), .shift, selection: set([lane1]), anchor: lane1, in: snapshot)
|
|
#expect(outcome.selection == set([lane1, lane2, lane3]))
|
|
#expect(outcome.anchor == lane1)
|
|
}
|
|
|
|
@Test("An invalid anchor makes ⇧ a plain click — nil, vanished, or across a boundary")
|
|
func invalidAnchorActsPlain() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
// Nothing to range from.
|
|
let noAnchor = click(target(card3, .card), .shift, selection: set([card1]), in: snapshot)
|
|
#expect(noAnchor.selection == set([card3]))
|
|
#expect(noAnchor.anchor == card3)
|
|
|
|
// An anchor that names nothing the board renders.
|
|
let ghost = ItemID(rawValue: Ident.indexless)
|
|
let vanished = click(target(card3, .card), .shift, selection: set([card1]), anchor: ghost, in: snapshot)
|
|
#expect(vanished.selection == set([card3]))
|
|
#expect(vanished.anchor == card3)
|
|
|
|
// An anchor in the *other* kind's list: the two lists are disjoint, so the anchor is not
|
|
// findable and the click degrades — never a mixed range.
|
|
let acrossKind = click(target(card3, .card), .shift, selection: set([lane1]), anchor: lane1, in: snapshot)
|
|
#expect(acrossKind.selection == set([card3]))
|
|
#expect(acrossKind.anchor == card3)
|
|
|
|
// Same for a container crossing: the board's card list holds no trash card.
|
|
let acrossContainer = click(target(card3, .card, .trash), .shift, selection: set([card1]), anchor: card1, in: snapshot)
|
|
#expect(acrossContainer.selection == set([card3], .trash))
|
|
}
|
|
|
|
@Test("A trash range walks the column's own order")
|
|
func trashRangeWalksTheColumn() throws {
|
|
let fixture = try makeTrashBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
// The column's order is `[card1, card2, card3]`; a range between the ends takes all three,
|
|
// with no kind to step over — lanes are never trashed.
|
|
let outcome = click(target(card3, .card, .trash), .shift, selection: set([card1], .trash), anchor: card1, in: snapshot)
|
|
#expect(outcome.selection == set([card1, card2, card3], .trash))
|
|
#expect(outcome.anchor == card1)
|
|
}
|
|
|
|
/// **A trash range sweeps every row** (04-interactions.md ▸ The trash, re-ruled 2026-07-31 —
|
|
/// superseding the skip-by-kind ruling this suite used to pin): "⇧-click ranges … all sweep every
|
|
/// row". The kinds are not a boundary inside the container any more; the container still is.
|
|
@Test("A trash range sweeps every row between its endpoints, both kinds")
|
|
func trashRangeSweepsEveryRow() throws {
|
|
let fixture = try makeMixedTrashBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
// The column reads [card1, lane2, card2, lane3, card3]: a range from the top to the bottom
|
|
// now takes all five rows rather than stepping over the two lane rows.
|
|
let cards = click(target(card3, .card, .trash), .shift, selection: set([card1], .trash), anchor: card1, in: snapshot)
|
|
#expect(cards.selection == set([card1, lane2, card2, lane3, card3], .trash))
|
|
|
|
// And a range anchored on a lane row picks up the card between them.
|
|
let rows = click(target(lane3, .lane, .trash), .shift, selection: set([lane2], .trash), anchor: lane2, in: snapshot)
|
|
#expect(rows.selection == set([lane2, card2, lane3], .trash))
|
|
|
|
// And a range aimed from a card to a lane row is now an ordinary range rather than a
|
|
// degraded plain click: both endpoints sit in the one list, so the anchor stays put.
|
|
let crossed = click(target(lane3, .lane, .trash), .shift, selection: set([card1], .trash), anchor: card1, in: snapshot)
|
|
#expect(crossed.selection == set([card1, lane2, card2, lane3], .trash))
|
|
#expect(crossed.anchor == card1)
|
|
}
|
|
|
|
@Test("A range never crosses the container boundary")
|
|
func trashRangeStopsAtTheBoundary() throws {
|
|
let fixture = try makeTrashBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
|
|
// `card6` is on the board and `card1` is in the trash: no single order list holds both, so
|
|
// the anchor is not findable and the ⇧-click degrades to a plain one.
|
|
let outcome = click(target(card1, .card, .trash), .shift, selection: set([card6]), anchor: card6, in: snapshot)
|
|
#expect(outcome.selection == set([card1], .trash))
|
|
#expect(outcome.anchor == card1)
|
|
}
|
|
}
|
|
|
|
// MARK: - The rubber band
|
|
|
|
@Suite("MarqueeMath")
|
|
struct MarqueeMathTests {
|
|
|
|
private static func card(_ id: ItemID, _ y: CGFloat, container: ItemContainer = .board) -> MarqueeTarget {
|
|
MarqueeTarget(id: id, kind: .card, container: container, frame: CGRect(x: 0, y: y, width: 100, height: 40))
|
|
}
|
|
|
|
@Test("On the board side the band takes intersecting cards, and only cards")
|
|
func boardSideTakesCards() {
|
|
let targets = [
|
|
Self.card(card1, 0),
|
|
Self.card(card2, 100),
|
|
// A lane registered by mistake is still never swept: "click-drag rubber-bands across
|
|
// lanes" (04-interactions.md § Selection) — across, not over.
|
|
MarqueeTarget(id: lane1, kind: .lane, container: .board, frame: CGRect(x: 0, y: 0, width: 200, height: 400)),
|
|
// A trash row cannot be reached by a band that began on the board.
|
|
Self.card(card3, 10, container: .trash)
|
|
]
|
|
let ids = MarqueeMath.selection(rect: CGRect(x: 0, y: 0, width: 50, height: 120), targets: targets, in: .board)
|
|
#expect(ids == [card1, card2])
|
|
}
|
|
|
|
/// **In the trash the band sweeps every row** (04-interactions.md ▸ The trash, re-ruled
|
|
/// 2026-07-31, superseding the card-only band): "the rubber band [sweeps] every row (the band's
|
|
/// full-height backdrop covers both kinds)". A trashed lane row registers its frame like a card
|
|
/// does, so this needed only the kind filter to come off on that side — the *container* filter
|
|
/// stays, and the band still never leaves the side it began on.
|
|
@Test("On the trash side the band takes every row, and stays on its own side")
|
|
func trashSideTakesEveryRow() {
|
|
let targets = [
|
|
Self.card(card1, 0, container: .trash),
|
|
MarqueeTarget(id: lane2, kind: .lane, container: .trash,
|
|
frame: CGRect(x: 0, y: 50, width: 100, height: 30)),
|
|
Self.card(card2, 100, container: .trash),
|
|
Self.card(card3, 50)
|
|
]
|
|
let all = CGRect(x: 0, y: 0, width: 50, height: 200)
|
|
|
|
#expect(MarqueeMath.selection(rect: all, targets: targets, in: .trash) == [card1, lane2, card2])
|
|
#expect(MarqueeMath.selection(rect: all, targets: targets, in: .board) == [card3])
|
|
}
|
|
|
|
@Test("A band touching nothing selects nothing")
|
|
func emptyBand() {
|
|
let targets = [Self.card(card1, 0), Self.card(card2, 100)]
|
|
#expect(MarqueeMath.selection(rect: CGRect(x: 500, y: 500, width: 10, height: 10), targets: targets, in: .board).isEmpty)
|
|
#expect(MarqueeMath.selection(rect: .zero, targets: [], in: .trash).isEmpty)
|
|
}
|
|
}
|
|
|
|
// MARK: - The anchor's storage and its reload rule
|
|
|
|
/// One foreign reload, start to settled — `TransientBoardStateTests`' helper, borrowed for the one
|
|
/// piece of transient state this card adds.
|
|
@MainActor
|
|
private func reload(_ store: BoardStore) async {
|
|
store.handleWatcherEvent(.treeChanged(.foreign))
|
|
await store.awaitQuiescence()
|
|
}
|
|
|
|
@MainActor
|
|
@Suite("TransientBoardState ▸ the selection anchor")
|
|
struct SelectionAnchorTests {
|
|
|
|
@Test("A sole selection anchors itself; a wholesale one does not; clearing drops it")
|
|
func anchorDefaults() {
|
|
let state = TransientBoardState()
|
|
|
|
state.select([card1], in: .board)
|
|
#expect(state.selectionAnchor == card1)
|
|
|
|
// "A marquee and wholesale selections pass no anchor deliberately."
|
|
state.select([card1, card2], in: .board)
|
|
#expect(state.selectionAnchor == nil)
|
|
|
|
// An explicit anchor wins over the default in both directions.
|
|
state.select([card1, card2, card3], in: .board, anchor: card2)
|
|
#expect(state.selectionAnchor == card2)
|
|
|
|
state.clearSelection()
|
|
#expect(state.selectionAnchor == nil)
|
|
}
|
|
|
|
@Test("A vanished anchor is dropped by the reload, and a surviving one is kept")
|
|
func vanishedAnchorIsDropped() async throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
|
|
store.select([card1, card2], in: .board, anchor: card1)
|
|
// A survivor of the same reload proves the rule is about the anchor, not about reloading.
|
|
try FileManager.default.removeItem(at: fixture.url("\(Ident.lane1)/\(Ident.card2)"))
|
|
await reload(store)
|
|
#expect(store.selection.ids == [card1])
|
|
#expect(store.transient.selectionAnchor == card1)
|
|
|
|
try FileManager.default.removeItem(at: fixture.url("\(Ident.lane1)/\(Ident.card1)"))
|
|
await reload(store)
|
|
// The anchor's card is gone — the rule this test exists for. The selection is not empty
|
|
// afterwards because the reload emptied it *and* took the cursor with it, which is
|
|
// 10-accessibility.md's vanishing-focus case: focus recovers to the card's lane, and a
|
|
// one-item selection made by any route is its own anchor (`BoardAnnouncerStoreTests`).
|
|
#expect(store.selection.ids == [lane1])
|
|
#expect(store.transient.selectionAnchor == lane1)
|
|
}
|
|
|
|
@Test("A container crossing is a vanish for the anchor too")
|
|
func crossedAnchorIsDropped() async throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
|
|
store.select([card1, card2], in: .board, anchor: card1)
|
|
try fixture.move("\(Ident.lane1)/\(Ident.card1)", toTrash: Ident.card1)
|
|
await reload(store)
|
|
|
|
// "A container crossing is a vanish for this purpose" (02-architecture.md's reload rule,
|
|
// resettled 2026-07-28).
|
|
#expect(store.selection.ids == [card2])
|
|
#expect(store.transient.selectionAnchor == nil)
|
|
}
|
|
|
|
@Test("An anchor no longer in the selection still ranges — membership is not the rule")
|
|
func anchorNeedNotBeSelected() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let snapshot = try load(fixture)
|
|
let state = TransientBoardState()
|
|
|
|
// A ⌘-click that toggled the anchor's own row out leaves the anchor standing.
|
|
state.select([card2, card3], in: .board, anchor: card1)
|
|
#expect(state.selectionAnchor == card1)
|
|
let outcome = click(target(card3, .card), .shift, selection: state.selection, anchor: state.selectionAnchor, in: snapshot)
|
|
#expect(outcome.selection == set([card1, card2, card3]))
|
|
}
|
|
}
|
|
|
|
// MARK: - Select All
|
|
|
|
@MainActor
|
|
@Suite("BoardStore ▸ Select All")
|
|
struct SelectAllTests {
|
|
|
|
@Test("Select All takes every rendered card, and never a lane")
|
|
func liveBranch() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
|
|
store.select([lane2], in: .board)
|
|
store.selectAll()
|
|
|
|
// "All visible cards on the board" (04-interactions.md ▸ The map).
|
|
#expect(store.selection == set([card1, card2, card3, card4, card5]))
|
|
// The lane the anchor named is not in the new set, so the anchor goes with it.
|
|
#expect(store.transient.selectionAnchor == nil)
|
|
}
|
|
|
|
@Test("An anchor inside the new set survives Select All")
|
|
func anchorSurvivesWhenStillInside() throws {
|
|
let fixture = try makeLiveBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
|
|
store.select([card3], in: .board)
|
|
store.selectAll()
|
|
#expect(store.transient.selectionAnchor == card3)
|
|
}
|
|
|
|
@Test("On the trash side Select All takes every visible trash card")
|
|
func trashBranchTakesTheColumn() throws {
|
|
let fixture = try makeTrashBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
store.transient.isTrashVisible = true
|
|
|
|
// "With the trash visible and a non-empty trash selection, Select All selects all visible
|
|
// trash rows" (04 ▸ The map; kind-blind since 2026-07-31). This container holds only cards,
|
|
// so rows and cards coincide — the mixed case is the test below.
|
|
store.select([card2], in: .trash)
|
|
store.selectAll()
|
|
#expect(store.selection == set([card1, card2, card3], .trash))
|
|
}
|
|
|
|
/// **In the trash, "all" is all rows** (04-interactions.md ▸ The trash and 11-command-nexus.md ▸
|
|
/// Select All, re-ruled 2026-07-31 with kind-blind trash selection: "Select All with a non-empty
|
|
/// trash selection selects **all visible trash rows**"). The live board's own Select All stays
|
|
/// card-scoped, which the board branch above pins.
|
|
@Test("Select All in the trash takes every row, lane rows included")
|
|
func trashBranchTakesEveryRow() throws {
|
|
let fixture = try makeMixedTrashBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
store.transient.isTrashVisible = true
|
|
|
|
store.select([lane2], in: .trash)
|
|
store.selectAll()
|
|
|
|
#expect(store.selection == set([card1, lane2, card2, lane3, card3], .trash))
|
|
}
|
|
|
|
@Test("The trash branch is narrow: hidden, live, empty, or ghost selections take the board")
|
|
func trashBranchFallsThrough() throws {
|
|
let fixture = try makeTrashBoard()
|
|
defer { fixture.tearDown() }
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
|
|
// Hidden — the column is invisible to every gesture (04 ▸ The trash).
|
|
store.select([card1], in: .trash)
|
|
store.selectAll()
|
|
#expect(store.selection.container == .board)
|
|
|
|
// Shown, but nothing in the trash is selected.
|
|
store.transient.isTrashVisible = true
|
|
store.clearSelection()
|
|
store.selectAll()
|
|
#expect(store.selection.container == .board)
|
|
|
|
// Shown, trash side, but the ids name no card there: a guess would be worse than the board.
|
|
store.select([card5], in: .trash)
|
|
store.selectAll()
|
|
#expect(store.selection.container == .board)
|
|
}
|
|
|
|
@Test("Select All on a board with no rendered cards clears rather than selecting an empty set")
|
|
func emptyBoardClears() throws {
|
|
let fixture = try WriterFixture()
|
|
defer { fixture.tearDown() }
|
|
try fixture.item("", Item.board)
|
|
try fixture.item(Ident.lane1, Item.rich(order: "1024", title: "Todo"))
|
|
let store = try BoardStore(rootURL: fixture.root)
|
|
|
|
store.select([lane1], in: .board)
|
|
store.selectAll()
|
|
#expect(store.selection.isEmpty)
|
|
#expect(store.transient.selectionAnchor == nil)
|
|
}
|
|
}
|