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
80pub 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
229fn 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
269pub(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 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 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 press(&mut view, &[KeyCode::Backspace]);
677 assert_eq!(view.query, "matc");
678 assert_eq!(view.selected(), 2);
679 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 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 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 *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 assert!(!click(&mut view, left, 1));
742 assert_eq!(view.selected(), 7);
743 *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 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 assert_eq!(texts(&matched("İa", "a", theme)), ["İa"]);
774 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 #[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 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 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 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 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 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 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 let mut ended = futures_util::stream::iter(Vec::<io::Result<Event>>::new());
938 assert!(next_navigation_event(&mut ended).await.is_err());
939 }
940}