Fix tags in tui on narrow screen, and bump to 0.33.9

This commit is contained in:
Ansho Rei
2026-11-06 17:45:49 +01:00
parent fbd752afc9
commit 8e7a3f1425
4 changed files with 180 additions and 32 deletions
+173 -27
View File
@@ -4557,11 +4557,19 @@ fn card_lines(card: &Card, selected: bool, width: u16) -> Vec<Line<'static>> {
/// use — the stronger fact takes the row and the weaker one gives way. Bold is what stops
/// it reading as another tag when a card carries five.
///
/// A row the column will not hold is dropped whole, the rule `corner_line` applies to a
/// corner: a cut list reads as a shorter one, and `bug` and `bugfix` truncated to the
/// same width say the same thing. A ticket with neither a campaign nor a tag spends no row
/// at all, the way a short title spends no second one, so a ticket in no campaign renders
/// exactly as it did before campaigns reached the card.
/// A row that will not hold every tag draws the ones it can and ends in `(+n)`, the count
/// of the ones it left out. No tag is ever cut in half, the rule `corner_line` applies to
/// a corner: `bug` and `bugfix` truncated to the same width say the same thing. What the
/// row may do is be short, as long as it says so — the indicator is the whole difference
/// between a list that was cut and one that reads as complete, which is why the row is
/// dropped whole when it cannot hold one tag and the indicator together. A cut list
/// without the count is the thing this must never draw. Parentheses rather than brackets,
/// which are the criteria count's two rows below, and grey like the owner and that count,
/// because it is a fact about the row rather than another tag on it.
///
/// A ticket with neither a campaign nor a tag spends no row at all, the way a short title
/// spends no second one, so a ticket in no campaign renders exactly as it did before
/// campaigns reached the card.
///
/// Each tag carries its own colour, from `tag_color`, so the same tag is the same
/// colour on every card in every column, and the campaign carries its own from
@@ -4578,21 +4586,13 @@ fn labels_line(campaign: Option<&Cell>, tags: &[String], width: u16) -> Option<L
// The space between the campaign and the first tag, which the row has to hold too.
let room = width.saturating_sub(used + usize::from(campaign.is_some()));
let row = tags
.iter()
.map(|tag| format!("#{tag}"))
.collect::<Vec<_>>()
.join(" ");
let tags: &[String] = match !row.is_empty() && row.chars().count() <= room {
true => tags,
false => &[],
};
let (tags, omitted) = tags_that_fit(tags, room);
if campaign.is_none() && tags.is_empty() {
return None;
}
let mut spans = Vec::with_capacity(tags.len() * 2 + 2);
let mut spans = Vec::with_capacity(tags.len() * 2 + 3);
if let Some(cell) = campaign {
spans
.push(span_of(cell.clone()).patch_style(Style::default().add_modifier(Modifier::BOLD)));
@@ -4605,9 +4605,70 @@ fn labels_line(campaign: Option<&Cell>, tags: &[String], width: u16) -> Option<L
spans.push(Span::styled(format!("#{tag}"), Style::default().fg(tag_color(tag).into())));
}
if omitted > 0 {
spans.push(Span::raw(" "));
spans.push(Span::styled(
omitted_label(omitted),
Style::default().fg(Color::Grey.into()),
));
}
Some(Line::from(spans))
}
/// How many tags `room` cells will hold, and how many that leaves over.
///
/// Whole tags only, single spaced, in the order the ticket carries them: the first tags
/// are the ones a reader is scanning for, and reordering them would mean the same ticket
/// reads differently in two columns of different widths.
///
/// The indicator is measured as part of the row it counts, not added to a row that was
/// already full, so the answer is the largest prefix whose tags **and** `(+n)` fit. It
/// shrinks as tags are dropped — `(+9)` for nine and `(+10)` for ten — so the fit is
/// recomputed against each candidate rather than reserved once up front, which would
/// spend a cell the row does not owe on every list of under ten.
///
/// A prefix of nothing and a count of everything is a row saying only how much it is not
/// showing, which is no use to anybody, so that case comes back as no tags at all and the
/// caller spends no row on it. Every other answer either shows every tag or says how many
/// it left out; a short list that reads as a complete one is the one thing this cannot
/// return.
fn tags_that_fit(tags: &[String], room: usize) -> (&[String], usize) {
// The whole list first, which is the common case and the only one that draws no
// indicator at all.
// The hash and the space before the next tag, less the space the first one does not pay.
let whole = tags
.iter()
.map(|tag| tag.chars().count() + 2)
.sum::<usize>()
.saturating_sub(1);
if !tags.is_empty() && whole <= room {
return (tags, 0);
}
let mut width = 0;
let mut kept = 0;
for (n, tag) in tags.iter().enumerate() {
// The space before this tag, which the first one does not pay.
width += tag.chars().count() + 1 + usize::from(n > 0);
// The space before the indicator is its own, the way the space before a tag is.
if width + 1 + omitted_label(tags.len() - n - 1).chars().count() > room {
break;
}
kept = n + 1;
}
match kept {
0 => (&[], 0),
kept => (&tags[..kept], tags.len() - kept),
}
}
/// The count of the tags a row left out, as it is drawn.
fn omitted_label(omitted: usize) -> String {
format!("(+{omitted})")
}
/// The project name as it fits beside whatever the row already carries.
///
/// The mark, the id and the blocked mark are the ticket's identity and its state, and
@@ -6536,23 +6597,101 @@ mod tests {
assert!(!rows.iter().any(|row| row.contains('#')), "{rows:?}");
}
/// A row too wide for the column goes whole, the rule a corner follows: a cut list
/// reads as a shorter one, and bug and bugfix cut to the same width say the same
/// thing.
/// A row that holds every tag draws every tag and says nothing about a count, which
/// is the common card and the one the indicator must not appear on.
#[test]
fn a_tag_row_too_wide_for_the_column_is_dropped_whole() {
fn a_row_that_holds_every_tag_spends_nothing_saying_so() {
let dir = board_dir();
write_tagged_card(&dir, "Short", "2026-12-31", "- [ ] One", "frontend, operations");
// One character short of "#frontend #operations", and one over it.
let narrow = only_card_at(&dir, 20);
assert_eq!(narrow.len(), 4, "the row was kept: {narrow:?}");
assert!(!narrow.iter().any(|row| row.contains('#')), "{narrow:?}");
// Exactly "#frontend #operations".
let fits = only_card_at(&dir, 21);
assert_eq!(fits[2], "#frontend #operations", "{fits:?}");
}
/// One character short of the whole list, the card draws what it can and counts the
/// rest. The row used to go whole there, so a narrow column — which is exactly where
/// a reader is scanning cards for a tag — showed no tags at all.
#[test]
fn a_row_too_narrow_for_every_tag_keeps_what_fits_and_counts_the_rest() {
let dir = board_dir();
write_tagged_card(&dir, "Short", "2026-12-31", "- [ ] One", "frontend, operations");
let narrow = only_card_at(&dir, 20);
assert_eq!(narrow.len(), 5, "the row was dropped: {narrow:?}");
assert_eq!(narrow[2], "#frontend (+1)", "{narrow:?}");
}
/// Whole tags only: half a tag is a different tag, and `bug` and `bugfix` cut to the
/// same width say the same thing. So the row gives up a tag before it gives up a
/// character of one, and what it draws stays inside the column.
#[test]
fn a_cut_row_cuts_whole_tags_and_stays_inside_the_column() {
let dir = board_dir();
write_tagged_card(&dir, "Short", "2026-12-31", "- [ ] One", "cli, tui, docs, tests");
for inner in 5..=23u16 {
let rows = only_card_at(&dir, inner);
let row = rows.iter().find(|row| row.contains('#'));
let Some(row) = row else { continue };
assert!(
row.chars().count() <= inner as usize,
"past the column at {inner}: {row:?}"
);
for word in row.split_whitespace().filter(|word| word.starts_with('#')) {
assert!(
["#cli", "#tui", "#docs", "#tests"].contains(&word),
"a tag was cut at {inner}: {row:?}"
);
}
}
}
/// The count is of the tags left out, not of the tags on the ticket, and it grows as
/// the column narrows rather than standing for whatever the first cut happened to be.
#[test]
fn the_indicator_counts_the_tags_the_row_left_out() {
let dir = board_dir();
write_tagged_card(&dir, "Short", "2026-12-31", "- [ ] One", "cli, tui, docs, tests");
assert_eq!(only_card_at(&dir, 20)[2], "#cli #tui #docs (+1)");
assert_eq!(only_card_at(&dir, 16)[2], "#cli #tui (+2)");
assert_eq!(only_card_at(&dir, 11)[2], "#cli (+3)");
}
/// A row with no room for one tag beside the count goes whole, as it always did: a
/// row saying only how many tags it is not showing is no use to anybody, and a tag
/// drawn without the count would read as the ticket's whole list.
#[test]
fn a_row_too_narrow_for_one_tag_and_the_count_is_dropped_whole() {
let dir = board_dir();
write_tagged_card(&dir, "Short", "2026-12-31", "- [ ] One", "frontend, operations");
// One short of "#frontend (+1)".
let narrow = only_card_at(&dir, 13);
assert_eq!(narrow.len(), 4, "the row was kept: {narrow:?}");
assert!(!narrow.iter().any(|row| row.contains('#')), "{narrow:?}");
}
/// The count is grey like the owner and the criteria count, not a colour of its own:
/// it is a fact about the row rather than another tag on it.
#[test]
fn the_indicator_is_drawn_in_grey_rather_than_as_a_tag() {
let dir = board_dir();
write_tagged_card(&dir, "Short", "2026-12-31", "- [ ] One", "frontend, operations");
let board = one_board(&dir);
let card = board.selected().expect("no card");
let colour = card_lines(card, false, 20)
.into_iter()
.flat_map(|line| line.spans)
.find(|span| span.content == "(+1)")
.map(|span| span.style.fg)
.expect("no indicator on the row");
assert_eq!(colour, Some(Color::Grey.into()));
}
/// And a title that fits gets one row, or the second is wasted on every short
/// ticket in the column.
#[test]
@@ -12556,7 +12695,9 @@ approach";
/// The campaign takes the row first and the tags give way, the order a corner and a
/// project label already follow: two cards in one campaign is what a reader looking
/// for a campaign is looking for, and the tags are the context around it.
/// for a campaign is looking for, and the tags are the context around it. They give
/// way a tag at a time, with the count for the ones that went, and give way whole
/// only when what the campaign left will not hold one tag and the count.
#[test]
fn the_campaign_keeps_the_row_and_the_tags_give_way() {
let dir = board_dir();
@@ -12564,11 +12705,16 @@ approach";
write_member_card(&dir, "Short", "frontend, operations", V1);
// One character short of "~v1 #frontend #operations", and one over it.
let narrow = only_card_at(&dir, 24);
assert_eq!(narrow[2], "~v1", "the tags took the row from the campaign: {narrow:?}");
let cut = only_card_at(&dir, 24);
assert_eq!(cut[2], "~v1 #frontend (+1)", "{cut:?}");
let fits = only_card_at(&dir, 25);
assert_eq!(fits[2], "~v1 #frontend #operations", "{fits:?}");
// One character short of "~v1 #frontend (+1)", where the tags have nothing left
// to give up and the campaign keeps the row alone.
let narrow = only_card_at(&dir, 17);
assert_eq!(narrow[2], "~v1", "the tags took the row from the campaign: {narrow:?}");
}
/// And a campaign the row will not hold goes whole, never cut: half a codename is a