use std::collections::HashMap;
use std::fs::{File, OpenOptions};
use std::io::{self, Read, Write};
use std::os::unix::io::{AsRawFd, RawFd};
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::{Duration, Instant};
use ratatui::backend::CrosstermBackend;
use ratatui::crossterm::{
cursor::MoveTo,
event::{DisableMouseCapture, EnableMouseCapture},
execute,
terminal::{
disable_raw_mode, enable_raw_mode, size, Clear as TermClear, ClearType,
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, 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, bool)> {
let s = spec.trim();
if let Some(p) = s.strip_suffix('%') {
let pct: u32 = p.trim().parse().ok()?;
if pct >= 100 {
return None;
}
let rows = size().map(|(_, h)| h).unwrap_or(24) as u32;
Some(((rows * pct / 100).clamp(3, rows) as u16, true))
} else {
s.parse::<u16>().ok().map(|n| (n.max(3), false))
}
}
pub fn min_height_rows(min: u16, plus: bool, chrome: u16, total: u16) -> u16 {
let want = if plus {
min.saturating_add(chrome)
} else {
min
};
want.min(total.max(1))
}
pub fn parse_cursor_report(buf: &[u8]) -> Option<u16> {
let start = buf.windows(2).rposition(|w| w == b"\x1b[").map(|i| i + 2)?;
let end = start + buf[start..].iter().position(|b| *b == b'R')?;
let body = std::str::from_utf8(&buf[start..end]).ok()?;
let row: u16 = body.split(';').next()?.parse().ok()?;
Some(row.saturating_sub(1))
}
fn tty_cursor_row(tty: &mut File) -> Option<u16> {
let fd = tty.as_raw_fd();
let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
if flags < 0 || unsafe { libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK) } < 0 {
return None;
}
let row = read_cursor_report(tty, fd, Duration::from_millis(300));
unsafe { libc::fcntl(fd, libc::F_SETFL, flags) };
row
}
fn read_cursor_report(tty: &mut File, fd: i32, budget: Duration) -> Option<u16> {
tty.write_all(b"\x1b[6n").ok()?;
tty.flush().ok()?;
let deadline = Instant::now() + budget;
let mut buf = Vec::new();
while let Some(left) = deadline.checked_duration_since(Instant::now()) {
let mut pfd = libc::pollfd {
fd,
events: libc::POLLIN,
revents: 0,
};
if unsafe { libc::poll(&mut pfd, 1, (left.as_millis() as i32).max(1)) } <= 0 {
break;
}
let mut chunk = [0u8; 32];
match tty.read(&mut chunk) {
Ok(n) if n > 0 => buf.extend_from_slice(&chunk[..n]),
Ok(_) => continue,
Err(e) if e.kind() == io::ErrorKind::WouldBlock => continue,
Err(_) => break,
}
if let Some(row) = parse_cursor_report(&buf) {
return Some(row);
}
}
None
}
pub fn inline_rect(bottom_row: u16, rows: u16, cols: u16, total: u16) -> Rect {
let h = rows.clamp(1, total.max(1));
let bottom = bottom_row.min(total.saturating_sub(1));
Rect {
x: 0,
y: bottom.saturating_sub(h - 1),
width: cols,
height: h,
}
}
#[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 toggles: Vec<usize>,
pub multi: 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 look: crate::fzf::Look,
pub fzf_page: usize,
pub preview_scroll: usize,
pub preview_view: Option<(Rect, usize)>,
pub preview_start: Option<(i64, usize)>,
pub fzf_count: usize,
pub toggle_all: bool,
pub expect_key: Option<String>,
}
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> {
fuzzy_score_case(line, pat, crate::fzf::Case::Smart)
}
pub fn fuzzy_score_case(line: &str, pat: &str, case: crate::fzf::Case) -> Option<i32> {
let (p, cased) = crate::algo::prepare_pattern_case(pat, case);
crate::algo::fuzzy_match_v2(
&crate::algo::Scheme::DEFAULT,
cased,
true,
&crate::algo::Text::new(line),
&p,
false,
)
.map(|(m, _)| m.score)
}
pub fn exact_score(line: &str, pat: &str) -> Option<i32> {
exact_score_case(line, pat, crate::fzf::Case::Smart)
}
pub fn exact_score_case(line: &str, pat: &str, case: crate::fzf::Case) -> Option<i32> {
let (p, cased) = crate::algo::prepare_pattern_case(pat, case);
crate::algo::exact_match_naive(
&crate::algo::Scheme::DEFAULT,
cased,
true,
&crate::algo::Text::new(line),
&p,
false,
)
.map(|(m, _)| m.score)
}
pub fn trim_length(s: &str) -> usize {
s.trim().chars().count()
}
pub fn item_text<'a>(line: &'a str, look: &crate::fzf::Look) -> std::borrow::Cow<'a, str> {
match look.ansi {
true => std::borrow::Cow::Owned(crate::fzf::strip_ansi(line)),
false => std::borrow::Cow::Borrowed(line),
}
}
pub fn search_key<'a>(line: &'a str, look: &crate::fzf::Look) -> std::borrow::Cow<'a, str> {
let item = rank_text(line, look);
if look.nth.is_empty() {
return item;
}
let delim = look.delimiter.as_deref();
let tokens = crate::fzf::tokenize(&item, delim);
std::borrow::Cow::Owned(crate::fzf::transform(&tokens, &look.nth, delim))
}
pub fn rank_text<'a>(line: &'a str, look: &crate::fzf::Look) -> std::borrow::Cow<'a, str> {
use std::borrow::Cow;
if look.with_nth.is_empty() {
return match look.ansi {
true => Cow::Owned(crate::fzf::strip_ansi(line)),
false => Cow::Borrowed(line),
};
}
let delim = look.delimiter.as_deref();
let tokens = crate::fzf::tokenize(line, delim);
let projected = crate::fzf::transform_join(&tokens, &look.with_nth);
Cow::Owned(match look.ansi {
true => crate::fzf::strip_ansi(&projected),
false => projected,
})
}
pub fn rank(
lines: &[&str],
pat: &str,
exact: bool,
no_sort: bool,
tac: bool,
look: &crate::fzf::Look,
) -> Vec<usize> {
let pattern = crate::pattern::Pattern::build_full(
pat,
exact,
look.extended,
look.case,
look.scheme,
&look.tiebreak,
look.algo_v1,
);
let mut hits: Vec<([u16; 4], usize)> = lines
.par_iter()
.enumerate()
.filter_map(|(i, line)| {
let key = search_key(line, look);
pattern.match_line(&key).map(|b| {
let item = rank_text(line, look);
(crate::pattern::points(&item, &key, &b, &look.tiebreak), i)
})
})
.collect();
hits.par_sort_by_key(|(_, i)| *i);
if tac {
hits.reverse();
}
if !no_sort && pattern.sortable {
hits.sort_by(|a, b| crate::pattern::compare_points(&a.0, &b.0));
}
hits.into_iter().map(|(_, i)| i).collect()
}
pub fn score_line(line: &str, pat: &str, exact: bool, case: crate::fzf::Case) -> Option<i32> {
if pat.is_empty() {
return Some(0);
}
if exact {
exact_score_case(line, pat, case)
} else {
fuzzy_score_case(line, pat, case)
}
}
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 fzf_key(buf: &[u8], i: usize) -> Option<(crate::fzf::Key, usize)> {
use crate::fzf::Key;
let b = *buf.get(i)?;
if b == 0x1b {
if buf.get(i + 1) == Some(&b'[') {
if buf.get(i + 2..i + 5) == Some(b"1;2".as_slice()) {
match buf.get(i + 5) {
Some(b'A') => return Some((Key::ShiftUp, 6)),
Some(b'B') => return Some((Key::ShiftDown, 6)),
_ => {}
}
}
let k = match buf.get(i + 2)? {
b'A' => Key::Up,
b'B' => Key::Down,
b'C' => Key::Right,
b'D' => Key::Left,
b'H' => Key::Home,
b'F' => Key::End,
b'Z' => Key::BTab,
d @ (b'1' | b'3' | b'4' | b'5' | b'6') if buf.get(i + 3) == Some(&b'~') => {
let k = match d {
b'1' => Key::Home,
b'3' => Key::Delete,
b'4' => Key::End,
b'5' => Key::PageUp,
_ => Key::PageDown,
};
return Some((k, 4));
}
_ => return None,
};
return Some((k, 3));
}
if let Some(&c) = buf.get(i + 1) {
if (0x20..0x7f).contains(&c) {
return Some((Key::Alt(c.to_ascii_lowercase() as char), 2));
}
}
return Some((Key::Esc, 1));
}
let k = match b {
0x09 => Key::Tab,
0x0d | 0x0a => Key::Enter,
0x08 | 0x7f => Key::Backspace,
0x20 => Key::Space,
0x01..=0x1a => Key::Ctrl((b'a' + b - 1) as char),
0x21..=0x7e => Key::Char(b as char),
_ => return None,
};
Some((k, 1))
}
fn fzf_action(c: &mut Controls, acts: &[crate::fzf::Action]) -> bool {
use crate::fzf::Action;
let page = c.fzf_page.max(1);
let preview_page = c.preview_view.map_or(1, |(_, rows)| rows).max(1);
let count = c.fzf_count;
let cycle = c.look.cycle;
let inv = c.look.layout == crate::fzf::Layout::Default;
for a in acts {
let a = &if inv {
match a {
Action::Up => Action::Down,
Action::Down => Action::Up,
Action::PageUp => Action::PageDown,
Action::PageDown => Action::PageUp,
Action::HalfPageUp => Action::HalfPageDown,
Action::HalfPageDown => Action::HalfPageUp,
other => *other,
}
} else {
*a
};
match a {
Action::Up => {
c.cursor = match (c.cursor, cycle, count) {
(0, true, n) if n > 0 => n - 1,
(cur, _, _) => cur.saturating_sub(1),
}
}
Action::Down => {
let next = c.cursor.saturating_add(1);
c.cursor = if cycle && count > 0 && next >= count {
0
} else {
next
};
}
Action::PageUp => c.cursor = c.cursor.saturating_sub(page),
Action::PageDown => c.cursor = c.cursor.saturating_add(page),
Action::HalfPageUp => c.cursor = c.cursor.saturating_sub(page / 2 + 1),
Action::HalfPageDown => c.cursor = c.cursor.saturating_add(page / 2 + 1),
Action::First => c.cursor = 0,
Action::Last => c.cursor = usize::MAX,
Action::Toggle => {
let at = c.cursor;
c.toggles.push(at);
}
Action::PreviewUp => c.preview_scroll = c.preview_scroll.saturating_sub(1),
Action::PreviewDown => c.preview_scroll = c.preview_scroll.saturating_add(1),
Action::PreviewPageUp => {
c.preview_scroll = c.preview_scroll.saturating_sub(preview_page)
}
Action::PreviewPageDown => {
c.preview_scroll = c.preview_scroll.saturating_add(preview_page)
}
Action::PreviewHalfPageUp => {
c.preview_scroll = c.preview_scroll.saturating_sub(preview_page / 2 + 1)
}
Action::PreviewHalfPageDown => {
c.preview_scroll = c.preview_scroll.saturating_add(preview_page / 2 + 1)
}
Action::PreviewTop => c.preview_scroll = 0,
Action::PreviewBottom => c.preview_scroll = usize::MAX,
Action::ToggleAll => c.toggle_all = true,
Action::Accept => {
c.submit = true;
return true;
}
Action::Abort => {
c.quit = true;
return true;
}
Action::ClearQuery => {
c.filter.clear();
c.cursor = 0;
}
Action::BackwardDeleteChar => {
c.filter.pop();
c.cursor = 0;
}
Action::Ignore => {}
}
}
false
}
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>>) -> Option<thread::JoinHandle<()>> {
let mut tty = OpenOptions::new().read(true).open("/dev/tty").ok()?;
let joinable = fd_selectable(tty.as_raw_fd());
let reader = thread::spawn(move || {
let fd = tty.as_raw_fd();
let mut buf = [0u8; 4096];
let mut pend: Vec<u8> = Vec::new();
loop {
if !select_readable(fd, STOP_POLL_MS).unwrap_or(true) {
if session_over(&controls) {
break;
}
continue;
}
let n = match tty.read(&mut buf) {
Ok(0) => break,
Ok(n) => n,
Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
Err(_) => break,
};
pend.extend_from_slice(&buf[..n]);
if drain_keys(&controls, &mut pend, true) {
break;
}
if !pend.is_empty()
&& !tty_readable(fd, ESC_WAIT_MS)
&& drain_keys(&controls, &mut pend, false)
{
break;
}
}
});
joinable.then_some(reader)
}
fn session_over(controls: &Mutex<Controls>) -> bool {
controls.lock().map(|c| c.quit || c.submit).unwrap_or(true)
}
struct SessionEnd {
controls: Arc<Mutex<Controls>>,
key_reader: Option<thread::JoinHandle<()>>,
}
impl Drop for SessionEnd {
fn drop(&mut self) {
match self.controls.lock() {
Ok(mut c) => c.quit = true,
Err(poisoned) => poisoned.into_inner().quit = true,
}
if let Some(t) = self.key_reader.take() {
let _ = t.join();
}
}
}
const ESC_WAIT_MS: i32 = 30;
fn tty_readable(fd: RawFd, ms: i32) -> bool {
select_readable(fd, ms).unwrap_or(false)
}
pub(crate) const STOP_POLL_MS: i32 = 50;
fn fd_selectable(fd: RawFd) -> bool {
fd >= 0 && (fd as usize) < libc::FD_SETSIZE
}
pub(crate) fn select_readable(fd: RawFd, ms: i32) -> Option<bool> {
if !fd_selectable(fd) {
return None;
}
Some(unsafe {
let mut set: libc::fd_set = std::mem::zeroed();
libc::FD_SET(fd, &mut set);
let mut tv = libc::timeval {
tv_sec: (ms / 1000) as libc::time_t,
tv_usec: (ms % 1000 * 1000) as libc::suseconds_t,
};
libc::select(
fd + 1,
&mut set,
std::ptr::null_mut(),
std::ptr::null_mut(),
&mut tv,
) > 0
})
}
fn drain_keys(controls: &Arc<Mutex<Controls>>, pend: &mut Vec<u8>, defer: bool) -> bool {
let (used, stop) = feed_keys(controls, pend, defer);
pend.drain(..used);
stop
}
fn feed_keys(controls: &Arc<Mutex<Controls>>, buf: &[u8], defer: bool) -> (usize, bool) {
let n = buf.len();
let mut c = controls.lock().unwrap();
let fzf = c.fzf;
let form = !fzf && !c.inputs.is_empty();
let mut i = 0;
while i < n {
if defer && partial_escape(buf, i) {
break;
}
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 {
return (i, true);
}
i += used;
continue;
}
}
if c.theme_picker_open {
if let Some(len) = csi_len(buf, i) {
match buf[i + len - 1] {
b'A' => theme_picker_move(&mut c, -1),
b'B' => theme_picker_move(&mut c, 1),
_ => {}
}
i += len;
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;
return (i, true);
}
_ => {}
}
i += 1;
continue;
}
if fzf && !c.look.expect.is_empty() {
if let Some((key, used)) = fzf_key(&buf[..n], i) {
if let Some(name) = c
.look
.expect
.iter()
.find(|(k, _)| *k == key)
.map(|(_, name)| name.clone())
{
c.expect_key = Some(name);
c.submit = true;
let _ = used;
return (i, true);
}
}
}
if fzf {
if let Some((key, used)) = fzf_key(&buf[..n], i) {
if let Some(acts) = c.look.bound_or_default(key) {
if fzf_action(&mut c, &acts) {
return (i, true);
}
i += used;
continue;
}
}
}
if let Some(len) = csi_len(buf, i) {
match buf[i + len - 1] {
b'A' if fzf => {
fzf_action(&mut c, &[crate::fzf::Action::Up]);
}
b'B' if fzf => {
fzf_action(&mut c, &[crate::fzf::Action::Down]);
}
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 += len;
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 {
return (i, true);
}
}
}
0x03 => {
c.quit = true;
return (i, true);
}
0x0d if fzf => {
c.submit = true;
return (i, true);
}
0x0e | 0x0a if fzf => {
fzf_action(&mut c, &[crate::fzf::Action::Down]);
}
0x10 | 0x0b if fzf => {
fzf_action(&mut c, &[crate::fzf::Action::Up]);
}
0x09 if fzf => {
fzf_action(
&mut c,
&[crate::fzf::Action::Toggle, crate::fzf::Action::Down],
);
}
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;
return (i, true);
} 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 {
return (i, true);
}
}
}
}
i += 1;
}
(i, false)
}
pub fn csi_len(bytes: &[u8], i: usize) -> Option<usize> {
if bytes.get(i)? != &0x1b || bytes.get(i + 1)? != &b'[' {
return None;
}
let mut p = i + 2;
while matches!(bytes.get(p), Some(0x30..=0x3f)) {
p += 1;
}
while matches!(bytes.get(p), Some(0x20..=0x2f)) {
p += 1;
}
match bytes.get(p) {
Some(0x40..=0x7e) => Some(p + 1 - i),
_ => None,
}
}
pub fn partial_escape(bytes: &[u8], i: usize) -> bool {
match bytes.get(i) {
Some(0x1b) => match bytes.get(i + 1) {
None => true,
Some(b'[') => csi_len(bytes, i).is_none(),
Some(_) => false, },
_ => false,
}
}
#[derive(Clone)]
pub enum FzfCand {
Ident(Arc<str>),
Proj(Box<[Arc<str>; 3]>),
}
impl FzfCand {
fn disp(&self) -> &Arc<str> {
match self {
FzfCand::Ident(a) => a,
FzfCand::Proj(p) => &p[0],
}
}
fn key(&self) -> &Arc<str> {
match self {
FzfCand::Ident(a) => a,
FzfCand::Proj(p) => &p[1],
}
}
fn orig(&self) -> &Arc<str> {
match self {
FzfCand::Ident(a) => a,
FzfCand::Proj(p) => &p[2],
}
}
}
type FzfHit = ([u16; 4], u32);
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 mut tty: File = OpenOptions::new().read(true).write(true).open("/dev/tty")?;
enable_raw_mode()?;
let (look0, header0) = {
let c = controls.lock().unwrap();
(c.look.clone(), c.header.clone())
};
let inline = height.as_deref().and_then(parse_height).map(|(rows, pct)| {
let (cols, total) = size().unwrap_or((80, 24));
let rows = match pct {
true => {
let chrome =
1 + u16::from(!matches!(
look0.info,
crate::fzf::Info::Inline(_) | crate::fzf::Info::InlineRight(_)
)) + u16::from(!header0.is_empty())
+ look0.border.map_or(0, |_| 2);
rows.max(min_height_rows(
look0.min_height,
look0.min_height_plus,
chrome,
total,
))
}
false => rows,
};
let _ = tty.write_all(b"\x1b[J");
let _ = tty.write_all("\n".repeat(rows.saturating_sub(1) as usize).as_bytes());
let _ = tty.flush();
let bottom = tty_cursor_row(&mut tty).unwrap_or(total.saturating_sub(1));
inline_rect(bottom, rows, cols, total)
});
let backend = CrosstermBackend::new(tty);
let mut terminal = match inline {
Some(area) => {
let mut t = Terminal::with_options(
backend,
TerminalOptions {
viewport: Viewport::Fixed(area),
},
)?;
t.clear()?;
t
}
None => {
let mut t = Terminal::new(backend)?;
execute!(t.backend_mut(), EnterAlternateScreen)?;
t
}
};
execute!(terminal.backend_mut(), EnableMouseCapture)?;
controls.lock().unwrap().fzf = fzf;
let session = SessionEnd {
controls: controls.clone(),
key_reader: 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<u32> = 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, fzf_multi, fzf_look) = {
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,
c.multi,
c.look.clone(),
)
};
let mut fzf_pattern = crate::pattern::Pattern::build_full(
"",
fzf_exact,
fzf_look.extended,
fzf_look.case,
fzf_look.scheme,
&fzf_look.tiebreak,
fzf_look.algo_v1,
);
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 mut fzf_start = 0usize;
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).map(|l| l.to_string()).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))
.map(|l| l.to_string())
.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 INGEST_BUDGET: Duration = Duration::from_millis(8);
let ingest_started = Instant::now();
let mut ingest_end = st.lines.len();
for i in fzf_raw_done..st.lines.len() {
if i % 4096 == 0 && ingest_started.elapsed() >= INGEST_BUDGET {
ingest_end = i;
break;
}
let raw = &st.lines[i];
if i < fzf_look.header_lines {
continue;
}
if !fzf_look.nth.is_empty() || !fzf_look.with_nth.is_empty() || fzf_look.ansi {
let delim = fzf_look.delimiter.as_deref();
let tokens = crate::fzf::tokenize(raw, delim);
let disp: Arc<str> = match fzf_look.with_nth.is_empty() {
true => Arc::clone(raw),
false => Arc::from(
crate::fzf::transform(&tokens, &fzf_look.with_nth, delim).as_str(),
),
};
let key_src = match fzf_look.nth.is_empty() {
true => disp.to_string(),
false => crate::fzf::transform(&tokens, &fzf_look.nth, delim),
};
let key: Arc<str> = match fzf_look.ansi {
true => Arc::from(crate::fzf::strip_ansi(&key_src).as_str()),
false => Arc::from(key_src.as_str()),
};
let orig: Arc<str> = match fzf_look.ansi {
true => Arc::from(crate::fzf::strip_ansi(raw).as_str()),
false => Arc::clone(raw),
};
fzf_cands.push(FzfCand::Proj(Box::new([disp, key, orig])));
continue;
}
if proj.is_empty() && search_proj.is_empty() {
fzf_cands.push(FzfCand::Ident(Arc::clone(raw)));
continue;
}
let orig: Arc<str> = Arc::clone(raw);
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(FzfCand::Proj(Box::new([d, k, orig.clone()])));
}
}
fzf_raw_done = ingest_end;
let n = fzf_cands.len();
let empty = filter.is_empty();
if filter != fzf_filter {
let next = crate::pattern::Pattern::build_full(
&filter,
fzf_exact,
fzf_look.extended,
fzf_look.case,
fzf_look.scheme,
&fzf_look.tiebreak,
fzf_look.algo_v1,
);
let extends = !empty
&& !fzf_filter.is_empty()
&& filter.starts_with(&fzf_filter)
&& fzf_pattern.cacheable
&& next.cacheable;
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(|(_, i)| {
let key = fzf_cands[i as usize].key();
next.match_line(key).map(|b| {
(
crate::pattern::points(
fzf_cands[i as usize].disp(),
key,
&b,
&fzf_look.tiebreak,
),
i,
)
})
})
.collect();
} else {
fzf_hits = fzf_cands
.par_iter()
.enumerate()
.filter_map(|(i, cand)| {
next.match_line(cand.key()).map(|b| {
(
crate::pattern::points(
cand.disp(),
cand.key(),
&b,
&fzf_look.tiebreak,
),
i as u32,
)
})
})
.collect();
fzf_processed = n;
}
fzf_pattern = next;
fzf_filter = filter.clone();
fzf_last_sort = Instant::now() - Duration::from_secs(1);
}
for (i, cand) in fzf_cands.iter().enumerate().take(n).skip(fzf_processed) {
if empty {
fzf_matched.push(i as u32);
} else if let Some(b) = fzf_pattern.match_line(cand.key()) {
let key =
crate::pattern::points(cand.disp(), cand.key(), &b, &fzf_look.tiebreak);
fzf_hits.push((key, i as u32));
}
}
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_look.tac {
h.reverse();
}
if !fzf_no_sort && fzf_pattern.sortable {
h.par_sort_by(|a, b| crate::pattern::compare_points(&a.0, &b.0));
}
fzf_matched = h.into_iter().map(|(_, i)| i).collect();
fzf_last_sort = now;
}
}
let matched = &fzf_matched;
let sel = cursor.min(matched.len().saturating_sub(1));
let tac_view = fzf_look.tac && filter.is_empty();
let rank = |pos: usize| tac_index(pos, matched.len(), tac_view);
let original = |pos: usize| -> Option<&str> {
matched
.get(pos)
.map(|i| fzf_cands[*i as usize].orig().as_ref())
};
let mut c = controls.lock().unwrap();
let cursor_line = original(rank(sel)).unwrap_or_default();
if c.current != cursor_line {
c.preview_scroll = 0;
c.preview_start = None;
c.current = cursor_line.to_string();
}
for at in std::mem::take(&mut c.toggles) {
let at = rank(at.min(matched.len().saturating_sub(1)));
let orig = original(at).filter(|_| c.multi).map(str::to_string);
if let Some(orig) = orig {
match c.marks.iter().position(|m| *m == orig) {
Some(pos) => {
c.marks.remove(pos);
}
None => c.marks.push(orig),
}
}
}
if c.toggle_all {
c.toggle_all = false;
if !c.multi {
} else if c.marks.len() == matched.len() {
c.marks.clear();
} else {
c.marks = matched
.iter()
.map(|i| fzf_cands[*i as usize].orig().to_string())
.collect();
}
}
c.fzf_count = matched.len();
if submit {
c.result = if c.marks.is_empty() {
original(rank(sel))
.map(str::to_string)
.into_iter()
.collect()
} else {
c.marks.clone()
};
break Ok(());
}
let marks = c.marks.clone();
if let (Some((line, denom)), Some((_, rows))) = (c.preview_start, c.preview_view) {
c.preview_start = None;
let sc = crate::fzf::PreviewScroll {
base: crate::fzf::ScrollBase::Line(line),
offset: 0,
denom,
};
c.preview_scroll = sc.top(line, rows);
}
let preview_scroll = c.preview_scroll;
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().map(|l| l.to_string()).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_rows = 0usize;
let mut preview_view = None;
let draw = terminal.draw(|f| {
(fzf_start, fzf_rows) = render_fzf(
f,
matched,
&fzf_cands,
&filter,
&fzf_pattern,
sel,
fzf_start,
&marks,
fzf_multi,
tac_view,
total,
err_ref,
prev_ref,
preview_scroll,
&fzf_prompt,
&fzf_header,
fzf_theme,
&fzf_look,
&mut hitmap,
&mut preview_view,
);
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;
c.fzf_page = fzf_rows;
c.preview_view = preview_view.map(|(rect, rows, _)| (rect, rows));
if let Some((_, _, scroll)) = preview_view {
c.preview_scroll = scroll;
}
}
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))
.map(|l| l.to_string())
.collect();
(tail, label.clone())
});
{
let lines: Vec<String> = {
let st = state.lock().unwrap();
st.lines.iter().map(|l| l.to_string()).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));
};
std::mem::forget(fzf_cands);
std::mem::forget(fzf_hits);
std::mem::forget(fzf_matched);
drop(session);
let _ = execute!(terminal.backend_mut(), DisableMouseCapture);
disable_raw_mode()?;
if let Some(area) = inline {
let _ = execute!(
terminal.backend_mut(),
MoveTo(0, area.y),
TermClear(ClearType::FromCursorDown)
);
} 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))
.map(|l| l.to_string())
.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_window_start(
prev: usize,
sel: usize,
list_h: usize,
n: usize,
scroll_off: usize,
) -> usize {
let so = scroll_off.min(list_h.saturating_sub(1));
let max_start = n.saturating_sub(list_h);
let mut start = prev.min(max_start);
if sel < start + so {
start = sel.saturating_sub(so);
}
if sel + so >= start + list_h {
start = (sel + so + 1).saturating_sub(list_h);
}
start.min(max_start)
}
pub fn tac_index(pos: usize, n: usize, tac: bool) -> usize {
if tac {
n.saturating_sub(1).saturating_sub(pos)
} else {
pos
}
}
pub fn fzf_row_to_cursor(list_top: u16, start: usize, row: u16) -> usize {
start + row.saturating_sub(list_top) as usize
}
pub fn fzf_row_to_cursor_rev(list_top: u16, start: usize, rows: usize, row: u16) -> usize {
let off = row.saturating_sub(list_top) as usize;
start + rows.saturating_sub(1).saturating_sub(off)
}
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) {
let over_preview = fzf
&& c.preview_view.is_some_and(|(r, _)| {
(r.x..r.x + r.width).contains(&ev.col) && (r.y..r.y + r.height).contains(&ev.row)
});
match ev.kind {
MouseKind::ScrollUp => {
if fzf {
if over_preview {
c.preview_scroll = c.preview_scroll.saturating_sub(1);
} else {
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 {
if over_preview {
c.preview_scroll = c.preview_scroll.saturating_add(1);
} else {
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 = if fzf && c.look.layout == crate::fzf::Layout::Default {
fzf_row_to_cursor_rev(
t.rect.y,
c.fzf_list_start,
c.fzf_page,
ev.row,
)
} else {
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()
}
crate::query::QueryResult::Error(_) => Vec::new(),
},
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> {
match_positions_case(line, pat, crate::fzf::Case::Smart)
}
pub fn match_positions_case(line: &str, pat: &str, case: crate::fzf::Case) -> Vec<usize> {
if pat.is_empty() {
return Vec::new();
}
let (p, cased) = crate::algo::prepare_pattern_case(pat, case);
let text = crate::algo::Text::new(line);
let hit =
crate::algo::fuzzy_match_v2(&crate::algo::Scheme::DEFAULT, cased, true, &text, &p, true)
.or_else(|| {
crate::algo::exact_match_naive(
&crate::algo::Scheme::DEFAULT,
cased,
true,
&text,
&p,
true,
)
});
match hit {
Some((_, Some(mut pos))) => {
pos.sort_unstable();
pos
}
_ => Vec::new(),
}
}
fn fzf_line(
line: &str,
pattern: &crate::pattern::Pattern,
width: usize,
marked: bool,
current: bool,
look: &crate::fzf::Look,
colors: &crate::fzf::Colors,
) -> Line<'static> {
let ptr_w = look.pointer.chars().count();
let mark_w = look.marker.chars().count();
let avail = width.saturating_sub(ptr_w + mark_w);
let ansi_spans = look
.ansi
.then(|| ansi_line(line))
.filter(|l| l.spans.len() > 1 || line.contains('\u{1b}'));
let line = &match &ansi_spans {
Some(l) => l
.spans
.iter()
.map(|s| s.content.as_ref())
.collect::<String>(),
None => line.to_string(),
};
let text: String = if line.chars().count() > avail {
let ell = look.ellipsis.chars().count();
line.chars()
.take(avail.saturating_sub(ell))
.chain(look.ellipsis.chars())
.collect()
} else {
line.chars().collect()
};
let row_bg = if current { colors.bg_plus } else { colors.bg }.bg();
let base_style = if current { colors.fg_plus } else { colors.fg }
.fg()
.patch(row_bg);
let ansi_at: Vec<Style> = match &ansi_spans {
Some(l) => l
.spans
.iter()
.flat_map(|sp| {
let keep = match sp.style.fg {
Some(Color::Reset) | None => Style::default(),
Some(c) => Style::default().fg(c),
};
let keep = keep.add_modifier(sp.style.add_modifier);
std::iter::repeat_n(keep, sp.content.chars().count())
})
.collect(),
None => Vec::new(),
};
let styled_run = |from: usize, s: String, over: Style| -> Vec<Span<'static>> {
if ansi_at.is_empty() {
return vec![Span::styled(s, over)];
}
let mut out: Vec<Span<'static>> = Vec::new();
let mut cur = String::new();
let mut cur_style: Option<Style> = None;
for (k, ch) in s.chars().enumerate() {
let st = over.patch(*ansi_at.get(from + k).unwrap_or(&Style::default()));
if cur_style != Some(st) && !cur.is_empty() {
out.push(Span::styled(
std::mem::take(&mut cur),
cur_style.unwrap_or(over),
));
}
cur_style = Some(st);
cur.push(ch);
}
if !cur.is_empty() {
out.push(Span::styled(cur, cur_style.unwrap_or(over)));
}
out
};
let pointer = if current {
Span::styled(look.pointer.clone(), colors.pointer.fg().patch(row_bg))
} else {
Span::styled(
"\u{258c}".repeat(ptr_w.max(1)),
colors.gutter.fg().patch(row_bg),
)
};
let gutter = if marked {
Span::styled(look.marker.clone(), colors.marker.fg().patch(row_bg))
} else {
Span::styled(" ".repeat(mark_w), row_bg)
};
if pattern.is_empty() {
let mut spans = vec![pointer, gutter];
spans.extend(styled_run(0, text, base_style));
return Line::from(spans);
}
let pos: std::collections::HashSet<usize> = pattern.positions(&text).into_iter().collect();
let hl = if current { colors.hl_plus } else { colors.hl }
.fg()
.patch(row_bg);
let mut spans = vec![pointer, gutter];
let mut cur = String::new();
let mut cur_hl = false;
let mut run_start = 0usize;
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);
match cur_hl {
true => spans.push(Span::styled(s, hl)),
false => spans.extend(styled_run(run_start, s, base_style)),
}
run_start = i;
}
cur_hl = h;
cur.push(ch);
}
if !cur.is_empty() {
match cur_hl {
true => spans.push(Span::styled(cur, hl)),
false => spans.extend(styled_run(run_start, cur, base_style)),
}
}
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(),
QueryResult::Error(e) => vec![format!("arb: {e}")],
}
}
#[allow(clippy::too_many_arguments)]
fn render_fzf(
f: &mut Frame,
matched: &[u32],
cands: &[FzfCand],
filter: &str,
pattern: &crate::pattern::Pattern,
sel: usize,
prev_start: usize,
marks: &[String],
multi: bool,
tac: bool,
total: u64,
err: Option<(&[String], &str)>,
preview: Option<(&[String], &str)>,
preview_scroll: usize,
prompt: &str,
header: &str,
theme: Option<crate::theme::Palette>,
look: &crate::fzf::Look,
hitmap: &mut Vec<HitTarget>,
preview_view: &mut Option<(Rect, usize, usize)>,
) -> (usize, 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 = top;
let body = match look.border {
Some((btype, sides)) => {
let block = Block::default()
.borders(sides)
.border_type(btype)
.border_style(look.colors.border.fg());
let inner = block.inner(main_top);
f.render_widget(block, main_top);
Rect {
x: inner.x + 1,
width: inner.width.saturating_sub(1),
..inner
}
}
None => main_top,
};
let colors = match theme {
Some(p) => {
let acc = crate::fzf::Ent {
color: Some(p.accent()),
attrs: Modifier::BOLD,
};
let dim = crate::fzf::Ent {
color: Some(p.dim()),
attrs: Modifier::empty(),
};
crate::fzf::Colors {
fg: crate::fzf::Ent {
color: Some(p.primary()),
attrs: Modifier::empty(),
},
bg: crate::fzf::Ent::default(),
hl: acc,
fg_plus: acc,
bg_plus: crate::fzf::Ent {
color: Some(p.bg()),
attrs: Modifier::empty(),
},
hl_plus: acc,
gutter: crate::fzf::Ent {
color: Some(p.bg()),
attrs: Modifier::empty(),
},
pointer: acc,
marker: acc,
prompt: acc,
query: crate::fzf::Ent {
color: Some(p.primary()),
attrs: Modifier::empty(),
},
info: dim,
spinner: acc,
header: dim,
border: dim,
separator: dim,
scrollbar: dim,
}
}
None => look.colors,
};
let body = match preview {
Some((lines, _)) => {
let area = match look.border.is_some() {
true => Rect {
width: body.width.saturating_sub(1),
..body
},
false => body,
};
let (list, pane) = look.preview_window.split(area);
if let Some(pane) = pane {
*preview_view = Some(render_preview_pane(
f,
pane,
lines,
preview_scroll,
&colors,
look.preview_window.wrap,
));
}
list
}
None => body,
};
let header_h: u16 = u16::from(!header.is_empty());
let info_h: u16 = u16::from(!matches!(
look.info,
crate::fzf::Info::Inline(_) | crate::fzf::Info::InlineRight(_)
));
let reverse = look.layout == crate::fzf::Layout::Reverse;
let rows = if reverse {
Layout::vertical([
Constraint::Length(1),
Constraint::Length(info_h),
Constraint::Length(header_h),
Constraint::Min(0),
])
.split(body)
} else {
Layout::vertical([
Constraint::Min(0),
Constraint::Length(header_h),
Constraint::Length(info_h),
Constraint::Length(1),
])
.split(body)
};
let (prompt_area, info_area, header_area, list_area) = if reverse {
(rows[0], rows[1], rows[2], rows[3])
} else {
(rows[3], rows[2], rows[1], rows[0])
};
let marked = if multi {
format!(" ({})", marks.len())
} else {
String::new()
};
let counter = format!("{}/{total}{marked}", matched.len());
let rule = "\u{2500}";
let text_w = |a: Rect| (a.width as usize).saturating_sub(1);
let list_w = |a: Rect| (a.width as usize).saturating_sub(usize::from(look.scrollbar));
let mut prompt_spans = vec![
Span::styled(prompt.to_string(), colors.prompt.fg()),
Span::styled(filter.to_string(), colors.query.fg()),
];
let used = prompt.chars().count() + filter.chars().count();
match &look.info {
crate::fzf::Info::Inline(prefix) => {
let head = format!(" {prefix}{counter} ");
let fill = text_w(prompt_area).saturating_sub(used + head.chars().count());
prompt_spans.push(Span::styled(head, colors.info.fg()));
prompt_spans.push(Span::styled(rule.repeat(fill), colors.separator.fg()));
}
crate::fzf::Info::InlineRight(prefix) => {
let text = format!("{prefix}{counter}");
let pad = text_w(prompt_area).saturating_sub(used + text.chars().count());
prompt_spans.push(Span::raw(" ".repeat(pad)));
prompt_spans.push(Span::styled(text, colors.info.fg()));
}
_ => {}
}
f.render_widget(Paragraph::new(Line::from(prompt_spans)), prompt_area);
let cx = prompt_area.x + used as u16;
f.set_cursor_position((cx.min(prompt_area.right().saturating_sub(1)), prompt_area.y));
if info_h == 1 {
let w = text_w(info_area);
let cw = counter.chars().count();
let spans = match look.info {
crate::fzf::Info::Hidden => {
vec![Span::styled(rule.repeat(w), colors.separator.fg())]
}
crate::fzf::Info::Right => {
let fill = w.saturating_sub(cw + 1);
vec![
Span::styled(format!("{} ", rule.repeat(fill)), colors.separator.fg()),
Span::styled(counter.clone(), colors.info.fg()),
]
}
_ => {
let fill = w.saturating_sub(cw + 3);
vec![
Span::raw(" "),
Span::styled(counter.clone(), colors.info.fg()),
Span::styled(format!(" {}", rule.repeat(fill)), colors.separator.fg()),
]
}
};
f.render_widget(Paragraph::new(Line::from(spans)), info_area);
}
if !header.is_empty() {
f.render_widget(
Paragraph::new(format!(" {header}")).style(colors.header.fg()),
header_area,
);
}
let inner_w = list_w(list_area);
let list_h = list_area.height as usize;
let n = matched.len();
let sel = sel.min(n.saturating_sub(1));
let max_start = n.saturating_sub(list_h);
let start = fzf_window_start(prev_start, sel, list_h, n, look.scroll_off);
let end = (start + list_h.max(1)).min(n);
let mark_set: std::collections::HashSet<&str> = marks.iter().map(String::as_str).collect();
let mut items: Vec<ListItem> = (start..end)
.filter_map(|pos| {
matched
.get(tac_index(pos, n, tac))
.and_then(|i| cands.get(*i as usize))
.map(|cand| (pos, (cand.disp(), cand.orig())))
})
.map(|(pos, (disp, orig))| {
let current = n > 0 && pos == sel;
let row = fzf_line(
disp,
pattern,
inner_w,
mark_set.contains(orig.as_ref()),
current,
look,
&colors,
);
ListItem::new(row).style(colors.bg.bg())
})
.collect();
if look.layout == crate::fzf::Layout::Default {
items.reverse();
let pad = list_h.saturating_sub(items.len());
let blanks = std::iter::repeat_with(|| ListItem::new("")).take(pad);
items = blanks.chain(items).collect();
}
f.render_widget(
List::new(items),
Rect {
width: inner_w as u16,
..list_area
},
);
if look.scrollbar && n > list_h && list_h > 0 {
let thumb = (list_h * list_h / n).max(1);
let top = match max_start {
0 => 0,
m => start * (list_h - thumb) / m,
};
let top = match look.layout {
crate::fzf::Layout::Default => list_h - thumb - top,
_ => top,
};
let x = list_area.right().saturating_sub(1);
for row in top..top + thumb {
let cell = Rect {
x,
y: list_area.y + row as u16,
width: 1,
height: 1,
};
f.render_widget(
Paragraph::new("\u{2502}").style(colors.scrollbar.fg()),
cell,
);
}
}
hitmap.clear();
hitmap.push(HitTarget {
rect: list_area,
kind: WidgetKind::Select,
control_name: String::new(),
meta_index: None,
tabs: Vec::new(),
});
(start, list_h)
}
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 render_preview_pane(
f: &mut Frame,
area: Rect,
lines: &[String],
scroll: usize,
colors: &crate::fzf::Colors,
wrap: bool,
) -> (Rect, usize, usize) {
let block = Block::default()
.borders(Borders::ALL)
.border_type(ratatui::widgets::BorderType::Rounded)
.border_style(colors.border.fg());
let inner = block.inner(area);
f.render_widget(block, area);
if area.y == 0 {
f.render_widget(
Paragraph::new(" "),
Rect {
x: area.x,
y: area.y,
width: 1,
height: 1,
},
);
}
let inner = Rect {
x: inner.x + 1,
width: inner.width.saturating_sub(1),
..inner
};
let rows = inner.height as usize;
let max_scroll = match wrap {
true => lines.len().saturating_sub(1),
false => lines.len().saturating_sub(rows),
};
let scroll = scroll.min(max_scroll);
let shown = lines.iter().skip(scroll);
if wrap {
let text: Vec<Line> = shown.take(rows * 4).map(|l| ansi_line(l)).collect();
f.render_widget(
Paragraph::new(text).wrap(ratatui::widgets::Wrap { trim: false }),
inner,
);
return (inner, rows, scroll);
}
let items: Vec<ListItem> = shown
.take(rows)
.map(|l| ListItem::new(ansi_line(l)))
.collect();
f.render_widget(List::new(items), inner);
(inner, rows, scroll)
}
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(),
Some(QueryResult::Error(e)) => format!("arb: {e}"),
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(),
Some(QueryResult::Error(e)) => vec![format!("arb: {e}")],
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))
.filled_symbol(symbols::line::THICK_HORIZONTAL)
.unfilled_symbol(symbols::line::THICK_HORIZONTAL)
.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],
Some(QueryResult::Error(_)) => Vec::new(),
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],
Some(QueryResult::Error(_)) => Vec::new(),
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],
Some(QueryResult::Error(_)) => Vec::new(),
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],
Some(QueryResult::Error(_)) => Vec::new(),
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],
Some(QueryResult::Error(_)) => Vec::new(),
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(),
Some(QueryResult::Error(e)) => vec![format!("arb: {e}")],
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(),
Some(QueryResult::Error(e)) => vec![format!("arb: {e}")],
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 fzf_view_tests {
use super::{fzf_key, fzf_row_to_cursor_rev, fzf_window_start, tac_index};
use crate::fzf::Key;
#[test]
fn window_scrolls_where_fzf_scrolls() {
let (h, n, so) = (6, 20, 3);
let mut start = 0;
let tops: Vec<usize> = (0..8)
.map(|sel| {
start = fzf_window_start(start, sel, h, n, so);
start
})
.collect();
assert_eq!(tops, vec![0, 0, 0, 1, 2, 3, 4, 5]);
let end = fzf_window_start(5, 19, h, n, so);
assert_eq!(end, 14);
assert_eq!(fzf_window_start(14, 18, h, n, so), 14);
assert_eq!(fzf_window_start(14, 16, h, n, so), 14);
assert_eq!(fzf_window_start(14, 15, h, n, so), 13);
}
#[test]
fn window_with_a_taller_list_keeps_the_same_margin() {
assert_eq!(fzf_window_start(0, 5, 10, 20, 3), 0);
assert_eq!(fzf_window_start(0, 8, 10, 20, 3), 2);
assert_eq!(fzf_window_start(2, 12, 10, 20, 3), 6);
assert_eq!(fzf_window_start(0, 4, 10, 5, 3), 0);
}
#[test]
fn tac_flips_display_positions_to_ranks() {
assert_eq!(tac_index(0, 10, false), 0);
assert_eq!(tac_index(0, 10, true), 9);
assert_eq!(tac_index(9, 10, true), 0);
assert_eq!(tac_index(0, 0, true), 0);
}
#[test]
fn bottom_up_click_mirrors_the_row() {
assert_eq!(fzf_row_to_cursor_rev(2, 10, 6, 2), 15);
assert_eq!(fzf_row_to_cursor_rev(2, 10, 6, 7), 10);
}
#[test]
fn inline_viewport_ends_on_the_row_the_terminal_reported() {
use super::inline_rect;
let area = inline_rect(9, 6, 80, 24);
assert_eq!((area.y, area.height), (4, 6));
let area = inline_rect(23, 6, 80, 24);
assert_eq!((area.y, area.height), (18, 6));
let area = inline_rect(23, 40, 80, 24);
assert_eq!((area.y, area.height), (0, 24));
}
#[test]
fn min_height_counts_list_rows_when_it_ends_in_plus() {
use super::min_height_rows;
assert_eq!(min_height_rows(10, true, 4, 40), 14);
assert_eq!(min_height_rows(10, false, 4, 40), 10);
assert_eq!(min_height_rows(10, true, 4, 12), 12);
}
#[test]
fn cursor_report_parses_the_row() {
use super::parse_cursor_report;
assert_eq!(parse_cursor_report(b"\x1b[12;40R"), Some(11));
assert_eq!(parse_cursor_report(b"\x1b[1;1R"), Some(0));
assert_eq!(parse_cursor_report(b"q\x1b[7;3R"), Some(6));
assert_eq!(parse_cursor_report(b"\x1b[7;3"), None);
assert_eq!(parse_cursor_report(b""), None);
}
#[test]
fn shift_arrows_are_fzf_key_names() {
assert_eq!(fzf_key(b"\x1b[1;2A", 0), Some((Key::ShiftUp, 6)));
assert_eq!(fzf_key(b"\x1b[1;2B", 0), Some((Key::ShiftDown, 6)));
assert_eq!(fzf_key(b"\x1b[1;5A", 0), None);
}
#[test]
fn preview_actions_scroll_by_line_page_and_half_page() {
use super::{fzf_action, Controls};
use crate::fzf::Action;
use ratatui::layout::Rect;
let mut c = Controls {
preview_view: Some((Rect::new(0, 0, 40, 10), 10)),
..Default::default()
};
fzf_action(&mut c, &[Action::PreviewDown, Action::PreviewDown]);
assert_eq!(c.preview_scroll, 2);
fzf_action(&mut c, &[Action::PreviewPageDown]);
assert_eq!(c.preview_scroll, 12);
fzf_action(&mut c, &[Action::PreviewHalfPageUp]);
assert_eq!(c.preview_scroll, 6); fzf_action(&mut c, &[Action::PreviewUp, Action::PreviewTop]);
assert_eq!(c.preview_scroll, 0);
fzf_action(&mut c, &[Action::PreviewPageUp]);
assert_eq!(c.preview_scroll, 0);
assert_eq!(c.cursor, 0);
}
#[test]
fn wheel_over_the_preview_pane_scrolls_it_not_the_list() {
use super::{dispatch_mouse, Controls, MouseEvent, MouseKind};
use ratatui::layout::Rect;
let ev = |kind, col| MouseEvent {
kind,
col,
row: 3,
button: 0,
press: true,
};
let mut c = Controls {
cursor: 5,
preview_scroll: 4,
preview_view: Some((Rect::new(20, 1, 20, 8), 8)),
..Default::default()
};
let now = std::time::Instant::now();
dispatch_mouse(&mut c, ev(MouseKind::ScrollDown, 25), true, now);
assert_eq!((c.cursor, c.preview_scroll), (5, 5));
dispatch_mouse(&mut c, ev(MouseKind::ScrollUp, 25), true, now);
assert_eq!((c.cursor, c.preview_scroll), (5, 4));
dispatch_mouse(&mut c, ev(MouseKind::ScrollDown, 5), true, now);
assert_eq!((c.cursor, c.preview_scroll), (6, 4));
}
#[test]
fn preview_pane_scroll_is_clamped_to_the_last_full_page() {
use super::render_preview_pane;
use ratatui::backend::TestBackend;
use ratatui::layout::Rect;
use ratatui::Terminal;
let lines: Vec<String> = (0..20).map(|i| format!("line{i:02}")).collect();
let colors = crate::fzf::Colors::default();
let mut term = Terminal::new(TestBackend::new(30, 8)).unwrap();
let mut got = None;
term.draw(|f| {
got = Some(render_preview_pane(
f,
Rect::new(0, 0, 30, 8),
&lines,
usize::MAX,
&colors,
false,
));
})
.unwrap();
let (rect, rows, scroll) = got.unwrap();
assert_eq!(rows, 6);
assert_eq!(scroll, 14); let buf = term.backend().buffer();
let text: String = (0..rect.height)
.map(|y| {
(0..rect.width)
.map(|x| buf[(rect.x + x, rect.y + y)].symbol().to_string())
.collect::<String>()
})
.collect::<Vec<_>>()
.join("\n");
assert!(text.contains("line14"), "{text}");
assert!(text.contains("line19"), "{text}");
assert!(!text.contains("line13"), "{text}");
}
#[test]
fn keystrokes_map_to_fzf_key_names() {
assert_eq!(fzf_key(b"\x0e", 0), Some((Key::Ctrl('n'), 1)));
assert_eq!(fzf_key(b"\t", 0), Some((Key::Tab, 1)));
assert_eq!(fzf_key(b"\r", 0), Some((Key::Enter, 1)));
assert_eq!(fzf_key(b"\x1b[A", 0), Some((Key::Up, 3)));
assert_eq!(fzf_key(b"\x1b[5~", 0), Some((Key::PageUp, 4)));
assert_eq!(fzf_key(b"\x1b[Z", 0), Some((Key::BTab, 3)));
assert_eq!(fzf_key(b"\x1bx", 0), Some((Key::Alt('x'), 2)));
assert_eq!(fzf_key(b"\x1b", 0), Some((Key::Esc, 1)));
assert_eq!(fzf_key(b"?", 0), Some((Key::Char('?'), 1)));
}
}
#[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,
look: crate::fzf::Look {
layout: crate::fzf::Layout::Reverse,
..crate::fzf::Look::default()
},
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 {
fzf_list_start: 10,
fzf_page: 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, 17); 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);
}
#[test]
fn split_wheel_reports_scroll_instead_of_typing_themselves() {
use super::{drain_keys, Controls};
use std::sync::{Arc, Mutex};
let burst: Vec<u8> = b"\x1b[<64;33;10M".repeat(6);
for size in [1usize, 3, 5, 8, 12, 32, 64] {
let c = Arc::new(Mutex::new(Controls {
fzf: true,
cursor: 10,
..Default::default()
}));
let mut pend: Vec<u8> = Vec::new();
for chunk in burst.chunks(size) {
pend.extend_from_slice(chunk);
assert!(!drain_keys(&c, &mut pend, true), "chunk {size}: stopped");
}
let g = c.lock().unwrap();
assert_eq!(g.filter, "", "chunk {size}: mouse bytes leaked as text");
assert_eq!(g.cursor, 4, "chunk {size}: 6 wheel-ups not applied");
assert!(!g.quit, "chunk {size}: a split report quit the UI");
assert!(pend.is_empty(), "chunk {size}: bytes left uncarried");
}
}
#[test]
fn long_csi_sequences_are_swallowed_not_typed() {
use super::{csi_len, drain_keys, Controls};
use std::sync::{Arc, Mutex};
assert_eq!(csi_len(b"\x1b[A", 0), Some(3));
assert_eq!(csi_len(b"\x1b[1;5A", 0), Some(6));
assert_eq!(csi_len(b"\x1b[15~", 0), Some(5));
assert_eq!(csi_len(b"\x1b[<64;33;10M", 0), Some(12));
assert_eq!(csi_len(b"\x1b[200~", 0), Some(6));
assert_eq!(csi_len(b"\x1b[1;5", 0), None);
let c = Arc::new(Mutex::new(Controls {
fzf: true,
cursor: 5,
..Default::default()
}));
let mut pend = b"\x1b[1;5A\x1b[15~\x1b[1;5B".to_vec();
assert!(!drain_keys(&c, &mut pend, true));
let g = c.lock().unwrap();
assert_eq!(g.filter, "", "CSI tail leaked into the filter");
assert_eq!(g.cursor, 5, "Ctrl-Up then Ctrl-Down nets zero movement");
assert!(pend.is_empty());
}
#[test]
fn lone_esc_still_quits_after_the_escape_wait() {
use super::{drain_keys, Controls};
use std::sync::{Arc, Mutex};
let c = Arc::new(Mutex::new(Controls {
fzf: true,
..Default::default()
}));
let mut pend = b"\x1b".to_vec();
assert!(!drain_keys(&c, &mut pend, true)); assert_eq!(pend, b"\x1b");
assert!(!c.lock().unwrap().quit);
assert!(drain_keys(&c, &mut pend, false)); assert!(c.lock().unwrap().quit);
}
#[test]
fn partial_escape_spots_truncated_sequences_only() {
use super::partial_escape;
for t in [
&b"\x1b"[..],
b"\x1b[",
b"\x1b[<",
b"\x1b[<64",
b"\x1b[<64;33;",
b"\x1b[<64;33;10",
] {
assert!(partial_escape(t, 0), "{t:?} should be carried");
}
for t in [
&b"\x1b[<64;33;10M"[..], b"\x1b[<0;1;1m", b"\x1b[A", b"\x1b[1;5A", b"\x1b[15~", b"abc", b"\x1bO", ] {
assert!(!partial_escape(t, 0), "{t:?} should decode now");
}
assert!(!partial_escape(b"\x1b[<64;33;10M\x1b[<64;3", 0));
assert!(partial_escape(b"\x1b[<64;33;10M\x1b[<64;3", 12));
}
}