use std::collections::HashMap;
use std::fs::{File, OpenOptions};
use std::io::{self, Read};
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::{Duration, Instant};
use ratatui::backend::CrosstermBackend;
use ratatui::crossterm::{
event::{DisableMouseCapture, EnableMouseCapture},
execute,
terminal::{
disable_raw_mode, enable_raw_mode, size, EnterAlternateScreen, LeaveAlternateScreen,
},
};
use ratatui::layout::{Constraint, Layout, Rect};
use ratatui::style::{Color, Modifier, Style};
use ratatui::symbols;
use ratatui::text::{Line, Span};
use ratatui::widgets::calendar::{CalendarEventStore, Monthly};
use ratatui::widgets::canvas::{Canvas, Map, MapResolution, Points};
use ratatui::widgets::{
Axis, BarChart, Block, Borders, Cell, Chart, Clear, Dataset, Gauge, GraphType, LineGauge, List,
ListItem, ListState, Paragraph, RatatuiLogo, Row, Scrollbar, ScrollbarOrientation,
ScrollbarState, Sparkline, Table, Tabs,
};
use ratatui::{Frame, Terminal, TerminalOptions, Viewport};
use rayon::prelude::*;
use crate::query::{eval, is_line_streamable, QueryOp, QueryResult};
use crate::spec::{Bind, BindAction, Spec, Timeout, Widget, WidgetKind};
use crate::stream::StreamState;
pub fn events_available() -> bool {
std::fs::OpenOptions::new()
.read(true)
.write(true)
.open("/dev/tty")
.is_ok()
}
fn parse_height(spec: &str) -> Option<u16> {
let s = spec.trim();
if let Some(p) = s.strip_suffix('%') {
let pct: u32 = p.trim().parse().ok()?;
let rows = size().map(|(_, h)| h).unwrap_or(24) as u32;
Some((rows * pct / 100).clamp(3, rows) as u16)
} else {
s.parse::<u16>().ok().map(|n| n.max(3))
}
}
#[derive(Default)]
pub struct Controls {
pub filter: String,
pub quit: bool,
pub cursor: usize,
pub submit: bool,
pub fzf: bool,
pub marks: Vec<String>,
pub toggle: bool,
pub result: Vec<String>,
pub current: String,
pub prompt: String,
pub header: String,
pub inputs: Vec<(String, String)>,
pub control_meta: Vec<ControlMeta>,
pub focus: usize,
pub binds: Vec<Bind>,
pub exact: bool,
pub no_sort: bool,
pub beep_pending: bool,
pub alert: Option<(String, Instant)>,
pub flashes: HashMap<String, (String, Instant)>,
pub hitmap: Vec<HitTarget>,
pub fzf_list_start: usize,
pub mouse_binds: Vec<(crate::spec::MouseTrigger, BindAction)>,
pub tab_sel: HashMap<String, usize>,
pub scroll: HashMap<String, usize>,
pub last_click: Option<(Instant, u16, u16)>,
pub pty_writer: Option<Box<dyn std::io::Write + Send>>,
pub session: crate::actor::Session,
pub theme: Option<crate::theme::Palette>,
pub theme_idx: usize,
pub help_open: bool,
pub theme_picker_open: bool,
pub theme_picker_sel: usize,
pub theme_picker_revert: usize,
}
pub fn filter_matches(line: &str, filter: &str) -> bool {
filter.is_empty() || line.to_lowercase().contains(&filter.to_lowercase())
}
pub fn fuzzy_score(line: &str, pat: &str) -> Option<i32> {
if pat.is_empty() {
return Some(0);
}
let cased = pat.chars().any(|c| c.is_uppercase());
let norm = |c: char| if cased { c } else { c.to_ascii_lowercase() };
let l: Vec<char> = line.chars().collect();
let p: Vec<char> = pat.chars().collect();
let mut score = 0i32;
let mut li = 0usize;
let mut prev: Option<usize> = None;
for &pc in &p {
let target = norm(pc);
let idx = loop {
if li >= l.len() {
return None;
}
if norm(l[li]) == target {
break li;
}
li += 1;
};
if let Some(pi) = prev {
if idx == pi + 1 {
score += 15; } else {
score -= (idx - pi - 1).min(10) as i32; }
}
if idx == 0 || !l[idx - 1].is_alphanumeric() {
score += 10; }
prev = Some(idx);
li = idx + 1;
}
Some(score)
}
pub fn exact_score(line: &str, pat: &str) -> Option<i32> {
if pat.is_empty() {
return Some(0);
}
let cased = pat.chars().any(|c| c.is_uppercase());
if cased {
line.find(pat).map(|i| -(i as i32))
} else {
line.to_lowercase()
.find(&pat.to_lowercase())
.map(|i| -(i as i32))
}
}
fn score_line(line: &str, pat: &str, exact: bool) -> Option<i32> {
if exact {
exact_score(line, pat)
} else {
fuzzy_score(line, pat)
}
}
fn ansi_line(s: &str) -> Line<'static> {
use ansi_to_tui::IntoText;
match s.as_bytes().into_text() {
Ok(text) => text.lines.into_iter().next().unwrap_or_default(),
Err(_) => Line::from(s.to_string()),
}
}
fn clip(s: &str, width: usize) -> String {
if s.chars().count() <= width {
s.to_string()
} else {
s.chars().take(width).collect()
}
}
fn apply_bind_action(c: &mut Controls, action: &BindAction) {
match action {
BindAction::Quit => c.quit = true,
BindAction::SetInput { name, value } => {
if let Some(slot) = c.inputs.iter_mut().find(|(n, _)| n == name) {
slot.1 = value.clone();
}
}
BindAction::Beep => c.beep_pending = true,
BindAction::Alert(msg) => {
c.alert = Some((msg.clone(), Instant::now() + Duration::from_secs(3)));
}
BindAction::Flash { widget, color } => {
c.flashes.insert(
widget.clone(),
(color.clone(), Instant::now() + Duration::from_secs(2)),
);
}
BindAction::Exec(cmd) => {
let _ = std::process::Command::new("sh")
.arg("-c")
.arg(cmd)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.spawn();
}
BindAction::Send(text) => {
if let Some(w) = c.pty_writer.as_mut() {
use std::io::Write;
let _ = w.write_all(text.as_bytes());
let _ = w.flush();
}
}
BindAction::ActorTell { refname, call } => {
if let Ok((msg, argexprs)) = crate::actor::parse_call(call) {
let inputs: HashMap<String, String> = c.inputs.iter().cloned().collect();
let args = crate::actor::eval_args(&argexprs, &inputs);
c.session.tell(refname, &msg, args);
}
}
BindAction::ActorAsk {
ctrl,
refname,
call,
} => {
if let Ok((msg, argexprs)) = crate::actor::parse_call(call) {
let inputs: HashMap<String, String> = c.inputs.iter().cloned().collect();
let args = crate::actor::eval_args(&argexprs, &inputs);
if let Some(v) = c.session.ask(refname, &msg, args) {
let text = crate::query::fmt_scalar(v);
if let Some(slot) = c.inputs.iter_mut().find(|(n, _)| n == ctrl) {
slot.1 = text;
}
}
}
}
BindAction::Seq(actions) => {
for a in actions {
apply_bind_action(c, a);
}
}
}
}
fn tick_timeouts(
timeouts: &[Timeout],
now_total: u64,
last_total: &mut u64,
last_activity: &mut Instant,
fired: &mut [bool],
now: Instant,
c: &mut Controls,
) {
if now_total != *last_total {
*last_total = now_total;
*last_activity = now;
fired.iter_mut().for_each(|f| *f = false);
return;
}
let idle = now.saturating_duration_since(*last_activity);
for (i, t) in timeouts.iter().enumerate() {
if !fired[i] && idle >= t.dur {
apply_bind_action(c, &t.action);
fired[i] = true;
}
}
}
fn spawn_key_handler(controls: Arc<Mutex<Controls>>) {
if let Ok(mut tty) = OpenOptions::new().read(true).open("/dev/tty") {
thread::spawn(move || {
let mut buf = [0u8; 32];
'read: loop {
let n = match tty.read(&mut buf) {
Ok(n) if n > 0 => n,
_ => break,
};
let mut c = controls.lock().unwrap();
let fzf = c.fzf;
let form = !fzf && !c.inputs.is_empty();
let mut i = 0;
while i < n {
let b = buf[i];
let fk = if form {
c.control_meta
.get(c.focus)
.map(|m| m.kind)
.unwrap_or(ControlKind::Text)
} else {
ControlKind::Text
};
if b == 0x1b && buf.get(i + 1) == Some(&b'[') && buf.get(i + 2) == Some(&b'<') {
if let Some((ev, used)) = parse_sgr_mouse(&buf[..n], i) {
dispatch_mouse(&mut c, ev, fzf, Instant::now());
if c.quit {
break 'read;
}
i += used;
continue;
}
i += 1;
continue;
}
if c.theme_picker_open {
if b == 0x1b && i + 2 < n && buf[i + 1] == b'[' {
match buf[i + 2] {
b'A' => theme_picker_move(&mut c, -1),
b'B' => theme_picker_move(&mut c, 1),
_ => {}
}
i += 3;
continue;
}
match b {
b'k' | 0x10 => theme_picker_move(&mut c, -1), b'j' | 0x0e => theme_picker_move(&mut c, 1), 0x0d => theme_picker_accept(&mut c), 0x1b | b'q' => theme_picker_cancel(&mut c), 0x14 => theme_picker_cancel(&mut c), 0x03 => {
c.quit = true;
break 'read;
}
_ => {}
}
i += 1;
continue;
}
if b == 0x1b && i + 2 < n && buf[i + 1] == b'[' {
match buf[i + 2] {
b'A' if fzf => c.cursor = c.cursor.saturating_sub(1),
b'B' if fzf => c.cursor = c.cursor.saturating_add(1),
b'A' if matches!(fk, ControlKind::Facet | ControlKind::Sel) => {
let f = c.focus;
c.control_meta[f].cursor =
c.control_meta[f].cursor.saturating_sub(1);
}
b'B' if matches!(fk, ControlKind::Facet | ControlKind::Sel) => {
let f = c.focus;
c.control_meta[f].cursor =
c.control_meta[f].cursor.saturating_add(1);
}
b'C' if fk == ControlKind::Slider => slider_key(&mut c, true),
b'D' if fk == ControlKind::Slider => slider_key(&mut c, false),
_ => {}
}
i += 3;
continue;
}
match b {
_ if b < 0x20 && c.binds.iter().any(|bd| bd.key == b) => {
let action = c
.binds
.iter()
.find(|bd| bd.key == b)
.map(|bd| bd.action.clone());
if let Some(action) = action {
apply_bind_action(&mut c, &action);
if c.quit {
break 'read;
}
}
}
0x03 => {
c.quit = true;
break 'read;
}
0x0d if fzf => {
c.submit = true;
break 'read;
}
0x0e | 0x0a if fzf => c.cursor = c.cursor.saturating_add(1),
0x10 | 0x0b if fzf => c.cursor = c.cursor.saturating_sub(1),
0x09 if fzf => c.toggle = true, 0x09 if form => {
let nlen = c.inputs.len();
c.focus = (c.focus + 1) % nlen;
}
0x1b => {
if c.help_open {
c.help_open = false;
} else if form {
let f = c.focus;
c.inputs[f].1.clear();
} else if fzf || c.filter.is_empty() {
c.quit = true;
break 'read;
} else {
c.filter.clear();
c.cursor = 0;
}
}
0x08 | 0x7f => {
if form {
let f = c.focus;
c.inputs[f].1.pop();
} else {
c.filter.pop();
c.cursor = 0;
}
}
0x15 => {
if form {
let f = c.focus;
c.inputs[f].1.clear();
} else {
c.filter.clear();
c.cursor = 0;
}
}
b'+' | b'=' | b'l' if fk == ControlKind::Slider => slider_key(&mut c, true),
b'-' | b'h' if fk == ControlKind::Slider => slider_key(&mut c, false),
0x20 | 0x0d if fk == ControlKind::Check => {
let f = c.focus;
c.inputs[f].1 = toggle_check(&c.inputs[f].1);
}
0x20 if fk == ControlKind::Facet => {
let f = c.focus;
let cur = c.control_meta[f].cursor;
if let Some(item) = c.control_meta[f].opts.get(cur).cloned() {
c.inputs[f].1 = toggle_set_member(&c.inputs[f].1, &item);
}
}
0x14 => open_theme_picker(&mut c),
0x07 => c.help_open = !c.help_open,
0x20..=0x7e => {
if form && fk == ControlKind::Text {
let f = c.focus;
c.inputs[f].1.push(b as char);
} else if !form {
c.filter.push(b as char);
c.cursor = 0;
}
}
_ => {
if let Some(action) = c
.binds
.iter()
.find(|bd| bd.key == b)
.map(|bd| bd.action.clone())
{
apply_bind_action(&mut c, &action);
if c.quit {
break 'read;
}
}
}
}
i += 1;
}
}
});
}
}
type FzfCand = (Arc<str>, Arc<str>, Arc<str>);
type FzfHit = (i32, Arc<str>, Arc<str>, Arc<str>);
pub fn run(
spec: &Spec,
state: Arc<Mutex<StreamState>>,
controls: Arc<Mutex<Controls>>,
down: Option<(Arc<Mutex<StreamState>>, String)>,
err: Option<(Arc<Mutex<StreamState>>, String)>,
fzf: bool,
height: Option<String>,
) -> io::Result<()> {
let tty: File = OpenOptions::new().read(true).write(true).open("/dev/tty")?;
enable_raw_mode()?;
let inline = height.as_deref().and_then(parse_height);
let backend = CrosstermBackend::new(tty);
let mut terminal = match inline {
Some(rows) => Terminal::with_options(
backend,
TerminalOptions {
viewport: Viewport::Inline(rows),
},
)?,
None => {
let mut t = Terminal::new(backend)?;
execute!(t.backend_mut(), EnterAlternateScreen)?;
t
}
};
execute!(terminal.backend_mut(), EnableMouseCapture)?;
controls.lock().unwrap().fzf = fzf;
spawn_key_handler(controls.clone());
let select_widget = spec.widgets.iter().find(|w| w.kind == WidgetKind::Select);
let proj: Vec<QueryOp> = select_widget
.and_then(|w| w.source.as_ref())
.map(|s| s.pipeline.clone())
.filter(|p| is_line_streamable(p))
.unwrap_or_default();
let search_proj: Vec<QueryOp> = select_widget
.and_then(|w| w.search.clone())
.filter(|p| is_line_streamable(p))
.unwrap_or_default();
let mut fzf_cands: Vec<FzfCand> = Vec::new();
let mut fzf_raw_done = 0usize; let mut fzf_filter = String::from("\u{0}"); let mut fzf_processed = 0usize; let mut fzf_hits: Vec<FzfHit> = Vec::new();
let mut fzf_matched: Vec<(Arc<str>, Arc<str>)> = Vec::new(); let mut fzf_last_sort = Instant::now() - Duration::from_secs(1);
let mut expect_total: u64 = 0;
let (fzf_prompt, fzf_header, fzf_exact, fzf_no_sort) = {
let c = controls.lock().unwrap();
let p = if c.prompt.is_empty() {
"> ".to_string()
} else {
c.prompt.clone()
};
(p, c.header.clone(), c.exact, c.no_sort)
};
let mut to_last_total: u64 = { state.lock().unwrap().total };
let mut to_last_activity = Instant::now();
let mut to_fired = vec![false; spec.timeouts.len()];
let mut last_size = size().unwrap_or((0, 0));
let outcome = loop {
let (filter, quit, submit, cursor) = {
let c = controls.lock().unwrap();
(c.filter.clone(), c.quit, c.submit, c.cursor)
};
if quit {
break Ok(());
}
if !spec.expects.is_empty() {
let new_lines: Vec<String> = {
let st = state.lock().unwrap();
let new_count = st.total.saturating_sub(expect_total) as usize;
let take = new_count.min(st.lines.len());
let start = st.lines.len() - take;
expect_total = st.total;
st.lines.iter().skip(start).cloned().collect()
};
if !new_lines.is_empty() {
let mut c = controls.lock().unwrap();
for line in &new_lines {
for ex in &spec.expects {
if ex.pattern.is_match(line) {
apply_bind_action(&mut c, &ex.action);
}
}
}
}
}
if !spec.timeouts.is_empty() {
let now_total = { state.lock().unwrap().total };
let mut c = controls.lock().unwrap();
tick_timeouts(
&spec.timeouts,
now_total,
&mut to_last_total,
&mut to_last_activity,
&mut to_fired,
Instant::now(),
&mut c,
);
}
let cur_size = size().unwrap_or(last_size);
if !spec.resize_binds.is_empty() && detect_resize(&mut last_size, cur_size) {
let mut c = controls.lock().unwrap();
let actions = spec.resize_binds.clone();
for a in &actions {
apply_bind_action(&mut c, a);
}
}
let err_snap: Option<(Vec<String>, String)> = err.as_ref().map(|(es, label)| {
let e = es.lock().unwrap();
let n = e.lines.len();
let tail = e
.lines
.iter()
.skip(n.saturating_sub(200))
.cloned()
.collect();
(tail, format!("{label} ({})", e.total))
});
let err_ref = err_snap
.as_ref()
.filter(|(l, _)| !l.is_empty())
.map(|(l, lab)| (l.as_slice(), lab.as_str()));
if fzf {
let total;
{
let st = state.lock().unwrap();
total = st.total;
const MAX_INGEST_PER_FRAME: usize = 50_000;
let ingest_end = st.lines.len().min(fzf_raw_done + MAX_INGEST_PER_FRAME);
for i in fzf_raw_done..ingest_end {
let raw = &st.lines[i];
if proj.is_empty() && search_proj.is_empty() {
let a: Arc<str> = Arc::from(raw.as_str());
fzf_cands.push((a.clone(), a.clone(), a));
continue;
}
let orig: Arc<str> = Arc::from(raw.as_str());
let key: Option<Arc<str>> = if search_proj.is_empty() {
None
} else {
Some(Arc::from(
project_line(&search_proj, raw).join(" ").as_str(),
))
};
for disp in project_line(&proj, raw) {
let d: Arc<str> = Arc::from(disp.as_str());
let k = key.clone().unwrap_or_else(|| d.clone());
fzf_cands.push((d, k, orig.clone()));
}
}
fzf_raw_done = ingest_end;
let n = fzf_cands.len();
let empty = filter.is_empty();
if filter != fzf_filter {
let extends =
!empty && !fzf_filter.is_empty() && filter.starts_with(&fzf_filter);
if empty {
fzf_hits.clear();
fzf_matched.clear();
fzf_processed = 0;
} else if extends {
let old = std::mem::take(&mut fzf_hits);
fzf_hits = old
.into_iter()
.filter_map(|(_, d, k, o)| {
score_line(&k, &filter, fzf_exact).map(|s| (s, d, k, o))
})
.collect();
} else {
fzf_hits = fzf_cands
.par_iter()
.filter_map(|(d, k, o)| {
score_line(k, &filter, fzf_exact)
.map(|s| (s, d.clone(), k.clone(), o.clone()))
})
.collect();
fzf_processed = n;
}
fzf_filter = filter.clone();
fzf_last_sort = Instant::now() - Duration::from_secs(1);
}
for (d, k, o) in fzf_cands.iter().take(n).skip(fzf_processed) {
if empty {
fzf_matched.push((d.clone(), o.clone()));
} else if let Some(sc) = score_line(k, &filter, fzf_exact) {
fzf_hits.push((sc, d.clone(), k.clone(), o.clone()));
}
}
fzf_processed = n;
}
if !filter.is_empty() {
let now = Instant::now();
if now.duration_since(fzf_last_sort) >= Duration::from_millis(100) {
let mut h = fzf_hits.clone();
if !fzf_no_sort {
h.par_sort_by(|a, b| b.0.cmp(&a.0));
}
fzf_matched = h.into_iter().map(|(_, d, _k, o)| (d, o)).collect();
fzf_last_sort = now;
}
}
let matched = &fzf_matched;
let sel = cursor.min(matched.len().saturating_sub(1));
let mut c = controls.lock().unwrap();
c.current = matched
.get(sel)
.map(|(_, o)| o.to_string())
.unwrap_or_default();
if c.toggle {
c.toggle = false;
if let Some((_, orig)) = matched.get(sel) {
match c.marks.iter().position(|m| m.as_str() == orig.as_ref()) {
Some(pos) => {
c.marks.remove(pos);
}
None => c.marks.push(orig.to_string()),
}
}
c.cursor = c.cursor.saturating_add(1);
}
if submit {
c.result = if c.marks.is_empty() {
matched
.get(sel)
.map(|(_, o)| o.to_string())
.into_iter()
.collect()
} else {
c.marks.clone()
};
break Ok(());
}
let marks = c.marks.clone();
let fzf_theme = c.theme; let fzf_help = c.help_open;
let fzf_picker = c.theme_picker_open.then_some(c.theme_picker_sel);
drop(c);
let prev_snap: Option<(Vec<String>, String)> = down.as_ref().map(|(ds, label)| {
let d = ds.lock().unwrap();
(d.lines.iter().cloned().collect(), label.clone())
});
let prev_ref = prev_snap
.as_ref()
.map(|(l, lab)| (l.as_slice(), lab.as_str()));
let mut hitmap: Vec<HitTarget> = Vec::new();
let mut fzf_start = 0usize;
let draw = terminal.draw(|f| {
fzf_start = render_fzf(
f,
matched,
&filter,
sel,
&marks,
total,
err_ref,
prev_ref,
&fzf_prompt,
&fzf_header,
fzf_theme,
&mut hitmap,
);
if fzf_help {
draw_help_overlay(f, spec, fzf_theme);
}
if let Some(sel) = fzf_picker {
draw_theme_picker(f, sel, fzf_theme);
}
});
{
let mut c = controls.lock().unwrap();
c.hitmap = hitmap;
c.fzf_list_start = fzf_start;
}
if let Err(e) = draw {
break Err(e);
}
thread::sleep(Duration::from_millis(20));
continue;
}
let down_snap: Option<(Vec<String>, String)> = down.as_ref().map(|(ds, label)| {
let d = ds.lock().unwrap();
let n = d.lines.len();
let tail = d
.lines
.iter()
.skip(n.saturating_sub(1000))
.cloned()
.collect();
(tail, label.clone())
});
{
let lines: Vec<String> = {
let st = state.lock().unwrap();
st.lines.iter().cloned().collect()
};
let mut c = controls.lock().unwrap();
update_sel_controls(spec, &lines, &mut c);
}
let mut c = controls.lock().unwrap();
let inputs: HashMap<String, String> = c.inputs.iter().cloned().collect();
let focus_name = c.inputs.get(c.focus).map(|(n, _)| n.clone());
let theme = c.theme; let help_open = c.help_open; let theme_picker = c.theme_picker_open.then_some(c.theme_picker_sel);
let cmeta: HashMap<String, ControlMeta> = c
.inputs
.iter()
.zip(c.control_meta.iter())
.map(|((n, _), m)| (n.clone(), m.clone()))
.collect();
let now = Instant::now();
let alert_msg = c
.alert
.as_ref()
.filter(|(_, exp)| *exp > now)
.map(|(m, _)| m.clone());
c.flashes.retain(|_, (_, exp)| *exp > now);
let flash_snap: HashMap<String, String> = c
.flashes
.iter()
.map(|(k, (col, _))| (k.clone(), col.clone()))
.collect();
let tab_sel_snap: HashMap<String, usize> = c.tab_sel.clone();
let scroll_snap: HashMap<String, usize> = c.scroll.clone();
let beep = std::mem::take(&mut c.beep_pending);
let control_names: Vec<String> = c.inputs.iter().map(|(n, _)| n.clone()).collect();
drop(c);
let st = state.lock().unwrap();
let mut hitmap: Vec<HitTarget> = Vec::new();
let draw = terminal.draw(|f| {
let down_ref = down_snap
.as_ref()
.map(|(l, lab)| (l.as_slice(), lab.as_str()));
render(
f,
spec,
&st,
&filter,
down_ref,
err_ref,
&inputs,
focus_name.as_deref(),
alert_msg.as_deref(),
&flash_snap,
&cmeta,
&mut hitmap,
&control_names,
&tab_sel_snap,
&scroll_snap,
theme,
help_open,
theme_picker,
);
});
drop(st);
if let Err(e) = draw {
break Err(e);
}
controls.lock().unwrap().hitmap = hitmap;
if beep {
use std::io::Write;
let _ = terminal.backend_mut().write_all(b"\x07");
let _ = terminal.backend_mut().flush();
}
thread::sleep(Duration::from_millis(120));
};
let _ = execute!(terminal.backend_mut(), DisableMouseCapture);
disable_raw_mode()?;
if inline.is_some() {
terminal.clear()?;
} else {
execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
}
terminal.show_cursor()?;
outcome
}
#[allow(clippy::too_many_arguments)]
fn render(
f: &mut Frame,
spec: &Spec,
st: &StreamState,
filter: &str,
down: Option<(&[String], &str)>,
err: Option<(&[String], &str)>,
inputs: &HashMap<String, String>,
focus: Option<&str>,
alert: Option<&str>,
flashes: &HashMap<String, String>,
cmeta: &HashMap<String, ControlMeta>,
hitmap: &mut Vec<HitTarget>,
control_names: &[String],
tab_sel: &HashMap<String, usize>,
scroll: &HashMap<String, usize>,
theme: Option<crate::theme::Palette>,
help: bool,
theme_picker: Option<usize>,
) {
let err_h = match err {
Some((lines, _)) => ((lines.len() as u16) + 2).clamp(3, 8),
None => 0,
};
let chunks = Layout::vertical([
Constraint::Min(0),
Constraint::Length(err_h),
Constraint::Length(1),
])
.split(f.area());
let mut area = chunks[0];
let bar = chunks[2];
if let Some((lines, label)) = err {
render_err_pane(f, chunks[1], label, lines);
}
if let Some((dlines, label)) = down {
let cols = Layout::horizontal([Constraint::Percentage(55), Constraint::Percentage(45)])
.split(area);
area = cols[0];
render_output_pane(f, cols[1], label, dlines);
}
let matched = st
.lines
.iter()
.filter(|l| filter_matches(l, filter))
.count();
if let Some(msg) = alert {
f.render_widget(
Paragraph::new(format!(" ⚠ {msg}")).style(
Style::default()
.fg(Color::Yellow)
.add_modifier(Modifier::BOLD),
),
bar,
);
} else {
let hint = if filter.is_empty() {
" type to filter · Ctrl-T theme · Ctrl-G help · Ctrl-C quit".to_string()
} else {
format!(" filter: {filter}▏ {matched}/{} lines", st.lines.len())
};
f.render_widget(Paragraph::new(hint), bar);
}
let raw: Vec<String> = st
.lines
.iter()
.filter(|l| filter_matches(l, filter))
.cloned()
.collect();
if spec.widgets.is_empty() {
let msg = Paragraph::new("arb: spec has no widgets")
.block(Block::default().borders(Borders::ALL).title(" arb "));
f.render_widget(msg, area);
return;
}
let rects = compute_rects(area, spec);
hitmap.clear();
for (i, w) in spec.widgets.iter().enumerate() {
let name = w.path.trim_start_matches('.').to_string();
let meta_index = if w.kind.is_control() {
control_names.iter().position(|n| *n == name)
} else {
None
};
let tabs = if w.kind == WidgetKind::Tabs {
w.opts
.get("tabs")
.map(|s| {
s.split(',')
.filter(|t| !t.is_empty())
.map(str::to_string)
.collect()
})
.unwrap_or_default()
} else {
Vec::new()
};
hitmap.push(HitTarget {
rect: rects[i],
kind: w.kind,
control_name: name,
meta_index,
tabs,
});
}
let elapsed = st.start.elapsed().as_secs_f64();
for (i, w) in spec.widgets.iter().enumerate() {
if w.kind.is_control() {
let name = w.path.trim_start_matches('.');
let val = inputs.get(name).map(String::as_str).unwrap_or("");
let default_meta = ControlMeta {
kind: control_kind(w.kind),
..Default::default()
};
let meta = cmeta.get(name).unwrap_or(&default_meta);
render_control(f, rects[i], w, val, meta, &raw, focus == Some(name), theme);
continue;
}
let result = w.source.as_ref().map(|s| {
let pipeline = crate::spec::resolve_pipeline(&s.pipeline, inputs);
eval(&pipeline, &raw, elapsed)
});
let flash = flashes
.get(w.path.trim_start_matches('.'))
.map(String::as_str);
let tsel = tab_sel
.get(w.path.trim_start_matches('.'))
.copied()
.unwrap_or(0);
let wsc = scroll
.get(w.path.trim_start_matches('.'))
.copied()
.unwrap_or(0);
render_widget(f, rects[i], w, st, &raw, result, flash, tsel, wsc, theme);
}
if help {
draw_help_overlay(f, spec, theme);
}
if let Some(sel) = theme_picker {
draw_theme_picker(f, sel, theme);
}
}
fn draw_help_overlay(f: &mut Frame, spec: &Spec, theme: Option<crate::theme::Palette>) {
let accent = theme_accent(theme);
let mut lines: Vec<Line> = vec![
Line::from(Span::styled(
"arb — keys",
Style::default().fg(accent).add_modifier(Modifier::BOLD),
)),
Line::from(""),
Line::from(" Ctrl-T cycle color theme (saved to ~/.arb)"),
Line::from(" Ctrl-G toggle this help"),
Line::from(" Ctrl-C quit · Esc clear / close"),
Line::from(" ↑ ↓ move a facet/sel/fzf cursor"),
Line::from(" Tab cycle inputs · mark an fzf row"),
Line::from(" wheel scroll back a tail/list/table"),
];
if !spec.binds.is_empty() {
lines.push(Line::from(""));
lines.push(Line::from(Span::styled(
" spec binds:",
Style::default().fg(accent),
)));
for b in &spec.binds {
lines.push(Line::from(format!(" {}", key_label(b.key))));
}
}
let w = 52u16.min(f.area().width.saturating_sub(4));
let h = (lines.len() as u16 + 2).min(f.area().height.saturating_sub(2));
let area = Rect {
x: (f.area().width.saturating_sub(w)) / 2,
y: (f.area().height.saturating_sub(h)) / 2,
width: w,
height: h,
};
f.render_widget(ratatui::widgets::Clear, area);
let block = Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(accent))
.title(" help ");
f.render_widget(Paragraph::new(lines).block(block), area);
}
fn draw_theme_picker(f: &mut Frame, sel: usize, theme: Option<crate::theme::Palette>) {
let accent = theme_accent(theme);
let themes = crate::theme::THEMES;
let area_full = f.area();
let w = 40u16.min(area_full.width.saturating_sub(4));
let h = (themes.len() as u16 + 4).min(area_full.height.saturating_sub(2));
let area = Rect {
x: (area_full.width.saturating_sub(w)) / 2,
y: (area_full.height.saturating_sub(h)) / 2,
width: w,
height: h,
};
f.render_widget(ratatui::widgets::Clear, area);
let block = Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(accent))
.title(" theme (↑↓ preview · Enter save · Esc cancel) ");
let inner_h = area.height.saturating_sub(2) as usize;
let start = sel.saturating_sub(inner_h.saturating_sub(1));
let rows: Vec<Line> = themes
.iter()
.enumerate()
.skip(start)
.take(inner_h)
.map(|(i, (name, pal))| {
let cursor = i == sel;
let mark = if cursor { "▸ " } else { " " };
let name_style = if cursor {
Style::default().fg(accent).add_modifier(Modifier::BOLD)
} else {
Style::default()
};
let mut spans = vec![Span::styled(format!("{mark}{name:<14}"), name_style)];
for &c in pal.iter() {
spans.push(Span::styled(" ", Style::default().bg(Color::Indexed(c))));
}
Line::from(spans)
})
.collect();
f.render_widget(Paragraph::new(rows).block(block), area);
}
fn key_label(key: u8) -> String {
match key {
b if (1..=26).contains(&b) => format!("Ctrl-{}", (b'A' + b - 1) as char),
0x1b => "Esc".into(),
b => format!("0x{b:02x}"),
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MouseKind {
Down,
Up,
Drag,
ScrollUp,
ScrollDown,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MouseEvent {
pub kind: MouseKind,
pub col: u16,
pub row: u16,
pub button: u8,
pub press: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MouseButton {
Left,
Middle,
Right,
Other,
}
pub fn mouse_button(b: u8) -> MouseButton {
match b & 0b11 {
0 => MouseButton::Left,
1 => MouseButton::Middle,
2 => MouseButton::Right,
_ => MouseButton::Other,
}
}
pub fn mouse_shift(b: u8) -> bool {
b & 0x04 != 0
}
pub fn mouse_alt(b: u8) -> bool {
b & 0x08 != 0
}
pub fn mouse_ctrl(b: u8) -> bool {
b & 0x10 != 0
}
#[derive(Debug, Clone)]
pub struct HitTarget {
pub rect: Rect,
pub kind: WidgetKind,
pub control_name: String,
pub meta_index: Option<usize>,
pub tabs: Vec<String>,
}
pub fn parse_sgr_mouse(bytes: &[u8], i: usize) -> Option<(MouseEvent, usize)> {
if bytes.get(i)? != &0x1b || bytes.get(i + 1)? != &b'[' || bytes.get(i + 2)? != &b'<' {
return None;
}
let mut p = i + 3;
let field = |p: &mut usize, want_semi: bool| -> Option<u32> {
let start = *p;
let mut v: u32 = 0;
while let Some(&d) = bytes.get(*p) {
if d.is_ascii_digit() {
v = v.checked_mul(10)?.checked_add((d - b'0') as u32)?;
*p += 1;
} else {
break;
}
}
if *p == start {
return None; }
if want_semi {
if bytes.get(*p)? != &b';' {
return None;
}
*p += 1;
}
Some(v)
};
let b = field(&mut p, true)?;
let x = field(&mut p, true)?;
let y = field(&mut p, false)?;
let press = match bytes.get(p)? {
b'M' => true,
b'm' => false,
_ => return None,
};
p += 1;
let kind = if b & 0x40 != 0 {
if b & 0x01 == 0 {
MouseKind::ScrollUp
} else {
MouseKind::ScrollDown
}
} else if !press {
MouseKind::Up
} else if b & 0x20 != 0 {
MouseKind::Drag
} else {
MouseKind::Down
};
let ev = MouseEvent {
kind,
col: x.saturating_sub(1).min(u16::MAX as u32) as u16,
row: y.saturating_sub(1).min(u16::MAX as u32) as u16,
button: (b & 0xff) as u8,
press,
};
Some((ev, p - i))
}
pub fn hit(h: &[HitTarget], col: u16, row: u16) -> Option<&HitTarget> {
h.iter().rev().find(|t| {
let r = t.rect;
col >= r.x && col < r.x + r.width && row >= r.y && row < r.y + r.height
})
}
pub fn facet_row_to_index(rect_y: u16, row: u16) -> Option<usize> {
if row <= rect_y {
None
} else {
Some((row - rect_y - 1) as usize)
}
}
pub fn fzf_row_to_cursor(list_top: u16, start: usize, row: u16) -> usize {
start + row.saturating_sub(list_top) as usize
}
fn is_scrollable(k: WidgetKind) -> bool {
matches!(
k,
WidgetKind::Tail
| WidgetKind::List
| WidgetKind::Text
| WidgetKind::Table
| WidgetKind::Block
| WidgetKind::Frame
)
}
pub fn scroll_skip(len: usize, cap: usize, scroll: usize) -> usize {
len.saturating_sub(cap).saturating_sub(scroll)
}
const DOUBLE_CLICK: Duration = Duration::from_millis(400);
pub fn is_double_click(last: Option<(Instant, u16, u16)>, now: Instant, row: u16) -> bool {
match last {
Some((t, _c, r)) => r == row && now.saturating_duration_since(t) <= DOUBLE_CLICK,
None => false,
}
}
pub fn tab_index_from_x(labels: &[&str], rect_x: u16, col: u16) -> Option<usize> {
let inner_x = rect_x.saturating_add(1); if col < inner_x {
return None;
}
let mut x = inner_x;
for (i, label) in labels.iter().enumerate() {
let last = i + 1 == labels.len();
let span = label.chars().count() as u16 + if last { 2 } else { 3 };
if col < x.saturating_add(span) {
return Some(i);
}
x = x.saturating_add(span);
}
None
}
pub fn slider_value_from_x(
rect_x: u16,
rect_w: u16,
col: u16,
min: f64,
max: f64,
step: f64,
) -> String {
let inner = (rect_w.saturating_sub(2)).max(1) as f64; let x = col.saturating_sub(rect_x + 1) as f64;
let p = (x / inner).clamp(0.0, 1.0);
let step = if step > 0.0 { step } else { 1.0 };
let raw = min + p * (max - min);
let snapped = (min + ((raw - min) / step).round() * step).clamp(min, max);
crate::query::fmt_scalar(snapped)
}
fn dispatch_mouse(c: &mut Controls, ev: MouseEvent, fzf: bool, now: Instant) {
match ev.kind {
MouseKind::ScrollUp => {
if fzf {
c.cursor = c.cursor.saturating_sub(1);
} else if let Some(name) = hit(&c.hitmap, ev.col, ev.row)
.filter(|t| is_scrollable(t.kind))
.map(|t| t.control_name.clone())
{
*c.scroll.entry(name).or_insert(0) += 1; } else if let Some(m) = c.control_meta.get_mut(c.focus) {
if m.kind == ControlKind::Facet {
m.cursor = m.cursor.saturating_sub(1);
}
}
}
MouseKind::ScrollDown => {
if fzf {
c.cursor = c.cursor.saturating_add(1);
} else if let Some(name) = hit(&c.hitmap, ev.col, ev.row)
.filter(|t| is_scrollable(t.kind))
.map(|t| t.control_name.clone())
{
if let Some(s) = c.scroll.get_mut(&name) {
*s = s.saturating_sub(1); }
} else if let Some(m) = c.control_meta.get_mut(c.focus) {
if m.kind == ControlKind::Facet {
m.cursor = m.cursor.saturating_add(1);
}
}
}
MouseKind::Down | MouseKind::Drag => {
let down = ev.kind == MouseKind::Down;
let button = mouse_button(ev.button);
let dbl = down && is_double_click(c.last_click, now, ev.row);
if down {
c.last_click = Some((now, ev.col, ev.row));
}
if let Some(t) = hit(&c.hitmap, ev.col, ev.row).cloned() {
let mi = t
.meta_index
.or_else(|| c.inputs.iter().position(|(n, _)| *n == t.control_name));
if let Some(mi) = mi {
c.focus = mi; }
if down && button == MouseButton::Right {
if let Some(mi) = mi {
let kind = c
.control_meta
.get(mi)
.map(|m| m.kind)
.unwrap_or(ControlKind::Text);
c.inputs[mi].1 = match kind {
ControlKind::Slider => crate::query::fmt_scalar(c.control_meta[mi].min),
ControlKind::Check => "0".to_string(),
ControlKind::Text | ControlKind::Facet | ControlKind::Sel => {
String::new()
}
};
if kind == ControlKind::Sel {
c.control_meta[mi].cursor = 0;
}
}
} else if button == MouseButton::Left {
match t.kind {
WidgetKind::Check if down => {
if let Some(mi) = mi {
c.inputs[mi].1 = toggle_check(&c.inputs[mi].1);
}
}
WidgetKind::Slider => {
if let Some(mi) = mi {
let m = &c.control_meta[mi];
let (mn, mx, sp) = (m.min, m.max, m.step);
c.inputs[mi].1 =
slider_value_from_x(t.rect.x, t.rect.width, ev.col, mn, mx, sp);
}
}
WidgetKind::Facet if down => {
if let Some(mi) = mi {
if let Some(idx) = facet_row_to_index(t.rect.y, ev.row) {
if let Some(item) = c.control_meta[mi].opts.get(idx).cloned() {
c.inputs[mi].1 = toggle_set_member(&c.inputs[mi].1, &item);
c.control_meta[mi].cursor = idx;
}
}
}
}
WidgetKind::Select if down && ev.row >= t.rect.y => {
c.cursor = fzf_row_to_cursor(t.rect.y, c.fzf_list_start, ev.row);
if dbl {
c.submit = true; }
}
WidgetKind::Sel if down => {
if let Some(mi) = mi {
if let Some(idx) = facet_row_to_index(t.rect.y, ev.row) {
c.control_meta[mi].cursor = idx;
}
}
}
WidgetKind::Tabs if down => {
let labels: Vec<&str> = t.tabs.iter().map(String::as_str).collect();
if let Some(idx) = tab_index_from_x(&labels, t.rect.x, ev.col) {
c.tab_sel.insert(t.control_name.clone(), idx);
}
}
_ => {} }
}
}
if down {
let actions: Vec<BindAction> =
c.mouse_binds.iter().map(|(_, a)| a.clone()).collect();
for a in &actions {
apply_bind_action(c, a);
}
}
}
MouseKind::Up => {}
}
}
pub fn detect_resize(last: &mut (u16, u16), cur: (u16, u16)) -> bool {
let changed = *last != cur;
*last = cur;
changed
}
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub enum ControlKind {
#[default]
Text,
Slider,
Check,
Facet,
Sel,
}
#[derive(Debug, Clone, Default)]
pub struct ControlMeta {
pub kind: ControlKind,
pub min: f64,
pub max: f64,
pub step: f64,
pub opts: Vec<String>,
pub cursor: usize,
}
pub fn control_kind(k: WidgetKind) -> ControlKind {
match k {
WidgetKind::Slider => ControlKind::Slider,
WidgetKind::Check => ControlKind::Check,
WidgetKind::Facet => ControlKind::Facet,
WidgetKind::Sel => ControlKind::Sel,
_ => ControlKind::Text, }
}
fn slider_key(c: &mut Controls, up: bool) {
let f = c.focus;
if let Some(m) = c.control_meta.get(f) {
let (min, max, step) = (m.min, m.max, m.step);
c.inputs[f].1 = slider_adjust(&c.inputs[f].1, min, max, step, up);
}
}
pub fn slider_adjust(cur: &str, min: f64, max: f64, step: f64, up: bool) -> String {
let v = cur.trim().parse::<f64>().unwrap_or(min);
let step = if step > 0.0 { step } else { 1.0 };
let next = if up { v + step } else { v - step }.clamp(min, max);
crate::query::fmt_scalar(next)
}
pub fn toggle_check(cur: &str) -> String {
if cur == "1" {
"0".to_string()
} else {
"1".to_string()
}
}
pub fn toggle_set_member(set: &str, item: &str) -> String {
let mut items: Vec<String> = set
.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.map(String::from)
.collect();
if let Some(pos) = items.iter().position(|x| x == item) {
items.remove(pos);
} else {
items.push(item.to_string());
}
items.join(",")
}
pub fn facet_candidates(w: &Widget, raw: &[String]) -> Vec<String> {
if let Some(opts) = w.opts.get("opts") {
return opts
.split(',')
.filter(|s| !s.is_empty())
.map(String::from)
.collect();
}
let Some(field) = w.opts.get("field") else {
return Vec::new();
};
let mut seen = Vec::new();
for line in raw {
let v = crate::query::field_str_pub(line, field);
if !v.is_empty() && !seen.contains(&v) {
seen.push(v);
if seen.len() >= 32 {
break;
}
}
}
seen
}
fn stream_event_dates(lines: &[String]) -> Vec<time::Date> {
let mut out = Vec::new();
for l in lines {
for tok in l.split(|c: char| !(c.is_ascii_digit() || c == '-')) {
let parts: Vec<&str> = tok.split('-').collect();
if parts.len() != 3 {
continue;
}
let (Ok(y), Ok(m), Ok(d)) = (
parts[0].parse::<i32>(),
parts[1].parse::<u8>(),
parts[2].parse::<u8>(),
) else {
continue;
};
if let Ok(month) = time::Month::try_from(m) {
if let Ok(date) = time::Date::from_calendar_date(y, month, d) {
if !out.contains(&date) {
out.push(date);
}
}
}
}
}
out
}
pub fn sel_candidates(w: &Widget, raw: &[String]) -> Vec<String> {
match &w.source {
Some(s) => match crate::query::eval(&s.pipeline, raw, 0.0) {
crate::query::QueryResult::Lines(ls) => ls,
crate::query::QueryResult::Scalar(v) => vec![crate::query::fmt_scalar(v)],
crate::query::QueryResult::Pairs(p) => {
p.iter().map(|(k, v)| format!("{k}\t{v}")).collect()
}
},
None => raw.to_vec(),
}
}
pub fn update_sel_controls(spec: &Spec, raw: &[String], c: &mut Controls) {
for w in spec.widgets.iter().filter(|w| w.kind == WidgetKind::Sel) {
let key = format!("{}.sel", w.path.trim_start_matches('.'));
let Some(idx) = c.inputs.iter().position(|(n, _)| *n == key) else {
continue;
};
let cands = sel_candidates(w, raw);
let cursor = if cands.is_empty() {
0
} else {
c.control_meta[idx].cursor.min(cands.len() - 1)
};
c.control_meta[idx].cursor = cursor;
c.inputs[idx].1 = cands.get(cursor).cloned().unwrap_or_default();
}
}
fn render_input(f: &mut Frame, area: Rect, w: &Widget, val: &str, focused: bool, accent: Color) {
let label = w
.opts
.get("title")
.or_else(|| w.opts.get("placeholder"))
.map(String::as_str)
.unwrap_or_else(|| w.path.trim_start_matches('.'));
let border = if focused { accent } else { Color::DarkGray };
let block = Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(border))
.title(format!(" {label} "));
let body = if focused {
Line::from(vec![
Span::raw(val.to_string()),
Span::styled("▏", Style::default().fg(accent)),
])
} else if val.is_empty() {
Line::from(Span::styled(
w.opts.get("placeholder").cloned().unwrap_or_default(),
Style::default().fg(Color::DarkGray),
))
} else {
Line::from(Span::raw(val.to_string()))
};
f.render_widget(Paragraph::new(body).block(block), area);
}
#[allow(clippy::too_many_arguments)]
fn render_control(
f: &mut Frame,
area: Rect,
w: &Widget,
val: &str,
meta: &ControlMeta,
raw: &[String],
focused: bool,
theme: Option<crate::theme::Palette>,
) {
let accent = theme_accent(theme);
let label = w
.opts
.get("label")
.or_else(|| w.opts.get("title"))
.map(String::as_str)
.unwrap_or_else(|| w.path.trim_start_matches('.'));
let border = if focused { accent } else { Color::DarkGray };
let block = Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(border))
.title(format!(" {label} "));
match meta.kind {
ControlKind::Text => render_input(f, area, w, val, focused, accent),
ControlKind::Slider => {
let v = val.trim().parse::<f64>().unwrap_or(meta.min);
let span = (meta.max - meta.min).max(f64::MIN_POSITIVE);
let filled = (((v - meta.min) / span) * 20.0).round().clamp(0.0, 20.0) as usize;
let bar: String = "█".repeat(filled) + &"─".repeat(20 - filled);
let body = Line::from(vec![
Span::styled(bar, Style::default().fg(accent)),
Span::raw(format!(" {}", crate::query::fmt_scalar(v))),
]);
f.render_widget(Paragraph::new(body).block(block), area);
}
ControlKind::Check => {
let on = val == "1";
let body = Line::from(Span::styled(
format!("[{}] {label}", if on { "x" } else { " " }),
Style::default().fg(if on { accent } else { Color::Gray }),
));
f.render_widget(Paragraph::new(body).block(block), area);
}
ControlKind::Facet => {
let cands = facet_candidates(w, raw);
let selected: Vec<&str> = val
.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.collect();
let items: Vec<ListItem> = cands
.iter()
.enumerate()
.map(|(i, c)| {
let mark = if selected.contains(&c.as_str()) {
"[x] "
} else {
"[ ] "
};
let style = if focused && i == meta.cursor {
Style::default().fg(accent).add_modifier(Modifier::REVERSED)
} else {
Style::default()
};
ListItem::new(Line::from(Span::styled(format!("{mark}{c}"), style)))
})
.collect();
f.render_widget(List::new(items).block(block), area);
}
ControlKind::Sel => {
let cands = sel_candidates(w, raw);
let inner_h = area.height.saturating_sub(2) as usize;
let skip = meta.cursor.saturating_sub(inner_h.saturating_sub(1));
let items: Vec<ListItem> = cands
.iter()
.enumerate()
.skip(skip)
.take(inner_h)
.map(|(i, row)| {
let cur = i == meta.cursor;
let mark = if cur { "▸ " } else { " " };
let mut style = Style::default();
if cur {
style = style.fg(accent);
if focused {
style = style.add_modifier(Modifier::REVERSED);
} else {
style = style.add_modifier(Modifier::BOLD);
}
}
ListItem::new(Line::from(Span::styled(format!("{mark}{row}"), style)))
})
.collect();
f.render_widget(List::new(items).block(block), area);
}
}
}
pub fn match_positions(line: &str, pat: &str) -> Vec<usize> {
if pat.is_empty() {
return Vec::new();
}
let cased = pat.chars().any(|c| c.is_uppercase());
let norm = |c: char| if cased { c } else { c.to_ascii_lowercase() };
let l: Vec<char> = line.chars().collect();
let mut positions = Vec::new();
let mut li = 0;
for pc in pat.chars() {
let target = norm(pc);
while li < l.len() {
if norm(l[li]) == target {
positions.push(li);
li += 1;
break;
}
li += 1;
}
}
positions
}
fn fzf_line(
line: &str,
filter: &str,
width: usize,
marked: bool,
base: Option<Color>,
accent: Color,
) -> Line<'static> {
let text: String = line.chars().take(width.saturating_sub(2)).collect();
let base_style = base.map(|c| Style::default().fg(c)).unwrap_or_default();
let base_span = |s: String| Span::styled(s, base_style);
let gutter = if marked {
Span::styled(
"+ ",
Style::default()
.fg(Color::Green)
.add_modifier(Modifier::BOLD),
)
} else {
Span::raw(" ")
};
if filter.is_empty() {
return Line::from(vec![gutter, base_span(text)]);
}
let pos: std::collections::HashSet<usize> =
match_positions(&text, filter).into_iter().collect();
let hl = Style::default().fg(accent).add_modifier(Modifier::BOLD);
let mut spans = vec![gutter];
let mut cur = String::new();
let mut cur_hl = false;
for (i, ch) in text.chars().enumerate() {
let h = pos.contains(&i);
if h != cur_hl && !cur.is_empty() {
let s = std::mem::take(&mut cur);
spans.push(if cur_hl {
Span::styled(s, hl)
} else {
base_span(s)
});
}
cur_hl = h;
cur.push(ch);
}
if !cur.is_empty() {
spans.push(if cur_hl {
Span::styled(cur, hl)
} else {
base_span(cur)
});
}
Line::from(spans)
}
fn render_err_pane(f: &mut Frame, area: Rect, label: &str, lines: &[String]) {
let block = Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(Color::Red))
.title(format!(" \u{26a0} {label} "));
let inner_h = area.height.saturating_sub(2) as usize;
let skip = lines.len().saturating_sub(inner_h);
let items: Vec<ListItem> = lines
.iter()
.skip(skip)
.map(|l| ListItem::new(ansi_line(l)))
.collect();
f.render_widget(List::new(items).block(block), area);
}
#[allow(clippy::too_many_arguments)]
pub fn project_line(proj: &[QueryOp], raw: &str) -> Vec<String> {
if proj.is_empty() {
return vec![raw.to_string()];
}
let one = [raw.to_string()];
match eval(proj, &one, 0.0) {
QueryResult::Lines(ls) => ls,
QueryResult::Scalar(v) => vec![format!("{v}")],
QueryResult::Pairs(p) => p.into_iter().map(|(k, v)| format!("{k}\t{v}")).collect(),
}
}
#[allow(clippy::too_many_arguments)]
fn render_fzf(
f: &mut Frame,
matched: &[(Arc<str>, Arc<str>)],
filter: &str,
sel: usize,
marks: &[String],
total: u64,
err: Option<(&[String], &str)>,
preview: Option<(&[String], &str)>,
prompt: &str,
header: &str,
theme: Option<crate::theme::Palette>,
hitmap: &mut Vec<HitTarget>,
) -> usize {
let (top, err_area) = match err {
Some((lines, _)) => {
let h = ((lines.len() as u16) + 2).clamp(3, 10);
let rows =
Layout::vertical([Constraint::Min(0), Constraint::Length(h)]).split(f.area());
(rows[0], Some(rows[1]))
}
None => (f.area(), None),
};
if let (Some(ea), Some((lines, label))) = (err_area, err) {
render_err_pane(f, ea, label, lines);
}
let (main_top, prev_area) = match preview {
Some(_) => {
let cols = Layout::horizontal([Constraint::Percentage(50), Constraint::Percentage(50)])
.split(top);
(cols[0], Some(cols[1]))
}
None => (top, None),
};
if let (Some(pa), Some((lines, label))) = (prev_area, preview) {
render_output_pane(f, pa, label, lines);
}
let header_h: u16 = if header.is_empty() { 0 } else { 1 };
let chunks = Layout::vertical([
Constraint::Length(1),
Constraint::Length(header_h),
Constraint::Min(0),
])
.split(main_top);
let marked = if marks.is_empty() {
String::new()
} else {
format!(" ({})", marks.len())
};
let accent = theme_accent(theme);
let base = theme.map(|p| p.primary()); let dim = theme.map(|p| p.dim()).unwrap_or(Color::DarkGray);
let bar_bg = theme.map(|p| p.bg()).unwrap_or(Color::Rgb(38, 38, 46));
let query_style = base.map(|c| Style::default().fg(c)).unwrap_or_default();
let acc = Style::default().fg(accent);
let prompt_line = Line::from(vec![
Span::styled(prompt.to_string(), acc.add_modifier(Modifier::BOLD)),
Span::styled(format!("{filter}\u{258f}"), query_style),
Span::styled(
format!(" {}/{total}{marked}", matched.len()),
Style::default().fg(dim),
),
Span::styled(
" Enter select · Tab mark · \u{2191}\u{2193} move · Ctrl-T theme · Ctrl-C abort",
Style::default().fg(dim),
),
]);
f.render_widget(Paragraph::new(prompt_line), chunks[0]);
if !header.is_empty() {
f.render_widget(
Paragraph::new(header).style(Style::default().fg(dim)),
chunks[1],
);
}
let inner_w = chunks[2].width as usize;
let list_h = chunks[2].height as usize;
let n = matched.len();
let sel = sel.min(n.saturating_sub(1));
let start = if list_h > 0 && sel >= list_h {
sel + 1 - list_h
} else {
0
};
let end = (start + list_h.max(1)).min(n);
let mark_set: std::collections::HashSet<&str> = marks.iter().map(String::as_str).collect();
let items: Vec<ListItem> = matched[start..end]
.iter()
.map(|(disp, orig)| {
ListItem::new(fzf_line(
disp,
filter,
inner_w,
mark_set.contains(orig.as_ref()),
base,
accent,
))
})
.collect();
let mut state = ListState::default();
if n > 0 {
state.select(Some(sel - start));
}
let list = List::new(items)
.highlight_symbol("\u{25b6} ")
.highlight_style(
Style::default()
.fg(accent)
.bg(bar_bg)
.add_modifier(Modifier::BOLD),
);
f.render_stateful_widget(list, chunks[2], &mut state);
hitmap.clear();
hitmap.push(HitTarget {
rect: chunks[2],
kind: WidgetKind::Select,
control_name: String::new(),
meta_index: None,
tabs: Vec::new(),
});
start
}
fn render_output_pane(f: &mut Frame, area: Rect, label: &str, lines: &[String]) {
let title = format!(" -- {label} · {} ln ", lines.len());
let block = Block::default().borders(Borders::ALL).title(title);
let inner_h = area.height.saturating_sub(2) as usize;
let skip = lines.len().saturating_sub(inner_h);
let items: Vec<ListItem> = lines
.iter()
.skip(skip)
.map(|l| ListItem::new(ansi_line(l)))
.collect();
f.render_widget(List::new(items).block(block), area);
}
fn track_to_constraint(t: crate::spec::Track) -> Constraint {
use crate::spec::Track;
match t {
Track::Length(n) => Constraint::Length(n),
Track::Percentage(n) => Constraint::Percentage(n),
Track::Fill(w) => Constraint::Fill(w),
}
}
fn track_cons(tracks: Option<&Vec<crate::spec::Track>>, n: usize) -> Vec<Constraint> {
(0..n)
.map(|i| {
tracks
.and_then(|t| t.get(i))
.map(|&t| track_to_constraint(t))
.unwrap_or(Constraint::Fill(1))
})
.collect()
}
pub fn compute_rects(area: Rect, spec: &Spec) -> Vec<Rect> {
use crate::spec::Flow;
let ws = &spec.widgets;
let grid_mode = ws.iter().any(|w| w.grid.is_some());
if !grid_mode {
let n = ws.len().max(1);
let lay = match spec.flow {
Flow::Vertical => Layout::vertical(track_cons(spec.row_tracks.as_ref(), n)),
Flow::Horizontal => Layout::horizontal(track_cons(spec.col_tracks.as_ref(), n)),
};
return lay.spacing(spec.gap).split(area).to_vec();
}
let cells: Vec<(usize, usize, usize, usize)> = ws
.iter()
.map(|w| {
let (r, c) = w.grid.unwrap_or((0, 0));
let (rs, cs) = w.span;
(r, c, rs.max(1), cs.max(1))
})
.collect();
let rows = cells
.iter()
.map(|(r, _, rs, _)| r + rs)
.max()
.unwrap_or(1)
.max(1)
.max(spec.row_tracks.as_ref().map_or(0, |t| t.len()));
let cols = cells
.iter()
.map(|(_, c, _, cs)| c + cs)
.max()
.unwrap_or(1)
.max(1)
.max(spec.col_tracks.as_ref().map_or(0, |t| t.len()));
let row_chunks = Layout::vertical(track_cons(spec.row_tracks.as_ref(), rows))
.spacing(spec.gap)
.split(area);
let col_cons = track_cons(spec.col_tracks.as_ref(), cols);
cells
.iter()
.map(|&(r, c, rs, cs)| {
let top = row_chunks[r.min(rows - 1)];
let bottom = row_chunks[(r + rs - 1).min(rows - 1)];
let y = top.y;
let height = bottom.y + bottom.height - top.y;
let band = Rect {
x: area.x,
y,
width: area.width,
height,
};
let col_chunks = Layout::horizontal(col_cons.clone())
.spacing(spec.gap)
.split(band);
let left = col_chunks[c.min(cols - 1)];
let right = col_chunks[(c + cs - 1).min(cols - 1)];
Rect {
x: left.x,
y,
width: right.x + right.width - left.x,
height,
}
})
.collect()
}
pub fn widget_limit(w: &Widget) -> Option<usize> {
w.opts
.get("limit")
.or_else(|| w.opts.get("lines"))
.and_then(|s| s.parse::<usize>().ok())
}
fn hex_color(hex: &str) -> Color {
let h = hex.trim_start_matches('#');
if h.len() == 6 {
if let (Ok(r), Ok(g), Ok(b)) = (
u8::from_str_radix(&h[0..2], 16),
u8::from_str_radix(&h[2..4], 16),
u8::from_str_radix(&h[4..6], 16),
) {
return Color::Rgb(r, g, b);
}
}
Color::Cyan
}
fn resolve_accent(name: Option<&str>, theme: Option<crate::theme::Palette>) -> Color {
if let Some(n) = name {
let nl = n.trim().to_ascii_lowercase();
if let Some(p) = theme {
if let Some(col) = p.slot(&nl) {
return col;
}
}
if crate::spec::is_named_color(&nl) {
return hex_color(crate::spec::color_hex(Some(&nl)));
}
}
match theme {
Some(p) => p.accent(),
None => hex_color(crate::spec::color_hex(None)),
}
}
fn theme_accent(theme: Option<crate::theme::Palette>) -> Color {
theme.map(|p| p.accent()).unwrap_or(Color::Cyan)
}
fn set_live_theme(c: &mut Controls, idx: usize) {
let n = crate::theme::THEMES.len();
c.theme_idx = idx % n;
c.theme = Some(crate::theme::Palette {
c: crate::theme::THEMES[c.theme_idx].1,
});
}
fn open_theme_picker(c: &mut Controls) {
c.theme_picker_open = true;
c.theme_picker_sel = c.theme_idx;
c.theme_picker_revert = c.theme_idx;
}
fn theme_picker_move(c: &mut Controls, delta: isize) {
let n = crate::theme::THEMES.len() as isize;
c.theme_picker_sel = (((c.theme_picker_sel as isize + delta) % n + n) % n) as usize;
set_live_theme(c, c.theme_picker_sel);
}
fn theme_picker_accept(c: &mut Controls) {
set_live_theme(c, c.theme_picker_sel);
let name = crate::theme::THEMES[c.theme_idx].0;
let _ = crate::theme::set_config_default(name);
c.alert = Some((
format!("theme: {name}"),
Instant::now() + Duration::from_secs(2),
));
c.theme_picker_open = false;
}
fn theme_picker_cancel(c: &mut Controls) {
set_live_theme(c, c.theme_picker_revert);
c.theme_picker_open = false;
}
fn default_slot_for_kind(kind: WidgetKind, p: crate::theme::Palette) -> Color {
use WidgetKind::*;
match kind {
Gauge | LineGauge => p.accent(),
Bars | Histo => p.alt(),
Spark | Sparkline | Scatter | Chart | Map => p.mid(),
Calendar => p.mid(),
Text | Tail | List | Table | Tabs | Block | Frame => p.primary(),
_ => p.accent(),
}
}
#[allow(clippy::too_many_arguments)]
fn render_widget(
f: &mut Frame,
area: Rect,
w: &Widget,
st: &StreamState,
lines: &[String],
result: Option<QueryResult>,
flash: Option<&str>,
tab_sel: usize,
scroll: usize,
theme: Option<crate::theme::Palette>,
) {
let name = w
.opts
.get("label")
.or_else(|| w.opts.get("title"))
.map(String::as_str)
.unwrap_or(&w.path);
let title = format!(
" {} · {} · {} ln {:.0}/s ",
name,
w.kind.label(),
st.total,
st.rate()
);
let color_name = flash.or_else(|| w.opts.get("color").map(String::as_str));
let accent = match color_name {
Some(_) => resolve_accent(color_name, theme),
None => match theme {
Some(p) => default_slot_for_kind(w.kind, p),
None => resolve_accent(None, None),
},
};
let block = Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(accent))
.title(title);
let inner_w = (area.width as usize).saturating_sub(2);
match w.kind {
WidgetKind::Text => {
let s = match &result {
Some(QueryResult::Scalar(v)) => format!("{v:.2}"),
Some(QueryResult::Lines(ls)) => ls.last().cloned().unwrap_or_default(),
Some(QueryResult::Pairs(p)) => p
.first()
.map(|(k, v)| format!("{k} ({v})"))
.unwrap_or_default(),
None => lines.last().cloned().unwrap_or_default(),
};
f.render_widget(Paragraph::new(clip(&s, inner_w)).block(block), area);
}
WidgetKind::Tail | WidgetKind::List => {
let owned: Vec<String> = match &result {
Some(QueryResult::Lines(ls)) => ls.clone(),
Some(QueryResult::Scalar(v)) => vec![format!("{v}")],
Some(QueryResult::Pairs(p)) => p.iter().map(|(k, v)| format!("{k} {v}")).collect(),
None => lines.to_vec(),
};
let inner_h = area.height.saturating_sub(2) as usize;
let cap = widget_limit(w).map_or(inner_h, |n| inner_h.min(n));
let skip = scroll_skip(owned.len(), cap, scroll);
let items: Vec<ListItem> = owned
.iter()
.skip(skip)
.take(cap)
.map(|l| ListItem::new(ansi_line(l)))
.collect();
f.render_widget(List::new(items).block(block), area);
render_scrollbar(f, area, owned.len(), cap, skip, accent);
}
WidgetKind::Gauge => {
let val = match &result {
Some(QueryResult::Scalar(v)) => *v,
_ => 0.0,
};
let max = w
.opts
.get("max")
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(100.0);
let ratio = if max > 0.0 {
(val / max).clamp(0.0, 1.0)
} else {
0.0
};
let g = Gauge::default()
.block(block)
.gauge_style(Style::default().fg(accent))
.ratio(ratio)
.label(format!("{val:.0}/{max:.0}"));
f.render_widget(g, area);
}
WidgetKind::LineGauge => {
let val = match &result {
Some(QueryResult::Scalar(v)) => *v,
_ => 0.0,
};
let max = w
.opts
.get("max")
.and_then(|s| s.parse::<f64>().ok())
.unwrap_or(100.0);
let ratio = if max > 0.0 {
(val / max).clamp(0.0, 1.0)
} else {
0.0
};
let g = LineGauge::default()
.block(block)
.filled_style(Style::default().fg(accent))
.line_set(symbols::line::THICK)
.ratio(ratio)
.label(format!("{val:.0}/{max:.0}"));
f.render_widget(g, area);
}
WidgetKind::Bars | WidgetKind::Histo => {
let pairs: Vec<(String, u64)> = match &result {
Some(QueryResult::Pairs(p)) => p.clone(),
_ => Vec::new(),
};
let top = w
.opts
.get("top")
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(20);
let shown: Vec<(&str, u64)> = pairs
.iter()
.take(top)
.map(|(k, v)| (k.as_str(), *v))
.collect();
let n = shown.len().max(1);
let inner_w = area.width.saturating_sub(2) as usize;
let bw = ((inner_w / n).saturating_sub(1)).clamp(1, 12) as u16;
let chart = BarChart::default()
.block(block)
.bar_style(Style::default().fg(accent))
.bar_width(bw)
.bar_gap(1)
.data(&shown[..]);
f.render_widget(chart, area);
}
WidgetKind::Chart => {
let series: Vec<f64> = match &result {
Some(QueryResult::Pairs(p)) => p.iter().map(|(_, v)| *v as f64).collect(),
Some(QueryResult::Lines(ls)) => crate::query::numeric_series(ls),
Some(QueryResult::Scalar(v)) => vec![*v],
None => crate::query::numeric_series(lines),
};
let points: Vec<(f64, f64)> = series
.iter()
.enumerate()
.map(|(i, v)| (i as f64, *v))
.collect();
let min = series.iter().cloned().fold(f64::INFINITY, f64::min);
let max = series.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
let (lo, hi) = if !min.is_finite() || min == max {
(min.min(0.0), max.max(min + 1.0))
} else {
(min, max)
};
let xmax = (series.len().saturating_sub(1)).max(1) as f64;
let datasets = vec![Dataset::default()
.marker(symbols::Marker::Braille)
.graph_type(GraphType::Line)
.style(Style::default().fg(accent))
.data(&points)];
let chart = Chart::new(datasets)
.block(block)
.x_axis(Axis::default().bounds([0.0, xmax]))
.y_axis(Axis::default().bounds([lo, hi]));
f.render_widget(chart, area);
}
WidgetKind::Scatter => {
let series: Vec<f64> = match &result {
Some(QueryResult::Pairs(p)) => p.iter().map(|(_, v)| *v as f64).collect(),
Some(QueryResult::Lines(ls)) => crate::query::numeric_series(ls),
Some(QueryResult::Scalar(v)) => vec![*v],
None => crate::query::numeric_series(lines),
};
let coords: Vec<(f64, f64)> = series
.iter()
.enumerate()
.map(|(i, v)| (i as f64, *v))
.collect();
let min = series.iter().cloned().fold(f64::INFINITY, f64::min);
let max = series.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
let (lo, hi) = if !min.is_finite() || min == max {
(min.min(0.0), max.max(min + 1.0))
} else {
(min, max)
};
let xmax = (series.len().saturating_sub(1)).max(1) as f64;
let canvas = Canvas::default()
.block(block)
.marker(symbols::Marker::Braille)
.x_bounds([0.0, xmax])
.y_bounds([lo, hi])
.paint(move |ctx| {
ctx.draw(&Points {
coords: &coords,
color: accent,
});
});
f.render_widget(canvas, area);
}
WidgetKind::Sparkline => {
let series: Vec<f64> = match &result {
Some(QueryResult::Pairs(p)) => p.iter().map(|(_, v)| *v as f64).collect(),
Some(QueryResult::Lines(ls)) => crate::query::numeric_series(ls),
Some(QueryResult::Scalar(v)) => vec![*v],
None => crate::query::numeric_series(lines),
};
let cap = inner_w.max(1);
let start = series.len().saturating_sub(cap);
let data: Vec<u64> = series[start..]
.iter()
.map(|v| {
if v.is_finite() && *v > 0.0 {
*v as u64
} else {
0
}
})
.collect();
let sp = Sparkline::default()
.block(block)
.style(Style::default().fg(accent))
.data(&data);
f.render_widget(sp, area);
}
WidgetKind::Map => {
let res = match w.opts.get("res").map(String::as_str) {
Some("low") => MapResolution::Low,
_ => MapResolution::High,
};
let pts: Vec<(f64, f64)> = lines
.iter()
.filter_map(|l| {
let mut it = l.split_whitespace();
let lon = it.next()?.parse::<f64>().ok()?;
let lat = it.next()?.parse::<f64>().ok()?;
(lon.abs() <= 180.0 && lat.abs() <= 90.0).then_some((lon, lat))
})
.collect();
let canvas = Canvas::default()
.block(block)
.marker(symbols::Marker::Braille)
.x_bounds([-180.0, 180.0])
.y_bounds([-90.0, 90.0])
.paint(move |ctx| {
ctx.draw(&Map {
resolution: res,
color: Color::DarkGray,
});
ctx.layer();
ctx.draw(&Points {
coords: &pts,
color: accent,
});
});
f.render_widget(canvas, area);
}
WidgetKind::Calendar => {
let today = time::OffsetDateTime::now_utc().date();
let mut events = CalendarEventStore::default();
events.add(today, Style::default().fg(Color::Black).bg(accent));
for d in stream_event_dates(lines) {
if d != today {
events.add(d, Style::default().fg(accent).add_modifier(Modifier::BOLD));
}
}
let cal = Monthly::new(today, events)
.block(block)
.show_month_header(Style::default().fg(accent))
.show_weekdays_header(Style::default().fg(Color::DarkGray));
f.render_widget(cal, area);
}
WidgetKind::LogView => {
let owned = result_lines(&result, lines);
let inner_h = area.height.saturating_sub(2) as usize;
let cap = widget_limit(w).map_or(inner_h, |n| inner_h.min(n));
let skip = scroll_skip(owned.len(), cap, scroll);
let items: Vec<ListItem> = owned
.iter()
.skip(skip)
.take(cap)
.map(|l| {
ListItem::new(Line::from(Span::styled(
clip(l, inner_w),
log_level_style(l, theme),
)))
})
.collect();
f.render_widget(List::new(items).block(block), area);
render_scrollbar(f, area, owned.len(), cap, skip, accent);
}
WidgetKind::Diff => {
let owned = result_lines(&result, lines);
let inner_h = area.height.saturating_sub(2) as usize;
let skip = scroll_skip(owned.len(), inner_h, scroll);
let items: Vec<ListItem> = owned
.iter()
.skip(skip)
.take(inner_h)
.map(|l| {
let style = match l.chars().next() {
Some('+') => Style::default().fg(Color::Green),
Some('-') => Style::default().fg(Color::Red),
Some('@') => Style::default().fg(accent).add_modifier(Modifier::BOLD),
_ => Style::default().fg(Color::DarkGray),
};
ListItem::new(Line::from(Span::styled(clip(l, inner_w), style)))
})
.collect();
f.render_widget(List::new(items).block(block), area);
render_scrollbar(f, area, owned.len(), inner_h, skip, accent);
}
WidgetKind::Heatmap => {
let series: Vec<f64> = match &result {
Some(QueryResult::Pairs(p)) => p.iter().map(|(_, v)| *v as f64).collect(),
Some(QueryResult::Lines(ls)) => crate::query::numeric_series(ls),
Some(QueryResult::Scalar(v)) => vec![*v],
None => crate::query::numeric_series(lines),
};
let (min, max) = series
.iter()
.fold((f64::INFINITY, f64::NEG_INFINITY), |(a, b), &v| {
(a.min(v), b.max(v))
});
let span = (max - min).max(f64::MIN_POSITIVE);
let cols = (inner_w / 2).max(1);
let rows: Vec<Line> = series
.chunks(cols)
.map(|chunk| {
Line::from(
chunk
.iter()
.map(|&v| {
let t = if min.is_finite() {
(v - min) / span
} else {
0.0
};
Span::styled(" ", Style::default().bg(heat_color(t, theme)))
})
.collect::<Vec<_>>(),
)
})
.collect();
f.render_widget(Paragraph::new(rows).block(block), area);
}
WidgetKind::Treemap => {
let pairs: Vec<(String, u64)> = match &result {
Some(QueryResult::Pairs(p)) => p.clone(),
_ => Vec::new(),
};
f.render_widget(block, area);
let inner = Rect {
x: area.x + 1,
y: area.y + 1,
width: area.width.saturating_sub(2),
height: area.height.saturating_sub(2),
};
for (i, (rect, (label, val))) in treemap_rects(inner, &pairs)
.into_iter()
.zip(pairs.iter())
.enumerate()
{
let col = slot_by_index(i, theme, accent);
let body = format!("{label} {val}");
f.render_widget(
Paragraph::new(clip(&body, rect.width.saturating_sub(1) as usize))
.style(Style::default().bg(col).fg(Color::Black)),
rect,
);
}
}
WidgetKind::Gantt => {
let owned = result_lines(&result, lines);
let bars: Vec<(String, f64, f64)> = owned
.iter()
.filter_map(|l| {
let mut it = l.split_whitespace();
let label = it.next()?.to_string();
let s = it.next()?.parse::<f64>().ok()?;
let e = it.next()?.parse::<f64>().ok()?;
Some((label, s, e.max(s)))
})
.collect();
let lo = bars
.iter()
.map(|(_, s, _)| *s)
.fold(f64::INFINITY, f64::min);
let hi = bars
.iter()
.map(|(_, _, e)| *e)
.fold(f64::NEG_INFINITY, f64::max);
let span = (hi - lo).max(f64::MIN_POSITIVE);
let label_w = 12usize.min(inner_w / 2);
let track = inner_w.saturating_sub(label_w + 1);
let inner_h = area.height.saturating_sub(2) as usize;
let rows: Vec<Line> = bars
.iter()
.take(inner_h)
.enumerate()
.map(|(i, (label, s, e))| {
let off = if lo.is_finite() {
(((s - lo) / span) * track as f64) as usize
} else {
0
};
let len = ((((e - s) / span) * track as f64) as usize).max(1);
let bar = " ".repeat(off) + &"█".repeat(len.min(track.saturating_sub(off)));
Line::from(vec![
Span::styled(
format!("{:<label_w$} ", clip(label, label_w)),
Style::default().fg(Color::Gray),
),
Span::styled(bar, Style::default().fg(slot_by_index(i, theme, accent))),
])
})
.collect();
f.render_widget(Paragraph::new(rows).block(block), area);
}
WidgetKind::Logo => {
f.render_widget(block, area);
let logo_area = Rect {
x: area.x + 1,
y: area.y + area.height / 2,
width: area.width.saturating_sub(2),
height: 1,
};
f.render_widget(RatatuiLogo::default(), logo_area);
}
WidgetKind::Blank => {
f.render_widget(Clear, area);
}
WidgetKind::Rule => {
let vertical = w.opts.get("dir").map(String::as_str) == Some("vertical");
let body = if vertical {
"│\n".repeat(area.height as usize)
} else {
"─".repeat(area.width as usize)
};
f.render_widget(
Paragraph::new(body).style(Style::default().fg(accent)),
area,
);
}
WidgetKind::Spark => {
let series: Vec<f64> = match &result {
Some(QueryResult::Pairs(p)) => p.iter().map(|(_, v)| *v as f64).collect(),
Some(QueryResult::Lines(ls)) => crate::query::numeric_series(ls),
Some(QueryResult::Scalar(v)) => vec![*v],
None => crate::query::numeric_series(lines),
};
let cap = (area.width as usize).saturating_sub(2).max(1);
let start = series.len().saturating_sub(cap);
let spark = crate::query::sparkline(&series[start..]);
f.render_widget(
Paragraph::new(spark)
.style(Style::default().fg(accent))
.block(block),
area,
);
}
WidgetKind::Table => {
let src_lines: Vec<String> = match &result {
Some(QueryResult::Lines(ls)) => ls.clone(),
Some(QueryResult::Pairs(p)) => p.iter().map(|(k, v)| format!("{k} {v}")).collect(),
_ => lines.to_vec(),
};
let (headers, rows) =
crate::query::table_data(&src_lines, w.opts.get("cols").map(String::as_str));
let ncols = crate::query::table_ncols(&headers, &rows);
let widths: Vec<Constraint> = (0..ncols)
.map(|_| Constraint::Ratio(1, ncols as u32))
.collect();
let reserve = if headers.is_empty() { 2 } else { 3 };
let inner_h = area.height.saturating_sub(reserve) as usize;
let skip = scroll_skip(rows.len(), inner_h, scroll);
let body: Vec<Row> = rows
.iter()
.skip(skip)
.take(inner_h)
.map(|r| {
Row::new(
(0..ncols)
.map(|i| Cell::from(r.get(i).cloned().unwrap_or_default()))
.collect::<Vec<_>>(),
)
})
.collect();
let mut table = Table::new(body, widths).block(block);
if !headers.is_empty() {
table = table.header(
Row::new(
headers
.iter()
.map(|h| Cell::from(h.clone()))
.collect::<Vec<_>>(),
)
.style(Style::default().fg(accent).add_modifier(Modifier::BOLD)),
);
}
f.render_widget(table, area);
}
WidgetKind::Tabs => {
let titles: Vec<Line> = w
.opts
.get("tabs")
.map(|s| {
s.split(',')
.filter(|t| !t.is_empty())
.map(|t| Line::from(t.to_string()))
.collect()
})
.unwrap_or_default();
let sel = tab_sel.min(titles.len().saturating_sub(1));
let tabs = Tabs::new(titles)
.block(block)
.style(Style::default().fg(accent))
.highlight_style(
Style::default()
.fg(accent)
.add_modifier(Modifier::BOLD | Modifier::REVERSED),
)
.select(sel);
f.render_widget(tabs, area);
}
_ => {
let owned: Vec<String> = match &result {
Some(QueryResult::Lines(ls)) => ls.clone(),
Some(QueryResult::Scalar(v)) => vec![format!("{v}")],
Some(QueryResult::Pairs(p)) => p.iter().map(|(k, v)| format!("{k} {v}")).collect(),
None => lines.to_vec(),
};
let inner_h = area.height.saturating_sub(2) as usize;
let skip = scroll_skip(owned.len(), inner_h, scroll);
let items: Vec<ListItem> = owned
.iter()
.skip(skip)
.take(inner_h)
.map(|l| ListItem::new(ansi_line(l)))
.collect();
f.render_widget(List::new(items).block(block), area);
render_scrollbar(f, area, owned.len(), inner_h, skip, accent);
}
}
}
fn render_scrollbar(
f: &mut Frame,
area: Rect,
content: usize,
visible: usize,
pos: usize,
accent: Color,
) {
if content <= visible || area.height < 3 {
return;
}
let mut state = ScrollbarState::new(content.saturating_sub(visible)).position(pos);
let bar = Scrollbar::new(ScrollbarOrientation::VerticalRight)
.begin_symbol(None)
.end_symbol(None)
.thumb_style(Style::default().fg(accent))
.track_style(Style::default().fg(Color::DarkGray));
f.render_stateful_widget(bar, area, &mut state);
}
fn result_lines(result: &Option<QueryResult>, lines: &[String]) -> Vec<String> {
match result {
Some(QueryResult::Lines(ls)) => ls.clone(),
Some(QueryResult::Scalar(v)) => vec![crate::query::fmt_scalar(*v)],
Some(QueryResult::Pairs(p)) => p.iter().map(|(k, v)| format!("{k} {v}")).collect(),
None => lines.to_vec(),
}
}
fn log_level_style(line: &str, theme: Option<crate::theme::Palette>) -> Style {
let u = line.to_ascii_uppercase();
let has = |p: &str| u.contains(p);
if has("ERROR") || has("FATAL") || has("CRIT") || has("PANIC") || has("[E]") {
Style::default().fg(Color::Red).add_modifier(Modifier::BOLD)
} else if has("WARN") {
Style::default().fg(Color::Yellow)
} else if has("DEBUG") || has("TRACE") {
Style::default().fg(theme.map(|p| p.dim()).unwrap_or(Color::DarkGray))
} else if has("INFO") {
Style::default().fg(theme.map(|p| p.accent()).unwrap_or(Color::Cyan))
} else {
theme
.map(|p| Style::default().fg(p.primary()))
.unwrap_or_default()
}
}
fn heat_color(t: f64, theme: Option<crate::theme::Palette>) -> Color {
let idx = ((t.clamp(0.0, 1.0) * 4.0).round() as usize).min(4);
let ramp: [u8; 5] = match theme {
Some(p) => [p.c[5], p.c[4], p.c[3], p.c[2], p.c[1]], None => [17, 39, 46, 226, 196],
};
Color::Indexed(ramp[idx])
}
fn slot_by_index(i: usize, theme: Option<crate::theme::Palette>, accent: Color) -> Color {
match theme {
Some(p) => [p.accent(), p.alt(), p.mid(), p.primary(), p.dim()][i % 5],
None => accent,
}
}
fn treemap_rects(area: Rect, pairs: &[(String, u64)]) -> Vec<Rect> {
let total: u64 = pairs.iter().map(|(_, v)| *v).sum();
if total == 0 || pairs.is_empty() || area.width == 0 || area.height == 0 {
return pairs.iter().map(|_| area).collect();
}
let mut out = Vec::with_capacity(pairs.len());
let mut rem = area;
let mut rem_total = total;
for (idx, (_, v)) in pairs.iter().enumerate() {
if idx + 1 == pairs.len() {
out.push(rem);
break;
}
let frac = *v as f64 / rem_total.max(1) as f64;
if rem.width >= rem.height {
let cw = ((rem.width as f64 * frac).round() as u16).clamp(1, rem.width);
out.push(Rect { width: cw, ..rem });
rem = Rect {
x: rem.x + cw,
width: rem.width - cw,
..rem
};
} else {
let ch = ((rem.height as f64 * frac).round() as u16).clamp(1, rem.height);
out.push(Rect { height: ch, ..rem });
rem = Rect {
y: rem.y + ch,
height: rem.height - ch,
..rem
};
}
rem_total = rem_total.saturating_sub(*v);
}
out
}
#[cfg(test)]
mod tests {
use super::compute_rects;
use crate::parser::parse;
use crate::spec::build;
use ratatui::layout::Rect;
#[test]
fn grid_span_widget_covers_multiple_cells() {
let spec = build(
&parse(
"chart .main\ngauge .a\ngauge .b\n\
grid .main -row 0 -col 0 -span 2\ngrid .a -row 1 -col 0\ngrid .b -row 1 -col 1",
)
.unwrap(),
)
.unwrap();
let rects = compute_rects(
Rect {
x: 0,
y: 0,
width: 100,
height: 100,
},
&spec,
);
assert_eq!(rects.len(), 3);
assert_eq!(
(rects[0].x, rects[0].y, rects[0].width, rects[0].height),
(0, 0, 100, 50)
);
assert_eq!((rects[1].x, rects[1].y, rects[1].width), (0, 50, 50));
assert_eq!((rects[2].x, rects[2].y, rects[2].width), (50, 50, 50));
}
#[test]
fn exact_score_is_substring_smartcase() {
use super::exact_score;
assert!(exact_score("hello world", "world").is_some());
assert!(exact_score("abc", "xyz").is_none());
assert!(exact_score("axbxc", "abc").is_none()); assert!(exact_score("Hello", "hello").is_some());
assert!(exact_score("hello", "Hello").is_none());
assert!(exact_score("xa", "a") < exact_score("a", "a"));
}
#[test]
fn no_grid_auto_stacks_vertically() {
let spec = build(&parse("gauge .a\ngauge .b").unwrap()).unwrap();
let rects = compute_rects(
Rect {
x: 0,
y: 0,
width: 80,
height: 40,
},
&spec,
);
assert_eq!(rects.len(), 2);
assert_eq!(rects[0].height, 20);
assert_eq!(rects[1].y, 20);
}
fn rects_of(src: &str, w: u16, h: u16) -> Vec<Rect> {
let spec = build(&parse(src).unwrap()).unwrap();
compute_rects(
Rect {
x: 0,
y: 0,
width: w,
height: h,
},
&spec,
)
}
#[test]
fn parse_tracks_lengths_percents_weights() {
use crate::spec::{parse_tracks, Track};
assert_eq!(
parse_tracks("20c * 2* 30%").unwrap(),
vec![
Track::Length(20),
Track::Fill(1),
Track::Fill(2),
Track::Percentage(30)
]
);
assert!(parse_tracks("").is_err());
assert!(parse_tracks("bogus").is_err());
}
#[test]
fn cols_weighted_split_proportionally() {
let r = rects_of(
"gauge .a\ngauge .b\ngrid .a -row 0 -col 0\ngrid .b -row 0 -col 1\ncols \"1* 2*\"",
90,
20,
);
assert_eq!(r[0].width, 30);
assert_eq!(r[1].width, 60);
assert_eq!(r[1].x, 30);
}
#[test]
fn bare_integers_are_weights() {
let r = rects_of(
"gauge .a\ngauge .b\ngauge .c\ngrid .a -row 0 -col 0\ngrid .b -row 0 -col 1\ngrid .c -row 0 -col 2\ncols \"1 2 1\"",
80,
20,
);
assert_eq!((r[0].width, r[1].width, r[2].width), (20, 40, 20));
}
#[test]
fn cols_fixed_length_then_fill() {
let r = rects_of(
"gauge .a\ngauge .b\ngrid .a -row 0 -col 0\ngrid .b -row 0 -col 1\ncols \"20c *\"",
80,
20,
);
assert_eq!(r[0].width, 20);
assert_eq!(r[1].width, 60);
}
#[test]
fn gap_inserts_spacing_between_cells() {
let r = rects_of(
"gauge .a\ngauge .b\ngrid .a -row 0 -col 0\ngrid .b -row 0 -col 1\ngap 2",
92,
20,
);
assert_eq!(r[0].width, 45);
assert_eq!(r[1].x, 47); }
#[test]
fn layout_horizontal_tiles_side_by_side() {
let r = rects_of("gauge .a\ngauge .b\nlayout horizontal", 80, 20);
assert_eq!(r[0].width, 40);
assert_eq!(r[1].x, 40);
assert_eq!(r[0].height, 20); }
fn render_text(spec_src: &str) -> String {
use super::render_widget;
use crate::stream::StreamState;
use ratatui::backend::TestBackend;
use ratatui::Terminal;
let spec = build(&parse(spec_src).unwrap()).unwrap();
let w = &spec.widgets[0];
let st = StreamState::new();
let data = vec!["one".to_string(), "two".to_string()];
let mut term = Terminal::new(TestBackend::new(40, 6)).unwrap();
term.draw(|f| render_widget(f, f.area(), w, &st, &data, None, None, 0, 0, None))
.unwrap();
term.backend()
.buffer()
.content()
.iter()
.map(|c| c.symbol())
.collect()
}
#[test]
fn tick_timeouts_fires_once_per_idle_span() {
use super::{tick_timeouts, Controls};
use crate::spec::{BindAction, Timeout};
use std::time::{Duration, Instant};
let mut c = Controls {
inputs: vec![("x".into(), String::new())],
..Default::default()
};
let timeouts = vec![Timeout {
dur: Duration::from_millis(10),
action: BindAction::SetInput {
name: "x".into(),
value: "hot".into(),
},
}];
let base = Instant::now();
let (mut last_total, mut last_activity, mut fired) = (0u64, base, vec![false]);
tick_timeouts(
&timeouts,
0,
&mut last_total,
&mut last_activity,
&mut fired,
base + Duration::from_millis(20),
&mut c,
);
assert_eq!(c.inputs[0].1, "hot");
assert!(fired[0]);
c.inputs[0].1.clear();
tick_timeouts(
&timeouts,
0,
&mut last_total,
&mut last_activity,
&mut fired,
base + Duration::from_millis(40),
&mut c,
);
assert_eq!(c.inputs[0].1, "");
tick_timeouts(
&timeouts,
1,
&mut last_total,
&mut last_activity,
&mut fired,
base + Duration::from_millis(41),
&mut c,
);
assert!(!fired[0]);
assert_eq!(c.inputs[0].1, "");
}
#[test]
fn actor_tell_then_ask_updates_control() {
use super::{apply_bind_action, Controls};
use crate::spec::BindAction;
let cmds = crate::parser::parse(
"actor acc(state) { on add(n) { state = state + n; reply state } }",
)
.unwrap();
let mut defs = std::collections::BTreeMap::new();
let d = std::sync::Arc::new(crate::actor::parse_actor(&cmds[0].args).unwrap());
defs.insert("acc".to_string(), d);
let decls = vec![crate::actor::RefDecl {
name: "w".into(),
actor: "acc".into(),
init: 100.0,
pool: None,
restart: true,
}];
let mut c = Controls {
inputs: vec![("out".into(), String::new())],
session: crate::actor::Session::build(&defs, &decls).unwrap(),
..Default::default()
};
apply_bind_action(
&mut c,
&BindAction::ActorTell {
refname: "w".into(),
call: "add(5)".into(),
},
); apply_bind_action(
&mut c,
&BindAction::ActorAsk {
ctrl: "out".into(),
refname: "w".into(),
call: "add(10)".into(),
},
); assert_eq!(c.inputs[0].1, "115");
}
#[test]
fn parse_sgr_mouse_decodes_reports() {
use super::{parse_sgr_mouse, MouseKind};
let (ev, n) = parse_sgr_mouse(b"\x1b[<0;5;3M", 0).unwrap();
assert_eq!(
(ev.kind, ev.col, ev.row, ev.press),
(MouseKind::Down, 4, 2, true)
);
assert_eq!(n, 9);
let (ev, _) = parse_sgr_mouse(b"\x1b[<0;5;3m", 0).unwrap();
assert_eq!((ev.kind, ev.press), (MouseKind::Up, false));
assert_eq!(
parse_sgr_mouse(b"\x1b[<64;10;20M", 0).unwrap().0.kind,
MouseKind::ScrollUp
);
assert_eq!(
parse_sgr_mouse(b"\x1b[<65;1;1M", 0).unwrap().0.kind,
MouseKind::ScrollDown
);
assert_eq!(
parse_sgr_mouse(b"\x1b[<32;7;8M", 0).unwrap().0.kind,
MouseKind::Drag
);
let (ev, n) = parse_sgr_mouse(b"xy\x1b[<0;3;4M", 2).unwrap();
assert_eq!((ev.col, ev.row), (2, 3));
assert_eq!(n, 9);
assert!(parse_sgr_mouse(b"\x1b[<0;5;", 0).is_none());
assert!(parse_sgr_mouse(b"\x1b[A", 0).is_none());
}
#[test]
fn mouse_hit_and_geometry_helpers() {
use super::{detect_resize, facet_row_to_index, hit, slider_value_from_x, HitTarget};
use crate::spec::WidgetKind;
use ratatui::layout::Rect;
let hm = vec![
HitTarget {
rect: Rect {
x: 0,
y: 0,
width: 10,
height: 5,
},
kind: WidgetKind::Filter,
control_name: "q".into(),
meta_index: Some(0),
tabs: Vec::new(),
},
HitTarget {
rect: Rect {
x: 0,
y: 2,
width: 10,
height: 3,
},
kind: WidgetKind::Check,
control_name: "c".into(),
meta_index: Some(1),
tabs: Vec::new(),
},
];
assert_eq!(hit(&hm, 3, 3).unwrap().control_name, "c");
assert_eq!(hit(&hm, 3, 1).unwrap().control_name, "q"); assert!(hit(&hm, 20, 20).is_none()); assert_eq!(facet_row_to_index(0, 1), Some(0));
assert_eq!(facet_row_to_index(0, 3), Some(2));
assert_eq!(facet_row_to_index(5, 5), None);
assert_eq!(slider_value_from_x(0, 12, 6, 0.0, 10.0, 1.0), "5"); assert_eq!(slider_value_from_x(0, 12, 0, 0.0, 10.0, 1.0), "0"); assert_eq!(slider_value_from_x(0, 12, 99, 0.0, 10.0, 1.0), "10"); let mut last = (80, 24);
assert!(!detect_resize(&mut last, (80, 24)));
assert!(detect_resize(&mut last, (100, 30)));
assert_eq!(last, (100, 30));
}
#[test]
fn dispatch_mouse_clicks_and_scrolls() {
use super::{
dispatch_mouse, ControlKind, ControlMeta, Controls, HitTarget, MouseEvent, MouseKind,
};
use crate::spec::WidgetKind;
use ratatui::layout::Rect;
let mut c = Controls {
inputs: vec![("chk".into(), "0".into()), ("sl".into(), "0".into())],
control_meta: vec![
ControlMeta {
kind: ControlKind::Check,
..Default::default()
},
ControlMeta {
kind: ControlKind::Slider,
min: 0.0,
max: 10.0,
step: 1.0,
..Default::default()
},
],
hitmap: vec![
HitTarget {
rect: Rect {
x: 0,
y: 0,
width: 10,
height: 3,
},
kind: WidgetKind::Check,
control_name: "chk".into(),
meta_index: Some(0),
tabs: Vec::new(),
},
HitTarget {
rect: Rect {
x: 0,
y: 3,
width: 12,
height: 3,
},
kind: WidgetKind::Slider,
control_name: "sl".into(),
meta_index: Some(1),
tabs: Vec::new(),
},
],
..Default::default()
};
let ev = |kind, col, row| MouseEvent {
kind,
col,
row,
button: 0,
press: kind == MouseKind::Down,
};
dispatch_mouse(
&mut c,
ev(MouseKind::Down, 2, 1),
false,
std::time::Instant::now(),
);
assert_eq!(c.inputs[0].1, "1");
assert_eq!(c.focus, 0);
dispatch_mouse(
&mut c,
ev(MouseKind::Down, 6, 4),
false,
std::time::Instant::now(),
);
assert_eq!(c.inputs[1].1, "5");
assert_eq!(c.focus, 1);
c.cursor = 5;
dispatch_mouse(
&mut c,
ev(MouseKind::ScrollUp, 0, 0),
true,
std::time::Instant::now(),
);
assert_eq!(c.cursor, 4);
}
#[test]
fn fzf_row_and_tab_geometry() {
use super::{fzf_row_to_cursor, tab_index_from_x};
assert_eq!(fzf_row_to_cursor(2, 10, 2), 10);
assert_eq!(fzf_row_to_cursor(2, 10, 4), 12);
assert_eq!(fzf_row_to_cursor(0, 0, 5), 5);
assert_eq!(fzf_row_to_cursor(2, 10, 1), 10); let labels = ["a", "bb", "ccc"];
assert_eq!(tab_index_from_x(&labels, 0, 0), None); assert_eq!(tab_index_from_x(&labels, 0, 1), Some(0)); assert_eq!(tab_index_from_x(&labels, 0, 5), Some(1)); assert_eq!(tab_index_from_x(&labels, 0, 10), Some(2)); assert_eq!(tab_index_from_x(&labels, 0, 99), None); }
#[test]
fn dispatch_mouse_fzf_row_and_tab_click() {
use super::{dispatch_mouse, Controls, HitTarget, MouseEvent, MouseKind};
use crate::spec::WidgetKind;
use ratatui::layout::Rect;
let mut c = Controls {
fzf_list_start: 10,
hitmap: vec![HitTarget {
rect: Rect {
x: 0,
y: 2,
width: 20,
height: 10,
},
kind: WidgetKind::Select,
control_name: String::new(),
meta_index: None,
tabs: Vec::new(),
}],
..Default::default()
};
dispatch_mouse(
&mut c,
MouseEvent {
kind: MouseKind::Down,
col: 3,
row: 4,
button: 0,
press: true,
},
true,
std::time::Instant::now(),
);
assert_eq!(c.cursor, 12); let mut c = Controls {
hitmap: vec![HitTarget {
rect: Rect {
x: 0,
y: 0,
width: 20,
height: 3,
},
kind: WidgetKind::Tabs,
control_name: "t".into(),
meta_index: None,
tabs: vec!["a".into(), "bb".into(), "ccc".into()],
}],
..Default::default()
};
dispatch_mouse(
&mut c,
MouseEvent {
kind: MouseKind::Down,
col: 5,
row: 0,
button: 0,
press: true,
},
false,
std::time::Instant::now(),
);
assert_eq!(c.tab_sel.get("t"), Some(&1));
}
#[test]
fn control_helpers_slider_check_facet() {
use super::{slider_adjust, toggle_check, toggle_set_member};
assert_eq!(slider_adjust("5", 0.0, 10.0, 2.0, true), "7");
assert_eq!(slider_adjust("9", 0.0, 10.0, 2.0, true), "10"); assert_eq!(slider_adjust("1", 0.0, 10.0, 2.0, false), "0"); assert_eq!(toggle_check("0"), "1");
assert_eq!(toggle_check("1"), "0");
assert_eq!(toggle_set_member("", "warn"), "warn");
assert_eq!(toggle_set_member("warn", "error"), "warn,error");
assert_eq!(toggle_set_member("warn,error", "warn"), "error");
}
#[test]
fn mouse_button_and_modifiers() {
use super::{mouse_alt, mouse_button, mouse_ctrl, mouse_shift, MouseButton};
assert_eq!(mouse_button(0), MouseButton::Left);
assert_eq!(mouse_button(1), MouseButton::Middle);
assert_eq!(mouse_button(2), MouseButton::Right);
assert_eq!(mouse_button(0x04 | 0x10), MouseButton::Left);
assert_eq!(mouse_button(2 | 0x08), MouseButton::Right);
assert!(mouse_shift(0x04) && !mouse_alt(0x04) && !mouse_ctrl(0x04));
assert!(mouse_alt(0x08) && !mouse_shift(0x08));
assert!(mouse_ctrl(0x10) && !mouse_alt(0x10));
assert!(!mouse_shift(0) && !mouse_alt(0) && !mouse_ctrl(0));
}
#[test]
fn scroll_skip_windows_the_tail() {
use super::scroll_skip;
assert_eq!(scroll_skip(100, 10, 0), 90);
assert_eq!(scroll_skip(100, 10, 5), 85);
assert_eq!(scroll_skip(100, 10, 200), 0);
assert_eq!(scroll_skip(5, 10, 3), 0);
}
#[test]
fn double_click_window() {
use super::{is_double_click, DOUBLE_CLICK};
use std::time::{Duration, Instant};
let t0 = Instant::now();
assert!(!is_double_click(None, t0, 4));
let last = Some((t0, 3u16, 4u16));
assert!(is_double_click(last, t0 + Duration::from_millis(100), 4));
assert!(!is_double_click(
last,
t0 + DOUBLE_CLICK + Duration::from_millis(1),
4
));
assert!(!is_double_click(last, t0 + Duration::from_millis(100), 5));
}
#[test]
fn dispatch_mouse_right_click_resets_and_double_click_submits() {
use super::{
dispatch_mouse, ControlKind, ControlMeta, Controls, HitTarget, MouseEvent, MouseKind,
};
use crate::spec::WidgetKind;
use ratatui::layout::Rect;
use std::time::{Duration, Instant};
let mk = |button, row| MouseEvent {
kind: MouseKind::Down,
col: 2,
row,
button,
press: true,
};
let mut c = Controls {
inputs: vec![
("chk".into(), "1".into()),
("sl".into(), "7".into()),
("txt".into(), "hi".into()),
],
control_meta: vec![
ControlMeta {
kind: ControlKind::Check,
..Default::default()
},
ControlMeta {
kind: ControlKind::Slider,
min: 2.0,
max: 10.0,
step: 1.0,
..Default::default()
},
ControlMeta {
kind: ControlKind::Text,
..Default::default()
},
],
hitmap: vec![
HitTarget {
rect: Rect {
x: 0,
y: 0,
width: 10,
height: 3,
},
kind: WidgetKind::Check,
control_name: "chk".into(),
meta_index: Some(0),
tabs: Vec::new(),
},
HitTarget {
rect: Rect {
x: 0,
y: 3,
width: 12,
height: 3,
},
kind: WidgetKind::Slider,
control_name: "sl".into(),
meta_index: Some(1),
tabs: Vec::new(),
},
HitTarget {
rect: Rect {
x: 0,
y: 6,
width: 12,
height: 3,
},
kind: WidgetKind::Filter,
control_name: "txt".into(),
meta_index: Some(2),
tabs: Vec::new(),
},
],
..Default::default()
};
let now = Instant::now();
dispatch_mouse(&mut c, mk(2, 1), false, now); assert_eq!(c.inputs[0].1, "0");
dispatch_mouse(&mut c, mk(2, 4), false, now); assert_eq!(c.inputs[1].1, "2");
dispatch_mouse(&mut c, mk(2, 7), false, now); assert_eq!(c.inputs[2].1, "");
let mut c = Controls {
fzf_list_start: 0,
hitmap: vec![HitTarget {
rect: Rect {
x: 0,
y: 0,
width: 20,
height: 10,
},
kind: WidgetKind::Select,
control_name: String::new(),
meta_index: None,
tabs: Vec::new(),
}],
..Default::default()
};
dispatch_mouse(
&mut c,
MouseEvent {
kind: MouseKind::Down,
col: 3,
row: 4,
button: 0,
press: true,
},
false,
now,
);
assert!(!c.submit); dispatch_mouse(
&mut c,
MouseEvent {
kind: MouseKind::Down,
col: 3,
row: 4,
button: 0,
press: true,
},
false,
now + Duration::from_millis(100),
);
assert!(c.submit); }
#[test]
fn dispatch_mouse_wheel_scrolls_widget() {
use super::{dispatch_mouse, Controls, HitTarget, MouseEvent, MouseKind};
use crate::spec::WidgetKind;
use ratatui::layout::Rect;
use std::time::Instant;
let mut c = Controls {
hitmap: vec![HitTarget {
rect: Rect {
x: 0,
y: 0,
width: 20,
height: 10,
},
kind: WidgetKind::Tail,
control_name: "log".into(),
meta_index: None,
tabs: Vec::new(),
}],
..Default::default()
};
let ev = |kind| MouseEvent {
kind,
col: 5,
row: 5,
button: 0,
press: false,
};
let now = Instant::now();
dispatch_mouse(&mut c, ev(MouseKind::ScrollUp), false, now);
dispatch_mouse(&mut c, ev(MouseKind::ScrollUp), false, now);
assert_eq!(c.scroll.get("log"), Some(&2));
dispatch_mouse(&mut c, ev(MouseKind::ScrollDown), false, now);
assert_eq!(c.scroll.get("log"), Some(&1));
dispatch_mouse(&mut c, ev(MouseKind::ScrollDown), false, now);
dispatch_mouse(&mut c, ev(MouseKind::ScrollDown), false, now);
assert_eq!(c.scroll.get("log"), Some(&0));
}
#[test]
fn facet_candidates_from_opts_and_field() {
use super::facet_candidates;
let w = &build(&parse("facet .lv -opts {info warn error}").unwrap())
.unwrap()
.widgets[0];
assert_eq!(facet_candidates(w, &[]), vec!["info", "warn", "error"]);
let w2 = &build(&parse("facet .lv -field level").unwrap())
.unwrap()
.widgets[0];
let raw = vec![
r#"{"level":"info"}"#.to_string(),
r#"{"level":"error"}"#.to_string(),
r#"{"level":"info"}"#.to_string(),
];
assert_eq!(facet_candidates(w2, &raw), vec!["info", "error"]);
}
#[test]
fn tick_timeouts_quit_action() {
use super::{tick_timeouts, Controls};
use crate::spec::{BindAction, Timeout};
use std::time::{Duration, Instant};
let mut c = Controls::default();
let timeouts = vec![Timeout {
dur: Duration::from_millis(5),
action: BindAction::Quit,
}];
let base = Instant::now();
let (mut lt, mut la, mut fired) = (0u64, base, vec![false]);
tick_timeouts(
&timeouts,
0,
&mut lt,
&mut la,
&mut fired,
base + Duration::from_millis(10),
&mut c,
);
assert!(c.quit);
}
#[test]
fn tabs_block_frame_render_without_placeholder() {
for src in [
"tabs .t -tabs {alpha beta}",
"block .b -title Box",
"frame .f",
] {
let text = render_text(src);
assert!(
!text.contains("not yet rendered"),
"placeholder leaked for `{src}`: {text}"
);
}
let tabs = render_text("tabs .t -tabs {alpha beta}");
assert!(
tabs.contains("alpha") && tabs.contains("beta"),
"tab labels missing: {tabs}"
);
assert!(render_text("block .b").contains("two"));
}
#[test]
fn theme_directive_sets_palette_and_resolve_accent() {
use super::resolve_accent;
use ratatui::style::Color;
let sp = build(&parse("theme neon-noir\ntext .t <- in").unwrap()).unwrap();
let th = sp.theme;
assert_eq!(th.map(|p| p.accent()), Some(Color::Indexed(231)));
assert_eq!(resolve_accent(None, th), Color::Indexed(231));
assert_eq!(resolve_accent(Some("dim"), th), Color::Indexed(57)); assert_eq!(
resolve_accent(Some("green"), th),
super::hex_color("#00e676")
);
assert_eq!(
resolve_accent(None, None),
super::hex_color(crate::spec::color_hex(None))
);
}
#[test]
fn key_label_formats_control_bytes() {
use super::key_label;
assert_eq!(key_label(0x14), "Ctrl-T");
assert_eq!(key_label(0x07), "Ctrl-G");
assert_eq!(key_label(0x15), "Ctrl-U");
assert_eq!(key_label(0x1b), "Esc");
}
#[test]
fn default_slot_varies_by_widget_kind() {
use super::default_slot_for_kind;
use crate::spec::WidgetKind;
let p = crate::theme::by_name("neon-noir").unwrap();
assert_eq!(default_slot_for_kind(WidgetKind::Gauge, p), p.accent());
assert_eq!(default_slot_for_kind(WidgetKind::Bars, p), p.alt());
assert_eq!(default_slot_for_kind(WidgetKind::Chart, p), p.mid());
assert_eq!(default_slot_for_kind(WidgetKind::Tail, p), p.primary());
assert_ne!(
default_slot_for_kind(WidgetKind::Gauge, p),
default_slot_for_kind(WidgetKind::Bars, p)
);
}
#[test]
fn theme_custom_and_unknown() {
let sp = build(&parse("theme custom 1 2 3 4 5 6\ntext .t <- in").unwrap()).unwrap();
assert_eq!(
sp.theme.map(|p| p.accent()),
Some(ratatui::style::Color::Indexed(2))
);
assert!(build(&parse("theme bogus\ntext .t <- in").unwrap()).is_err());
assert!(build(&parse("theme custom 1 2 3\ntext .t <- in").unwrap()).is_err());
}
#[test]
fn linegauge_and_scatter_render_without_panic() {
let lg = render_text("linegauge .load -max 8");
assert!(lg.contains("linegauge"), "linegauge title missing: {lg}");
let sc = render_text("scatter .lat");
assert!(sc.contains("scatter"), "scatter title missing: {sc}");
}
#[test]
fn logview_heatmap_treemap_gantt_diff_render_without_panic() {
for (src, kind) in [
("logview .l", "logview"),
("heatmap .h", "heatmap"),
("treemap .t", "treemap"),
("gantt .g", "gantt"),
("diff .d", "diff"),
] {
let text = render_text(src);
assert!(text.contains(kind), "{kind} title missing: {text}");
}
assert!(!render_text("logo .b").is_empty());
assert!(!render_text("clear .s").is_empty());
assert!(!render_text("rule .r").is_empty());
}
#[test]
fn treemap_rects_are_proportional() {
use super::treemap_rects;
use ratatui::layout::Rect;
let area = Rect {
x: 0,
y: 0,
width: 100,
height: 10,
};
let rects = treemap_rects(area, &[("a".into(), 1), ("b".into(), 1)]);
assert_eq!(rects.len(), 2);
assert!(
(rects[0].width as i32 - 50).abs() <= 1,
"got {}",
rects[0].width
);
for r in &rects {
assert!(r.x + r.width <= area.width && r.y + r.height <= area.height);
}
}
#[test]
fn log_level_style_colors_by_level() {
use super::log_level_style;
use ratatui::style::Color;
assert_eq!(
log_level_style("2026 ERROR boom", None).fg,
Some(Color::Red)
);
assert_eq!(
log_level_style("2026 WARN slow", None).fg,
Some(Color::Yellow)
);
assert_eq!(log_level_style("2026 INFO ok", None).fg, Some(Color::Cyan));
assert_eq!(
log_level_style("2026 DEBUG x", None).fg,
Some(Color::DarkGray)
);
}
#[test]
fn sparkline_map_calendar_render_without_panic() {
assert!(render_text("sparkline .s").contains("sparkline"));
assert!(!render_text("map .m").is_empty());
assert!(!render_text("calendar .c").is_empty());
}
#[test]
fn stream_event_dates_parses_iso_dates() {
use super::stream_event_dates;
let lines = vec![
"2026-07-19 login ok".to_string(),
"no date here".to_string(),
"[2026-07-20] event".to_string(),
"2026-13-40 bad".to_string(), "2026-07-19 dup".to_string(), ];
let dates = stream_event_dates(&lines);
assert_eq!(dates.len(), 2);
assert!(
dates.contains(&time::Date::from_calendar_date(2026, time::Month::July, 19).unwrap())
);
assert!(
dates.contains(&time::Date::from_calendar_date(2026, time::Month::July, 20).unwrap())
);
}
#[test]
fn sel_publishes_highlighted_row_as_control() {
use super::{sel_candidates, update_sel_controls, ControlKind, ControlMeta, Controls};
let spec = build(&parse("sel .ps\nsource .ps { in; fields 1 }").unwrap()).unwrap();
let raw = vec![
"alice 30".to_string(),
"bob 25".to_string(),
"carol 40".to_string(),
];
assert_eq!(
sel_candidates(&spec.widgets[0], &raw),
vec!["alice", "bob", "carol"]
);
let mut c = Controls {
inputs: vec![("ps.sel".into(), String::new())],
control_meta: vec![ControlMeta {
kind: ControlKind::Sel,
cursor: 1,
..Default::default()
}],
..Default::default()
};
update_sel_controls(&spec, &raw, &mut c);
assert_eq!(c.inputs[0].1, "bob");
c.control_meta[0].cursor = 99;
update_sel_controls(&spec, &raw, &mut c);
assert_eq!(c.inputs[0].1, "carol");
assert_eq!(c.control_meta[0].cursor, 2);
}
}