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:
10 files changed
+204
-189
No files matched your search
+31
-40
@@ -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
|
||||
|
||||
@@ -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",
|
||||
]
|
||||
);
|
||||
|
||||
@@ -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}"
|
||||
);
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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 = " ";
|
||||
@@ -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),
|
||||
|
||||
@@ -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}");
|
||||
|
||||
@@ -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> {
|
||||
|
||||
Reference in new issue
Block a user