ZacharyZhang-NY
a02b555e66
Sweep every first-party crate source (1956 .rs files) to the project comment guidelines: delete redundant restatements, decorative banners, change narration, and end-of-line comments; keep and tighten the crucial ones (invariants, bug rationale, SAFETY blocks, ported-source attribution). No functional code changed. Every edit is proven comment-only against the prior tree by a comment-stripping lexer (string/char/raw-string aware) plus a separate doctest-fence check. Where removing a comment made rustfmt or clippy want to re-lay-out adjacent code, the minimal triggering comment is restored so code tokens stay byte-identical. Gates green: cargo fmt --all --check (0 diffs), cargo check and cargo clippy --workspace --all-targets (0 warnings). Adds scripts/check_codegen_comment_guidelines.py — the enforcement gate for these guidelines (flags banners, end-of-line comments, change narration, and commented-out code).
733 lines
28 KiB
Rust
733 lines
28 KiB
Rust
//! Pure layout computation for the dashboard view.
|
||
|
||
use ratatui::layout::Rect;
|
||
|
||
/// Minimum width at which the dashboard can render meaningful rows.
|
||
/// Below this, the renderer falls back to a stripped, single-column
|
||
/// view; row labels are middle-truncated.
|
||
pub const MIN_DASHBOARD_WIDTH: u16 = 40;
|
||
|
||
/// Minimum total height at which the peek panel is allowed to render.
|
||
/// Below this we drop the peek section even when toggled on so the
|
||
/// row list still has room to breathe.
|
||
pub const MIN_PEEK_HEIGHT: u16 = 12;
|
||
|
||
/// Outer horizontal padding for the dispatch box (cols on each side).
|
||
///
|
||
/// Matches `LayoutConfig::outer_hpad_left/right = 2` from the agent
|
||
/// view's default appearance config.
|
||
pub const DISPATCH_OUTER_HPAD: u16 = 2;
|
||
|
||
/// Outer horizontal padding for the top page header (cols on each side).
|
||
/// Slightly less than the list to give the title and status chips a bit
|
||
/// more horizontal real estate.
|
||
pub const HEADER_OUTER_HPAD: u16 = 1;
|
||
|
||
/// Outer horizontal padding for the row list (cols on each side).
|
||
///
|
||
/// Gives the list (rows + group headers + scrollbar) breathing room so
|
||
/// selection markers, group header rules (`────`), and row text don't
|
||
/// sit flush against the terminal edges.
|
||
pub const LIST_OUTER_HPAD: u16 = 2;
|
||
|
||
/// Output of [`compute_layout`].
|
||
#[derive(Debug, Clone, Copy)]
|
||
pub struct DashboardLayout {
|
||
/// Top margin row (blank space above the header). Height: 0 or 1.
|
||
/// Matches the welcome view's `v_margin` so the
|
||
/// dashboard's title row doesn't sit flush against the alt-screen
|
||
/// top edge.
|
||
pub top_margin: Rect,
|
||
/// Header row (title + summary). Height: 0 or 1.
|
||
pub header: Rect,
|
||
/// Vertical breathing room between the header and the row list.
|
||
/// Height: 0 or 1. Drops to 0 on short terminals (`area.height
|
||
/// <= 10`, mirroring the dispatch/shortcuts gap threshold).
|
||
/// No sub-renderer ever touches this rect — the area-wide
|
||
/// `bg_base` fill paints it. Conceptually it's the same "blank
|
||
/// breathing-room row" as the dispatch_gap / shortcuts_gap (it's
|
||
/// kept as a named rect rather than an anonymous y-cursor bump
|
||
/// only so tests can pin its position and threshold).
|
||
pub header_gap: Rect,
|
||
/// Scrollable list area (rows + group headers).
|
||
pub list: Rect,
|
||
/// Peek panel area, or `Rect::default()` when hidden.
|
||
pub peek: Rect,
|
||
/// Bottom dispatch input area.
|
||
pub dispatch: Rect,
|
||
/// Footer / shortcut hint row.
|
||
pub footer: Rect,
|
||
/// Bottom margin row (blank space below the shortcuts bar).
|
||
/// Height: 0 or 1. Matches the agent view's
|
||
/// `bottom_vpad` from `eff_outer_vpad` in `LayoutConfig::default`
|
||
/// so the dashboard's shortcuts bar doesn't sit flush against the
|
||
/// alt-screen's bottom edge. Drops to 0 on short terminals
|
||
/// (`area.height <= 16`, same threshold as
|
||
/// `views::agent::AgentViewLayout::compute`).
|
||
pub bottom_margin: Rect,
|
||
}
|
||
|
||
/// Compute the dashboard layout for a given content area.
|
||
///
|
||
/// `peek_visible` requests the peek panel; the layout shows it only
|
||
/// when the area has enough vertical room (edge case 9). When the area
|
||
/// is narrower than [`MIN_DASHBOARD_WIDTH`], the layout still returns a
|
||
/// valid arrangement (the renderer truncates labels).
|
||
pub fn compute_layout(area: Rect, peek_visible: bool) -> DashboardLayout {
|
||
// Single text row is the default — callers that support a growing
|
||
// multiline dispatch box (Shift+Enter newlines) use
|
||
// [`compute_layout_with_dispatch`] to request more.
|
||
compute_layout_with_dispatch(area, peek_visible, 1)
|
||
}
|
||
|
||
/// Like [`compute_layout`] but lets the caller request a taller
|
||
/// dispatch box. `dispatch_text_rows` is the number of *text* rows the
|
||
/// dispatch input wants (≥1); the box adds 2 more for its top/bottom
|
||
/// border chrome. Used to grow the box as the user inserts newlines
|
||
/// (Shift+Enter) so multiline dispatch prompts are fully visible.
|
||
///
|
||
/// The caller is responsible for clamping `dispatch_text_rows` so the
|
||
/// row list keeps usable space; this function only enforces a ≥1 floor.
|
||
pub fn compute_layout_with_dispatch(
|
||
area: Rect,
|
||
peek_visible: bool,
|
||
dispatch_text_rows: u16,
|
||
) -> DashboardLayout {
|
||
// When `area.height == 0`, every subrect collapses
|
||
// to zero. A footer_h = 1 default would produce a non-zero
|
||
// footer rect even on a 0-height area.
|
||
if area.height == 0 {
|
||
let z = Rect {
|
||
x: area.x,
|
||
y: area.y,
|
||
width: area.width,
|
||
height: 0,
|
||
};
|
||
return DashboardLayout {
|
||
top_margin: z,
|
||
header: z,
|
||
header_gap: z,
|
||
list: z,
|
||
peek: z,
|
||
dispatch: z,
|
||
footer: z,
|
||
bottom_margin: z,
|
||
};
|
||
}
|
||
// Match the welcome / agent view's top margin so
|
||
// the dashboard's header doesn't sit flush against the alt-screen's
|
||
// top edge. The welcome view uses `v_margin = 1` (see
|
||
// `views::welcome::render_welcome`). Dropped to 0 on very short
|
||
// terminals so we don't starve the row list.
|
||
let top_margin_h: u16 = if area.height > 6 { 1 } else { 0 };
|
||
let header_h: u16 = if area.height > 4 { 1 } else { 0 };
|
||
// 1-row gap between the header and the row list so the title /
|
||
// status chips don't sit flush against the first row (or the
|
||
// first group header). Collapses on short terminals so the row
|
||
// list isn't starved (same threshold as the dispatch/shortcuts
|
||
// gaps).
|
||
let header_gap_h: u16 = if area.height > 10 { 1 } else { 0 };
|
||
let footer_h: u16 = if area.height >= 2 { 1 } else { 0 };
|
||
// Vertical gaps around the dispatch box, matching
|
||
// the agent view's `prompt_gap` and `shortcuts_gap` (both = 1) so
|
||
// the dispatch chrome doesn't sit flush against the list above or
|
||
// the footer below. Gaps drop to 0 on short terminals so the row
|
||
// list still gets visible space. Computed BEFORE `dispatch_h` so the
|
||
// content-sized peek box can leave the row list at least one row.
|
||
let dispatch_gap_h: u16 = if area.height > 10 { 1 } else { 0 };
|
||
let shortcuts_gap_h: u16 = if area.height > 10 { 1 } else { 0 };
|
||
// Bottom margin below the shortcuts bar, matching
|
||
// the agent view's `bottom_vpad` (`outer_vpad = 1` from
|
||
// `LayoutConfig::default` dropped to 0 when `area.height <= 16`).
|
||
let bottom_margin_h: u16 = if area.height > 16 { 1 } else { 0 };
|
||
|
||
// The peek panel sizes to its CONTENT instead of a fixed
|
||
// height. Its inner rows are: status (1) + wrapped response (N) +
|
||
// one blank breathing row (1) + `❯ reply` (1); the caller passes
|
||
// that inner content count via `dispatch_text_rows` (floored at
|
||
// status + blank + reply = 3 when there's no response yet). Adding
|
||
// the 2 borders gives the box height, clamped so the row list keeps
|
||
// at least one visible row.
|
||
//
|
||
// Otherwise (no peek) the dispatch reserves 2 borders + N text rows
|
||
// so the rounded box reads as a real input field and grows for
|
||
// multiline (Alt+Enter) prompts. Very short terminals (height ≤ 8)
|
||
// fall back to a single line so the row list isn't starved.
|
||
let dispatch_h: u16 = if peek_visible {
|
||
if area.height <= 8 {
|
||
1
|
||
} else {
|
||
let fixed_overhead = top_margin_h
|
||
+ header_h
|
||
+ header_gap_h
|
||
+ footer_h
|
||
+ dispatch_gap_h
|
||
+ shortcuts_gap_h
|
||
+ bottom_margin_h;
|
||
let content = dispatch_text_rows.max(3);
|
||
let desired = content + 2;
|
||
// Keep ≥1 row for the list; never collapse below a 3-row box.
|
||
let max_box = area.height.saturating_sub(fixed_overhead + 1).max(3);
|
||
desired.min(max_box)
|
||
}
|
||
} else if area.height > 8 {
|
||
2 + dispatch_text_rows.max(1)
|
||
} else {
|
||
1
|
||
};
|
||
// Peek renders INSIDE the dispatch rect (which grows when
|
||
// `peek_visible`, computed above); this field stays zero-height so
|
||
// call sites that still destructure `layout.peek` keep compiling.
|
||
let peek_h: u16 = 0;
|
||
let remaining = area.height.saturating_sub(
|
||
top_margin_h
|
||
+ header_h
|
||
+ header_gap_h
|
||
+ footer_h
|
||
+ dispatch_h
|
||
+ peek_h
|
||
+ dispatch_gap_h
|
||
+ shortcuts_gap_h
|
||
+ bottom_margin_h,
|
||
);
|
||
|
||
let mut y = area.y;
|
||
let top_margin = Rect {
|
||
x: area.x,
|
||
y,
|
||
width: area.width,
|
||
height: top_margin_h,
|
||
};
|
||
y += top_margin_h;
|
||
// Inset the top page header using its own (slightly smaller) padding
|
||
// so the title and status chips have breathing room without losing
|
||
// as much width as the list content.
|
||
let header_inner_pad = HEADER_OUTER_HPAD.saturating_mul(2);
|
||
let header_width = area.width.saturating_sub(header_inner_pad);
|
||
let header_x = if header_width > 0 {
|
||
area.x.saturating_add(HEADER_OUTER_HPAD)
|
||
} else {
|
||
area.x
|
||
};
|
||
let header = Rect {
|
||
x: header_x,
|
||
y,
|
||
width: if header_width > 0 {
|
||
header_width
|
||
} else {
|
||
area.width
|
||
},
|
||
height: header_h,
|
||
};
|
||
y += header_h;
|
||
|
||
// 1-row gap between header and list (collapsed on short
|
||
// terminals). Painted by `render_dashboard`'s full-area fill —
|
||
// no sub-renderer touches it.
|
||
let header_gap = Rect {
|
||
x: area.x,
|
||
y,
|
||
width: area.width,
|
||
height: header_gap_h,
|
||
};
|
||
y += header_gap_h;
|
||
|
||
// Inset the list by LIST_OUTER_HPAD on each side so the
|
||
// row content and group header rules have side breathing room.
|
||
// The outer columns stay painted bg_base by the area-wide fill in
|
||
// render_dashboard. Mirrors the dispatch inset pattern but with a
|
||
// smaller pad (1 vs 2) because row text is long and dense.
|
||
let list_inner_pad = LIST_OUTER_HPAD.saturating_mul(2);
|
||
let list_width = area.width.saturating_sub(list_inner_pad);
|
||
let list_x = if list_width > 0 {
|
||
area.x.saturating_add(LIST_OUTER_HPAD)
|
||
} else {
|
||
area.x
|
||
};
|
||
let list = Rect {
|
||
x: list_x,
|
||
y,
|
||
width: if list_width > 0 {
|
||
list_width
|
||
} else {
|
||
area.width
|
||
},
|
||
height: remaining,
|
||
};
|
||
y += remaining;
|
||
|
||
let peek = if peek_h > 0 {
|
||
let r = Rect {
|
||
x: area.x,
|
||
y,
|
||
width: area.width,
|
||
height: peek_h,
|
||
};
|
||
y += peek_h;
|
||
r
|
||
} else {
|
||
Rect::default()
|
||
};
|
||
|
||
// 1-row gap between list/peek and the dispatch
|
||
// box (mirrors `prompt_gap` in `views::agent::AgentViewLayout`).
|
||
y += dispatch_gap_h;
|
||
|
||
// Single-line dispatch input keeps its 2-col
|
||
// outer padding so the `❯` prefix lines up with the row content
|
||
// (rows are indented past the marker column too).
|
||
let dispatch_inner_pad = DISPATCH_OUTER_HPAD.saturating_mul(2);
|
||
let dispatch_width = area.width.saturating_sub(dispatch_inner_pad);
|
||
let dispatch_x = if dispatch_width > 0 {
|
||
area.x.saturating_add(DISPATCH_OUTER_HPAD)
|
||
} else {
|
||
area.x
|
||
};
|
||
let dispatch = Rect {
|
||
x: dispatch_x,
|
||
y,
|
||
width: if dispatch_width > 0 {
|
||
dispatch_width
|
||
} else {
|
||
area.width
|
||
},
|
||
height: dispatch_h,
|
||
};
|
||
y += dispatch_h;
|
||
|
||
// 1-row gap between the dispatch box and the
|
||
// shortcuts footer (mirrors `shortcuts_gap`).
|
||
y += shortcuts_gap_h;
|
||
|
||
let footer = Rect {
|
||
x: area.x,
|
||
y,
|
||
width: area.width,
|
||
height: footer_h,
|
||
};
|
||
y += footer_h;
|
||
|
||
// Bottom margin row below the shortcuts bar
|
||
// (matches the agent view's `bottom_vpad`). Painted with
|
||
// `bg_base` by `render_dashboard`'s full-area fill — no
|
||
// sub-renderer ever touches this rect.
|
||
let bottom_margin = Rect {
|
||
x: area.x,
|
||
y,
|
||
width: area.width,
|
||
height: bottom_margin_h,
|
||
};
|
||
|
||
DashboardLayout {
|
||
top_margin,
|
||
header,
|
||
header_gap,
|
||
list,
|
||
peek,
|
||
dispatch,
|
||
footer,
|
||
bottom_margin,
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn layout_assigns_disjoint_areas() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let layout = compute_layout(area, true);
|
||
// top_margin + header + list + peek + dispatch + footer
|
||
// + bottom_margin == total. Three blank rows sit between the
|
||
// content rects: the header_gap (between header and list),
|
||
// the dispatch_gap (between list/peek and dispatch), and the
|
||
// shortcuts_gap (between dispatch and footer). The
|
||
// bottom_margin IS a rect with bg_base, so it stays inside
|
||
// `total`. Same mental model as the dispatch/shortcuts
|
||
// gaps — those are intentional blank breathing-room rows
|
||
// that the area-wide bg fill paints without any dedicated
|
||
// sub-renderer.
|
||
let total = layout.top_margin.height
|
||
+ layout.header.height
|
||
+ layout.list.height
|
||
+ layout.peek.height
|
||
+ layout.dispatch.height
|
||
+ layout.footer.height
|
||
+ layout.bottom_margin.height;
|
||
// 3 rows are absorbed by the gaps (header_gap +
|
||
// dispatch_gap + shortcuts_gap).
|
||
assert_eq!(total + 3, area.height);
|
||
}
|
||
|
||
/// Multiline dispatch: the box grows by exactly one row per extra
|
||
/// text row (2 border rows + N text rows), and the row list gives up
|
||
/// the space so the totals still tile the area.
|
||
#[test]
|
||
fn dispatch_box_grows_for_multiline_input() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let single = compute_layout(area, false);
|
||
// Single-line default is 3 rows (top border + 1 text + bottom).
|
||
assert_eq!(single.dispatch.height, 3);
|
||
|
||
let three = compute_layout_with_dispatch(area, false, 3);
|
||
assert_eq!(
|
||
three.dispatch.height, 5,
|
||
"3 text rows → 2 border + 3 text = 5 rows",
|
||
);
|
||
// The list absorbs the extra two rows the dispatch box took.
|
||
assert_eq!(
|
||
three.list.height + 2,
|
||
single.list.height,
|
||
"the row list must shrink by exactly the dispatch growth",
|
||
);
|
||
// Dispatch still sits above the footer with the same gap.
|
||
assert_eq!(three.footer.y, three.dispatch.y + three.dispatch.height + 1);
|
||
}
|
||
|
||
/// A `dispatch_text_rows` of 0 is floored to a single text row so the
|
||
/// box never collapses below its single-line chrome.
|
||
#[test]
|
||
fn dispatch_box_floors_at_single_text_row() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let zero = compute_layout_with_dispatch(area, false, 0);
|
||
assert_eq!(zero.dispatch.height, 3, "0 text rows floors to 1 (3 total)");
|
||
}
|
||
|
||
/// The dashboard reserves 1 row of bottom margin
|
||
/// below the shortcuts bar on tall enough terminals so the
|
||
/// shortcuts don't sit flush against the alt-screen's bottom edge.
|
||
/// Mirrors the agent view's `bottom_vpad` (`outer_vpad = 1`,
|
||
/// dropped to 0 at `area.height <= 16`).
|
||
#[test]
|
||
fn layout_reserves_bottom_margin_on_tall_terminals() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(
|
||
layout.bottom_margin.height, 1,
|
||
"tall terminal must reserve a bottom margin row",
|
||
);
|
||
// Bottom margin must sit directly below the footer.
|
||
assert_eq!(
|
||
layout.bottom_margin.y,
|
||
layout.footer.y + layout.footer.height,
|
||
"bottom_margin must sit directly below the footer",
|
||
);
|
||
// Bottom margin must end exactly at area.height — no slack
|
||
// before the alt-screen's bottom edge.
|
||
assert_eq!(
|
||
layout.bottom_margin.y + layout.bottom_margin.height,
|
||
area.y + area.height,
|
||
"bottom_margin must extend to the bottom of `area`",
|
||
);
|
||
}
|
||
|
||
/// Bottom margin collapses to 0 on short
|
||
/// terminals (`area.height <= 16`, matching the agent view's
|
||
/// threshold) so the row list isn't starved.
|
||
#[test]
|
||
fn layout_drops_bottom_margin_on_short_terminals() {
|
||
let area = Rect::new(0, 0, 80, 16);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(layout.bottom_margin.height, 0);
|
||
}
|
||
|
||
/// Dispatch box gets `DISPATCH_OUTER_HPAD` cols of
|
||
/// outer padding on each side so its rounded border doesn't reach
|
||
/// the terminal edge. Matches the agent view's `outer_hpad_left/right`.
|
||
#[test]
|
||
fn layout_applies_outer_hpad_to_dispatch_box() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(
|
||
layout.dispatch.x,
|
||
area.x + DISPATCH_OUTER_HPAD,
|
||
"dispatch must be inset by DISPATCH_OUTER_HPAD on the left",
|
||
);
|
||
assert_eq!(
|
||
layout.dispatch.width,
|
||
area.width - DISPATCH_OUTER_HPAD * 2,
|
||
"dispatch width must lose DISPATCH_OUTER_HPAD on each side",
|
||
);
|
||
}
|
||
|
||
/// Header is inset by HEADER_OUTER_HPAD; list by LIST_OUTER_HPAD.
|
||
/// Footer remains full-width.
|
||
#[test]
|
||
fn layout_insets_header_and_list() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(
|
||
layout.header.width,
|
||
area.width - HEADER_OUTER_HPAD * 2,
|
||
"header must be inset by HEADER_OUTER_HPAD on each side",
|
||
);
|
||
assert_eq!(layout.footer.width, area.width);
|
||
// List is intentionally inset by LIST_OUTER_HPAD on each side.
|
||
assert_eq!(layout.list.width, area.width - LIST_OUTER_HPAD * 2);
|
||
}
|
||
|
||
/// The list rect is inset by LIST_OUTER_HPAD cols on each
|
||
/// side so row content (markers, rules, text) has breathing room
|
||
/// and doesn't touch the terminal edges. The outer columns remain
|
||
/// bg_base (painted by the top-level area fill).
|
||
#[test]
|
||
fn layout_applies_outer_hpad_to_list() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(
|
||
layout.list.x,
|
||
area.x + LIST_OUTER_HPAD,
|
||
"list must be inset by LIST_OUTER_HPAD on the left",
|
||
);
|
||
assert_eq!(
|
||
layout.list.width,
|
||
area.width - LIST_OUTER_HPAD * 2,
|
||
"list width must lose LIST_OUTER_HPAD on each side",
|
||
);
|
||
}
|
||
|
||
/// The header rect is inset by HEADER_OUTER_HPAD (slightly less
|
||
/// than the list) for side breathing room on the title and status chips.
|
||
#[test]
|
||
fn layout_applies_outer_hpad_to_header() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(
|
||
layout.header.x,
|
||
area.x + HEADER_OUTER_HPAD,
|
||
"header must be inset by HEADER_OUTER_HPAD on the left",
|
||
);
|
||
assert_eq!(
|
||
layout.header.width,
|
||
area.width - HEADER_OUTER_HPAD * 2,
|
||
"header width must lose HEADER_OUTER_HPAD on each side",
|
||
);
|
||
}
|
||
|
||
/// A 1-row gap separates the list/peek from the
|
||
/// dispatch box, and another 1-row gap separates the dispatch box
|
||
/// from the footer. Mirrors `prompt_gap` + `shortcuts_gap` in the
|
||
/// agent view's layout.
|
||
#[test]
|
||
fn layout_reserves_dispatch_and_shortcuts_gaps() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let layout = compute_layout(area, false);
|
||
// 1-row gap before dispatch: dispatch.y - (list.y + list.height) == 1.
|
||
let list_end = layout.list.y + layout.list.height;
|
||
assert_eq!(
|
||
layout.dispatch.y - list_end,
|
||
1,
|
||
"expected 1-row gap between list and dispatch, got {} (list_end={list_end}, dispatch.y={})",
|
||
layout.dispatch.y - list_end,
|
||
layout.dispatch.y,
|
||
);
|
||
// 1-row gap before footer: footer.y - (dispatch.y + dispatch.height) == 1.
|
||
let dispatch_end = layout.dispatch.y + layout.dispatch.height;
|
||
assert_eq!(
|
||
layout.footer.y - dispatch_end,
|
||
1,
|
||
"expected 1-row gap between dispatch and footer, got {} (dispatch_end={dispatch_end}, footer.y={})",
|
||
layout.footer.y - dispatch_end,
|
||
layout.footer.y,
|
||
);
|
||
}
|
||
|
||
/// Gaps collapse to 0 on short terminals so the
|
||
/// row list isn't starved. Threshold mirrors the top-margin
|
||
/// threshold pattern (`> 10`).
|
||
#[test]
|
||
fn layout_drops_gaps_on_short_terminals() {
|
||
let area = Rect::new(0, 0, 80, 10);
|
||
let layout = compute_layout(area, false);
|
||
let list_end = layout.list.y + layout.list.height;
|
||
let dispatch_end = layout.dispatch.y + layout.dispatch.height;
|
||
assert_eq!(
|
||
layout.dispatch.y - list_end,
|
||
0,
|
||
"short terminal must collapse dispatch gap",
|
||
);
|
||
assert_eq!(
|
||
layout.footer.y - dispatch_end,
|
||
0,
|
||
"short terminal must collapse shortcuts gap",
|
||
);
|
||
}
|
||
|
||
/// The dashboard reserves a 1-row gap between
|
||
/// the header and the row list on tall enough terminals so the
|
||
/// status chips / `Dashboard` label don't sit flush against the
|
||
/// first group header or row. The gap sits immediately below the
|
||
/// header and immediately above the list.
|
||
#[test]
|
||
fn layout_reserves_header_gap_on_tall_terminals() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(
|
||
layout.header_gap.height, 1,
|
||
"tall terminal must reserve a header gap row",
|
||
);
|
||
// Header gap sits directly below the header.
|
||
assert_eq!(
|
||
layout.header_gap.y,
|
||
layout.header.y + layout.header.height,
|
||
"header_gap must sit directly below the header",
|
||
);
|
||
// List starts directly below the header gap.
|
||
assert_eq!(
|
||
layout.list.y,
|
||
layout.header_gap.y + layout.header_gap.height,
|
||
"list must start directly below the header_gap",
|
||
);
|
||
}
|
||
|
||
/// The header gap collapses to 0 on short
|
||
/// terminals (`area.height <= 10`, same threshold as the
|
||
/// dispatch / shortcuts gaps) so the row list still gets visible
|
||
/// space.
|
||
#[test]
|
||
fn layout_drops_header_gap_on_short_terminals() {
|
||
let area = Rect::new(0, 0, 80, 10);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(
|
||
layout.header_gap.height, 0,
|
||
"short terminal must collapse header_gap",
|
||
);
|
||
// And the list must start immediately below the header (no
|
||
// implicit gap left behind).
|
||
assert_eq!(
|
||
layout.list.y,
|
||
layout.header.y + layout.header.height,
|
||
"list must start directly below the header when the gap collapses",
|
||
);
|
||
}
|
||
|
||
/// The dashboard reserves one row of top margin
|
||
/// on terminals tall enough to spare it, mirroring the welcome
|
||
/// view's `v_margin`. Below the height threshold the margin
|
||
/// collapses to 0 so the row list isn't starved.
|
||
#[test]
|
||
fn layout_reserves_top_margin_on_tall_terminals() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(
|
||
layout.top_margin.height, 1,
|
||
"tall terminal must reserve a top margin row",
|
||
);
|
||
assert_eq!(
|
||
layout.header.y,
|
||
area.y + 1,
|
||
"header must sit below the top margin",
|
||
);
|
||
}
|
||
|
||
/// Short terminals collapse the top margin to 0
|
||
/// so the row list still gets visible space. Threshold matches
|
||
/// the dispatch chrome's threshold (`area.height > 6`).
|
||
#[test]
|
||
fn layout_drops_top_margin_on_short_terminals() {
|
||
let area = Rect::new(0, 0, 80, 6);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(layout.top_margin.height, 0);
|
||
}
|
||
|
||
#[test]
|
||
fn layout_hides_peek_when_too_short() {
|
||
let area = Rect::new(0, 0, 80, 8);
|
||
let layout = compute_layout(area, true);
|
||
assert_eq!(layout.peek.height, 0);
|
||
}
|
||
|
||
#[test]
|
||
fn layout_at_minimum_width_returns_valid_rect() {
|
||
let area = Rect::new(0, 0, MIN_DASHBOARD_WIDTH, 30);
|
||
let layout = compute_layout(area, false);
|
||
// List is inset by LIST_OUTER_HPAD on each side even at the
|
||
// minimum dashboard width (40 cols → 38 usable for content).
|
||
assert_eq!(layout.list.width, MIN_DASHBOARD_WIDTH - LIST_OUTER_HPAD * 2);
|
||
}
|
||
|
||
// Boundary tests: the existing three tests cover the happy paths;
|
||
// the following four close the boundary gaps explicitly.
|
||
|
||
/// Zero-height area produces zero-height sub-rects
|
||
/// (and doesn't panic on saturating subtraction).
|
||
#[test]
|
||
fn layout_height_zero_produces_zero_subrects() {
|
||
let area = Rect::new(0, 0, 80, 0);
|
||
let layout = compute_layout(area, true);
|
||
assert_eq!(layout.header.height, 0);
|
||
assert_eq!(layout.list.height, 0);
|
||
assert_eq!(layout.peek.height, 0);
|
||
assert_eq!(layout.dispatch.height, 0);
|
||
assert_eq!(layout.footer.height, 0);
|
||
}
|
||
|
||
/// One row below the peek minimum hides the peek.
|
||
#[test]
|
||
fn layout_just_below_min_peek_height_hides_peek() {
|
||
let area = Rect::new(0, 0, 80, MIN_PEEK_HEIGHT - 1);
|
||
let layout = compute_layout(area, true);
|
||
assert_eq!(layout.peek.height, 0);
|
||
}
|
||
|
||
/// Peek renders INSIDE the dispatch box, so the peek rect is
|
||
/// always zero-height; what changes when `peek_visible == true` is
|
||
/// the dispatch rect, which grows from 3 to 5 rows to host
|
||
/// the peek's status + reply input.
|
||
#[test]
|
||
fn layout_grows_dispatch_when_peek_visible() {
|
||
let area = Rect::new(0, 0, 80, 30);
|
||
let no_peek = compute_layout(area, false);
|
||
let with_peek = compute_layout(area, true);
|
||
assert_eq!(no_peek.peek.height, 0);
|
||
assert_eq!(with_peek.peek.height, 0);
|
||
assert!(
|
||
with_peek.dispatch.height > no_peek.dispatch.height,
|
||
"peek-visible must grow the dispatch rect, no_peek={} with_peek={}",
|
||
no_peek.dispatch.height,
|
||
with_peek.dispatch.height,
|
||
);
|
||
}
|
||
|
||
/// The peek box sizes to its content: 2 borders + the
|
||
/// inner content rows (status + response + blank + reply) the caller
|
||
/// passes via `dispatch_text_rows`. A bigger response → taller box.
|
||
#[test]
|
||
fn peek_box_sizes_to_content_rows() {
|
||
let area = Rect::new(0, 0, 80, 40);
|
||
// content = status(1) + blank(1) + reply(1) = 3 → box 5 (no response).
|
||
let empty = compute_layout_with_dispatch(area, true, 3);
|
||
// content = status + 3 response + blank + reply = 6 → box 8.
|
||
let full = compute_layout_with_dispatch(area, true, 6);
|
||
assert_eq!(empty.dispatch.height, 5);
|
||
assert_eq!(full.dispatch.height, 8);
|
||
assert!(full.dispatch.height > empty.dispatch.height);
|
||
// The list reclaims the rows the smaller box doesn't use.
|
||
assert!(empty.list.height > full.list.height);
|
||
}
|
||
|
||
/// Zero-width area returns valid zero-width rects.
|
||
#[test]
|
||
fn layout_width_zero_returns_zero_width_subrects() {
|
||
let area = Rect::new(0, 0, 0, 30);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(layout.list.width, 0);
|
||
assert_eq!(layout.dispatch.width, 0);
|
||
}
|
||
|
||
/// A 39-wide area (below `MIN_DASHBOARD_WIDTH=40`)
|
||
/// returns valid sub-rects — the renderer will fall back to
|
||
/// narrow mode. List still receives its outer hpad inset.
|
||
#[test]
|
||
fn layout_width_below_min_returns_valid_subrects() {
|
||
let area = Rect::new(0, 0, MIN_DASHBOARD_WIDTH - 1, 30);
|
||
let layout = compute_layout(area, false);
|
||
assert_eq!(
|
||
layout.list.width,
|
||
MIN_DASHBOARD_WIDTH - 1 - LIST_OUTER_HPAD * 2
|
||
);
|
||
assert!(layout.list.height > 0);
|
||
}
|
||
}
|