git_worktree_manager/tui/
arrow_select.rs

1//! Arrow-key TUI selector for interactive worktree selection.
2//!
3
4use std::io::{IsTerminal, Write};
5
6// ---------------------------------------------------------------------------
7// Public API
8// ---------------------------------------------------------------------------
9
10/// Arrow-key selector that renders on stderr and returns selected value.
11///
12/// # Arguments
13/// * `items` - List of (label, value) tuples
14/// * `title` - Title shown above the list
15/// * `default_index` - Initially highlighted item
16///
17/// # Returns
18/// The value of the selected item, or None if cancelled.
19pub fn arrow_select(
20    items: &[(String, String)],
21    title: &str,
22    default_index: usize,
23) -> Option<String> {
24    if items.is_empty() {
25        return None;
26    }
27
28    if !std::io::stderr().is_terminal() {
29        return None;
30    }
31
32    let default_index = default_index.min(items.len() - 1);
33
34    // Try Unix raw-mode selector first
35    #[cfg(unix)]
36    {
37        if let Some(result) = arrow_select_unix(items, title, default_index) {
38            return result;
39        }
40    }
41
42    // Fallback to numbered input
43    arrow_select_fallback(items, title, default_index)
44}
45
46// ---------------------------------------------------------------------------
47// Terminal helpers
48// ---------------------------------------------------------------------------
49
50/// Get terminal width from stderr, defaulting to 80.
51#[cfg(unix)]
52fn get_terminal_width() -> usize {
53    console::Term::stderr().size().1 as usize
54}
55
56/// Write raw bytes to stderr (unbuffered).
57#[cfg(unix)]
58fn write_stderr(s: &str) {
59    let stderr = std::io::stderr();
60    let mut handle = stderr.lock();
61    let _ = handle.write_all(s.as_bytes());
62    let _ = handle.flush();
63}
64
65/// Strip ANSI escape sequences and return the visible length.
66#[cfg(any(unix, test))]
67fn visible_len(text: &str) -> usize {
68    let mut len = 0;
69    let bytes = text.as_bytes();
70    let mut i = 0;
71    while i < bytes.len() {
72        if bytes[i] == b'\x1b' {
73            // Skip until 'm'
74            i += 1;
75            while i < bytes.len() && bytes[i] != b'm' {
76                i += 1;
77            }
78            if i < bytes.len() {
79                i += 1; // skip 'm'
80            }
81        } else {
82            len += 1;
83            i += 1;
84        }
85    }
86    len
87}
88
89/// Truncate text to fit within `width` visible characters, preserving ANSI codes.
90#[cfg(any(unix, test))]
91fn truncate(text: &str, width: usize) -> String {
92    if visible_len(text) <= width {
93        return text.to_string();
94    }
95
96    let mut vis_pos = 0;
97    let mut cut_pos = 0;
98    let bytes = text.as_bytes();
99    let mut i = 0;
100
101    while i < bytes.len() && vis_pos < width.saturating_sub(1) {
102        if bytes[i] == b'\x1b' {
103            // Skip ANSI escape sequence
104            i += 1;
105            while i < bytes.len() && bytes[i] != b'm' {
106                i += 1;
107            }
108            if i < bytes.len() {
109                i += 1; // skip 'm'
110            }
111        } else {
112            vis_pos += 1;
113            i += 1;
114        }
115        cut_pos = i;
116    }
117
118    let mut result = text[..cut_pos].to_string();
119    result.push_str("\x1b[0m");
120    result
121}
122
123// ---------------------------------------------------------------------------
124// Rendering
125// ---------------------------------------------------------------------------
126
127/// Render the selector list on stderr using ANSI escape codes.
128#[cfg(unix)]
129fn render(
130    items: &[(String, String)],
131    title: &str,
132    selected: usize,
133    _total_lines: usize,
134    first_render: bool,
135) {
136    let width = get_terminal_width();
137
138    if !first_render {
139        // Restore cursor to saved position
140        write_stderr("\x1b[u");
141    }
142
143    // Save cursor position at the start of our render area
144    write_stderr("\x1b[s");
145
146    // Title
147    let line = format!("  \x1b[1m{title}\x1b[0m");
148    write_stderr(&format!("\x1b[2K{}\r\n", truncate(&line, width)));
149    // Blank line
150    write_stderr("\x1b[2K\r\n");
151
152    for (i, (label, value)) in items.iter().enumerate() {
153        write_stderr("\x1b[2K"); // clear line
154        let line = if i == selected {
155            format!("  \x1b[1;7m > {label} \x1b[0m  \x1b[2m{value}\x1b[0m")
156        } else {
157            format!("    {label}  \x1b[2m{value}\x1b[0m")
158        };
159        write_stderr(&format!("{}\r\n", truncate(&line, width)));
160    }
161
162    // Clear any leftover lines below
163    for _ in 0..2 {
164        write_stderr("\x1b[2K\r\n");
165    }
166    // Move back up to just after our items
167    write_stderr("\x1b[2A");
168}
169
170/// Erase the rendered selector from stderr.
171#[cfg(unix)]
172fn cleanup(total_lines: usize) {
173    // Restore to saved position
174    write_stderr("\x1b[u");
175    for _ in 0..total_lines + 2 {
176        write_stderr("\x1b[2K\r\n");
177    }
178    write_stderr("\x1b[u");
179}
180
181// ---------------------------------------------------------------------------
182// Key reading
183// ---------------------------------------------------------------------------
184
185/// Recognized key events.
186#[cfg(unix)]
187#[derive(Debug, PartialEq)]
188enum Key {
189    Up,
190    Down,
191    Enter,
192    Escape,
193    CtrlC,
194    Quit,
195    Number(u8),
196    Unknown,
197}
198
199/// Read a single keypress from the given file descriptor (Unix).
200#[cfg(unix)]
201fn read_key(fd: std::os::unix::io::RawFd) -> Result<Key, std::io::Error> {
202    let mut buf = [0u8; 1];
203    let n = unsafe { libc::read(fd, buf.as_mut_ptr() as *mut libc::c_void, 1) };
204    if n <= 0 {
205        return Err(std::io::Error::new(
206            std::io::ErrorKind::UnexpectedEof,
207            "EOF on stdin",
208        ));
209    }
210
211    match buf[0] {
212        b'\x1b' => {
213            // Could be escape sequence -- peek with a short timeout using select/poll
214            let mut pollfd = libc::pollfd {
215                fd,
216                events: libc::POLLIN,
217                revents: 0,
218            };
219            let ready = unsafe { libc::poll(&mut pollfd as *mut libc::pollfd, 1, 50) };
220            if ready <= 0 {
221                // Bare Escape key
222                return Ok(Key::Escape);
223            }
224            let mut seq1 = [0u8; 1];
225            let n = unsafe { libc::read(fd, seq1.as_mut_ptr() as *mut libc::c_void, 1) };
226            if n <= 0 {
227                return Ok(Key::Escape);
228            }
229            if seq1[0] == b'[' {
230                let mut seq2 = [0u8; 1];
231                let n = unsafe { libc::read(fd, seq2.as_mut_ptr() as *mut libc::c_void, 1) };
232                if n <= 0 {
233                    return Ok(Key::Unknown);
234                }
235                match seq2[0] {
236                    b'A' => Ok(Key::Up),
237                    b'B' => Ok(Key::Down),
238                    _ => Ok(Key::Unknown),
239                }
240            } else {
241                Ok(Key::Unknown)
242            }
243        }
244        b'\r' | b'\n' => Ok(Key::Enter),
245        0x03 => Ok(Key::CtrlC),
246        b'q' => Ok(Key::Quit),
247        c @ b'1'..=b'9' => Ok(Key::Number(c - b'0')),
248        _ => Ok(Key::Unknown),
249    }
250}
251
252// ---------------------------------------------------------------------------
253// Unix raw-mode selector
254// ---------------------------------------------------------------------------
255
256#[cfg(unix)]
257fn arrow_select_unix(
258    items: &[(String, String)],
259    title: &str,
260    default_index: usize,
261) -> Option<Option<String>> {
262    use std::os::unix::io::AsRawFd;
263
264    let stdin = std::io::stdin();
265    let fd = stdin.as_raw_fd();
266
267    // Save original terminal attributes
268    let mut old_termios: libc::termios = unsafe { std::mem::zeroed() };
269    if unsafe { libc::tcgetattr(fd, &mut old_termios) } != 0 {
270        return None; // Can't get termios, fall back
271    }
272
273    let mut selected = default_index;
274    let total_lines = items.len() + 2; // title + blank + items
275
276    // Hide cursor
277    write_stderr("\x1b[?25l");
278
279    // Set raw mode
280    let mut raw = old_termios;
281    // cfmakeraw equivalent
282    raw.c_iflag &= !(libc::IGNBRK
283        | libc::BRKINT
284        | libc::PARMRK
285        | libc::ISTRIP
286        | libc::INLCR
287        | libc::IGNCR
288        | libc::ICRNL
289        | libc::IXON);
290    raw.c_oflag &= !libc::OPOST;
291    raw.c_lflag &= !(libc::ECHO | libc::ECHONL | libc::ICANON | libc::ISIG | libc::IEXTEN);
292    raw.c_cflag &= !(libc::CSIZE | libc::PARENB);
293    raw.c_cflag |= libc::CS8;
294    raw.c_cc[libc::VMIN] = 1;
295    raw.c_cc[libc::VTIME] = 0;
296
297    if unsafe { libc::tcsetattr(fd, libc::TCSAFLUSH, &raw) } != 0 {
298        write_stderr("\x1b[?25h");
299        return None;
300    }
301
302    let result = (|| -> Option<String> {
303        render(items, title, selected, total_lines, true);
304
305        loop {
306            let key = match read_key(fd) {
307                Ok(k) => k,
308                Err(_) => {
309                    cleanup(total_lines);
310                    return None;
311                }
312            };
313
314            match key {
315                Key::Enter => {
316                    cleanup(total_lines);
317                    return Some(items[selected].1.clone());
318                }
319                Key::CtrlC | Key::Quit | Key::Escape => {
320                    cleanup(total_lines);
321                    return None;
322                }
323                Key::Up => {
324                    selected = if selected == 0 {
325                        items.len() - 1
326                    } else {
327                        selected - 1
328                    };
329                    render(items, title, selected, total_lines, false);
330                }
331                Key::Down => {
332                    selected = (selected + 1) % items.len();
333                    render(items, title, selected, total_lines, false);
334                }
335                Key::Number(n) => {
336                    let idx = (n as usize) - 1;
337                    if idx < items.len() {
338                        cleanup(total_lines);
339                        return Some(items[idx].1.clone());
340                    }
341                }
342                Key::Unknown => {}
343            }
344        }
345    })();
346
347    // Restore terminal
348    unsafe {
349        libc::tcsetattr(fd, libc::TCSADRAIN, &old_termios);
350    }
351    // Show cursor
352    write_stderr("\x1b[?25h");
353
354    Some(result)
355}
356
357// ---------------------------------------------------------------------------
358// Fallback: numbered list
359// ---------------------------------------------------------------------------
360
361/// Fallback numbered list with text input.
362fn arrow_select_fallback(
363    items: &[(String, String)],
364    title: &str,
365    default_index: usize,
366) -> Option<String> {
367    let stderr = std::io::stderr();
368    let mut out = stderr.lock();
369
370    let _ = writeln!(out, "\n  {title}\n");
371    for (i, (label, value)) in items.iter().enumerate() {
372        let marker = if i == default_index { ">" } else { " " };
373        let _ = writeln!(out, "  {marker} [{num}] {label}  {value}", num = i + 1);
374    }
375    let _ = writeln!(out);
376    let _ = write!(out, "Select [1-{}]: ", items.len());
377    let _ = out.flush();
378
379    let mut input = String::new();
380    match std::io::stdin().read_line(&mut input) {
381        Ok(_) => {
382            let input = input.trim();
383            if input.is_empty() {
384                return Some(items[default_index].1.clone());
385            }
386            if let Ok(n) = input.parse::<usize>() {
387                let idx = n.wrapping_sub(1);
388                if idx < items.len() {
389                    return Some(items[idx].1.clone());
390                }
391            }
392            None
393        }
394        Err(_) => None,
395    }
396}
397
398// ---------------------------------------------------------------------------
399// Tests
400// ---------------------------------------------------------------------------
401
402#[cfg(test)]
403mod tests {
404    use super::*;
405
406    #[test]
407    fn test_visible_len_plain_text() {
408        assert_eq!(visible_len("hello"), 5);
409        assert_eq!(visible_len(""), 0);
410        assert_eq!(visible_len("abc def"), 7);
411    }
412
413    #[test]
414    fn test_visible_len_with_ansi() {
415        assert_eq!(visible_len("\x1b[1mhello\x1b[0m"), 5);
416        assert_eq!(
417            visible_len("\x1b[1;7m > foo \x1b[0m  \x1b[2mbar\x1b[0m"),
418            12
419        );
420        assert_eq!(visible_len("\x1b[32m\x1b[0m"), 0);
421    }
422
423    #[test]
424    fn test_truncate_no_truncation_needed() {
425        let text = "short";
426        assert_eq!(truncate(text, 80), "short");
427    }
428
429    #[test]
430    fn test_truncate_plain_text() {
431        let text = "hello world this is a long string";
432        let result = truncate(text, 10);
433        // Should be at most 9 visible chars + reset
434        assert!(visible_len(&result) <= 10);
435        assert!(result.ends_with("\x1b[0m"));
436    }
437
438    #[test]
439    fn test_truncate_with_ansi() {
440        let text = "\x1b[1mhello world long text\x1b[0m";
441        let result = truncate(text, 10);
442        assert!(visible_len(&result) <= 10);
443        assert!(result.ends_with("\x1b[0m"));
444    }
445
446    #[test]
447    fn test_truncate_width_one() {
448        let result = truncate("hello", 1);
449        // With width=1, saturating_sub(1) = 0, so no visible chars
450        assert!(result.ends_with("\x1b[0m"));
451    }
452
453    #[test]
454    fn test_arrow_select_empty_items() {
455        assert_eq!(arrow_select(&[], "title", 0), None);
456    }
457
458    #[cfg(unix)]
459    #[test]
460    fn test_key_enum_equality() {
461        assert_eq!(Key::Up, Key::Up);
462        assert_eq!(Key::Number(3), Key::Number(3));
463        assert_ne!(Key::Up, Key::Down);
464    }
465
466    #[test]
467    fn test_fallback_default_index_clamped() {
468        let items = [
469            ("a".to_string(), "val_a".to_string()),
470            ("b".to_string(), "val_b".to_string()),
471        ];
472        let clamped = 10usize.min(items.len() - 1);
473        assert_eq!(clamped, 1);
474    }
475}
git_worktree_manager/tui/arrow_select.rs

git_worktree_manager/tui/
arrow_select.rs
