(b8ce18c) Show a blocked marker on the tui card, and bump to 0.13.4
A ticket held up by an open blocker looked exactly like one that is ready, and the board is where the next thing to pick up is chosen. The mark is × in brightred, after the short id. Not a fourth Geometric Shapes glyph: those are the priority meter's, two cells away, and another circle there reads as part of that ramp. × is Latin-1, like the middle dot the unset priority draws, so it renders wherever the meter does. After the id rather than before it, because ahead of it the mark would push every id in the column out of line whenever one card was blocked. It is measured before the project label and the due date, so both give way to it: those are context for a ticket somebody can start, and this is the one thing on a card that says not to. Dropped whole when the row cannot hold the identity and the mark together. No scan of the board per tick was needed after all. collect_ticket_items also reads the ticket's own uuid and the targets of its blocked by lines, off the file it is already holding, and mark_blocked walks the four columns once for a uuid-to-status map and once to answer every card. The flag is on Card rather than TicketItem: the answer is about two tickets at once, so no card can reach it alone, and it is settled at reload the way project is. The merge carries each card's flag from the board it came from. relate resolves its target inside one .worklane, so a blocker in another project is not a relation anything can record, and recomputing over the merged columns would let one project's uuid match another project's ticket. project_label now takes the width the row has actually spent, measured off the spans, instead of adding up the widths those spans are supposed to have. The hand-written sum left out the space after the priority mark, so a cut label was handed one cell more than the column had. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5
parent
3d6a74bc53
commit
a16169ce8c
+303
-20
@@ -7,6 +7,7 @@
|
||||
//! **Read only.** Moving a card by keypress is a follow-up. Everything here observes.
|
||||
|
||||
use std::collections::hash_map::DefaultHasher;
|
||||
use std::collections::HashMap;
|
||||
use std::hash::{Hash, Hasher};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, SystemTime};
|
||||
@@ -100,6 +101,14 @@ fn project_name(dir: &Path) -> String {
|
||||
pub struct Card {
|
||||
pub ticket: TicketItem,
|
||||
pub project: Option<String>,
|
||||
/// Whether a ticket this one is `blocked by` is on the board and not done.
|
||||
///
|
||||
/// Decided at reload like `project`, and for a stronger reason: the answer lives on
|
||||
/// two tickets at once, so no card can reach it alone and asking per draw would mean
|
||||
/// reading the tree per frame. Computed on the board the ticket came from and
|
||||
/// carried into the merge unchanged — `relate` resolves its target against one
|
||||
/// `.worklane`, so there is no such thing as a blocker in another project.
|
||||
pub blocked: bool,
|
||||
}
|
||||
|
||||
/// One status and the cards in it.
|
||||
@@ -534,7 +543,7 @@ fn detail_of(card: &Card) -> Detail {
|
||||
|
||||
/// The four columns of one board.
|
||||
fn columns_of(worklane_dir: &Path) -> Vec<Column> {
|
||||
status_dirs()
|
||||
let mut columns: Vec<Column> = status_dirs()
|
||||
.into_iter()
|
||||
.map(|status| {
|
||||
// An absent or unreadable directory is an empty column, not a missing one:
|
||||
@@ -545,11 +554,47 @@ fn columns_of(worklane_dir: &Path) -> Vec<Column> {
|
||||
.map(|ticket| Card {
|
||||
ticket,
|
||||
project: None,
|
||||
blocked: false,
|
||||
})
|
||||
.collect();
|
||||
Column { status, cards }
|
||||
})
|
||||
.collect()
|
||||
.collect();
|
||||
|
||||
mark_blocked(&mut columns);
|
||||
columns
|
||||
}
|
||||
|
||||
/// Set `blocked` on every card whose ticket waits on one that is not done.
|
||||
///
|
||||
/// Two walks of what `columns_of` has just read, not a lookup per relation: the status
|
||||
/// of a blocker is on another card, so the pass builds the uuid to status map once and
|
||||
/// then answers every card from it. Nothing is read from disk here, which is the point
|
||||
/// — the blockers came off the same read that built the cards.
|
||||
///
|
||||
/// A blocker the board does not hold marks nothing, the answer `mv` already gives it: a
|
||||
/// uuid nothing carries is a bookkeeping fault rather than a dependency. A ticket with
|
||||
/// no ID field is left out of the map entirely, or every ticket missing one would block
|
||||
/// every other ticket missing one, which is the guard `RelationIndex::inbound` makes.
|
||||
fn mark_blocked(columns: &mut [Column]) {
|
||||
let status_of: HashMap<String, &'static str> = columns
|
||||
.iter()
|
||||
.flat_map(|column| {
|
||||
column
|
||||
.cards
|
||||
.iter()
|
||||
.map(|card| (card.ticket.uuid.clone(), column.status))
|
||||
})
|
||||
.filter(|(uuid, _)| !uuid.trim().is_empty() && !is_unknown_value(uuid))
|
||||
.collect();
|
||||
|
||||
for column in columns.iter_mut() {
|
||||
for card in column.cards.iter_mut() {
|
||||
card.blocked = card.ticket.blockers.iter().any(|blocker| {
|
||||
matches!(status_of.get(blocker.as_str()), Some(status) if *status != DONE)
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Every board's columns as one set of four, each card labelled with the project it
|
||||
@@ -571,6 +616,10 @@ fn merge(per_project: &[Vec<Column>], projects: &[Project]) -> Vec<Column> {
|
||||
cards.extend(column.cards.iter().map(|card| Card {
|
||||
ticket: card.ticket.clone(),
|
||||
project: Some(project.name.clone()),
|
||||
// Already answered on the board the card came from. Recomputing it
|
||||
// over the merged columns would let one project's uuid resolve
|
||||
// against another's ticket, which is a relation nothing can record.
|
||||
blocked: card.blocked,
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -824,6 +873,15 @@ fn aligned_offset(offset: u16, start: u16, end: u16, inner: u16, total: u16) ->
|
||||
offset.min(total.saturating_sub(inner))
|
||||
}
|
||||
|
||||
/// The mark a card carries while it waits on a ticket that is not done.
|
||||
///
|
||||
/// Not a fourth circle. The Geometric Shapes glyphs belong to the priority meter, and
|
||||
/// another one two cells away from it would read as part of that ramp rather than as a
|
||||
/// different fact. A multiplication sign is Latin-1, like the middle dot the unset
|
||||
/// priority draws, so it renders wherever the meter already does. That is the same
|
||||
/// safe-glyph rule that took the quadrant circles out of the ramp.
|
||||
const BLOCKED_MARK: &str = "\u{d7}";
|
||||
|
||||
/// One card as four corners with the title between them:
|
||||
///
|
||||
/// ```text
|
||||
@@ -845,6 +903,10 @@ fn aligned_offset(offset: u16, start: u16, end: u16, inner: u16, total: u16) ->
|
||||
///
|
||||
/// The tags sit between the title and the bottom corners, on a row a ticket without
|
||||
/// them does not spend. See [`tags_line`].
|
||||
///
|
||||
/// A held-up ticket carries [`BLOCKED_MARK`] after its id, ahead of the project and the
|
||||
/// due date, both of which give way to it: those are context for a ticket somebody can
|
||||
/// start, and this is the one thing on a card that says not to.
|
||||
fn card_lines(card: &Card, selected: bool, width: u16) -> Vec<Line<'static>> {
|
||||
let ticket = &card.ticket;
|
||||
let (glyph, colour) = priority_mark(ticket.priority);
|
||||
@@ -865,10 +927,25 @@ fn card_lines(card: &Card, selected: bool, width: u16) -> Vec<Line<'static>> {
|
||||
Style::default().fg(Color::Red.into()).add_modifier(emphasis),
|
||||
),
|
||||
];
|
||||
// After the id, not before it: inserted ahead of the id the mark would push it out
|
||||
// of line, and a column of ids that do not start at the same cell is harder to read
|
||||
// than one card's worth of state is worth. Dropped whole when the row cannot hold
|
||||
// the identity and the mark together, the rule a corner follows, rather than
|
||||
// wrapping or cutting it.
|
||||
if card.blocked && spans_width(&left) + 1 + BLOCKED_MARK.chars().count() <= width as usize {
|
||||
left.push(Span::raw(" "));
|
||||
left.push(Span::styled(
|
||||
BLOCKED_MARK.to_string(),
|
||||
Style::default()
|
||||
.fg(Color::BrightRed.into())
|
||||
.add_modifier(emphasis),
|
||||
));
|
||||
}
|
||||
|
||||
let label = card
|
||||
.project
|
||||
.as_deref()
|
||||
.and_then(|name| project_label(name, width));
|
||||
.and_then(|name| project_label(name, width, spans_width(&left)));
|
||||
if let Some(label) = label {
|
||||
left.push(Span::raw(" "));
|
||||
// Grey like the owner and the criteria count: the shape carries which project
|
||||
@@ -957,21 +1034,24 @@ fn tags_line(tags: &[String], width: u16) -> Option<Line<'static>> {
|
||||
Some(Line::from(spans))
|
||||
}
|
||||
|
||||
/// The project name as it fits beside the mark and the id.
|
||||
/// The project name as it fits beside whatever the row already carries.
|
||||
///
|
||||
/// The mark and the id are the ticket's identity and never give way, so the label takes
|
||||
/// what the row has left and ends in an ellipsis where it was cut. It is measured before
|
||||
/// the due date, which is what gives the project the narrow column: on the All tab the
|
||||
/// project matters more than the date, and `corner_line` drops the date when what is
|
||||
/// left will not hold it.
|
||||
/// The mark, the id and the blocked mark are the ticket's identity and its state, and
|
||||
/// neither gives way, so the label takes what the row has left and ends in an ellipsis
|
||||
/// where it was cut. It is measured before the due date, which is what gives the project
|
||||
/// the narrow column: on the All tab the project matters more than the date, and
|
||||
/// `corner_line` drops the date when what is left will not hold it.
|
||||
///
|
||||
/// `used` is measured off the spans already built rather than added up from the widths
|
||||
/// they are supposed to have. The hand-written version left out the space after the
|
||||
/// priority mark, so the label was handed one cell more than the row had and a narrow
|
||||
/// column drew a card one character wider than its column.
|
||||
///
|
||||
/// Under three characters there is nothing left to say, and a single letter and a dot
|
||||
/// would only crowd the corner, so the label goes instead.
|
||||
fn project_label(name: &str, width: u16) -> Option<String> {
|
||||
// The mark and the space after it, the id in its brackets, and the space before the
|
||||
// label.
|
||||
let used = 2 + SHORT_ID_WIDTH + 2 + 1;
|
||||
let room = (width as usize).checked_sub(used)?;
|
||||
fn project_label(name: &str, width: u16, used: usize) -> Option<String> {
|
||||
// The space between the label and what precedes it.
|
||||
let room = (width as usize).checked_sub(used + 1)?;
|
||||
if room < 3 {
|
||||
return None;
|
||||
}
|
||||
@@ -1010,7 +1090,7 @@ fn corner_line(
|
||||
width: u16,
|
||||
) -> Line<'static> {
|
||||
let mut spans = left;
|
||||
let used: usize = spans.iter().map(|span| span.content.chars().count()).sum();
|
||||
let used = spans_width(&spans);
|
||||
|
||||
let Some(right) = right else {
|
||||
return Line::from(spans);
|
||||
@@ -1027,6 +1107,11 @@ fn corner_line(
|
||||
Line::from(spans)
|
||||
}
|
||||
|
||||
/// The cells a run of spans takes, counted in characters rather than bytes.
|
||||
fn spans_width(spans: &[Span<'static>]) -> usize {
|
||||
spans.iter().map(|span| span.content.chars().count()).sum()
|
||||
}
|
||||
|
||||
/// The title over one row or two, wrapped on spaces, cut with an ellipsis if even two
|
||||
/// are not enough.
|
||||
///
|
||||
@@ -2676,13 +2761,211 @@ mod tests {
|
||||
|
||||
/// The label takes what the row has left, never the mark or the id, and says it was
|
||||
/// cut. A column too narrow for even that keeps the identity alone.
|
||||
///
|
||||
/// The mark, a space and the id in its brackets, which is what `card_lines` has
|
||||
/// built by the time it asks.
|
||||
#[test]
|
||||
fn the_project_label_gives_way_to_the_mark_and_the_id() {
|
||||
assert_eq!(project_label("alpha", 38).as_deref(), Some("alpha"));
|
||||
// Room for four characters of a longer name, the last of them the ellipsis.
|
||||
assert_eq!(project_label("factry-core", 16).as_deref(), Some("fac…"));
|
||||
assert_eq!(project_label("factry-core", 13), None);
|
||||
assert_eq!(project_label("alpha", 4), None);
|
||||
const IDENTITY: usize = 2 + 1 + SHORT_ID_WIDTH + 2;
|
||||
|
||||
assert_eq!(project_label("alpha", 38, IDENTITY).as_deref(), Some("alpha"));
|
||||
// Room for three characters of a longer name, the last of them the ellipsis.
|
||||
assert_eq!(
|
||||
project_label("factry-core", 16, IDENTITY).as_deref(),
|
||||
Some("fa…")
|
||||
);
|
||||
assert_eq!(project_label("factry-core", 13, IDENTITY), None);
|
||||
assert_eq!(project_label("alpha", 4, IDENTITY), None);
|
||||
}
|
||||
|
||||
/// The label plus everything before it has to fit the column it is drawn in. The
|
||||
/// arithmetic this replaced left out the space after the priority mark, so the row
|
||||
/// came out one cell wider than the column at every width the label was cut at.
|
||||
#[test]
|
||||
fn the_project_label_leaves_the_row_inside_the_column() {
|
||||
const IDENTITY: usize = 2 + 1 + SHORT_ID_WIDTH + 2;
|
||||
|
||||
for width in 13u16..40 {
|
||||
let Some(label) = project_label("factry-core", width, IDENTITY) else {
|
||||
continue;
|
||||
};
|
||||
let row = IDENTITY + 1 + label.chars().count();
|
||||
assert!(row <= width as usize, "row {row} over column {width}");
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------- the blocked mark --
|
||||
|
||||
const BLOCKER: &str = "aaaaaaaa-0000-4000-8000-000000000000";
|
||||
const WAITER: &str = "bbbbbbbb-0000-4000-8000-000000000000";
|
||||
const ELSEWHERE: &str = "cccccccc-0000-4000-8000-000000000000";
|
||||
|
||||
/// A Relations section as `relate` writes it, for the `extra` a fixture appends.
|
||||
///
|
||||
/// It lands after the Metadata rather than in `SECTION_ORDER`'s place for it, which
|
||||
/// `section_body` reads all the same: these tests are about what the section says,
|
||||
/// not where the writer puts it.
|
||||
fn blocked_by(uuid: &str) -> String {
|
||||
format!("\n## Relations\n\n- blocked by {uuid}\n")
|
||||
}
|
||||
|
||||
/// Whether the board decided the named ticket is held up.
|
||||
///
|
||||
/// Over every column, done included: the flag is filled whether or not the column
|
||||
/// is drawn, the same way `reload` scans done while `d` hides it.
|
||||
fn marked_blocked(board: &Board, title: &str) -> bool {
|
||||
board
|
||||
.current()
|
||||
.columns
|
||||
.iter()
|
||||
.flat_map(|column| &column.cards)
|
||||
.find(|card| card.ticket.title == title)
|
||||
.unwrap_or_else(|| panic!("no card titled '{title}'"))
|
||||
.blocked
|
||||
}
|
||||
|
||||
/// The rows of the named ticket's card, laid out in a column of `inner` characters.
|
||||
fn card_rows(board: &Board, title: &str, inner: u16) -> Vec<String> {
|
||||
let card = board
|
||||
.current()
|
||||
.columns
|
||||
.iter()
|
||||
.flat_map(|column| &column.cards)
|
||||
.find(|card| card.ticket.title == title)
|
||||
.unwrap_or_else(|| panic!("no card titled '{title}'"));
|
||||
|
||||
card_lines(card, false, inner)
|
||||
.iter()
|
||||
.map(|line| line.spans.iter().map(|span| span.content.as_ref()).collect())
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The one thing on a card that says do not start this. Without it a ticket whose
|
||||
/// blocker is still open reads exactly like one that is ready.
|
||||
#[test]
|
||||
fn a_card_waiting_on_an_open_ticket_carries_the_blocked_mark() {
|
||||
let dir = board_dir();
|
||||
write_ticket(&dir, "committed", BLOCKER, "The blocker", "");
|
||||
write_ticket(&dir, "backlog", WAITER, "The waiter", &blocked_by(BLOCKER));
|
||||
|
||||
let board = one_board(&dir);
|
||||
assert!(marked_blocked(&board, "The waiter"));
|
||||
// The far end of the relation is not held up by holding somebody else up.
|
||||
assert!(!marked_blocked(&board, "The blocker"));
|
||||
|
||||
let screen = render(&board, 120, 20).join("\n");
|
||||
assert!(
|
||||
screen.contains(&format!("({}) {}", short_id(WAITER), BLOCKED_MARK)),
|
||||
"no mark after the id:\n{screen}"
|
||||
);
|
||||
}
|
||||
|
||||
/// The mark is the state of the dependency, not a note that one was ever recorded.
|
||||
#[test]
|
||||
fn a_card_whose_blockers_are_all_done_carries_none() {
|
||||
let dir = board_dir();
|
||||
write_ticket(&dir, "done", BLOCKER, "The blocker", "");
|
||||
write_ticket(&dir, "backlog", WAITER, "The waiter", &blocked_by(BLOCKER));
|
||||
|
||||
let board = one_board(&dir);
|
||||
assert!(!marked_blocked(&board, "The waiter"));
|
||||
|
||||
let screen = render(&board, 120, 20).join("\n");
|
||||
assert!(
|
||||
!screen.contains(BLOCKED_MARK),
|
||||
"a cleared blocker still marked:\n{screen}"
|
||||
);
|
||||
}
|
||||
|
||||
/// One open blocker out of two is still a reason not to start, the rule `mv` applies
|
||||
/// when it names every open blocker rather than the first.
|
||||
#[test]
|
||||
fn a_card_is_marked_while_any_one_of_its_blockers_is_open() {
|
||||
let dir = board_dir();
|
||||
write_ticket(&dir, "done", BLOCKER, "The blocker", "");
|
||||
write_ticket(&dir, "reviewing", ELSEWHERE, "The other blocker", "");
|
||||
write_ticket(
|
||||
&dir,
|
||||
"backlog",
|
||||
WAITER,
|
||||
"The waiter",
|
||||
&format!("\n## Relations\n\n- blocked by {BLOCKER}\n- blocked by {ELSEWHERE}\n"),
|
||||
);
|
||||
|
||||
assert!(marked_blocked(&one_board(&dir), "The waiter"));
|
||||
}
|
||||
|
||||
/// The answer `mv` gives a dangling uuid: a bookkeeping fault, not a dependency.
|
||||
#[test]
|
||||
fn a_blocker_the_board_does_not_hold_marks_nothing() {
|
||||
let dir = board_dir();
|
||||
write_ticket(&dir, "backlog", WAITER, "The waiter", &blocked_by(ELSEWHERE));
|
||||
|
||||
assert!(!marked_blocked(&one_board(&dir), "The waiter"));
|
||||
}
|
||||
|
||||
/// Nothing but `relate` writes the section, so a line that is not a relation means a
|
||||
/// hand-edited file. `show` and `mv` are where that is reported; the board draws the
|
||||
/// ticket unmarked, the exception `detail_of` already makes for the same reason.
|
||||
#[test]
|
||||
fn a_relations_section_that_cannot_be_parsed_leaves_the_board_drawable() {
|
||||
let dir = board_dir();
|
||||
write_ticket(
|
||||
&dir,
|
||||
"backlog",
|
||||
WAITER,
|
||||
"The waiter",
|
||||
"\n## Relations\n\n- waits for the other one\n",
|
||||
);
|
||||
|
||||
let board = one_board(&dir);
|
||||
assert!(!marked_blocked(&board, "The waiter"));
|
||||
|
||||
let screen = render(&board, 120, 20).join("\n");
|
||||
assert!(screen.contains("The waiter"), "the board lost the ticket:\n{screen}");
|
||||
}
|
||||
|
||||
/// Dropped whole in a column that cannot hold the identity and the mark together,
|
||||
/// the rule a corner follows. The id keeps its place either way: a column of ids
|
||||
/// starting at different cells costs more than one card's state is worth.
|
||||
#[test]
|
||||
fn a_column_too_narrow_for_the_mark_drops_it() {
|
||||
let dir = board_dir();
|
||||
write_ticket(&dir, "committed", BLOCKER, "The blocker", "");
|
||||
write_ticket(&dir, "backlog", WAITER, "The waiter", &blocked_by(BLOCKER));
|
||||
|
||||
let board = one_board(&dir);
|
||||
// The mark, a space, the id in its brackets, and the space the mark needs.
|
||||
let identity = (2 + 1 + SHORT_ID_WIDTH + 2) as u16;
|
||||
let id = format!("({})", short_id(WAITER));
|
||||
|
||||
let wide = card_rows(&board, "The waiter", identity + 2);
|
||||
assert!(wide[0].contains(BLOCKED_MARK), "no mark with room for it: {:?}", wide[0]);
|
||||
|
||||
let narrow = card_rows(&board, "The waiter", identity);
|
||||
assert!(!narrow[0].contains(BLOCKED_MARK), "mark kept over the column: {:?}", narrow[0]);
|
||||
assert!(narrow[0].contains(&id), "the identity gave way instead: {:?}", narrow[0]);
|
||||
assert!(narrow[0].chars().count() <= identity as usize, "row over the column");
|
||||
}
|
||||
|
||||
/// The merge resolves nothing of its own. A relation names a uuid `relate` looked up
|
||||
/// in one `.worklane`, so a blocker in another project is not a thing that exists,
|
||||
/// and the flag each card arrives with is the one its own board worked out.
|
||||
#[test]
|
||||
fn the_blocked_mark_follows_a_card_onto_the_merge() {
|
||||
let (first, second) = (board_dir(), board_dir());
|
||||
write_ticket(&first, "committed", BLOCKER, "The blocker", "");
|
||||
write_ticket(&first, "backlog", WAITER, "The waiter", &blocked_by(BLOCKER));
|
||||
write_ticket(&second, "backlog", ELSEWHERE, "Elsewhere", &blocked_by(BLOCKER));
|
||||
|
||||
// The merge tab is where the view opens.
|
||||
let board = boards(&[("alpha", &first), ("beta", &second)]);
|
||||
assert_eq!(board.current().name, ALL);
|
||||
assert!(marked_blocked(&board, "The waiter"));
|
||||
assert!(
|
||||
!marked_blocked(&board, "Elsewhere"),
|
||||
"a uuid on another board was read as a blocker"
|
||||
);
|
||||
}
|
||||
|
||||
/// A change in any monitored board has to redraw, not only one in the first.
|
||||
|
||||
Reference in New Issue
Block a user