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.
This commit is contained in:
Willem Vanhulle committed 2026-11-02 19:29:04 +01:00
1 parent 795819d5c8
commit c1449439e8
10 files changed
+204 -189

No files matched your search

+31 -40
View File
@@ -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
+14 -15
View File
@@ -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<Line<'static>> {
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",
]
);
+6 -6
View File
@@ -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}"
);
}
+34 -16
View File
@@ -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<TimelineEntry> = 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::<Vec<_>>(),
)
.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)
+25 -23
View File
@@ -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);
}
}
+8
View File
@@ -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 = " ";
+10 -4
View File
@@ -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),
+1 -1
View File
@@ -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}");
+73 -79
View File
@@ -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<Constraint>,
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<Constraint> = 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<T>(&self, cells: [T; 5]) -> impl Iterator<Item = T> {
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<Item = Constraint> {
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);
}
}
}
@@ -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> {