Fix tags in tui on narrow screen, and bump to 0.33.9
This commit is contained in:
+173
-27
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user