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> {