(ebad2fa) Scroll the campaign description in the frame above the board

The frame showed the opening line of a description and the rest was only
readable through `campaign show`, which means leaving the board. It now
holds three rows of prose and pages through the remainder on `pgup` and
`pgdn`, reached by going up past the top card of a column.

Four decisions rather than four edits:

`section_prose` replaces `section_opening`. The campaign file is only in
hand while the campaigns directory is being read, so that read carries
the whole description and `CampaignRow::summary` takes the picker's one
line back off it. Two fields, one cut from the other, would be two
strings free to come from different reads of the same file.

`CAMPAIGN_PROSE_ROWS` is a constant. Fitting the frame to the
description would resize every column whenever the filter changed, so
the height is fixed at three rows and scrolling covers the rest. Two
more rows of cards spent than the one row cost.

`Focus` is the third place the selection can be, held on `Tab` beside
the filter and the new `frame_offset`. Every key that acts on a card
answers for it: `enter` is inert because `Tab::selected` hands back
nothing there, `left` and `right` are inert because the frame spans the
board, and `y` copies the campaign's short id, so `y copy id` means the
id of the selected thing in every state. No card is drawn reversed while
the frame holds the selection, since that highlight is what says which
ticket a key is about. The frame is out of reach from under an open
ticket, where up and down step through tickets and the overlay follows.

`Board::scroll_page` holds the precedence, not the `main.rs` arm: an
open ticket keeps both keys whatever holds the selection behind it, the
rule `dismiss` follows for the same reason. The page indicator, the
step and the clamp are the overlay's `page_indicator`, `scroll_step` and
`last_offset`, so the two places a reader presses these keys behave the
same. The indicator sits beside `q board` rather than up beside the
title, which would shorten a long campaign name whenever its
description grew.

Criterion 11 is not done: 2a83bd4 has not landed, so there is no tag
frame to give the same treatment. The model it inherits is in place and
named on the ticket.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ansho Rei
2026-08-23 17:47:09 +02:00
co-authored by Claude Opus 5
parent 8e2ab6332c
commit af1ef1f97f
7 changed files with 927 additions and 68 deletions
+7 -3
View File
@@ -215,11 +215,15 @@ fn run_tui(paths: &[std::path::PathBuf], start: &std::path::Path) -> Result<()>
KeyCode::Right | KeyCode::Char('l') => board.select_column(1, screen),
// Up and down stay on the selection, open detail view or not, so a
// column can be read through without closing the modal. Scrolling the
// open ticket is a page at a time.
// open ticket is a page at a time, and so is scrolling the campaign
// frame that up reaches from the top card of a column.
KeyCode::Up | KeyCode::Char('k') => board.select_card(-1, screen),
KeyCode::Down | KeyCode::Char('j') => board.select_card(1, screen),
KeyCode::PageUp => board.scroll_detail(-1, screen),
KeyCode::PageDown => board.scroll_detail(1, screen),
// The open ticket first and the campaign frame behind it, which is
// `Board::scroll_page` rather than a condition written here: the arms in
// this dispatch are not reachable from a test.
KeyCode::PageUp => board.scroll_page(-1, screen),
KeyCode::PageDown => board.scroll_page(1, screen),
// Tabs cycle rather than clamp, the way tabs everywhere do, and are
// a no-op with a single board. Free of every other binding: the
// columns took hjkl and the arrows.
+881 -49
View File
File diff suppressed because it is too large Load Diff
+26 -11
View File
@@ -1776,23 +1776,38 @@ fn section_body(lines: &[&str], heading: &str) -> Option<std::ops::Range<usize>>
Some(after..section_end(lines, after))
}
/// The first line of a section's body, or nothing when the section is absent or holds
/// only its placeholder.
/// A section's body as prose, or nothing when the section is absent or holds only its
/// placeholder.
///
/// For a view with one row to spend on prose: the board's campaign frame and its picker
/// both want the opening line of a description and have no room for the rest. Through
/// [`section_body`] rather than a scan of its own, so what counts as the section is
/// The whole of it, the blank lines between paragraphs included, for a view that can page
/// through what it cannot fit: the board's campaign frame gives a description three rows
/// and scrolls the rest, and the one line the picker draws is the first line of this.
///
/// It replaced `section_opening`, which did the cut here. The cut belongs to the view that
/// wants one line, not to the read: the file is only in hand while the campaigns directory
/// is being read, so what that read has to carry is everything a view might want, and
/// `CampaignRow::summary` is where the one line comes off it again.
///
/// Through [`section_body`] rather than a scan of its own, so what counts as the section is
/// decided in one place, and the placeholder reads as nothing here the way it does to
/// `append`.
pub fn section_opening(content: &str, section: &Section) -> Option<String> {
/// `append`. Only the ends are trimmed: those blanks separate the body from its heading and
/// from whatever follows, and a view that kept them would open on empty rows and scroll
/// past empty ones at the end. Indentation inside a line survives, since a nested list is
/// part of the prose.
pub fn section_prose(content: &str, section: &Section) -> Option<String> {
let lines: Vec<&str> = content.lines().collect();
let body = section_body(&lines, section.heading)?;
lines[body]
let kept: Vec<&str> = lines[body]
.iter()
.map(|line| line.trim())
.find(|line| !line.is_empty() && *line != section.placeholder)
.map(|line| line.to_string())
.map(|line| line.trim_end())
.filter(|line| *line != section.placeholder)
.collect();
let start = kept.iter().position(|line| !line.is_empty())?;
let end = kept.iter().rposition(|line| !line.is_empty())?;
Some(kept[start..=end].join("\n"))
}
/// Where the body's content ends, ignoring the blank lines that separate it from