Skip to main content

rigspark_cli/
tui_view.rs

1use crate::tui_theme::{SyncWriter, Theme};
2use crossterm::{
3    cursor::{Hide, Show},
4    event::{
5        Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers, MouseButton, MouseEvent,
6        MouseEventKind,
7    },
8    execute,
9    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
10};
11use futures_util::StreamExt;
12use ratatui::{
13    Frame, Terminal,
14    backend::CrosstermBackend,
15    layout::{Constraint, Layout, Position, Rect},
16    text::{Line, Span},
17    widgets::{HighlightSpacing, List, ListItem, ListState},
18};
19use rigspark_core::reports::strip_control;
20use std::io;
21use unicode_segmentation::UnicodeSegmentation;
22
23pub struct ReportView {
24    title: String,
25    lines: Vec<String>,
26    state: ListState,
27    query: String,
28    searching: bool,
29    color: bool,
30    picker: bool,
31    horizontal: usize,
32    page: usize,
33    list_area: Rect,
34}
35
36impl ReportView {
37    pub fn new(title: &str, text: &str, color: bool) -> io::Result<Self> {
38        if text.len() > 1024 * 1024 || text.lines().count() > 20000 || title.len() > 256 {
39            return Err(io::Error::other("report exceeds terminal display limits"));
40        }
41        let mut lines: Vec<_> = text.lines().map(strip_control).collect();
42        if lines.is_empty() {
43            lines.push("No results".into());
44        }
45        Ok(Self {
46            title: strip_control(title),
47            lines,
48            state: ListState::default().with_selected(Some(0)),
49            query: String::new(),
50            searching: false,
51            color,
52            picker: false,
53            horizontal: 0,
54            page: 10,
55            list_area: Rect::default(),
56        })
57    }
58    pub fn selected(&self) -> usize {
59        self.state.selected().unwrap_or(0)
60    }
61    fn select(&mut self, selected: usize) {
62        self.state.select(Some(selected.min(self.lines.len() - 1)));
63    }
64    fn find(&mut self, next: bool) {
65        if self.query.is_empty() {
66            return;
67        }
68        let query = self.query.to_lowercase();
69        let start = if next { self.selected() + 1 } else { 0 };
70        for offset in 0..self.lines.len() {
71            let index = (start + offset) % self.lines.len();
72            if self.lines[index].to_lowercase().contains(&query) {
73                self.select(index);
74                break;
75            }
76        }
77    }
78}
79
80/// Wheel scrolls; clicking a row selects it. Returns true when an already-selected row is clicked again.
81pub fn handle_mouse(view: &mut ReportView, mouse: MouseEvent) -> bool {
82    match mouse.kind {
83        MouseEventKind::ScrollDown => view.select(view.selected().saturating_add(3)),
84        MouseEventKind::ScrollUp => view.select(view.selected().saturating_sub(3)),
85        MouseEventKind::Down(MouseButton::Left)
86            if view
87                .list_area
88                .contains(Position::new(mouse.column, mouse.row)) =>
89        {
90            let row = view.state.offset() + usize::from(mouse.row - view.list_area.y);
91            if row < view.lines.len() {
92                let again = row == view.selected();
93                view.select(row);
94                return again;
95            }
96        }
97        _ => (),
98    }
99    false
100}
101
102pub fn handle_key(view: &mut ReportView, key: KeyEvent) -> bool {
103    if key.kind == KeyEventKind::Release {
104        return false;
105    }
106    if key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c') {
107        return true;
108    }
109    if view.searching {
110        match key.code {
111            KeyCode::Esc => {
112                view.searching = false;
113                view.query.clear();
114            }
115            KeyCode::Enter => view.searching = false,
116            KeyCode::Backspace => {
117                view.query.pop();
118                view.find(false);
119            }
120            KeyCode::Char(character)
121                if !character.is_control() && view.query.len() + character.len_utf8() <= 256 =>
122            {
123                view.query.push(character);
124                view.find(false);
125            }
126            _ => (),
127        }
128        return false;
129    }
130    match key.code {
131        KeyCode::Char('q') | KeyCode::Esc | KeyCode::Enter => return true,
132        KeyCode::Down | KeyCode::Char('j') => view.select(view.selected().saturating_add(1)),
133        KeyCode::Up | KeyCode::Char('k') => view.select(view.selected().saturating_sub(1)),
134        KeyCode::PageDown => view.select(view.selected().saturating_add(view.page)),
135        KeyCode::PageUp => view.select(view.selected().saturating_sub(view.page)),
136        KeyCode::Home => view.select(0),
137        KeyCode::End => view.select(view.lines.len() - 1),
138        KeyCode::Right => view.horizontal = view.horizontal.saturating_add(8).min(32768),
139        KeyCode::Left => view.horizontal = view.horizontal.saturating_sub(8),
140        KeyCode::Char('/') => {
141            view.searching = true;
142            view.query.clear();
143        }
144        KeyCode::Char('n') => view.find(true),
145        _ => (),
146    }
147    false
148}
149
150pub fn render(frame: &mut Frame<'_>, view: &mut ReportView) {
151    let area = frame.area();
152    let [header, body, footer] = Layout::vertical([
153        Constraint::Length(1),
154        Constraint::Min(1),
155        Constraint::Length(if area.height >= 4 { 1 } else { 0 }),
156    ])
157    .areas(area);
158    let theme = Theme::new(view.color);
159    theme.header(
160        frame,
161        header,
162        &format!("rigspark / {}", view.title),
163        if view.picker { "Select" } else { "Report" },
164    );
165    let inner = theme.panel(frame, body, if view.picker { "Choices" } else { "Output" });
166    view.page = usize::from(inner.height.max(1));
167    view.list_area = inner;
168    let query = view.query.to_lowercase();
169    let items: Vec<_> = view
170        .lines
171        .iter()
172        .map(|line| {
173            let visible: String = line.graphemes(true).skip(view.horizontal).collect();
174            ListItem::new(Line::from(matched(&visible, &query, theme)))
175        })
176        .collect();
177    frame.render_stateful_widget(
178        List::new(items)
179            .highlight_symbol("▸ ")
180            .highlight_spacing(HighlightSpacing::Always)
181            .highlight_style(theme.selection()),
182        inner,
183        &mut view.state,
184    );
185    crate::tui_theme::scrollbar(
186        frame,
187        body,
188        view.lines.len(),
189        view.state.offset(),
190        usize::from(inner.height),
191        theme,
192    );
193    let position = Line::styled(
194        format!("{}/{} ", view.selected() + 1, view.lines.len()),
195        theme.muted(),
196    );
197    let left = if view.searching {
198        Line::from(vec![
199            Span::styled(" /", theme.title()),
200            Span::raw(view.query.clone()),
201            Span::styled("▌", theme.accent()),
202        ])
203    } else if view.picker {
204        theme.hints(
205            &[
206                ("Enter", "select"),
207                ("↑↓", "move"),
208                ("/", "find"),
209                ("n", "next"),
210                ("q", "cancel"),
211            ],
212            footer.width.saturating_sub(10),
213        )
214    } else {
215        theme.hints(
216            &[
217                ("q", "close"),
218                ("↑↓", "scroll"),
219                ("/", "find"),
220                ("n", "next"),
221                ("←→", "pan"),
222            ],
223            footer.width.saturating_sub(10),
224        )
225    };
226    theme.bar(frame, footer, left, position);
227}
228
229/// Highlights case-insensitive occurrences of `query`; non-ASCII case folds that change length are left plain.
230fn matched(line: &str, query: &str, theme: Theme) -> Vec<Span<'static>> {
231    let lower = line.to_lowercase();
232    if query.is_empty() || lower.len() != line.len() {
233        return vec![Span::raw(line.to_owned())];
234    }
235    let mut spans = Vec::new();
236    let mut cursor = 0;
237    for (start, _) in lower.match_indices(query) {
238        if start < cursor || !line.is_char_boundary(start) {
239            continue;
240        }
241        spans.push(Span::raw(line[cursor..start].to_owned()));
242        spans.push(Span::styled(
243            line[start..start + query.len()].to_owned(),
244            theme.highlight(),
245        ));
246        cursor = start + query.len();
247    }
248    spans.push(Span::raw(line[cursor..].to_owned()));
249    spans
250}
251
252#[derive(Clone, Copy, Debug, PartialEq, Eq)]
253pub(crate) enum TerminalResource {
254    Raw,
255    Alternate,
256    Cursor,
257    Paste,
258    Mouse,
259}
260
261const TERMINAL_RESOURCES: [TerminalResource; 5] = [
262    TerminalResource::Raw,
263    TerminalResource::Alternate,
264    TerminalResource::Cursor,
265    TerminalResource::Paste,
266    TerminalResource::Mouse,
267];
268
269/// Mouse capture blocks native text selection, so users can opt out.
270pub(crate) fn mouse_enabled() -> bool {
271    std::env::var_os("RIGSPARK_NO_MOUSE").is_none_or(|value| value.is_empty())
272}
273
274fn set_mouse(enabled: bool) -> io::Result<()> {
275    #[cfg(windows)]
276    {
277        if enabled {
278            execute!(io::stderr(), crossterm::event::EnableMouseCapture)
279        } else {
280            execute!(io::stderr(), crossterm::event::DisableMouseCapture)
281        }
282    }
283    #[cfg(not(windows))]
284    {
285        use std::io::Write;
286        // Press and wheel reports only (SGR encoding); motion tracking would flood redraws.
287        let sequence: &[u8] = if enabled {
288            b"\x1b[?1000h\x1b[?1006h"
289        } else {
290            b"\x1b[?1006l\x1b[?1000l"
291        };
292        let mut stderr = io::stderr();
293        stderr.write_all(sequence)?;
294        stderr.flush()
295    }
296}
297
298pub(crate) trait TerminalControl {
299    fn raw(&self) -> io::Result<bool>;
300    fn set(&mut self, resource: TerminalResource, enabled: bool) -> io::Result<()>;
301}
302
303pub(crate) struct SystemTerminal;
304
305impl TerminalControl for SystemTerminal {
306    fn raw(&self) -> io::Result<bool> {
307        crossterm::terminal::is_raw_mode_enabled()
308    }
309    fn set(&mut self, resource: TerminalResource, enabled: bool) -> io::Result<()> {
310        match (resource, enabled) {
311            (TerminalResource::Raw, true) => enable_raw_mode(),
312            (TerminalResource::Raw, false) => disable_raw_mode(),
313            (TerminalResource::Alternate, true) => execute!(io::stderr(), EnterAlternateScreen),
314            (TerminalResource::Alternate, false) => execute!(io::stderr(), LeaveAlternateScreen),
315            (TerminalResource::Cursor, true) => execute!(io::stderr(), Hide),
316            (TerminalResource::Cursor, false) => execute!(io::stderr(), Show),
317            (TerminalResource::Paste, true) => {
318                execute!(io::stderr(), crossterm::event::EnableBracketedPaste)
319            }
320            (TerminalResource::Paste, false) => {
321                execute!(io::stderr(), crossterm::event::DisableBracketedPaste)
322            }
323            (TerminalResource::Mouse, true) if mouse_enabled() => set_mouse(true),
324            (TerminalResource::Mouse, true) => Ok(()),
325            (TerminalResource::Mouse, false) => set_mouse(false),
326        }
327    }
328}
329
330pub(crate) struct RestoreTerminal<Control: TerminalControl = SystemTerminal> {
331    control: Control,
332    initially_raw: bool,
333    acquired: usize,
334}
335
336impl<Control: TerminalControl> RestoreTerminal<Control> {
337    fn acquire(control: Control) -> io::Result<Self> {
338        let initially_raw = control.raw()?;
339        let mut restore = Self {
340            control,
341            initially_raw,
342            acquired: 0,
343        };
344        for resource in TERMINAL_RESOURCES {
345            restore.acquired += 1;
346            restore.control.set(resource, true)?;
347        }
348        Ok(restore)
349    }
350}
351
352impl<Control: TerminalControl> Drop for RestoreTerminal<Control> {
353    fn drop(&mut self) {
354        for resource in TERMINAL_RESOURCES[..self.acquired].iter().rev() {
355            let enabled = *resource == TerminalResource::Raw && self.initially_raw;
356            let _ = self.control.set(*resource, enabled);
357        }
358    }
359}
360
361pub(crate) type TerminalBackend = CrosstermBackend<SyncWriter<io::Stderr>>;
362
363pub(crate) fn enter_terminal() -> io::Result<(Terminal<TerminalBackend>, RestoreTerminal)> {
364    let restore = RestoreTerminal::acquire(SystemTerminal)?;
365    let terminal = Terminal::new(CrosstermBackend::new(SyncWriter::new(io::stderr())))?;
366    Ok((terminal, restore))
367}
368
369pub async fn show_report(title: &str, text: &str, color: bool) -> io::Result<u8> {
370    let mut view = ReportView::new(title, text, color)?;
371    let mut signals = crate::cancellation::TerminalSignals::new()?;
372    let (mut terminal, _restore) = enter_terminal()?;
373    let mut events = crate::terminal_events::terminal_events();
374    loop {
375        terminal.draw(|frame| render(frame, &mut view))?;
376        let event = tokio::select! {
377            code = signals.recv() => return code,
378            event = events.next() => event.ok_or_else(|| io::Error::other("terminal input ended"))??,
379        };
380        if let Event::Mouse(mouse) = event {
381            handle_mouse(&mut view, mouse);
382        }
383        if let Event::Key(key) = event {
384            let interrupted =
385                key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c');
386            if handle_key(&mut view, key) {
387                return Ok(if interrupted { 130 } else { 0 });
388            }
389        }
390    }
391}
392pub(crate) async fn next_navigation_event(
393    events: &mut (impl futures_util::Stream<Item = io::Result<Event>> + Unpin),
394) -> io::Result<Event> {
395    let event = events
396        .next()
397        .await
398        .ok_or_else(|| io::Error::other("terminal input ended"))??;
399    let Event::Key(escape) = event else {
400        return Ok(event);
401    };
402    if escape.code != KeyCode::Esc || escape.kind == KeyEventKind::Release {
403        return Ok(event);
404    }
405    let deadline = tokio::time::Instant::now() + std::time::Duration::from_millis(50);
406    let mut bracket = false;
407    loop {
408        let Ok(next) = tokio::time::timeout_at(deadline, events.next()).await else {
409            return Ok(event);
410        };
411        let next = next.ok_or_else(|| io::Error::other("terminal input ended"))??;
412        let Event::Key(mut key) = next else {
413            continue;
414        };
415        if key.kind == KeyEventKind::Release {
416            continue;
417        }
418        if key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c') {
419            return Ok(next);
420        }
421        if key
422            .modifiers
423            .intersects(KeyModifiers::CONTROL | KeyModifiers::ALT | KeyModifiers::SUPER)
424        {
425            return Ok(event);
426        }
427        match (bracket, key.code) {
428            (false, KeyCode::Char('[')) => bracket = true,
429            (true, KeyCode::Char('H' | 'F')) => {
430                key.code = if key.code == KeyCode::Char('H') {
431                    KeyCode::Home
432                } else {
433                    KeyCode::End
434                };
435                return Ok(Event::Key(key));
436            }
437            _ => return Ok(event),
438        }
439    }
440}
441
442pub async fn pick(title: &str, choices: &[String], color: bool) -> io::Result<(Option<usize>, u8)> {
443    crate::accessible::validate_picker_choices(choices, 8192)?;
444    let mut view = ReportView::new(title, &choices.join("\n"), color)?;
445    view.picker = true;
446    let mut signals = crate::cancellation::TerminalSignals::new()?;
447    let (mut terminal, _restore) = enter_terminal()?;
448    let mut events = crate::terminal_events::terminal_events();
449    loop {
450        terminal.draw(|frame| render(frame, &mut view))?;
451        let event = tokio::select! {
452            code = signals.recv() => return Ok((None, code?)),
453            event = next_navigation_event(&mut events) => event?,
454        };
455        if let Event::Mouse(mouse) = event
456            && handle_mouse(&mut view, mouse)
457            && !view.searching
458        {
459            return Ok((Some(view.selected()), 0));
460        }
461        if let Event::Key(key) = event {
462            if key.kind == KeyEventKind::Release {
463                continue;
464            }
465            if key.code == KeyCode::Enter && !view.searching {
466                return Ok((Some(view.selected()), 0));
467            }
468            let interrupted =
469                key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('c');
470            if handle_key(&mut view, key) {
471                return Ok((None, if interrupted { 130 } else { 0 }));
472            }
473        }
474    }
475}
476
477#[cfg(test)]
478mod resource_tests {
479    use super::*;
480    use std::{cell::RefCell, rc::Rc};
481
482    #[derive(Default)]
483    struct State {
484        raw: bool,
485        calls: Vec<(TerminalResource, bool)>,
486    }
487
488    struct Control {
489        state: Rc<RefCell<State>>,
490        fail: Option<(TerminalResource, bool)>,
491    }
492
493    impl TerminalControl for Control {
494        fn raw(&self) -> io::Result<bool> {
495            Ok(self.state.borrow().raw)
496        }
497        fn set(&mut self, resource: TerminalResource, enabled: bool) -> io::Result<()> {
498            let mut state = self.state.borrow_mut();
499            state.calls.push((resource, enabled));
500            if resource == TerminalResource::Raw {
501                state.raw = enabled;
502            }
503            if self.fail == Some((resource, enabled)) {
504                return Err(io::Error::other("injected failure after mutation"));
505            }
506            Ok(())
507        }
508    }
509
510    #[test]
511    fn partial_acquisition_restores_each_owned_resource_and_original_raw_mode() {
512        use TerminalResource::*;
513        for fail in [Raw, Alternate, Cursor, Paste, Mouse] {
514            let state = Rc::new(RefCell::new(State::default()));
515            assert!(
516                RestoreTerminal::acquire(Control {
517                    state: state.clone(),
518                    fail: Some((fail, true))
519                })
520                .is_err()
521            );
522            let state = state.borrow();
523            assert!(!state.raw);
524            for resource in [Raw, Alternate, Cursor, Paste, Mouse] {
525                let acquired = state.calls.contains(&(resource, true));
526                assert_eq!(
527                    state
528                        .calls
529                        .iter()
530                        .filter(|call| **call == (resource, false))
531                        .count(),
532                    usize::from(acquired)
533                );
534            }
535        }
536        let state = Rc::new(RefCell::new(State {
537            raw: true,
538            ..Default::default()
539        }));
540        drop(
541            RestoreTerminal::acquire(Control {
542                state: state.clone(),
543                fail: None,
544            })
545            .unwrap(),
546        );
547        assert!(state.borrow().raw);
548        assert!(!state.borrow().calls.contains(&(Raw, false)));
549    }
550
551    #[test]
552    fn restoration_continues_after_independent_output_failure_and_repeated_sessions() {
553        use TerminalResource::*;
554        for failed in [Mouse, Paste, Cursor, Alternate, Raw] {
555            let state = Rc::new(RefCell::new(State::default()));
556            for _ in 0..20 {
557                let restore = RestoreTerminal::acquire(Control {
558                    state: state.clone(),
559                    fail: Some((failed, false)),
560                })
561                .unwrap();
562                assert!(state.borrow().raw);
563                drop(restore);
564                assert!(!state.borrow().raw);
565            }
566            for resource in [Raw, Alternate, Cursor, Paste, Mouse] {
567                assert_eq!(
568                    state
569                        .borrow()
570                        .calls
571                        .iter()
572                        .filter(|call| **call == (resource, false))
573                        .count(),
574                    20
575                );
576            }
577        }
578    }
579}
580
581#[cfg(test)]
582mod view_tests {
583    use super::*;
584    use crossterm::event::KeyEventState;
585
586    fn view(lines: usize) -> ReportView {
587        let text: Vec<_> = (0..lines).map(|n| format!("line{n}")).collect();
588        ReportView::new("title", &text.join("\n"), false).unwrap()
589    }
590    fn key(code: KeyCode) -> KeyEvent {
591        KeyEvent::new(code, KeyModifiers::NONE)
592    }
593    fn with(code: KeyCode, modifiers: KeyModifiers) -> KeyEvent {
594        KeyEvent::new(code, modifiers)
595    }
596    fn press(view: &mut ReportView, codes: &[KeyCode]) {
597        for code in codes {
598            assert!(!handle_key(view, key(*code)), "{code:?}");
599        }
600    }
601    fn typed(view: &mut ReportView, text: &str) {
602        for character in text.chars() {
603            handle_key(view, key(KeyCode::Char(character)));
604        }
605    }
606
607    #[test]
608    fn keys_move_by_line_page_and_end_and_stop_at_the_last_line() {
609        let mut view = view(30);
610        press(&mut view, &[KeyCode::Down, KeyCode::Char('j')]);
611        assert_eq!(view.selected(), 2);
612        press(&mut view, &[KeyCode::Up]);
613        assert_eq!(view.selected(), 1);
614        press(&mut view, &[KeyCode::Char('k'), KeyCode::Up]);
615        assert_eq!(view.selected(), 0);
616        press(&mut view, &[KeyCode::PageDown]);
617        assert_eq!(view.selected(), 10);
618        press(&mut view, &[KeyCode::PageUp]);
619        assert_eq!(view.selected(), 0);
620        press(&mut view, &[KeyCode::End]);
621        assert_eq!(view.selected(), 29);
622        press(&mut view, &[KeyCode::Home]);
623        assert_eq!(view.selected(), 0);
624        // Moving past the end stays on the last line.
625        press(&mut view, &[KeyCode::PageDown; 4]);
626        assert_eq!(view.selected(), 29);
627        press(&mut view, &[KeyCode::Down]);
628        assert_eq!(view.selected(), 29);
629    }
630
631    #[test]
632    fn panning_moves_eight_columns_up_to_32768() {
633        let mut view = view(1);
634        press(&mut view, &[KeyCode::Right, KeyCode::Right]);
635        assert_eq!(view.horizontal, 16);
636        press(&mut view, &[KeyCode::Left]);
637        assert_eq!(view.horizontal, 8);
638        press(&mut view, &[KeyCode::Left, KeyCode::Left]);
639        assert_eq!(view.horizontal, 0);
640        for _ in 0..5000 {
641            handle_key(&mut view, key(KeyCode::Right));
642        }
643        assert_eq!(view.horizontal, 32768);
644    }
645
646    #[test]
647    fn only_quit_keys_and_control_c_close_the_view() {
648        let mut view = view(3);
649        for code in [KeyCode::Char('q'), KeyCode::Esc, KeyCode::Enter] {
650            assert!(handle_key(&mut view, key(code)), "{code:?}");
651        }
652        assert!(handle_key(
653            &mut view,
654            with(KeyCode::Char('c'), KeyModifiers::CONTROL)
655        ));
656        assert!(!handle_key(&mut view, key(KeyCode::Char('c'))));
657        assert!(!handle_key(
658            &mut view,
659            with(KeyCode::Char('x'), KeyModifiers::CONTROL)
660        ));
661        let mut release = key(KeyCode::Char('q'));
662        release.kind = KeyEventKind::Release;
663        release.state = KeyEventState::NONE;
664        assert!(!handle_key(&mut view, release));
665    }
666
667    #[test]
668    fn search_finds_edits_and_repeats_matches() {
669        let lines = ["alpha", "beta", "Match one", "gamma", "match two", "delta"].join("\n");
670        let mut view = ReportView::new("t", &lines, false).unwrap();
671        press(&mut view, &[KeyCode::Char('/')]);
672        assert!(view.searching);
673        typed(&mut view, "matcx");
674        assert_eq!(view.query, "matcx");
675        // Backspace edits the query and searches again from the top.
676        press(&mut view, &[KeyCode::Backspace]);
677        assert_eq!(view.query, "matc");
678        assert_eq!(view.selected(), 2);
679        // Enter ends the search but keeps the query for `n`.
680        press(&mut view, &[KeyCode::Enter]);
681        assert!(!view.searching);
682        assert_eq!(view.query, "matc");
683        press(&mut view, &[KeyCode::Char('n')]);
684        assert_eq!(view.selected(), 4);
685        press(&mut view, &[KeyCode::Char('n')]);
686        assert_eq!(view.selected(), 2);
687        // Esc cancels a search and clears it.
688        press(&mut view, &[KeyCode::Char('/')]);
689        typed(&mut view, "x");
690        press(&mut view, &[KeyCode::Esc]);
691        assert!(!view.searching);
692        assert!(view.query.is_empty());
693    }
694
695    #[test]
696    fn queries_take_printable_characters_up_to_256_bytes() {
697        let mut view = view(3);
698        press(&mut view, &[KeyCode::Char('/')]);
699        typed(&mut view, "a\u{7}b");
700        assert_eq!(view.query, "ab");
701        typed(&mut view, &"a".repeat(198));
702        // A two-byte character fits at 200 bytes.
703        typed(&mut view, "é");
704        assert_eq!(view.query.len(), 202);
705        typed(&mut view, &"a".repeat(53));
706        assert_eq!(view.query.len(), 255);
707        typed(&mut view, "é");
708        assert_eq!(view.query.len(), 255);
709        typed(&mut view, "aa");
710        assert_eq!(view.query.len(), 256);
711    }
712
713    fn click(view: &mut ReportView, kind: MouseEventKind, row: u16) -> bool {
714        handle_mouse(
715            view,
716            MouseEvent {
717                kind,
718                column: 5,
719                row,
720                modifiers: KeyModifiers::NONE,
721            },
722        )
723    }
724
725    #[test]
726    fn the_wheel_scrolls_three_lines_and_clicks_select_rows() {
727        let mut view = view(20);
728        view.list_area = Rect::new(0, 2, 40, 10);
729        assert!(!click(&mut view, MouseEventKind::ScrollDown, 0));
730        assert_eq!(view.selected(), 3);
731        click(&mut view, MouseEventKind::ScrollDown, 0);
732        click(&mut view, MouseEventKind::ScrollUp, 0);
733        assert_eq!(view.selected(), 3);
734        let left = MouseEventKind::Down(MouseButton::Left);
735        // Rows are counted from the top of the list, plus the scroll offset.
736        *view.state.offset_mut() = 5;
737        assert!(!click(&mut view, left, 4));
738        assert_eq!(view.selected(), 7);
739        assert!(click(&mut view, left, 4));
740        // Outside the list nothing changes.
741        assert!(!click(&mut view, left, 1));
742        assert_eq!(view.selected(), 7);
743        // The last line is selectable; the row after it is not.
744        *view.state.offset_mut() = 10;
745        assert!(!click(&mut view, left, 11));
746        assert_eq!(view.selected(), 19);
747        let mut short = self::view(3);
748        short.list_area = Rect::new(0, 2, 40, 10);
749        assert!(!click(&mut short, left, 5));
750        assert_eq!(short.selected(), 0);
751        assert!(!click(&mut short, MouseEventKind::Moved, 3));
752    }
753
754    fn texts(spans: &[Span<'_>]) -> Vec<String> {
755        spans.iter().map(|span| span.content.to_string()).collect()
756    }
757
758    #[test]
759    fn matches_are_highlighted_case_insensitively_without_overlap() {
760        let theme = Theme::new(false);
761        assert_eq!(texts(&matched("Hello", "", theme)), ["Hello"]);
762        let spans = matched("say Hello, hello", "hello", theme);
763        assert_eq!(texts(&spans), ["say ", "Hello", ", ", "hello", ""]);
764        assert_eq!(spans[1].style, theme.highlight());
765        assert_eq!(spans[0].style, Span::raw("").style);
766        // Overlapping occurrences highlight only the first.
767        assert_eq!(texts(&matched("aaa", "aa", theme)), ["", "aa", "a"]);
768        assert_eq!(
769            texts(&matched("xaaaay", "aa", theme)),
770            ["x", "aa", "", "aa", "y"]
771        );
772        // A case fold that changes length leaves the line plain.
773        assert_eq!(texts(&matched("İa", "a", theme)), ["İa"]);
774        // Same total length, shifted boundaries: the Kelvin sign shrinks by two bytes and each
775        // `Ⱥ` grows by one, so matches in the lowered text fall inside characters of the line.
776        assert_eq!("\u{212A}ȺȺ".len(), "\u{212A}ȺȺ".to_lowercase().len());
777        assert_eq!(texts(&matched("\u{212A}ȺȺ", "ⱥ", theme)), ["\u{212A}ȺȺ"]);
778    }
779
780    #[test]
781    fn the_footer_appears_from_four_rows_and_the_page_follows_the_panel() {
782        let draw = |height: u16| {
783            let mut view = view(30);
784            let mut terminal =
785                Terminal::new(ratatui::backend::TestBackend::new(40, height)).unwrap();
786            terminal.draw(|frame| render(frame, &mut view)).unwrap();
787            let buffer = terminal.backend().buffer().clone();
788            let last: String = (0..40)
789                .map(|x| buffer[(x, height - 1)].symbol().to_owned())
790                .collect();
791            (last, view.page, view.list_area)
792        };
793        let (last, _, _) = draw(4);
794        assert!(last.contains("1/30"), "{last:?}");
795        let (last, _, _) = draw(3);
796        assert!(!last.contains("1/30"), "{last:?}");
797        let (_, page, area) = draw(12);
798        assert_eq!(page, usize::from(area.height));
799        assert!(page > 1);
800    }
801
802    /// Run in a child process by the test below, with the variable already set.
803    #[test]
804    fn mouse_probe() {
805        if let Some(expected) = std::env::var_os("RIGSPARK_TEST_MOUSE_EXPECT") {
806            assert_eq!(mouse_enabled().to_string(), expected.to_string_lossy());
807        }
808    }
809
810    #[test]
811    fn mouse_capture_can_be_turned_off_with_a_non_empty_variable() {
812        for (value, expected) in [(None, "true"), (Some(""), "true"), (Some("1"), "false")] {
813            let mut child = std::process::Command::new(std::env::current_exe().unwrap());
814            child
815                .args([
816                    "--exact",
817                    "tui_view::view_tests::mouse_probe",
818                    "--test-threads=1",
819                ])
820                .env("RIGSPARK_TEST_MOUSE_EXPECT", expected)
821                .env_remove("RIGSPARK_NO_MOUSE");
822            if let Some(value) = value {
823                child.env("RIGSPARK_NO_MOUSE", value);
824            }
825            let output = child.output().unwrap();
826            let stdout = String::from_utf8_lossy(&output.stdout);
827            assert!(output.status.success(), "{value:?}: {stdout}");
828            assert!(stdout.contains("1 passed"), "{value:?}: {stdout}");
829        }
830    }
831
832    fn keys(events: Vec<KeyEvent>) -> Vec<io::Result<Event>> {
833        events.into_iter().map(|key| Ok(Event::Key(key))).collect()
834    }
835    /// Events that arrive 10 ms apart, then a stream that stays open.
836    async fn navigate(events: Vec<io::Result<Event>>) -> Event {
837        let stream = futures_util::stream::iter(events)
838            .then(|event| async {
839                tokio::time::sleep(std::time::Duration::from_millis(10)).await;
840                event
841            })
842            .chain(futures_util::stream::pending());
843        let mut stream = Box::pin(stream);
844        next_navigation_event(&mut stream).await.unwrap()
845    }
846    fn code(event: Event) -> KeyCode {
847        match event {
848            Event::Key(key) => key.code,
849            other => panic!("{other:?}"),
850        }
851    }
852
853    #[tokio::test]
854    async fn escape_bracket_h_and_f_become_home_and_end() {
855        let esc = key(KeyCode::Esc);
856        let bracket = key(KeyCode::Char('['));
857        assert_eq!(
858            code(navigate(keys(vec![esc, bracket, key(KeyCode::Char('H'))])).await),
859            KeyCode::Home
860        );
861        assert_eq!(
862            code(navigate(keys(vec![esc, bracket, key(KeyCode::Char('F'))])).await),
863            KeyCode::End
864        );
865        // Releases in between are skipped.
866        let mut release = key(KeyCode::Char('x'));
867        release.kind = KeyEventKind::Release;
868        assert_eq!(
869            code(navigate(keys(vec![esc, release, bracket, key(KeyCode::Char('H'))])).await),
870            KeyCode::Home
871        );
872        // Anything else leaves the escape as it was.
873        for tail in [
874            vec![key(KeyCode::Char('x'))],
875            vec![bracket, key(KeyCode::Char('x'))],
876            vec![key(KeyCode::Char('H'))],
877            vec![bracket, bracket],
878            vec![
879                with(KeyCode::Char('['), KeyModifiers::ALT),
880                key(KeyCode::Char('H')),
881            ],
882            vec![
883                with(KeyCode::Char('['), KeyModifiers::SUPER),
884                key(KeyCode::Char('H')),
885            ],
886            vec![bracket, with(KeyCode::Char('H'), KeyModifiers::CONTROL)],
887            vec![],
888        ] {
889            let mut events = vec![esc];
890            events.extend(tail.iter().copied());
891            assert_eq!(code(navigate(keys(events)).await), KeyCode::Esc, "{tail:?}");
892        }
893        // Control-C after an escape is delivered.
894        let interrupt = with(KeyCode::Char('c'), KeyModifiers::CONTROL);
895        assert_eq!(
896            navigate(keys(vec![esc, interrupt])).await,
897            Event::Key(interrupt)
898        );
899    }
900
901    #[tokio::test]
902    async fn only_a_pressed_escape_waits_for_a_sequence() {
903        // Other keys and events come straight back.
904        assert_eq!(
905            code(navigate(keys(vec![key(KeyCode::Char('['))])).await),
906            KeyCode::Char('[')
907        );
908        assert_eq!(
909            navigate(vec![Ok(Event::FocusGained)]).await,
910            Event::FocusGained
911        );
912        let mut released = key(KeyCode::Esc);
913        released.kind = KeyEventKind::Release;
914        assert_eq!(
915            navigate(keys(vec![
916                released,
917                key(KeyCode::Char('[')),
918                key(KeyCode::Char('H'))
919            ]))
920            .await,
921            Event::Key(released)
922        );
923        // Non-key events inside the window are skipped.
924        assert_eq!(
925            code(
926                navigate(vec![
927                    Ok(Event::Key(key(KeyCode::Esc))),
928                    Ok(Event::FocusLost),
929                    Ok(Event::Key(key(KeyCode::Char('[')))),
930                    Ok(Event::Key(key(KeyCode::Char('H')))),
931                ])
932                .await
933            ),
934            KeyCode::Home
935        );
936        // An input stream that ends is an error.
937        let mut ended = futures_util::stream::iter(Vec::<io::Result<Event>>::new());
938        assert!(next_navigation_event(&mut ended).await.is_err());
939    }
940}