Skip to main content

rigspark_cli/
tui_view.rs

1use crossterm::{
2    cursor::{Hide, Show},
3    event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers},
4    execute,
5    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
6};
7use futures_util::StreamExt;
8use ratatui::{
9    Frame, Terminal,
10    backend::CrosstermBackend,
11    layout::{Constraint, Layout},
12    style::{Color, Modifier, Style},
13    widgets::{List, ListItem, ListState, Paragraph},
14};
15use rigspark_core::reports::strip_control;
16use std::io;
17use unicode_segmentation::UnicodeSegmentation;
18
19pub struct ReportView {
20    title: String,
21    lines: Vec<String>,
22    state: ListState,
23    query: String,
24    searching: bool,
25    color: bool,
26    horizontal: usize,
27    page: usize,
28}
29
30impl ReportView {
31    pub fn new(title: &str, text: &str, color: bool) -> io::Result<Self> {
32        if text.len() > 1024 * 1024 || text.lines().count() > 20000 || title.len() > 256 {
33            return Err(io::Error::other("report exceeds terminal display limits"));
34        }
35        let mut lines: Vec<_> = text.lines().map(strip_control).collect();
36        if lines.is_empty() {
37            lines.push("No results".into());
38        }
39        Ok(Self {
40            title: strip_control(title),
41            lines,
42            state: ListState::default().with_selected(Some(0)),
43            query: String::new(),
44            searching: false,
45            color,
46            horizontal: 0,
47            page: 10,
48        })
49    }
50    pub fn selected(&self) -> usize {
51        self.state.selected().unwrap_or(0)
52    }
53    fn select(&mut self, selected: usize) {
54        self.state.select(Some(selected.min(self.lines.len() - 1)));
55    }
56    fn find(&mut self, next: bool) {
57        if self.query.is_empty() {
58            return;
59        }
60        let query = self.query.to_lowercase();
61        let start = if next { self.selected() + 1 } else { 0 };
62        for offset in 0..self.lines.len() {
63            let index = (start + offset) % self.lines.len();
64            if self.lines[index].to_lowercase().contains(&query) {
65                self.select(index);
66                break;
67            }
68        }
69    }
70}
71
72pub fn handle_key(view: &mut ReportView, key: KeyEvent) -> bool {
73    if key.kind == KeyEventKind::Release {
74        return false;
75    }
76    if key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c') {
77        return true;
78    }
79    if view.searching {
80        match key.code {
81            KeyCode::Esc => {
82                view.searching = false;
83                view.query.clear();
84            }
85            KeyCode::Enter => view.searching = false,
86            KeyCode::Backspace => {
87                view.query.pop();
88                view.find(false);
89            }
90            KeyCode::Char(character)
91                if !character.is_control() && view.query.len() + character.len_utf8() <= 256 =>
92            {
93                view.query.push(character);
94                view.find(false);
95            }
96            _ => (),
97        }
98        return false;
99    }
100    match key.code {
101        KeyCode::Char('q') | KeyCode::Esc | KeyCode::Enter => return true,
102        KeyCode::Down | KeyCode::Char('j') => view.select(view.selected().saturating_add(1)),
103        KeyCode::Up | KeyCode::Char('k') => view.select(view.selected().saturating_sub(1)),
104        KeyCode::PageDown => view.select(view.selected().saturating_add(view.page)),
105        KeyCode::PageUp => view.select(view.selected().saturating_sub(view.page)),
106        KeyCode::Home => view.select(0),
107        KeyCode::End => view.select(view.lines.len() - 1),
108        KeyCode::Right => view.horizontal = view.horizontal.saturating_add(8).min(32768),
109        KeyCode::Left => view.horizontal = view.horizontal.saturating_sub(8),
110        KeyCode::Char('/') => {
111            view.searching = true;
112            view.query.clear();
113        }
114        KeyCode::Char('n') => view.find(true),
115        _ => (),
116    }
117    false
118}
119
120pub fn render(frame: &mut Frame<'_>, view: &mut ReportView) {
121    let [header, body, footer] = Layout::vertical([
122        Constraint::Length(1),
123        Constraint::Min(1),
124        Constraint::Length(1),
125    ])
126    .areas(frame.area());
127    view.page = usize::from(body.height.max(1));
128    let accent = if view.color {
129        Style::default().fg(Color::Cyan)
130    } else {
131        Style::default()
132    };
133    frame.render_widget(
134        Paragraph::new(view.title.as_str()).style(accent.add_modifier(Modifier::BOLD)),
135        header,
136    );
137    let items: Vec<_> = view
138        .lines
139        .iter()
140        .map(|line| {
141            ListItem::new(
142                line.graphemes(true)
143                    .skip(view.horizontal)
144                    .collect::<String>(),
145            )
146        })
147        .collect();
148    frame.render_stateful_widget(
149        List::new(items)
150            .highlight_symbol("> ")
151            .highlight_style(accent.add_modifier(Modifier::REVERSED)),
152        body,
153        &mut view.state,
154    );
155    let status = if view.searching {
156        format!("/{}", view.query)
157    } else {
158        format!("{} / {}", view.selected() + 1, view.lines.len())
159    };
160    frame.render_widget(Paragraph::new(status), footer);
161}
162
163#[derive(Clone, Copy, Debug, PartialEq, Eq)]
164pub(crate) enum TerminalResource {
165    Raw,
166    Alternate,
167    Cursor,
168    Paste,
169}
170
171const TERMINAL_RESOURCES: [TerminalResource; 4] = [
172    TerminalResource::Raw,
173    TerminalResource::Alternate,
174    TerminalResource::Cursor,
175    TerminalResource::Paste,
176];
177
178pub(crate) trait TerminalControl {
179    fn raw(&self) -> io::Result<bool>;
180    fn set(&mut self, resource: TerminalResource, enabled: bool) -> io::Result<()>;
181}
182
183pub(crate) struct SystemTerminal;
184
185impl TerminalControl for SystemTerminal {
186    fn raw(&self) -> io::Result<bool> {
187        crossterm::terminal::is_raw_mode_enabled()
188    }
189    fn set(&mut self, resource: TerminalResource, enabled: bool) -> io::Result<()> {
190        match (resource, enabled) {
191            (TerminalResource::Raw, true) => enable_raw_mode(),
192            (TerminalResource::Raw, false) => disable_raw_mode(),
193            (TerminalResource::Alternate, true) => execute!(io::stderr(), EnterAlternateScreen),
194            (TerminalResource::Alternate, false) => execute!(io::stderr(), LeaveAlternateScreen),
195            (TerminalResource::Cursor, true) => execute!(io::stderr(), Hide),
196            (TerminalResource::Cursor, false) => execute!(io::stderr(), Show),
197            (TerminalResource::Paste, true) => {
198                execute!(io::stderr(), crossterm::event::EnableBracketedPaste)
199            }
200            (TerminalResource::Paste, false) => {
201                execute!(io::stderr(), crossterm::event::DisableBracketedPaste)
202            }
203        }
204    }
205}
206
207pub(crate) struct RestoreTerminal<Control: TerminalControl = SystemTerminal> {
208    control: Control,
209    initially_raw: bool,
210    acquired: usize,
211}
212
213impl<Control: TerminalControl> RestoreTerminal<Control> {
214    fn acquire(control: Control) -> io::Result<Self> {
215        let initially_raw = control.raw()?;
216        let mut restore = Self {
217            control,
218            initially_raw,
219            acquired: 0,
220        };
221        for resource in TERMINAL_RESOURCES {
222            restore.acquired += 1;
223            restore.control.set(resource, true)?;
224        }
225        Ok(restore)
226    }
227}
228
229impl<Control: TerminalControl> Drop for RestoreTerminal<Control> {
230    fn drop(&mut self) {
231        for resource in TERMINAL_RESOURCES[..self.acquired].iter().rev() {
232            let enabled = *resource == TerminalResource::Raw && self.initially_raw;
233            let _ = self.control.set(*resource, enabled);
234        }
235    }
236}
237
238pub(crate) fn enter_terminal()
239-> io::Result<(Terminal<CrosstermBackend<io::Stderr>>, RestoreTerminal)> {
240    let restore = RestoreTerminal::acquire(SystemTerminal)?;
241    let terminal = Terminal::new(CrosstermBackend::new(io::stderr()))?;
242    Ok((terminal, restore))
243}
244
245pub async fn show_report(title: &str, text: &str, color: bool) -> io::Result<u8> {
246    let mut view = ReportView::new(title, text, color)?;
247    let mut signals = crate::cancellation::TerminalSignals::new()?;
248    let (mut terminal, _restore) = enter_terminal()?;
249    let mut events = crate::terminal_events::terminal_events();
250    loop {
251        terminal.draw(|frame| render(frame, &mut view))?;
252        let event = tokio::select! {
253            code = signals.recv() => return code,
254            event = events.next() => event.ok_or_else(|| io::Error::other("terminal input ended"))??,
255        };
256        if let Event::Key(key) = event {
257            let interrupted =
258                key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c');
259            if handle_key(&mut view, key) {
260                return Ok(if interrupted { 130 } else { 0 });
261            }
262        }
263    }
264}
265pub(crate) async fn next_navigation_event(
266    events: &mut (impl futures_util::Stream<Item = io::Result<Event>> + Unpin),
267) -> io::Result<Event> {
268    let event = events
269        .next()
270        .await
271        .ok_or_else(|| io::Error::other("terminal input ended"))??;
272    let Event::Key(escape) = event else {
273        return Ok(event);
274    };
275    if escape.code != KeyCode::Esc || escape.kind == KeyEventKind::Release {
276        return Ok(event);
277    }
278    let deadline = tokio::time::Instant::now() + std::time::Duration::from_millis(50);
279    let mut bracket = false;
280    loop {
281        let Ok(next) = tokio::time::timeout_at(deadline, events.next()).await else {
282            return Ok(event);
283        };
284        let next = next.ok_or_else(|| io::Error::other("terminal input ended"))??;
285        let Event::Key(mut key) = next else {
286            continue;
287        };
288        if key.kind == KeyEventKind::Release {
289            continue;
290        }
291        if key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c') {
292            return Ok(next);
293        }
294        if key
295            .modifiers
296            .intersects(KeyModifiers::CONTROL | KeyModifiers::ALT | KeyModifiers::SUPER)
297        {
298            return Ok(event);
299        }
300        match (bracket, key.code) {
301            (false, KeyCode::Char('[')) => bracket = true,
302            (true, KeyCode::Char('H' | 'F')) => {
303                key.code = if key.code == KeyCode::Char('H') {
304                    KeyCode::Home
305                } else {
306                    KeyCode::End
307                };
308                return Ok(Event::Key(key));
309            }
310            _ => return Ok(event),
311        }
312    }
313}
314
315pub async fn pick(title: &str, choices: &[String], color: bool) -> io::Result<(Option<usize>, u8)> {
316    crate::accessible::validate_picker_choices(choices, 8192)?;
317    let mut view = ReportView::new(title, &choices.join("\n"), color)?;
318    let mut signals = crate::cancellation::TerminalSignals::new()?;
319    let (mut terminal, _restore) = enter_terminal()?;
320    let mut events = crate::terminal_events::terminal_events();
321    loop {
322        terminal.draw(|frame| render(frame, &mut view))?;
323        let event = tokio::select! {
324            code = signals.recv() => return Ok((None, code?)),
325            event = next_navigation_event(&mut events) => event?,
326        };
327        if let Event::Key(key) = event {
328            if key.kind == KeyEventKind::Release {
329                continue;
330            }
331            if key.code == KeyCode::Enter && !view.searching {
332                return Ok((Some(view.selected()), 0));
333            }
334            let interrupted =
335                key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c');
336            if handle_key(&mut view, key) {
337                return Ok((None, if interrupted { 130 } else { 0 }));
338            }
339        }
340    }
341}
342
343#[cfg(test)]
344mod resource_tests {
345    use super::*;
346    use std::{cell::RefCell, rc::Rc};
347
348    #[derive(Default)]
349    struct State {
350        raw: bool,
351        calls: Vec<(TerminalResource, bool)>,
352    }
353
354    struct Control {
355        state: Rc<RefCell<State>>,
356        fail: Option<(TerminalResource, bool)>,
357    }
358
359    impl TerminalControl for Control {
360        fn raw(&self) -> io::Result<bool> {
361            Ok(self.state.borrow().raw)
362        }
363        fn set(&mut self, resource: TerminalResource, enabled: bool) -> io::Result<()> {
364            let mut state = self.state.borrow_mut();
365            state.calls.push((resource, enabled));
366            if resource == TerminalResource::Raw {
367                state.raw = enabled;
368            }
369            if self.fail == Some((resource, enabled)) {
370                return Err(io::Error::other("injected failure after mutation"));
371            }
372            Ok(())
373        }
374    }
375
376    #[test]
377    fn partial_acquisition_restores_each_owned_resource_and_original_raw_mode() {
378        use TerminalResource::*;
379        for fail in [Raw, Alternate, Cursor, Paste] {
380            let state = Rc::new(RefCell::new(State::default()));
381            assert!(
382                RestoreTerminal::acquire(Control {
383                    state: state.clone(),
384                    fail: Some((fail, true))
385                })
386                .is_err()
387            );
388            let state = state.borrow();
389            assert!(!state.raw);
390            for resource in [Raw, Alternate, Cursor, Paste] {
391                let acquired = state.calls.contains(&(resource, true));
392                assert_eq!(
393                    state
394                        .calls
395                        .iter()
396                        .filter(|call| **call == (resource, false))
397                        .count(),
398                    usize::from(acquired)
399                );
400            }
401        }
402        let state = Rc::new(RefCell::new(State {
403            raw: true,
404            ..Default::default()
405        }));
406        drop(
407            RestoreTerminal::acquire(Control {
408                state: state.clone(),
409                fail: None,
410            })
411            .unwrap(),
412        );
413        assert!(state.borrow().raw);
414        assert!(!state.borrow().calls.contains(&(Raw, false)));
415    }
416
417    #[test]
418    fn restoration_continues_after_independent_output_failure_and_repeated_sessions() {
419        use TerminalResource::*;
420        for failed in [Paste, Cursor, Alternate, Raw] {
421            let state = Rc::new(RefCell::new(State::default()));
422            for _ in 0..20 {
423                let restore = RestoreTerminal::acquire(Control {
424                    state: state.clone(),
425                    fail: Some((failed, false)),
426                })
427                .unwrap();
428                assert!(state.borrow().raw);
429                drop(restore);
430                assert!(!state.borrow().raw);
431            }
432            for resource in [Raw, Alternate, Cursor, Paste] {
433                assert_eq!(
434                    state
435                        .borrow()
436                        .calls
437                        .iter()
438                        .filter(|call| **call == (resource, false))
439                        .count(),
440                    20
441                );
442            }
443        }
444    }
445}