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}