475 lines
17 KiB
Rust
475 lines
17 KiB
Rust
//! The terminal runtime: raw mode and alternate screen, an input thread,
|
|
//! timers and background commands feeding one message loop, and a
|
|
//! line-diffing frame writer.
|
|
//!
|
|
//! The terminal is restored on every exit path: normal quit, errors and
|
|
//! panics (a panic hook restores it before the default hook prints; the
|
|
//! scanner aborts the process on worker panics after the hook has run).
|
|
|
|
use super::model::{debug_panic, Button, Cmd, Key, Model, Msg, Options, Profile};
|
|
use crate::brand;
|
|
use crate::cancel::Cancel;
|
|
use crate::textutil;
|
|
use crossbeam_channel::{after, select, Receiver, Sender};
|
|
use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers, MouseButton, MouseEventKind};
|
|
use crossterm::{cursor, execute, terminal};
|
|
use std::fmt::Write as _;
|
|
use std::io::{self, Write};
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::sync::{Arc, Once};
|
|
use std::time::{Duration, Instant};
|
|
|
|
/// Whether the terminal is currently in TUI mode (raw, alternate screen).
|
|
static ACTIVE: AtomicBool = AtomicBool::new(false);
|
|
/// Set by the SIGTERM handler; the input thread turns it into a quit.
|
|
static TERMINATED: AtomicBool = AtomicBool::new(false);
|
|
|
|
/// Mouse off (1000/1002/1003/1015/1006), bracketed paste off, cursor on,
|
|
/// main screen.
|
|
const RESTORE: &str = "\x1b[?1006l\x1b[?1015l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?2004l\x1b[?25h\x1b[?1049l";
|
|
|
|
fn write_raw(s: &str) {
|
|
let mut b = s.as_bytes();
|
|
while !b.is_empty() {
|
|
let n = unsafe { libc::write(1, b.as_ptr().cast(), b.len()) };
|
|
if n <= 0 {
|
|
return;
|
|
}
|
|
b = &b[n as usize..];
|
|
}
|
|
}
|
|
|
|
/// Leaves TUI mode. Safe to call repeatedly and from the panic hook (it
|
|
/// writes directly to fd 1, so it cannot block on a stdout lock).
|
|
fn restore_terminal() {
|
|
if ACTIVE.swap(false, Ordering::SeqCst) {
|
|
write_raw(RESTORE);
|
|
let _ = terminal::disable_raw_mode();
|
|
}
|
|
}
|
|
|
|
fn install_panic_hook() {
|
|
static ONCE: Once = Once::new();
|
|
ONCE.call_once(|| {
|
|
let prev = std::panic::take_hook();
|
|
std::panic::set_hook(Box::new(move |info| {
|
|
restore_terminal();
|
|
prev(info);
|
|
}));
|
|
extern "C" fn on_term(_: libc::c_int) {
|
|
TERMINATED.store(true, Ordering::SeqCst);
|
|
}
|
|
unsafe { libc::signal(libc::SIGTERM, on_term as *const () as libc::sighandler_t) };
|
|
});
|
|
}
|
|
|
|
fn forced_profile(c: &str) -> Option<Profile> {
|
|
match c {
|
|
"truecolor" | "24bit" => Some(Profile::TrueColor),
|
|
"256" => Some(Profile::Ansi256),
|
|
"16" => Some(Profile::Ansi),
|
|
"none" => Some(Profile::Ascii),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Detects the colour profile from the environment (NO_COLOR, COLORTERM,
|
|
/// TERM). Over SSH COLORTERM is often not forwarded; --color overrides.
|
|
fn detect_profile() -> Profile {
|
|
let env = |k: &str| std::env::var(k).unwrap_or_default().to_lowercase();
|
|
let (term, ct) = (env("TERM"), env("COLORTERM"));
|
|
if !env("NO_COLOR").is_empty() || term == "dumb" {
|
|
return Profile::Ascii;
|
|
}
|
|
if ct == "truecolor" || ct == "24bit" || term.ends_with("-direct") {
|
|
return Profile::TrueColor;
|
|
}
|
|
if ["kitty", "alacritty", "wezterm", "ghostty", "foot", "contour", "rio"].iter().any(|t| term.contains(t)) {
|
|
return Profile::TrueColor;
|
|
}
|
|
if term.contains("256color") || !ct.is_empty() {
|
|
return Profile::Ansi256;
|
|
}
|
|
Profile::Ansi
|
|
}
|
|
|
|
/// Starts the interactive UI.
|
|
pub fn run(opts: Options) -> Result<(), crate::Error> {
|
|
let cancel = Cancel::new();
|
|
let (s, t) = (opts.start)(cancel.clone())?;
|
|
let forced = forced_profile(&opts.color);
|
|
if forced.is_none() && !opts.color.is_empty() && opts.color != "auto" {
|
|
cancel.cancel();
|
|
return Err(format!("invalid --color {:?} (auto, truecolor, 256, 16, none)", opts.color).into());
|
|
}
|
|
let mouse = opts.mouse;
|
|
let mut m = Model::new(opts, s, t, cancel.clone());
|
|
m.profile = forced.unwrap_or_else(detect_profile);
|
|
|
|
install_panic_hook();
|
|
if debug_panic() == "scanner" {
|
|
std::thread::spawn(|| {
|
|
std::thread::sleep(Duration::from_millis(500));
|
|
// Mirrors the scanner's guard: a worker panic aborts after the hook.
|
|
if std::panic::catch_unwind(|| panic!("MAPSIZE_DEBUG_PANIC=scanner: deliberate panic to test terminal restoration")).is_err() {
|
|
std::process::abort();
|
|
}
|
|
});
|
|
}
|
|
let res = enter_terminal(mouse).and_then(|_| event_loop(&mut m));
|
|
restore_terminal();
|
|
cancel.cancel();
|
|
m.cancel.cancel(); // a rescan may have replaced the token
|
|
Ok(res?)
|
|
}
|
|
|
|
fn enter_terminal(mouse: bool) -> io::Result<()> {
|
|
terminal::enable_raw_mode()?;
|
|
ACTIVE.store(true, Ordering::SeqCst);
|
|
let mut out = io::stdout();
|
|
execute!(out, terminal::EnterAlternateScreen, cursor::Hide, event::EnableBracketedPaste, terminal::SetTitle(brand::NAME))?;
|
|
if mouse {
|
|
execute!(out, event::EnableMouseCapture)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Bubble Tea keystroke name for a key event.
|
|
fn convert_key(ev: KeyEvent) -> Option<Key> {
|
|
if ev.kind == KeyEventKind::Release {
|
|
return None;
|
|
}
|
|
let m = ev.modifiers;
|
|
let (ctrl, alt, shift) = (m.contains(KeyModifiers::CONTROL), m.contains(KeyModifiers::ALT), m.contains(KeyModifiers::SHIFT));
|
|
let mut prefix = String::new();
|
|
if ctrl {
|
|
prefix += "ctrl+";
|
|
}
|
|
if alt {
|
|
prefix += "alt+";
|
|
}
|
|
let named = |n: &str| Some(Key { name: format!("{prefix}{}{n}", if shift { "shift+" } else { "" }), text: String::new(), ctrl_alt: ctrl || alt });
|
|
match ev.code {
|
|
KeyCode::Char(c) => {
|
|
let base = if c == ' ' { "space".to_string() } else if ctrl || alt { c.to_lowercase().collect() } else { c.to_string() };
|
|
let text = if ctrl || alt { String::new() } else { c.to_string() };
|
|
Some(Key { name: prefix + &base, text, ctrl_alt: ctrl || alt })
|
|
}
|
|
KeyCode::BackTab => Some(Key { name: format!("{prefix}shift+tab"), ..Default::default() }),
|
|
KeyCode::Enter => named("enter"),
|
|
KeyCode::Esc => named("esc"),
|
|
KeyCode::Tab => named("tab"),
|
|
KeyCode::Backspace => named("backspace"),
|
|
KeyCode::Delete => named("delete"),
|
|
KeyCode::Insert => named("insert"),
|
|
KeyCode::Home => named("home"),
|
|
KeyCode::End => named("end"),
|
|
KeyCode::PageUp => named("pgup"),
|
|
KeyCode::PageDown => named("pgdown"),
|
|
KeyCode::Up => named("up"),
|
|
KeyCode::Down => named("down"),
|
|
KeyCode::Left => named("left"),
|
|
KeyCode::Right => named("right"),
|
|
KeyCode::F(n) => named(&format!("f{n}")),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn convert(ev: Event) -> Option<Msg> {
|
|
match ev {
|
|
Event::Key(k) => convert_key(k).map(Msg::Key),
|
|
Event::Resize(w, h) => Some(Msg::Size(w as i32, h as i32)),
|
|
Event::Mouse(me) => {
|
|
let (x, y) = (me.column as i32, me.row as i32);
|
|
match me.kind {
|
|
MouseEventKind::Down(b) => {
|
|
let button = match b {
|
|
MouseButton::Left => Button::Left,
|
|
MouseButton::Right => Button::Right,
|
|
MouseButton::Middle => Button::Middle,
|
|
};
|
|
Some(Msg::Click { x, y, button })
|
|
}
|
|
MouseEventKind::ScrollUp => Some(Msg::Wheel { x, y, up: true }),
|
|
MouseEventKind::ScrollDown => Some(Msg::Wheel { x, y, up: false }),
|
|
MouseEventKind::Moved | MouseEventKind::Drag(_) => Some(Msg::Motion { x, y }),
|
|
_ => None,
|
|
}
|
|
}
|
|
// Pastes are ignored, as in the Go version.
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Reads terminal events until stopped.
|
|
fn input_thread(tx: Sender<Msg>, stop: Arc<AtomicBool>) {
|
|
while !stop.load(Ordering::Relaxed) {
|
|
if TERMINATED.load(Ordering::SeqCst) {
|
|
let _ = tx.send(Msg::Quit);
|
|
return;
|
|
}
|
|
match event::poll(Duration::from_millis(100)) {
|
|
Ok(true) => match event::read() {
|
|
Ok(ev) => {
|
|
if let Some(msg) = convert(ev) {
|
|
if tx.send(msg).is_err() {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Err(_) => return,
|
|
},
|
|
Ok(false) => {}
|
|
Err(_) => return,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Executes commands: background closures on threads, timers in the loop,
|
|
/// clipboard writes into the output.
|
|
struct Runtime {
|
|
tx: Sender<Msg>,
|
|
timers: Vec<(Instant, Msg)>,
|
|
out: String, // pending escape sequences (clipboard)
|
|
}
|
|
|
|
impl Runtime {
|
|
fn exec(&mut self, cmd: Cmd) {
|
|
match cmd {
|
|
Cmd::None => {}
|
|
Cmd::Batch(v) => v.into_iter().for_each(|c| self.exec(c)),
|
|
Cmd::Run(f) => {
|
|
let tx = self.tx.clone();
|
|
std::thread::spawn(move || {
|
|
let _ = tx.send(f());
|
|
});
|
|
}
|
|
Cmd::Tick(d, msg) => self.timers.push((Instant::now() + d, msg)),
|
|
Cmd::Clipboard(s) => {
|
|
let _ = write!(self.out, "\x1b]52;c;{}\x07", base64(s.as_bytes()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn base64(b: &[u8]) -> String {
|
|
const A: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
let mut s = String::with_capacity(b.len().div_ceil(3) * 4);
|
|
for c in b.chunks(3) {
|
|
let n = (c[0] as u32) << 16 | (*c.get(1).unwrap_or(&0) as u32) << 8 | *c.get(2).unwrap_or(&0) as u32;
|
|
for i in 0..4 {
|
|
if i <= c.len() {
|
|
s.push(A[(n >> (18 - 6 * i) & 63) as usize] as char);
|
|
} else {
|
|
s.push('=');
|
|
}
|
|
}
|
|
}
|
|
s
|
|
}
|
|
|
|
/// Writes frames, rewriting only what changed since the last one: within a
|
|
/// changed line, the span between the first and last differing style run.
|
|
#[derive(Default)]
|
|
struct Screen {
|
|
prev: Vec<String>,
|
|
size: (i32, i32),
|
|
buf: String,
|
|
}
|
|
|
|
/// Splits a serialised line into its SGR-led runs as (start byte, start
|
|
/// column). The canvas emits an escape only to start a run (text is
|
|
/// sanitised), and the trailing reset is a zero-width run.
|
|
fn runs(l: &str) -> Vec<(usize, usize)> {
|
|
let starts: Vec<usize> = l.match_indices("\x1b[").map(|(i, _)| i).collect();
|
|
let mut col = 0;
|
|
let mut out = Vec::with_capacity(starts.len());
|
|
for (k, &s) in starts.iter().enumerate() {
|
|
let seg = &l[s..starts.get(k + 1).copied().unwrap_or(l.len())];
|
|
out.push((s, col));
|
|
col += textutil::width(&seg[seg.find('m').map_or(seg.len(), |p| p + 1)..]);
|
|
}
|
|
out
|
|
}
|
|
|
|
/// The changed parts of a line as (column, byte range of new): runs of new
|
|
/// that do not appear unchanged at the same column in old, grouped into
|
|
/// contiguous segments. Empty if the lines are equal.
|
|
fn line_diff(old: &str, new: &str) -> Vec<(usize, std::ops::Range<usize>)> {
|
|
if old == new {
|
|
return Vec::new();
|
|
}
|
|
let (ro, rn) = (runs(old), runs(new));
|
|
let end = |l: &str, r: &[(usize, usize)], k: usize| r.get(k + 1).map_or(l.len(), |x| x.0);
|
|
let mut changed = vec![true; rn.len()];
|
|
let (mut i, mut j) = (0, 0);
|
|
while i < ro.len() && j < rn.len() {
|
|
let (co, cn) = (ro[i].1, rn[j].1);
|
|
if co == cn {
|
|
changed[j] = old[ro[i].0..end(old, &ro, i)] != new[rn[j].0..end(new, &rn, j)];
|
|
(i, j) = (i + 1, j + 1);
|
|
} else if co < cn {
|
|
i += 1;
|
|
} else {
|
|
j += 1;
|
|
}
|
|
}
|
|
let mut out: Vec<(usize, std::ops::Range<usize>)> = Vec::new();
|
|
for (k, &c) in changed.iter().enumerate() {
|
|
if !c {
|
|
continue;
|
|
}
|
|
let r = rn[k].0..end(new, &rn, k);
|
|
match out.last_mut() {
|
|
Some(last) if last.1.end == r.start => last.1.end = r.end,
|
|
_ => out.push((rn[k].1, r)),
|
|
}
|
|
}
|
|
if out.is_empty() {
|
|
out.push((0, 0..new.len())); // a line without runs (cannot happen)
|
|
}
|
|
out
|
|
}
|
|
|
|
impl Screen {
|
|
fn draw(&mut self, out: &mut impl Write, frame: &str, w: i32, h: i32, extra: &str) -> io::Result<()> {
|
|
self.buf.clear();
|
|
self.buf.push_str("\x1b[?2026h"); // synchronized output, where supported
|
|
if (w, h) != self.size {
|
|
self.buf.push_str("\x1b[0m\x1b[2J");
|
|
self.prev.clear();
|
|
self.size = (w, h);
|
|
}
|
|
let mut n = 0;
|
|
for (y, l) in frame.split('\n').enumerate() {
|
|
match self.prev.get_mut(y) {
|
|
Some(p) => {
|
|
let d = line_diff(p, l);
|
|
for (col, r) in &d {
|
|
let _ = write!(self.buf, "\x1b[{};{}H{}", y + 1, col + 1, &l[r.clone()]);
|
|
}
|
|
if !d.is_empty() {
|
|
p.clear();
|
|
p.push_str(l);
|
|
}
|
|
}
|
|
None => {
|
|
let _ = write!(self.buf, "\x1b[{};1H{l}", y + 1);
|
|
self.prev.push(l.to_string());
|
|
}
|
|
}
|
|
n = y + 1;
|
|
}
|
|
self.prev.truncate(n);
|
|
self.buf.push_str(extra);
|
|
self.buf.push_str("\x1b[?2026l");
|
|
out.write_all(self.buf.as_bytes())?;
|
|
out.flush()
|
|
}
|
|
}
|
|
|
|
fn next_msg(rx: &Receiver<Msg>, timers: &[(Instant, Msg)]) -> Option<Msg> {
|
|
match timers.iter().map(|t| t.0).min() {
|
|
Some(d) => select! {
|
|
recv(rx) -> msg => msg.ok(),
|
|
recv(after(d.saturating_duration_since(Instant::now()))) -> _ => None,
|
|
},
|
|
None => rx.recv().ok(),
|
|
}
|
|
}
|
|
|
|
fn event_loop(m: &mut Model) -> io::Result<()> {
|
|
let (tx, rx) = crossbeam_channel::unbounded::<Msg>();
|
|
let stop = Arc::new(AtomicBool::new(false));
|
|
{
|
|
let (tx, stop) = (tx.clone(), stop.clone());
|
|
std::thread::spawn(move || input_thread(tx, stop));
|
|
}
|
|
let (w, h) = terminal::size()?;
|
|
let mut rt = Runtime { tx, timers: Vec::new(), out: String::new() };
|
|
rt.exec(m.update(Msg::Size(w as i32, h as i32)));
|
|
let init = m.init();
|
|
rt.exec(init);
|
|
let mut screen = Screen::default();
|
|
let mut stdout = io::stdout();
|
|
let mut last = String::new();
|
|
let res = loop {
|
|
if m.quit {
|
|
break Ok(());
|
|
}
|
|
let (w, h) = (m.w, m.h);
|
|
let frame = m.view();
|
|
if frame != last || !rt.out.is_empty() {
|
|
if let Err(e) = screen.draw(&mut stdout, frame, w, h, &rt.out) {
|
|
break Err(e);
|
|
}
|
|
last.clear();
|
|
last.push_str(frame);
|
|
rt.out.clear();
|
|
}
|
|
if let Some(msg) = next_msg(&rx, &rt.timers) {
|
|
let c = m.update(msg);
|
|
rt.exec(c);
|
|
}
|
|
// Fire due timers, then drain whatever else is queued before the next
|
|
// frame, so bursts (resize storms) cost one render.
|
|
let now = Instant::now();
|
|
let (due, later): (Vec<_>, Vec<_>) = std::mem::take(&mut rt.timers).into_iter().partition(|t| t.0 <= now);
|
|
rt.timers = later;
|
|
for (_, msg) in due {
|
|
let c = m.update(msg);
|
|
rt.exec(c);
|
|
}
|
|
while let Ok(msg) = rx.try_recv() {
|
|
if m.quit {
|
|
break;
|
|
}
|
|
let c = m.update(msg);
|
|
rt.exec(c);
|
|
}
|
|
};
|
|
stop.store(true, Ordering::Relaxed);
|
|
res
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn base64_matches_rfc4648() {
|
|
for (i, o) in [("", ""), ("f", "Zg=="), ("fo", "Zm8="), ("foo", "Zm9v"), ("foob", "Zm9vYg=="), ("foobar", "Zm9vYmFy")] {
|
|
assert_eq!(base64(i.as_bytes()), o);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn screen_rewrites_only_changed_lines() {
|
|
let mut s = Screen::default();
|
|
let mut out = Vec::new();
|
|
s.draw(&mut out, "a\nb\nc", 1, 3, "").unwrap();
|
|
out.clear();
|
|
s.draw(&mut out, "a\nX\nc", 1, 3, "").unwrap();
|
|
assert_eq!(String::from_utf8(out).unwrap(), "\x1b[?2026h\x1b[2;1HX\x1b[?2026l");
|
|
// Within a line only the differing style runs are rewritten.
|
|
let a = "\x1b[0;1mab\x1b[0;7m日x\x1b[0mcd\x1b[0m";
|
|
let b = "\x1b[0;1mab\x1b[0;7m日y\x1b[0mcd\x1b[0m";
|
|
assert_eq!(line_diff(a, b), vec![(2, 8..18)]);
|
|
assert_eq!(&b[8..18], "\x1b[0;7m日y");
|
|
assert!(line_diff(a, a).is_empty());
|
|
let c = "\x1b[0;2mab\x1b[0;7m日x\x1b[0mcz\x1b[0m";
|
|
assert_eq!(line_diff(a, c), vec![(0, 0..8), (5, 18..24)]);
|
|
}
|
|
|
|
#[test]
|
|
fn keys_use_bubbletea_names() {
|
|
let k = |code, m| convert_key(KeyEvent::new(code, m)).unwrap().name;
|
|
assert_eq!(k(KeyCode::Char('c'), KeyModifiers::CONTROL), "ctrl+c");
|
|
assert_eq!(k(KeyCode::Char('G'), KeyModifiers::SHIFT), "G");
|
|
assert_eq!(k(KeyCode::Char(' '), KeyModifiers::NONE), "space");
|
|
assert_eq!(k(KeyCode::BackTab, KeyModifiers::SHIFT), "shift+tab");
|
|
assert_eq!(k(KeyCode::PageDown, KeyModifiers::NONE), "pgdown");
|
|
assert_eq!(k(KeyCode::Backspace, KeyModifiers::ALT), "alt+backspace");
|
|
}
|
|
}
|