From 8206a78ecccacad974a56837af8cfdfe97efbbeb Mon Sep 17 00:00:00 2001 From: rzen Date: Sat, 1 Aug 2026 08:07:54 -0400 Subject: [PATCH] =?UTF-8?q?Redraw=20a=20copy's=20originals=20at=20the=20so?= =?UTF-8?q?urce=20=E2=80=94=20the=20resting=20layout=20follows=20the=20ope?= =?UTF-8?q?ration?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The modifier flip (⌥ copy / ⌘ move) now reflows the source board once: a copy re-admits the dragged originals into the resting layout, standing dimmed in place, and a move lifts them out as before. This retires DRAG-REORDER.md's operation-blind carve-out and makes 04-interactions.md's "originals stay" true in flight, not just at echo. The one seam is DragSession.hiddenMembers reading the observed operation. Consequences carried honestly: copyCards now takes its index in the lane's full rendered space (the zones counted the originals, so the geometry's number is the writer's number — the old neighbour remap is deleted); resolveOperation freezes under the committed hold exactly as propose does, fixing a real bug where a settled within-board ⌥-copy drew the move arrangement until the echo and visibly re-shuffled. Stationary flips still wait for the next dropUpdated (their own Backlog card). Claude-Session: https://claude.ai/code/session_01CqjXB7ASoWtbyoGod68k97 --- DRAG-REORDER.md | 12 +- Kanban/LiveStore/BoardStore.swift | 25 ++-- Kanban/UI/Board/BoardDrops.swift | 22 ++++ Kanban/UI/Board/BoardView.swift | 13 +- Kanban/UI/Board/CardFaceView.swift | 12 +- Kanban/UI/Board/DragSession.swift | 59 +++++++-- Kanban/UI/Board/LaneView.swift | 12 +- KanbanTests/DragSessionTests.swift | 203 +++++++++++++++++++++++++++++ KanbanTests/DragWriteTests.swift | 76 ++++++++++- 9 files changed, 383 insertions(+), 51 deletions(-) diff --git a/DRAG-REORDER.md b/DRAG-REORDER.md index 259f57b..682d701 100644 --- a/DRAG-REORDER.md +++ b/DRAG-REORDER.md @@ -23,7 +23,13 @@ While a drag is in flight, the proposal (an insertion index) is computed geometr The proposal is a pure function of the cursor over these fixed zones. This is deliberately **not** derived from per-item hover events, which feed back off the very reflow they cause (items move under the cursor → a different item fires → the proposal moves again) and jitter. Because the zones are reconstructed analytically rather than measured, they do not move when the placeholder does. -**The resting layout excludes the dragged run whatever the effective operation is.** A within-board ⌥-drag copies, and the originals really do stay — but ⌥ can be pressed and released mid-drag, and a layout that re-admitted the originals on every modifier flip would flap the whole board under the cursor. The dragged items are lifted out at pickup and stay out until release; the copy's originals reappear when the write lands. This is why the drop index means the same thing for `moveCards` and `copyCards` (see **The drop commits** below). +**The resting layout follows the effective operation: a move lifts the dragged run out, a copy leaves it in.** 04-interactions.md says the originals stay for both copies — the within-board ⌥-drag and the cross-board default — so the source board draws what it will still hold: the originals stand in place, dimmed (`ClipboardTreatment.dimmedOpacity`, the same treatment a trash row being dragged out wears), and the shadow run opens beside them. A move's originals are lifted out at pickup and stay out until the echo lands. The single expression is `DragSession.hiddenMembers(onBoardRooted:)`, which every surface that builds a resting layout goes through. + +Pressing or releasing ⌥/⌘ mid-drag therefore reflows the source board **once**, and that one-shot reflow is the point rather than a cost: the modifier's whole job is to change what the drop will leave behind, and the board answering the question is the feedback being asked for. (This retires an earlier carve-out that lifted the run out for every operation to keep the board still. The stillness was real; it was bought by never answering the question.) The flip lands on the next `dropUpdated`, because that is where the operation is re-resolved — a modifier pressed with the mouse perfectly still waits for the next motion. Once a release has settled, the operation is frozen for the duration of the committed hold (`DragSession.resolveOperation` guards on `hold == nil`, exactly as `propose` does), so a settled copy keeps its originals on screen and a settled move keeps them lifted until the echo snapshot lands. + +The index-space consequence is real and is carried by the writers rather than papered over: **the drop index means different things for `moveCards` and `copyCards`**, and each one is counted in the layout its own gesture was showing. A move's index counts slots among the cards the run vacates; a copy's counts them among the lane's full rendered set, originals included. Neither writer has to guess — the operation picks the writer and the operation picked the layout — and a within-board ⌥-copy therefore lands exactly at the shadow's slot, including when the shadow sits below the dragged run in the same lane (see **The drop commits** below). + +Lanes get this for free and the invariant is worth stating: a within-board lane drag never resolves to `.copy` (⌥ is ignored there), so the strip's zones never see a re-admitted lane under the cursor; a **cross-board** lane copy re-admits the lane into the *source* strip while the cursor is over the foreign board, where none of the source strip's zones are being consulted. `moveLanes` and `receiveLanes` keep the index space they always had. The strip's lane rendering has no dim of its own, so a re-admitted lane reads as an ordinary lane rather than as the source of the drag — the card face and the trash rows are the only surfaces wearing that treatment today. Two stability rules on top: @@ -108,7 +114,7 @@ Geometry does not change across the boundary. The destination board's own restin ## The drop commits -The commit is the store's, and it is one `performWrite` bracket per gesture whatever the set's size: one app-mediated reload, and (on git boards) one commit rather than N. Every one of them takes an index counted **against the destination's rendered items with the dragged run removed** — the resting layout's own convention, so the number the geometry produced is the number the writer consumes, unrewritten. +The commit is the store's, and it is one `performWrite` bracket per gesture whatever the set's size: one app-mediated reload, and (on git boards) one commit rather than N. Every one of them takes an index counted **against the destination's rendered items as the resting layout showed them** — so the number the geometry produced is the number the writer consumes, unrewritten. For every move that means "with the dragged run removed"; for the within-board ⌥-copy it means "with the originals still there", because a copy leaves them there and the zones counted them (see **Resting-layout zones**). Cross-board arrivals never face the question: the destination never held the originals. | Gesture | Store method | Writer | | --- | --- | --- | @@ -123,7 +129,7 @@ The commit is the store's, and it is one `performWrite` bracket per gesture what Three properties of that table are load-bearing: - **Ranks are inserted, never permuted.** A drop writes only the dragged items' `order` — the siblings' files are not touched, so `modified` (and a git commit) stays honest about what actually moved. `Ranks.insertionRanks(amongVisible:at:count:)` produces the N ranks the contiguous run needs; `nil` from it is the renumber trigger, exactly as an exhausted midpoint is everywhere else, and the fallback compacts the destination and places again (`moveLane`'s and `sortSelection`'s pattern). -- **A copy's ranks are computed against the destination's *full* rendered set**, because the originals stay and a rank chosen in the gap the lifted originals vacated would collide with them. A move's are computed against the set the moving members vacate. One expression covers both: the ranks are placed among the rendered cards minus whatever will actually leave. +- **A copy's ranks are computed against the destination's *full* rendered set**, because the originals stay and are still on disk holding their ranks. A move's are computed against the set the moving members vacate. One expression covers both: the ranks are placed among the rendered cards minus whatever will actually leave — which is also, exactly, the layout each gesture's zones were built over, so the index needs no translation on the way in. - **Cross-board writes are executed by the destination store**, inside *its* bracket. The source board's tree changes outside its own store's bracket, which is correct and needs no coordination: the source store's watcher sees a foreign change and reloads, which is what a foreign change is. Identity follows 01-storage-format.md exactly. A copy mints fresh UUIDs at every level and keeps `created` (a copy is a fork). A move keeps the UUID; only the **import boundary** remints, per folder, at the finest grain — a lane arriving with one colliding card is still a lane move with one reminted card. diff --git a/Kanban/LiveStore/BoardStore.swift b/Kanban/LiveStore/BoardStore.swift index e570ba1..3e2e9e2 100644 --- a/Kanban/LiveStore/BoardStore.swift +++ b/Kanban/LiveStore/BoardStore.swift @@ -2704,26 +2704,23 @@ public final class BoardStore: HealHost { /// "originals stay, cursor shows the copy badge, fresh-GUID duplicates land at the drop"). /// `created` survives because a copy is a fork — `CopyStamps.fork`, the same stamps paste uses. /// - /// **The ranks are placed among the lane's *full* rendered set**, not among the set with the - /// dragged members removed — the one place a copy's arithmetic differs from a move's. The - /// originals are lifted out of the layout for the duration of the drag whatever the effective - /// operation is (⌥ can be pressed and released mid-drag; a layout that re-admitted them on every - /// flip would flap the whole board), but they are still *on disk* holding their ranks, and a - /// rank chosen in the gap they appear to have vacated would collide with them the instant they - /// reappear. So the drop's index is mapped through to the neighbour it names — the card the run - /// lands in front of — and the rank is taken there. + /// **`index` is counted among the lane's *full* rendered cards — the originals included** — and + /// that is the one place a copy's index space differs from a move's (`moveCards` counts among + /// the cards its run vacates). It is not a special case bolted on here: a copy's originals stay + /// in the source board's resting layout for the whole drag (`DragSession.hiddenMembers`, ruled + /// 2026-08-01), so the zones the shadow was resolved against already counted them, and the + /// geometry's number is this method's number unrewritten. + /// + /// The ranks fall out of the same fact. The originals are still on disk holding their ranks, so + /// a rank chosen in a gap they had apparently vacated would collide with them the instant they + /// reappeared — and with the index counted among them there is no such gap to choose in. public func copyCards(_ ids: Set, toLane laneID: ItemID, at index: Int) { guard let destination = snapshot.lanes.first(where: { $0.id == laneID }) else { return } let members = draggedCards(ids) guard !members.isEmpty else { return } let rendered = destination.cards - let remaining = rendered.filter { !ids.contains($0.id) } - let target = min(max(0, index), remaining.count) - // The resting-layout index, re-read against the layout the originals are still part of. - let placement = target < remaining.count - ? (rendered.firstIndex { $0.id == remaining[target].id } ?? rendered.count) - : rendered.count + let placement = min(max(0, index), rendered.count) let root = rootURL let laneFolder = ItemPath.lane(laneID).folder(under: root) diff --git a/Kanban/UI/Board/BoardDrops.swift b/Kanban/UI/Board/BoardDrops.swift index 219c1e9..80886fa 100644 --- a/Kanban/UI/Board/BoardDrops.swift +++ b/Kanban/UI/Board/BoardDrops.swift @@ -168,6 +168,15 @@ struct BoardDropContext { /// slot's uncapped reach past the last real lane lands *before* it. The delete a lane drag can /// propose over the column is not a slot at all — it is the column's own target answering /// (`retargetTrash`), and it names `.trash` rather than an index in this list. + /// + /// **These zones never see a re-admitted lane, and that is an invariant rather than an + /// accident.** `hiddenMembers` now leaves a copy's originals in the resting layout, but a lane + /// can only be re-admitted into the strip it was picked up from, and a lane drag over its own + /// board never resolves to `.copy` (`DragLocality.operation`'s first carve-out). A cross-board + /// lane copy does re-admit — into the **source** strip, while the cursor is over the foreign + /// board, where no zone of this board's is being consulted at all. So the strip's slot list is + /// still "the lanes minus the run" every time this function actually runs, and `moveLanes` / + /// `receiveLanes` keep the index space they always had. func retargetLanes() { guard session.isDraggingLanes, let cursor = stripCursor() else { return } let hidden = session.hiddenMembers(onBoardRooted: store.rootURL) @@ -191,6 +200,13 @@ struct BoardDropContext { /// The single answer the lane's own drop delegate, the strip's fall-through, and the autoscroll /// driver all go through — "the lane's drop delegate and the autoscroll driver must go through /// one shared retarget, so they can never disagree" (DRAG-REORDER.md § Edge autoscroll). + /// + /// **The zones are built over whatever `hiddenMembers` leaves standing**, which is what makes + /// the proposal's index space follow the operation for free: a within-board move counts slots in + /// the lane minus the dragged run, a within-board ⌥-copy counts them in the lane *including* the + /// originals, because that is the layout the user is looking at. `DropSlotMath` has no opinion + /// on the matter — the caller decides what the resting layout contains — and the commit's two + /// writers are counted in exactly these two spaces (`BoardStore.moveCards` / `copyCards`). func retargetCards(inLane laneID: ItemID) { guard session.isDraggingCards, let cursor = globalCursor() else { return } guard let lane = store.snapshot.lanes.first(where: { $0.id == laneID }) else { @@ -644,6 +660,12 @@ struct BoardDropContext { // restore *is* the within-board move and a cross-board restore *is* the ordinary // arrival — which is exactly what retiring the restore-specific machinery bought. if within { + // **Each writer is counted in the layout its own gesture was showing.** The zones + // that produced `target.index` were built over the resting layout for *this* + // operation (`retargetCards` → `DragSession.hiddenMembers`): a move's excludes the + // dragged run, a copy's includes the originals, because a copy leaves them there. + // So the number goes to each writer unrewritten and the drop lands where the shadow + // was — the two index spaces differ, and neither writer has to guess which it got. if operation == .copy { store.copyCards(Set(ids), toLane: laneID, at: target.index) } else { diff --git a/Kanban/UI/Board/BoardView.swift b/Kanban/UI/Board/BoardView.swift index 830269c..3f936d2 100644 --- a/Kanban/UI/Board/BoardView.swift +++ b/Kanban/UI/Board/BoardView.swift @@ -428,9 +428,11 @@ struct BoardView: View { /// The outer frame is always the snapped slot width, so the `HStack` lays the other lanes out /// off the tidy snapped layout regardless of the live overflow. /// - /// A lane being **dragged** is simply absent from the strip: it is lifted out of the resting - /// layout at pickup and stays out until release, whatever the effective operation is - /// (DRAG-REORDER.md § Resting-layout zones), while the system drag session carries its replica. + /// A lane being **dragged as a move** is simply absent from the strip: it is lifted out of the + /// resting layout at pickup and stays out until release, while the system drag session carries + /// its replica. A lane being dragged as a **copy** stays in the strip instead, because the copy + /// leaves it there (DRAG-REORDER.md § Resting-layout zones) — which on this board means the + /// cross-board case alone, ⌥ being ignored by a within-board lane drag. @ViewBuilder private func laneSlot(_ lane: Lane, standard: CGFloat) -> some View { let resizing = resize.isResizing(lane.id) @@ -628,8 +630,9 @@ struct BoardView: View { } } - /// What the strip lays out: the resting lanes — the dragged run lifted out, whatever the - /// effective operation is — with the shadows opened at the proposal. + /// What the strip lays out: the resting lanes — the dragged run lifted out when the release + /// would be a move, left standing when it would be a copy (`DragSession.hiddenMembers`) — with + /// the shadows opened at the proposal. private var stripSlots: [StripSlot] { let session = appModel.dragSession let hidden = session.hiddenMembers(onBoardRooted: store.rootURL) diff --git a/Kanban/UI/Board/CardFaceView.swift b/Kanban/UI/Board/CardFaceView.swift index 5fc7904..6e21b17 100644 --- a/Kanban/UI/Board/CardFaceView.swift +++ b/Kanban/UI/Board/CardFaceView.swift @@ -212,10 +212,14 @@ struct CardFaceView: View { // genuinely fires on the trash side too: "⌘X works — cut in the trash, paste into a lane is // the keyboard-native restore" (04 ▸ The trash, resettled 2026-07-28). .cutTreatment(of: card.id, in: store) - // The face being dragged out dims the same way while the session is in flight on the trash - // side, where the source stays visible: a restore is not a removal until the write lands. - // (On the board a dragged card is lifted out of the resting layout entirely, so this never - // has anything to act on there — `LaneView.renderedCards`.) + // The face being dragged out dims the same way while the session is in flight, wherever the + // source stays visible — which is now two places rather than one. On the **trash** side a + // restore is not a removal until the write lands, so the row never leaves. On the **board** + // side a drag whose effective operation is `.copy` leaves its originals in the resting + // layout, because the copy leaves them there (`DragSession.hiddenMembers`), and this is what + // marks them as the source of the drag rather than as ordinary neighbours. A `.move`'s + // originals are lifted out entirely and this has nothing to act on + // (`LaneView.renderedCards`). .opacity(drops.session.isDragging(card.id) ? ClipboardTreatment.dimmedOpacity : 1) .contentShape(Rectangle()) // **A card is one flattened accessibility element** (10-accessibility.md ▸ The board through diff --git a/Kanban/UI/Board/DragSession.swift b/Kanban/UI/Board/DragSession.swift index 395dd02..a9e1f31 100644 --- a/Kanban/UI/Board/DragSession.swift +++ b/Kanban/UI/Board/DragSession.swift @@ -379,18 +379,33 @@ final class DragSession { /// /// Only the source board hides anything, and only for a board-side session: a trash card's drag /// carries items that render in the trash column, not in any lane's masonry, so no lane loses a - /// card to it. + /// card to it. Those rows dim in place instead (`CardFaceView`, `TrashLaneRowView`), which is + /// the same treatment a re-admitted board original now wears — one vocabulary for "this is the + /// source of the drag", wherever the source stays visible. /// - /// **The dragged run is lifted out whatever the effective operation is** (DRAG-REORDER.md § - /// Resting-layout zones): ⌥ can be pressed and released mid-drag, and a layout that re-admitted - /// the originals on every modifier flip would flap the whole board under the cursor. The copy's - /// originals reappear when the write lands — the hold keeps them lifted for that round trip, so - /// the arrangement on screen is the one the release proposed and stays still until the echo. + /// **A move lifts the run out; a copy leaves it in** (04-interactions.md ▸ Drag and drop: + /// "originals stay", for the within-board ⌥-drag and for the cross-board default alike — ruled + /// 2026-08-01, retiring the operation-blind carve-out this used to be). The layout on screen is + /// therefore always the arrangement the release would produce: a copy's source board shows what + /// it will still hold, a move's shows what it will have given away. Flipping ⌥ or ⌘ mid-drag + /// reflows the source board once, and that one-shot reflow *is* the feedback the modifier is + /// asking for — the previous rule's fear of "flapping" traded the answer to "what will this + /// drop leave behind?" for a stillness nobody asked for. + /// + /// Reading `operation` here is what makes the flip visible at all: the property is observed, so + /// every surface that builds a resting layout off this method re-renders when it changes. The + /// flip lands on the next `dropUpdated`, since that is where the operation is re-resolved; a + /// modifier pressed with the mouse perfectly still waits for the next motion (Backlog ▸ + /// Stationary modifier flips). + /// + /// **The hold freezes the answer**, because `resolveOperation` refuses to move once a release + /// has settled: a settled copy keeps its originals on screen and a settled move keeps them + /// lifted, in both cases until the echo snapshot lands and the real faces take over. func hiddenMembers(onBoardRooted root: URL) -> Set { guard isActive, container == .board, let sourceRoot, DragLocality.isSameBoard(root, sourceRoot) else { return [] } - return memberSet + return operation == .copy ? [] : memberSet } /// The proposal's index when it names this board's strip, else `nil` — the lane strip's shadow @@ -575,14 +590,27 @@ final class DragSession { /// Re-resolves the effective operation against the board under the cursor and the modifiers /// **right now**, and hands it back for the `DropProposal` the badge tracks. + /// + /// **A settled release freezes it**, `propose`'s guard for a reason that is now the same one: + /// the operation decides what the source board's resting layout holds (`hiddenMembers`) as well + /// as which write went out, so a stray `dropUpdated` arriving after the commit — with the user's + /// finger already off ⌥ — would re-lift originals the write is about to leave in place. The + /// write named an operation; the overlay draws that operation until the echo lands. + /// + /// `modifiers` defaults to the live flags, which is the only thing the app ever passes; it is a + /// parameter so the resolution is checkable without a keyboard, exactly as `DragLocality`'s own + /// pure function is. @discardableResult - func resolveOperation(destinationRoot: URL) -> TransferOperation { - guard let kind, let sourceRoot else { return operation } + func resolveOperation( + destinationRoot: URL, + modifiers: NSEvent.ModifierFlags = NSEvent.modifierFlags + ) -> TransferOperation { + guard let kind, let sourceRoot, hold == nil else { return operation } let resolved = DragLocality.operation( kind: kind, container: container, isWithinBoard: DragLocality.isSameBoard(sourceRoot, destinationRoot), - modifiers: NSEvent.modifierFlags + modifiers: modifiers ) if resolved != operation { operation = resolved } return resolved @@ -609,10 +637,13 @@ final class DragSession { /// Enters the committed phase: the arrangement the session was showing stays on screen until /// `store` applies its next snapshot (`CommittedHold`). /// - /// Everything that drives the rendering — the members, the proposal, the source root — is kept - /// exactly as it was, so "keeps rendering the arrangement it was showing" needs no second - /// mechanism: the shadows stay at the landing slots and the originals stay lifted out until the - /// snapshot carrying the write arrives and the real faces take their place. + /// Everything that drives the rendering — the members, the proposal, the source root, the + /// operation — is kept exactly as it was, so "keeps rendering the arrangement it was showing" + /// needs no second mechanism: the shadows stay at the landing slots and the originals stay + /// exactly where the operation put them — lifted out for a move, standing dimmed in place for a + /// copy — until the snapshot carrying the write arrives and the real faces take their place. + /// Freezing the operation is `resolveOperation`'s own guard; the hold this method arms is what + /// that guard reads. func commit(into store: BoardStore) { guard isActive else { return } sourceStore?.transient.dragMembers = .empty diff --git a/Kanban/UI/Board/LaneView.swift b/Kanban/UI/Board/LaneView.swift index 5e58fd4..ae6b613 100644 --- a/Kanban/UI/Board/LaneView.swift +++ b/Kanban/UI/Board/LaneView.swift @@ -859,11 +859,13 @@ struct LaneView: View { /// `lane.cards` and the trash column renders it instead. The tombstone era's ancestor walk and /// effective-liveness predicate are retired with the flag they read. /// - /// **A dragged card renders nowhere either, for as long as the session lasts.** It is lifted out - /// of the resting layout at pickup and stays out until release *whatever the effective operation - /// is* — a ⌥-copy's originals really do stay, but ⌥ can be pressed and released mid-drag, and a - /// layout that re-admitted them on every flip would flap the board under the cursor - /// (DRAG-REORDER.md § Resting-layout zones). The copy's originals reappear when the write lands. + /// **A card being dragged *as a move* renders nowhere, for as long as the session lasts.** It is + /// lifted out of the resting layout at pickup and stays out until release. A card being dragged + /// as a **copy** stays exactly where it is and dims (`CardFaceView`), because that is what the + /// copy will leave behind — so flipping ⌥ or ⌘ mid-drag reflows this lane once, which is the + /// feedback the modifier is asking for (DRAG-REORDER.md § Resting-layout zones, ruled + /// 2026-08-01). Either way the drop's index is counted in the layout on screen, which is why + /// `copyCards` and `moveCards` take their index in different spaces. /// /// **A card the live search filter hides renders nowhere either** (04-interactions.md § Search): /// "cards whose title *and* body both miss the query animate out". This is the one collection diff --git a/KanbanTests/DragSessionTests.swift b/KanbanTests/DragSessionTests.swift index 9d9ceb1..a91a499 100644 --- a/KanbanTests/DragSessionTests.swift +++ b/KanbanTests/DragSessionTests.swift @@ -654,3 +654,206 @@ struct DropSettleTests { #expect(session.hold == nil) } } + +// MARK: - What the source board's resting layout holds + +/// **The resting layout follows the effective operation** (DRAG-REORDER.md § Resting-layout zones, +/// ruled 2026-08-01; 04-interactions.md ▸ Drag and drop: "originals stay" for both copies): a move +/// lifts the dragged run out of the source board, a copy leaves it standing there, because that is +/// what the release will actually leave behind. The whole rule is `hiddenMembers(onBoardRooted:)`, +/// and every surface that builds a resting layout — the lane masonries, the strip, the drop zones — +/// reads it, so pinning it here pins all of them. +/// +/// The modifiers are passed to `resolveOperation` rather than held down: it is the same seam +/// `DragLocalityTests` uses one level down, and it is what makes the flip checkable without a +/// keyboard. +@MainActor +@Suite("The source board's resting layout") +struct DragRestingLayoutTests { + + private static let lane1 = ItemID(rawValue: Ident.lane1) + private static let card1 = ItemID(rawValue: Ident.card1) + private static let card2 = ItemID(rawValue: Ident.card2) + + private let none: NSEvent.ModifierFlags = [] + private let option: NSEvent.ModifierFlags = [.option] + private let command: NSEvent.ModifierFlags = [.command] + + /// Another board entirely — the right-hand side of every cross-board resolution below. It needs + /// no fixture: locality compares paths, and nothing here reads the foreign board's contents. + private let elsewhere = URL(fileURLWithPath: "/Boards/Elsewhere.kanban", isDirectory: true) + + /// One lane holding two cards, plus a trashed card so a `.trash`-container session has something + /// real to name. + private func makeBoard() 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(".trash/\(Ident.card3)", Item.rich(order: "1024", title: "Trashed")) + return fixture + } + + /// A card session over `members`, picked up out of `lane1`. + private func cardSession( + _ store: BoardStore, + members: [ItemID] = [card1], + container: ItemContainer = .board + ) -> DragSession { + let session = DragSession() + session.beginCards( + members, + folders: members.map { + store.rootURL + .appendingPathComponent(Ident.lane1, isDirectory: true) + .appendingPathComponent($0.rawValue, isDirectory: true) + }, + heights: members.map { _ in 44 }, + container: container, + source: store + ) + return session + } + + // MARK: The two layouts + + @Test("A move lifts the dragged run out — the source board shows what it is giving away") + func aMoveLiftsTheRunOut() throws { + let fixture = try makeBoard() + defer { fixture.tearDown() } + let store = try BoardStore(rootURL: fixture.root) + let session = cardSession(store, members: [Self.card1, Self.card2]) + + #expect(session.resolveOperation(destinationRoot: store.rootURL, modifiers: none) == .move) + #expect(session.hiddenMembers(onBoardRooted: store.rootURL) == [Self.card1, Self.card2]) + + // ⌘ over a foreign board is the cross-board move, and it lifts them out just the same. + #expect(session.resolveOperation(destinationRoot: elsewhere, modifiers: command) == .move) + #expect(session.hiddenMembers(onBoardRooted: store.rootURL) == [Self.card1, Self.card2]) + } + + /// The card the user filed: ⌥ says "leave the originals here", so the originals are drawn here. + @Test("A copy hides nothing — the originals re-admit into the source board's layout") + func aCopyReAdmitsTheOriginals() throws { + let fixture = try makeBoard() + defer { fixture.tearDown() } + let store = try BoardStore(rootURL: fixture.root) + let session = cardSession(store, members: [Self.card1, Self.card2]) + + // The within-board ⌥-copy. + #expect(session.resolveOperation(destinationRoot: store.rootURL, modifiers: option) == .copy) + #expect(session.hiddenMembers(onBoardRooted: store.rootURL).isEmpty) + + // And the cross-board default, which is a copy with no modifier at all. + #expect(session.resolveOperation(destinationRoot: elsewhere, modifiers: none) == .copy) + #expect(session.hiddenMembers(onBoardRooted: store.rootURL).isEmpty) + } + + /// The flip is a deliberate user action and the one-shot reflow is its feedback — which means + /// the layout has to answer *both* ways, as many times as the user asks. + @Test("Flipping the modifier mid-drag re-admits and re-lifts, every time") + func theFlipGoesBothWays() throws { + let fixture = try makeBoard() + defer { fixture.tearDown() } + let store = try BoardStore(rootURL: fixture.root) + let session = cardSession(store) + + for modifiers in [none, option, none, option] { + session.resolveOperation(destinationRoot: store.rootURL, modifiers: modifiers) + let hidden = session.hiddenMembers(onBoardRooted: store.rootURL) + #expect(hidden == (modifiers == option ? [] : [Self.card1])) + } + } + + // MARK: The two things the rule does not reach + + /// The trash column's rows never lift, whatever the operation: they render in the column rather + /// than in a lane's masonry, so there is no resting layout of a lane's for them to leave. They + /// dim in place instead (`CardFaceView`, `TrashLaneRowView`). + @Test("A trash-container session hides nothing, under either operation") + func trashSessionsAreUnchanged() throws { + let fixture = try makeBoard() + defer { fixture.tearDown() } + let store = try BoardStore(rootURL: fixture.root) + let session = cardSession(store, members: [ItemID(rawValue: Ident.card3)], container: .trash) + + #expect(session.resolveOperation(destinationRoot: store.rootURL, modifiers: none) == .move) + #expect(session.hiddenMembers(onBoardRooted: store.rootURL).isEmpty) + + #expect(session.resolveOperation(destinationRoot: store.rootURL, modifiers: option) == .copy) + #expect(session.hiddenMembers(onBoardRooted: store.rootURL).isEmpty) + } + + @Test("Only the source board hides anything, whatever the operation") + func onlyTheSourceBoardHides() throws { + let fixture = try makeBoard() + defer { fixture.tearDown() } + let store = try BoardStore(rootURL: fixture.root) + let session = cardSession(store) + + session.resolveOperation(destinationRoot: elsewhere, modifiers: command) + #expect(session.hiddenMembers(onBoardRooted: elsewhere).isEmpty) + #expect(session.hiddenMembers(onBoardRooted: store.rootURL) == [Self.card1]) + } + + /// The lane carve-out, read as a layout claim: a within-board lane drag never resolves to + /// `.copy`, so the strip's zones under the cursor never see a re-admitted lane and `moveLanes` + /// keeps the index space it always had. A **cross-board** lane copy does re-admit — into the + /// source strip, while the cursor is over the foreign board. + @Test("A within-board lane drag never re-admits; a cross-board lane copy does") + func laneSessionsFollowTheCarveOut() throws { + let fixture = try makeBoard() + defer { fixture.tearDown() } + let store = try BoardStore(rootURL: fixture.root) + let session = DragSession() + session.beginLanes( + [Self.lane1], + folders: [store.rootURL.appendingPathComponent(Ident.lane1, isDirectory: true)], + units: [1], + source: store + ) + + #expect(session.resolveOperation(destinationRoot: store.rootURL, modifiers: option) == .move) + #expect(session.hiddenMembers(onBoardRooted: store.rootURL) == [Self.lane1]) + + #expect(session.resolveOperation(destinationRoot: elsewhere, modifiers: none) == .copy) + #expect(session.hiddenMembers(onBoardRooted: store.rootURL).isEmpty) + } + + // MARK: The hold freezes it + + /// A release settles the arrangement, and the operation is part of the arrangement now: the + /// write that went out named one, and a stray `dropUpdated` sampling a modifier the user has + /// already let go of must not redraw the board against the other one. + @Test("A settled copy keeps its originals on screen, whatever the modifiers do next") + func aSettledCopyStaysReAdmitted() throws { + let fixture = try makeBoard() + defer { fixture.tearDown() } + let store = try BoardStore(rootURL: fixture.root) + let session = cardSession(store) + + session.resolveOperation(destinationRoot: store.rootURL, modifiers: option) + session.commit(into: store) + + #expect(session.resolveOperation(destinationRoot: store.rootURL, modifiers: none) == .copy) + #expect(session.resolveOperation(destinationRoot: elsewhere, modifiers: command) == .copy) + #expect(session.operation == .copy) + #expect(session.hiddenMembers(onBoardRooted: store.rootURL).isEmpty) + } + + @Test("A settled move keeps its originals lifted, whatever the modifiers do next") + func aSettledMoveStaysLifted() throws { + let fixture = try makeBoard() + defer { fixture.tearDown() } + let store = try BoardStore(rootURL: fixture.root) + let session = cardSession(store) + + session.resolveOperation(destinationRoot: store.rootURL, modifiers: none) + session.commit(into: store) + + #expect(session.resolveOperation(destinationRoot: store.rootURL, modifiers: option) == .move) + #expect(session.operation == .move) + #expect(session.hiddenMembers(onBoardRooted: store.rootURL) == [Self.card1]) + } +} diff --git a/KanbanTests/DragWriteTests.swift b/KanbanTests/DragWriteTests.swift index dbf0f37..a9d44b5 100644 --- a/KanbanTests/DragWriteTests.swift +++ b/KanbanTests/DragWriteTests.swift @@ -231,6 +231,12 @@ struct MoveCardsTests { // MARK: - Within-board ⌥-copies +/// **A copy's index is counted among the lane's full rendered cards, originals included** — unlike +/// `moveCards`', which is counted among the cards its run vacates (DRAG-REORDER.md § Resting-layout +/// zones, ruled 2026-08-01). That is not an arbitrary split: a copy leaves its originals in the +/// source board's resting layout for the whole drag (`DragSession.hiddenMembers`), so the zones that +/// produced the number counted them too, and each writer consumes the number in the space its own +/// gesture was showing. `DragRestingLayoutTests` pins the layout half; these pin the write half. @MainActor @Suite("BoardStore ▸ copyCards") struct CopyCardsTests { @@ -242,8 +248,9 @@ struct CopyCardsTests { let store = try BoardStore(rootURL: fixture.root) let stamp = try stat(fixture, "\(Ident.lane1)/\(Ident.card1)") - // With First lifted the lane reads [Second, Third]; 1 is "before Third". - store.copyCards([card1], toLane: lane1, at: 1) + // The lane the user is looking at reads [First, Second, Third] — the ⌥-copy's originals + // stay in it — so 2 is "before Third". + store.copyCards([card1], toLane: lane1, at: 2) #expect(try titles(lane1, in: fixture) == ["First", "Second", "First", "Third"]) let landed = try ids(lane1, in: fixture) @@ -253,6 +260,41 @@ struct CopyCardsTests { #expect(store.banners.oneShots.isEmpty) } + /// **The drop lands exactly where the shadow showed, below the dragged run included.** This is + /// the case the index space is actually about: the shadow sits *after* the original, so the + /// slot number the geometry produced counts the original on its way there, and a writer that + /// re-read the number against the originals-removed layout would push the copy one slot too far + /// — off the end of a three-card lane, in this fixture. + @Test("A copy below the dragged run lands at the shadow's slot, not past it") + func landsBelowTheRun() throws { + let fixture = try makeBoard() + defer { fixture.tearDown() } + let store = try BoardStore(rootURL: fixture.root) + + // Dragging First, ⌥ held, with the shadow between Second and Third: the drawn lane is + // [First, Second, ▮, Third], so the proposal is slot 2. + store.copyCards([card1], toLane: lane1, at: 2) + + #expect(try titles(lane1, in: fixture) == ["First", "Second", "First", "Third"]) + let landed = try ids(lane1, in: fixture)[2] + #expect(try order(fixture, "\(Ident.lane1)/\(landed)") == .valid(2560), + "between Second and Third, where the shadow was") + } + + /// The end slot, in the same space: one past the last card of the layout on screen appends. + @Test("The terminal slot appends, counted among the originals like every other slot") + func theTerminalSlotAppends() throws { + let fixture = try makeBoard() + defer { fixture.tearDown() } + let store = try BoardStore(rootURL: fixture.root) + + store.copyCards([card1], toLane: lane1, at: 3) + + #expect(try titles(lane1, in: fixture) == ["First", "Second", "Third", "First"]) + let landed = try ids(lane1, in: fixture)[3] + #expect(try order(fixture, "\(Ident.lane1)/\(landed)") == .valid(4096)) + } + @Test("A copy keeps created — a copy is a fork") func createdIsKept() throws { let fixture = try makeBoard() @@ -274,14 +316,36 @@ struct CopyCardsTests { defer { fixture.tearDown() } let store = try BoardStore(rootURL: fixture.root) - // Index 0 in the resting layout means "before Second" — the layout the originals are lifted - // out of. The rank has to sit between First and Second, not at First's apparently vacated - // 1024, because First reappears the instant the write lands. - store.copyCards([card1], toLane: lane1, at: 0) + // Index 1 is "between First and Second" in the lane as drawn, and the original First is + // genuinely still sitting at 1024 — so the rank has to land strictly inside that gap. There + // is no apparently-vacated slot to choose in, which is the whole point of counting the + // index among the originals rather than around them. + store.copyCards([card1], toLane: lane1, at: 1) #expect(try titles(lane1, in: fixture) == ["First", "First", "Second", "Third"]) let landed = try ids(lane1, in: fixture)[1] #expect(try order(fixture, "\(Ident.lane1)/\(landed)") == .valid(1536)) + #expect(try order(fixture, "\(Ident.lane1)/\(Ident.card1)") == .valid(1024), + "the original keeps its rank — nothing was written to it") + } + + /// Slot 0 in the copy's space is genuinely *before* the original, which the old + /// originals-removed space could not name at all: its 0 meant "before the first survivor", + /// i.e. after the original. + @Test("Slot 0 lands the copy in front of its own original") + func slotZeroLandsInFront() throws { + let fixture = try makeBoard() + defer { fixture.tearDown() } + let store = try BoardStore(rootURL: fixture.root) + + store.copyCards([card1], toLane: lane1, at: 0) + + #expect(try titles(lane1, in: fixture) == ["First", "First", "Second", "Third"]) + let landed = try ids(lane1, in: fixture)[0] + #expect(landed != Ident.card1, "the copy is the one in front") + let rank = try #require(order(fixture, "\(Ident.lane1)/\(landed)").value) + #expect(rank < 1024, "a whole gap below the original, which keeps its own 1024") + #expect(try order(fixture, "\(Ident.lane1)/\(Ident.card1)") == .valid(1024)) } @Test("A multi-copy lands the run contiguously, in flatten order")