From c1449439e804b1a8bf992119a790d86f7504e7c8 Mon Sep 17 00:00:00 2001 From: Willem Vanhulle Date: Mon, 2 Nov 2026 18:14:07 +0100 Subject: [PATCH] refactor: reduce screen spacing to a small named set and declarative layouts Replace measured column widths and ad-hoc spacing arithmetic with one list of named values, ratatui constraints and its Table footer, Paragraph block and Rect centring. Footer gaps and failure log indents get slightly tighter, and the kind and timeout columns get a fixed width. --- bootvine/src/boot_view.rs | 71 ++++---- bootvine/src/boot_view/failure_panel.rs | 29 ++-- bootvine/src/boot_view/panel_render_tests.rs | 12 +- bootvine/src/boot_view/run_timeline.rs | 50 ++++-- bootvine/src/boot_view/screen_chrome.rs | 48 +++--- bootvine/src/boot_view/screen_spacing.rs | 8 + bootvine/src/boot_view/stage_summary.rs | 14 +- bootvine/src/boot_view/tree_render_tests.rs | 2 +- bootvine/src/boot_view/unit_tree.rs | 152 +++++++++--------- .../src/console_session/resume_console.rs | 7 +- 10 files changed, 204 insertions(+), 189 deletions(-) create mode 100644 bootvine/src/boot_view/screen_spacing.rs diff --git a/bootvine/src/boot_view.rs b/bootvine/src/boot_view.rs index cf2bf57..db87590 100644 --- a/bootvine/src/boot_view.rs +++ b/bootvine/src/boot_view.rs @@ -7,6 +7,7 @@ mod run_timeline; mod screen_chrome; #[cfg(test)] mod screen_render_fixtures; +mod screen_spacing; mod stage_summary; mod tree_height_fitting; #[cfg(test)] @@ -18,7 +19,10 @@ use std::time::Duration; use jiff::fmt::friendly::{Designator, FractionalUnit, Spacing, SpanPrinter}; use ratatui::{ buffer::Buffer, - layout::{Constraint, Layout, Rect}, + layout::{ + Constraint::{Fill, Length}, + Layout, Rect, + }, style::Color, text::Line, widgets::{Block, Borders, Widget}, @@ -29,8 +33,9 @@ use unicode_width::UnicodeWidthStr; pub use self::screen_chrome::PasswordPrompt; use self::{ failure_panel::FailurePanel, - run_timeline::{RunningRun, Timeline}, - screen_chrome::{FOOTER_HEIGHT, Footer, Header, PasswordPopup}, + run_timeline::{RunningRun, Timeline, timeline_fits}, + screen_chrome::{Footer, Header, PasswordPopup}, + screen_spacing::{PANEL_MINIMUM_HEIGHT, RULED_ROW_HEIGHT, TEXT_ROW_HEIGHT}, stage_summary::Stages, tree_height_fitting::rows_within_height, unit_tree::UnitTree, @@ -43,14 +48,7 @@ use crate::{ screen_settings::{color_scheme::Colors, config_file::Timing, font_glyphs::Glyphs}, }; -const DURATION_WIDTH: u16 = 9; -const MIN_BAR_WIDTH: u16 = 12; -const MIN_HEIGHT_FOR_TIMELINE: u16 = 12; -const MIN_TIMELINE_HEIGHT: u16 = run_timeline::CHROME_HEIGHT + 4; -const HEADER_HEIGHT: u16 = 1; -const MIN_FAILURE_PANEL_HEIGHT: u16 = failure_panel::RULE_HEIGHT + 1; -const RESERVED_FAILURE_PANEL_HEIGHT: u16 = failure_panel::RULE_HEIGHT + 3; -const MIN_TREE_HEIGHT_BESIDE_FAILURES: u16 = 4; +const MIN_TIMELINE_HEIGHT: u16 = RULED_ROW_HEIGHT + PANEL_MINIMUM_HEIGHT; const BRANCH: &str = "├─ "; const LAST_BRANCH: &str = "└─ "; const PASSING_TRUNK: &str = "│ "; @@ -160,18 +158,23 @@ impl Widget for BootView<'_> { colors: &self.colors.footer, glyphs: self.glyphs, }; - let fits_timeline = area.width >= run_timeline::LABEL_WIDTH + 1 + MIN_BAR_WIDTH - && area.height >= MIN_HEIGHT_FOR_TIMELINE; - let free = area - .height - .saturating_sub(HEADER_HEIGHT + stages.height() + FOOTER_HEIGHT); + let [header_area, stage_area, body_area, footer_area] = area.layout(&Layout::vertical([ + Length(TEXT_ROW_HEIGHT), + Length(stages.height()), + Fill(1), + Length(RULED_ROW_HEIGHT), + ])); let heights = Heights::share( - free, + body_area.height, UnitTree::height_of(pending_count, 0), failure_panel.height(), - if fits_timeline { timeline.height() } else { 0 }, + if timeline_fits(body_area) { + timeline.height() + } else { + 0 + }, ); - let budget = usize::from(heights.tree.saturating_sub(1)); + let budget = usize::from(heights.tree.saturating_sub(TEXT_ROW_HEIGHT)); let rows = rows_within_height(forest, budget); let tree = UnitTree { phase: stages.current_phase(), @@ -184,24 +187,12 @@ impl Widget for BootView<'_> { }; let tree_height = tree.height().min(heights.tree); - let [ - header_area, - stage_area, - tree_area, - _, - failure_area, - timeline_area, - footer_area, - ] = Layout::vertical([ - Constraint::Length(HEADER_HEIGHT), - Constraint::Length(stages.height()), - Constraint::Length(tree_height), - Constraint::Fill(1), - Constraint::Length(heights.failures), - Constraint::Length(heights.timeline), - Constraint::Length(FOOTER_HEIGHT), - ]) - .areas(area); + let [tree_area, _, failure_area, timeline_area] = body_area.layout(&Layout::vertical([ + Length(tree_height), + Fill(1), + Length(heights.failures), + Length(heights.timeline), + ])); header.render(header_area, buf); stages.render(stage_area, buf); @@ -232,13 +223,13 @@ struct Heights { impl Heights { fn share(free: u16, tree_need: u16, failures_need: u16, timeline_need: u16) -> Self { - let reserved = RESERVED_FAILURE_PANEL_HEIGHT + let reserved = PANEL_MINIMUM_HEIGHT .min(failures_need) - .min(free.saturating_sub(MIN_TREE_HEIGHT_BESIDE_FAILURES)); + .min(free.saturating_sub(PANEL_MINIMUM_HEIGHT)); let failures = failures_need .min(free.saturating_sub(tree_need)) .max(reserved); - let failures = if failures >= MIN_FAILURE_PANEL_HEIGHT { + let failures = if failures >= RULED_ROW_HEIGHT { failures } else { 0 diff --git a/bootvine/src/boot_view/failure_panel.rs b/bootvine/src/boot_view/failure_panel.rs index 8b8b9b9..b8d3d59 100644 --- a/bootvine/src/boot_view/failure_panel.rs +++ b/bootvine/src/boot_view/failure_panel.rs @@ -9,16 +9,15 @@ use ratatui::{ }; use unicode_width::UnicodeWidthStr; -use super::{fit_width, rule}; +use super::{ + fit_width, rule, + screen_spacing::{TEXT_GAP, TEXT_INDENT, TEXT_ROW_HEIGHT}, +}; use crate::{ boot_model::{FailedUnit, FailureExplanation}, screen_settings::{color_scheme::FailureColors, font_glyphs::Glyphs}, }; -pub const RULE_HEIGHT: u16 = 1; -const LOG_INDENT: &str = " "; -const REASON_GAP: &str = " "; - pub struct FailurePanel<'a> { pub newest_first: Vec<&'a FailedUnit>, pub colors: &'a FailureColors, @@ -42,14 +41,14 @@ impl FailurePanel<'_> { .iter() .map(|failed| 1 + log_lines(failed).len()) .sum(); - RULE_HEIGHT.saturating_add(u16::try_from(rows).unwrap_or(u16::MAX)) + TEXT_ROW_HEIGHT.saturating_add(u16::try_from(rows).unwrap_or(u16::MAX)) } fn headline(&self, failed: &FailedUnit, width: usize) -> Line<'static> { let marker = format!("{} ", self.glyphs.failed); let label_room = width.saturating_sub(marker.width()); let label = fit_width(&failed.label, label_room, self.glyphs.ellipsis); - let reason_room = label_room.saturating_sub(label.width() + REASON_GAP.width()); + let reason_room = label_room.saturating_sub(label.width() + TEXT_GAP.width()); let reason = match &failed.explanation { FailureExplanation::Explained(cause) if reason_room > 0 => { fit_width(&cause.reason, reason_room, self.glyphs.ellipsis) @@ -57,7 +56,7 @@ impl FailurePanel<'_> { _ => String::new(), }; let reason_span = - (!reason.is_empty()).then(|| format!("{REASON_GAP}{reason}").fg(self.colors.reason)); + (!reason.is_empty()).then(|| format!("{TEXT_GAP}{reason}").fg(self.colors.reason)); Line::from( [ marker.fg(self.colors.unit), @@ -70,11 +69,11 @@ impl FailurePanel<'_> { } fn block(&self, failed: &FailedUnit, width: usize) -> Vec> { - let log_room = width.saturating_sub(LOG_INDENT.width()); + let log_room = width.saturating_sub(TEXT_INDENT.width()); once(self.headline(failed, width)) .chain(log_lines(failed).iter().map(|line| { format!( - "{LOG_INDENT}{}", + "{TEXT_INDENT}{}", fit_width(line, log_room, self.glyphs.ellipsis) ) .fg(self.colors.log) @@ -170,8 +169,8 @@ mod tests { panel_text(&failures, 5), [ "× web exited with status 1", - " bind: address in use", - " giving up", + " bind: address in use", + " giving up", "× db exited with status 1", "× cache exited with status 1", ] @@ -189,10 +188,10 @@ mod tests { panel_text(&failures, 6), [ "× web exited with status 1", - " giving up", + " giving up", "× db exited with status 1", - " disk full", - " read-only file system", + " disk full", + " read-only file system", "× cache exited with status 1", ] ); diff --git a/bootvine/src/boot_view/panel_render_tests.rs b/bootvine/src/boot_view/panel_render_tests.rs index a770195..2af7f26 100644 --- a/bootvine/src/boot_view/panel_render_tests.rs +++ b/bootvine/src/boot_view/panel_render_tests.rs @@ -65,7 +65,7 @@ fn tree_on_top_timeline_below() { ); assert!(!screen.contains("root switch"), "{screen}"); assert!( - lines[23].starts_with("√ 2 done 2 running 3 waiting × 1 failed"), + lines[23].starts_with("√ 2 done 2 running 3 waiting × 1 failed"), "{screen}" ); } @@ -99,7 +99,7 @@ fn password_prompt_floats_over_a_dimmed_view() { assert!(lines[title_row + 3].contains("│ > ***_"), "{screen}"); assert!(lines[title_row + 4].contains("Enter unlock"), "{screen}"); assert!( - lines[23].starts_with("√ 2 done 2 running 3 waiting × 1 failed"), + lines[23].starts_with("√ 2 done 2 running 3 waiting × 1 failed"), "{screen}" ); assert_eq!( @@ -239,7 +239,7 @@ fn long_timeline_labels_end_in_an_ellipsis() { #[test] fn narrow_screens_drop_the_timeline() { - let lines = render(&boot_in_progress(), 12_400 * MS, 40, 24); + let lines = render(&boot_in_progress(), 12_400 * MS, 37, 24); assert!( lines.iter().all(|line| !line.contains('■')), "{}", @@ -427,10 +427,10 @@ fn failures_show_their_reason_and_journal_lines_above_the_timeline() { ); assert_eq!( lines[failures + 2], - " ERROR! Failed to get system power limits", + " ERROR! Failed to get system power limits", "{screen}" ); - assert_eq!(lines[failures + 3], " giving up", "{screen}"); + assert_eq!(lines[failures + 3], " giving up", "{screen}"); } #[test] @@ -448,7 +448,7 @@ fn failure_lines_are_cut_to_a_narrow_screen() { ); assert_eq!( lines[failures + 2], - " ERROR! Failed to get syst…", + " ERROR! Failed to get syste…", "{screen}" ); } diff --git a/bootvine/src/boot_view/run_timeline.rs b/bootvine/src/boot_view/run_timeline.rs index 1ac7eae..9158ecd 100644 --- a/bootvine/src/boot_view/run_timeline.rs +++ b/bootvine/src/boot_view/run_timeline.rs @@ -2,7 +2,10 @@ use std::{cmp::Reverse, iter::once, time::Duration}; use ratatui::{ buffer::Buffer, - layout::{Constraint, Layout, Rect}, + layout::{ + Constraint::{Fill, Length}, + Layout, Rect, + }, style::{Color, Stylize}, symbols::Marker, text::{Line, Span}, @@ -12,18 +15,22 @@ use ratatui::{ }, }; -use super::{WHOLE_UNITS, fit_width, rule, unit_count}; +use super::{ + WHOLE_UNITS, fit_width, rule, + screen_spacing::{ + ANNOTATION_COLUMN_WIDTH, COLUMN_GAP_WIDTH, RULED_ROW_HEIGHT, TEXT_ROW_HEIGHT, + TIMELINE_LABEL_WIDTH, + }, + unit_count, +}; use crate::{ boot_model::{FinishedRun, MilestoneRow}, screen_settings::{color_scheme::TimelineColors, font_glyphs::Glyphs}, }; -pub const LABEL_WIDTH: u16 = 28; -pub const CHROME_HEIGHT: u16 = 2; const MARK_WIDTH: u16 = 2; const SLOWEST_RUNS_SHOWN: usize = 5; const KERNEL_ORIGIN_LABEL: &str = "Kernel"; -const AXIS_LABEL_SPACING: u16 = 8; const AXIS_STEPS: [Duration; 12] = [ Duration::from_secs(1), Duration::from_secs(2), @@ -56,6 +63,17 @@ pub struct RunningRun<'a> { pub since: Duration, } +fn label_and_bar_areas(area: Rect) -> [Rect; 2] { + area.layout( + &Layout::horizontal([Length(TIMELINE_LABEL_WIDTH), Fill(1)]).spacing(COLUMN_GAP_WIDTH), + ) +} + +pub fn timeline_fits(area: Rect) -> bool { + let [_, bar_area] = label_and_bar_areas(area); + bar_area.width >= ANNOTATION_COLUMN_WIDTH +} + impl Timeline<'_> { pub fn height(&self) -> u16 { let entries = self.milestones.len() @@ -64,11 +82,11 @@ impl Timeline<'_> { if entries == 0 { return 0; } - CHROME_HEIGHT.saturating_add(u16::try_from(entries).unwrap_or(u16::MAX)) + RULED_ROW_HEIGHT.saturating_add(u16::try_from(entries).unwrap_or(u16::MAX)) } fn finished_that_fit(&self, height: u16) -> Vec<&FinishedRun> { - let bar_rows = usize::from(height.saturating_sub(CHROME_HEIGHT)); + let bar_rows = usize::from(height.saturating_sub(RULED_ROW_HEIGHT)); let room = bar_rows.saturating_sub(self.milestones.len() + self.running.len()); let mut longest_first = self.finished.clone(); longest_first @@ -128,7 +146,7 @@ impl Timeline<'_> { fn fitted(&self, label: &str) -> String { fit_width( label, - usize::from(LABEL_WIDTH - MARK_WIDTH), + usize::from(TIMELINE_LABEL_WIDTH - MARK_WIDTH), self.glyphs.ellipsis, ) } @@ -169,10 +187,7 @@ impl Widget for Timeline<'_> { ); let inner = block.inner(area); block.render(area, buf); - let [label_area, bar_area] = - Layout::horizontal([Constraint::Length(LABEL_WIDTH), Constraint::Fill(1)]) - .spacing(1) - .areas(inner); + let [label_area, bar_area] = label_and_bar_areas(inner); let entries: Vec = self .milestones .iter() @@ -184,12 +199,15 @@ impl Widget for Timeline<'_> { ) .chain(self.running.iter().map(|row| self.running_entry(row))) .collect(); + let [_, entry_labels_area] = + label_area.layout(&Layout::vertical([Length(TEXT_ROW_HEIGHT), Fill(1)])); Paragraph::new( - once(Line::default()) - .chain(entries.iter().map(|entry| entry.label.clone())) + entries + .iter() + .map(|entry| entry.label.clone()) .collect::>(), ) - .render(label_area, buf); + .render(entry_labels_area, buf); let axis = TimeAxis::new(self.origin, self.now, bar_area.width); let label_row = f64::from(bar_area.height.saturating_sub(1).max(1)); let axis_color = self.colors.axis; @@ -265,7 +283,7 @@ struct TimeAxis { impl TimeAxis { fn new(origin: Duration, now: Duration, width: u16) -> Self { let elapsed = now.saturating_sub(origin).max(AXIS_STEPS[0]); - let max_labels = u128::from((width / AXIS_LABEL_SPACING).max(1)); + let max_labels = u128::from((width / ANNOTATION_COLUMN_WIDTH).max(1)); let step = AXIS_STEPS .into_iter() .find(|step| elapsed.as_nanos().div_ceil(step.as_nanos()) <= max_labels) diff --git a/bootvine/src/boot_view/screen_chrome.rs b/bootvine/src/boot_view/screen_chrome.rs index f70e7a1..61c6aa3 100644 --- a/bootvine/src/boot_view/screen_chrome.rs +++ b/bootvine/src/boot_view/screen_chrome.rs @@ -2,13 +2,19 @@ use std::{iter::once, time::Duration}; use ratatui::{ buffer::Buffer, - layout::{Constraint, Rect}, + layout::{ + Constraint::{self, Fill, Length}, + Layout, Rect, + }, style::{Style, Stylize}, text::{Line, Span}, - widgets::{Block, Borders, Clear, Padding, Paragraph, Widget, Wrap}, + widgets::{Block, Clear, Padding, Paragraph, Widget, Wrap}, }; -use super::{DURATION_WIDTH, ELAPSED}; +use super::{ + ELAPSED, rule, + screen_spacing::{ANNOTATION_COLUMN_WIDTH, TEXT_GAP}, +}; use crate::{ boot_model::{Tally, boot_origin::BootOrigin}, screen_settings::{ @@ -17,7 +23,6 @@ use crate::{ }, }; -pub const FOOTER_HEIGHT: u16 = 2; const SEPARATOR: &str = " · "; const REJECTED_PASSPHRASE: &str = "Wrong passphrase, try again"; @@ -47,19 +52,17 @@ impl Header<'_> { impl Widget for Header<'_> { fn render(self, area: Rect, buf: &mut Buffer) { - self.origin().render( - Rect { - width: area.width.saturating_sub(DURATION_WIDTH), - ..area - }, - buf, - ); + let [origin_area, total_area] = area.layout(&Layout::horizontal([ + Fill(1), + Length(ANNOTATION_COLUMN_WIDTH), + ])); + self.origin().render(origin_area, buf); if let Some(total) = self.total { Line::from(ELAPSED.unsigned_duration_to_string(&total)) .fg(self.colors.total_time) .bold() .right_aligned() - .render(area, buf); + .render(total_area, buf); } } } @@ -72,24 +75,23 @@ pub struct Footer<'a> { impl Widget for Footer<'_> { fn render(self, area: Rect, buf: &mut Buffer) { - let failed = format!(" {} {} failed", self.glyphs.failed, self.tally.failed); + let failed = format!( + "{TEXT_GAP}{} {} failed", + self.glyphs.failed, self.tally.failed + ); let failed = if self.tally.failed > 0 { failed.fg(self.colors.failed).bold() } else { failed.fg(self.colors.no_failures) }; - let block = Block::new() - .borders(Borders::TOP) - .border_style(self.colors.rule); - let inner = block.inner(area); - block.render(area, buf); - Line::from(vec![ + Paragraph::new(Line::from(vec![ format!("{} {} done", self.glyphs.done, self.tally.done).fg(self.colors.done), - format!(" {} running", self.tally.running).fg(self.colors.running), - format!(" {} waiting", self.tally.waiting).fg(self.colors.waiting), + format!("{TEXT_GAP}{} running", self.tally.running).fg(self.colors.running), + format!("{TEXT_GAP}{} waiting", self.tally.waiting).fg(self.colors.waiting), failed, - ]) - .render(inner, buf); + ])) + .block(rule(self.colors.rule, Line::default())) + .render(area, buf); } } diff --git a/bootvine/src/boot_view/screen_spacing.rs b/bootvine/src/boot_view/screen_spacing.rs new file mode 100644 index 0000000..be8062e --- /dev/null +++ b/bootvine/src/boot_view/screen_spacing.rs @@ -0,0 +1,8 @@ +pub const TEXT_ROW_HEIGHT: u16 = 1; +pub const RULED_ROW_HEIGHT: u16 = 2; +pub const PANEL_MINIMUM_HEIGHT: u16 = 4; +pub const COLUMN_GAP_WIDTH: u16 = 1; +pub const ANNOTATION_COLUMN_WIDTH: u16 = 9; +pub const TIMELINE_LABEL_WIDTH: u16 = 28; +pub const TEXT_GAP: &str = " "; +pub const TEXT_INDENT: &str = " "; diff --git a/bootvine/src/boot_view/stage_summary.rs b/bootvine/src/boot_view/stage_summary.rs index 8c50fa5..9d8f588 100644 --- a/bootvine/src/boot_view/stage_summary.rs +++ b/bootvine/src/boot_view/stage_summary.rs @@ -8,14 +8,20 @@ use ratatui::{ widgets::{Paragraph, Widget}, }; -use super::{BRANCH, ELAPSED, LAST_BRANCH, unit_count}; +use super::{BRANCH, ELAPSED, LAST_BRANCH, screen_spacing::ANNOTATION_COLUMN_WIDTH, unit_count}; use crate::{ boot_model::BootState, screen_settings::{color_scheme::StageColors, font_glyphs::Glyphs}, }; const SHUTDOWN_SUCCESSOR: &str = "systemd-shutdown"; -const PHASE_WIDTH: usize = 9; + +fn padded_phase_label(label: &str) -> String { + format!( + "{label:phase_width$}", + phase_width = usize::from(ANNOTATION_COLUMN_WIDTH) + ) +} pub struct Stages<'a> { pub state: &'a BootState, @@ -57,7 +63,7 @@ impl Stages<'_> { self.state.finished_stages.iter().map(|stage| { Line::from(vec![ BRANCH.fg(self.colors.branches), - format!("{:PHASE_WIDTH$}", stage.label).fg(self.colors.finished_label), + padded_phase_label(stage.label).fg(self.colors.finished_label), format!( "{} done in {}", self.glyphs.bead, @@ -105,7 +111,7 @@ impl Stages<'_> { let elapsed = ELAPSED.unsigned_duration_to_string(&self.now.saturating_sub(started_at)); Line::from(vec![ LAST_BRANCH.fg(self.colors.branches), - format!("{:PHASE_WIDTH$}", self.state.phase.label()) + padded_phase_label(self.state.phase.label()) .fg(self.colors.current) .bold(), elapsed.fg(self.colors.current), diff --git a/bootvine/src/boot_view/tree_render_tests.rs b/bootvine/src/boot_view/tree_render_tests.rs index 88879a8..015545a 100644 --- a/bootvine/src/boot_view/tree_render_tests.rs +++ b/bootvine/src/boot_view/tree_render_tests.rs @@ -109,7 +109,7 @@ fn slow_runs_show_their_timeout_in_a_column() { "{screen}" ); assert!( - line_with(&lines, "slow").ends_with("6.40s 1m30s"), + line_with(&lines, "slow").ends_with("6.40s 1m30s"), "{screen}" ); assert!(line_with(&lines, "quick").ends_with("2.40s"), "{screen}"); diff --git a/bootvine/src/boot_view/unit_tree.rs b/bootvine/src/boot_view/unit_tree.rs index c8f8dda..c303f69 100644 --- a/bootvine/src/boot_view/unit_tree.rs +++ b/bootvine/src/boot_view/unit_tree.rs @@ -2,7 +2,10 @@ use std::{iter::once, time::Duration}; use ratatui::{ buffer::Buffer, - layout::{Constraint, Rect}, + layout::{ + Constraint::{self, Fill, Length}, + Layout, Rect, + }, style::{Style, Stylize}, text::{Line, Span}, widgets::{Row, Table, Widget}, @@ -10,8 +13,8 @@ use ratatui::{ use unicode_width::UnicodeWidthStr; use super::{ - BRANCH, DURATION_WIDTH, ENDED_TRUNK, LAST_BRANCH, PASSING_TRUNK, RUNNING_ELAPSED, WHOLE_UNITS, - fit_width, + BRANCH, ENDED_TRUNK, LAST_BRANCH, PASSING_TRUNK, RUNNING_ELAPSED, WHOLE_UNITS, fit_width, + screen_spacing::{ANNOTATION_COLUMN_WIDTH, COLUMN_GAP_WIDTH, TEXT_ROW_HEIGHT}, }; use crate::{ boot_model::{RowStatus, TreeRow, UnitKind}, @@ -20,10 +23,8 @@ use crate::{ const SPINNER: [char; 4] = ['|', '/', '-', '\\']; const SPINNER_STEP: Duration = Duration::from_millis(100); -const MIN_DESCRIPTION_WIDTH: u16 = 12; -const MIN_TAG_WIDTH: u16 = 6; -const MIN_LABEL_WIDTH: u16 = 24; -const HEADER_ROWS: u16 = 1; +const LABEL_SHARE: u16 = 3; +const DESCRIPTION_SHARE: u16 = 2; const SHOW_TIMEOUT_AFTER: Duration = Duration::from_secs(5); const TIMEOUT_HEADER: &str = "Timeout"; @@ -43,10 +44,11 @@ pub struct UnitTree<'a> { } struct Columns { + constraints: Vec, label: u16, - tag: u16, description: u16, - timeout: u16, + shows_annotations: bool, + shows_timeout: bool, } #[derive(Clone, Copy, PartialEq, Eq)] @@ -66,15 +68,42 @@ fn spinner_at(now: Duration) -> char { SPINNER[usize::try_from(steps % 4).unwrap_or_default()] } -fn width_of(text: &str) -> u16 { - u16::try_from(text.width()).unwrap_or(u16::MAX) +fn solved_columns(width: u16, shows_annotations: bool, shows_timeout: bool) -> Columns { + let leading = if shows_annotations { + vec![ + Fill(LABEL_SHARE), + Length(ANNOTATION_COLUMN_WIDTH), + Fill(DESCRIPTION_SHARE), + ] + } else { + vec![Fill(1)] + }; + let constraints: Vec = leading + .into_iter() + .chain(once(Length(ANNOTATION_COLUMN_WIDTH))) + .chain(shows_timeout.then_some(Length(ANNOTATION_COLUMN_WIDTH))) + .collect(); + let solved = Layout::horizontal(constraints.clone()) + .spacing(COLUMN_GAP_WIDTH) + .split(Rect::new(0, 0, width, TEXT_ROW_HEIGHT)); + Columns { + label: solved[0].width, + description: if shows_annotations { + solved[2].width + } else { + 0 + }, + constraints, + shows_annotations, + shows_timeout, + } } impl UnitTree<'_> { pub fn height_of(rows: usize, hidden: usize) -> u16 { u16::try_from(rows + usize::from(hidden > 0)) .unwrap_or(u16::MAX) - .saturating_add(HEADER_ROWS) + .saturating_add(TEXT_ROW_HEIGHT) } pub fn height(&self) -> u16 { @@ -87,7 +116,7 @@ impl UnitTree<'_> { fn header(&self, columns: &Columns) -> Row<'static> { if !self.phase_fits_its_column(columns) { - return Row::default().height(HEADER_ROWS); + return Row::default().height(TEXT_ROW_HEIGHT); } let name = |text: &'static str| Line::from(text).fg(self.colors.columns); Row::new(columns.shown([ @@ -116,15 +145,6 @@ impl UnitTree<'_> { }) } - fn timeout_width(&self) -> u16 { - self.rows - .iter() - .filter_map(|row| self.run_timeout(row)) - .map(|timeout| width_of(&WHOLE_UNITS.unsigned_duration_to_string(&timeout.limit))) - .max() - .map_or(0, |widest| widest.max(width_of(TIMEOUT_HEADER))) - } - fn timeout_cell(&self, row: &TreeRow) -> Line<'static> { self.run_timeout(row) .map_or_else(Line::default, |timeout| { @@ -218,39 +238,16 @@ impl UnitTree<'_> { } fn columns(&self, width: u16) -> Columns { - let timeout = self.timeout_width(); - let timeout_room = if timeout > 0 { timeout + 1 } else { 0 }; - let unannotated = width.saturating_sub(DURATION_WIDTH + 1 + timeout_room); - let annotated: Vec<(&TreeRow, Stage)> = self - .rows - .iter() - .zip(self.stages()) - .filter(|(row, _)| { - row.chain.is_empty() && !(row.description.is_none() && row.kind.tag().is_none()) - }) - .collect(); - let tag = annotated - .iter() - .map(|(row, _)| width_of(row.kind.tag().unwrap_or_default())) - .fold(MIN_TAG_WIDTH, u16::max); - let content = unannotated.saturating_sub(2); - let label = (content * 3 / 5).max(MIN_LABEL_WIDTH); - let fits_annotations = - !annotated.is_empty() && label + tag + MIN_DESCRIPTION_WIDTH <= content; - fits_annotations.then_some(label).map_or( - Columns { - label: unannotated, - tag: 0, - description: 0, - timeout, - }, - |label| Columns { - label, - tag, - description: content - label - tag, - timeout, - }, - ) + let shows_timeout = self.rows.iter().any(|row| self.run_timeout(row).is_some()); + let has_annotated_rows = self.rows.iter().any(|row| { + row.chain.is_empty() && !(row.description.is_none() && row.kind.tag().is_none()) + }); + let annotated = solved_columns(width, true, shows_timeout); + if has_annotated_rows && annotated.description >= ANNOTATION_COLUMN_WIDTH { + annotated + } else { + solved_columns(width, false, shows_timeout) + } } fn row(&self, row: &TreeRow, stage: Stage, prefix: String, columns: &Columns) -> Row<'static> { @@ -279,8 +276,11 @@ impl UnitTree<'_> { marker, Span::styled(self.chained_label(row, room), style), ]), - Line::from(annotation(row.kind.tag().unwrap_or_default(), columns.tag)) - .fg(self.colors.columns), + Line::from(annotation( + row.kind.tag().unwrap_or_default(), + ANNOTATION_COLUMN_WIDTH, + )) + .fg(self.colors.columns), Line::from(annotation( row.description.as_deref().unwrap_or_default(), columns.description, @@ -297,33 +297,22 @@ impl Columns { fn shown(&self, cells: [T; 5]) -> impl Iterator { let present = [ true, - self.tag > 0, - self.description > 0, + self.shows_annotations, + self.shows_annotations, true, - self.timeout > 0, + self.shows_timeout, ]; cells .into_iter() .zip(present) .filter_map(|(cell, present)| present.then_some(cell)) } - - fn widths(&self) -> impl Iterator { - self.shown([ - self.label, - self.tag, - self.description, - DURATION_WIDTH, - self.timeout, - ]) - .map(Constraint::Length) - } } impl Widget for UnitTree<'_> { fn render(self, area: Rect, buf: &mut Buffer) { - let capacity = usize::from(area.height.saturating_sub(HEADER_ROWS)); - let shown = if usize::from(self.height() - HEADER_ROWS) > capacity { + let capacity = usize::from(area.height.saturating_sub(TEXT_ROW_HEIGHT)); + let shown = if usize::from(self.height() - TEXT_ROW_HEIGHT) > capacity { capacity.saturating_sub(1).min(self.rows.len()) } else { self.rows.len() @@ -336,20 +325,25 @@ impl Widget for UnitTree<'_> { ]) }); let columns = self.columns(area.width); - Table::new( + let table = Table::new( self.rows .iter() .zip(self.stages()) .zip(tree_prefixes(self.rows)) .take(shown) - .map(|((row, stage), prefix)| self.row(row, stage, prefix, &columns)) - .chain(overflow), - columns.widths(), + .map(|((row, stage), prefix)| self.row(row, stage, prefix, &columns)), + columns.constraints.clone(), ) - .header(self.header(&columns)) + .column_spacing(COLUMN_GAP_WIDTH) + .header(self.header(&columns)); + match overflow { + Some(overflow_row) => table.footer(overflow_row), + None => table, + } .render(area, buf); if !self.phase_fits_its_column(&columns) { - self.phase.render(Rect { height: 1, ..area }, buf); + let [phase_row, _] = area.layout(&Layout::vertical([Length(TEXT_ROW_HEIGHT), Fill(1)])); + self.phase.render(phase_row, buf); } } } diff --git a/bootvine/src/console_session/resume_console.rs b/bootvine/src/console_session/resume_console.rs index b0bb5ff..070da6a 100644 --- a/bootvine/src/console_session/resume_console.rs +++ b/bootvine/src/console_session/resume_console.rs @@ -15,7 +15,7 @@ use crossterm::{ use ratatui::{ backend::CrosstermBackend, buffer::Buffer, - layout::{Constraint, Flex, Layout, Rect}, + layout::{Constraint, Rect}, style::{Color, Style}, widgets::{Block, Borders, Widget}, }; @@ -55,10 +55,7 @@ pub fn resume_console_is_open(marker: &Path) -> bool { } fn band_area(screen: Rect) -> Rect { - let [band] = Layout::vertical([Constraint::Length(BAND_HEIGHT)]) - .flex(Flex::Center) - .areas(screen); - band + screen.centered_vertically(Constraint::Length(BAND_HEIGHT)) } fn band_frame() -> Block<'static> {