14468617911

Committed 15 Apr 2025 11:47AM UTC coverage: 29.024% (-1.8%) from 30.835%

Build # 14468617911

Build Type

Pull #225

github

Committed by

web-flow

Commit Message

Merge d5543fd61 into 00641afc4

Pull Request Pull Request #225: Provide best-of-class precommit hook (facet-dev)

Run Details

4 of 940 new or added lines in 9 files covered. (0.43%)

1 existing line in 1 file now uncovered.

2032 of 7001 relevant lines covered (29.02%)

24.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/facet-dev/src/menu.rs

use facet_ansi::{Style, Stylize};

/// A menu item
pub struct MenuItem {
    /// may contain `[]`, like `[Y]es` — that's the shortcut key. pressing it immediately executes the action
    pub label: String,

    /// style for the action
    pub style: Style,

    /// returned by show_menu
    pub action: String,
}

pub fn show_menu(question: &str, items: &[MenuItem]) -> Option<String> {
    // Requires the 'termion' crate for raw input handling
    use std::io::{self, Write};
    use termion::event::{Event, Key};
    use termion::input::TermRead;
    use termion::raw::IntoRawMode;

    use termion::color;
    println!("{}", question);
    for item in items.iter() {
        let label = &item.label;
        let mut chars = label.chars().peekable();
        let mut after_colon = false;
        while let Some(ch) = chars.next() {
            // Check for shortcut
            if ch == '[' {
                let mut shortcut = String::new();
                while let Some(&next_ch) = chars.peek() {
                    if next_ch == ']' {
                        chars.next(); // consume ']'
                        print!("[{}]", shortcut.style(item.style));
                        break;
                    } else {
                        shortcut.push(next_ch);
                        chars.next();
                    }
                }
                continue;
            }
            // Check for ':'
            if !after_colon && ch == ':' {
                after_colon = true;
                print!("{}", color::Fg(color::LightBlack));
                print!("{}", ch);
                continue;
            }
            // After colon? Dim color, otherwise normal
            if after_colon {
                print!("{}", ch.to_string().dim());
            } else {
                print!("{}", ch);
            }
        }
        if after_colon {
            print!("{}", color::Fg(color::Reset));
        }
        println!();
    }
    print!("Enter your choice: ");
    io::stdout().flush().unwrap();

    #[cfg(any(target_os = "linux", target_os = "macos"))]
    let tty = std::fs::OpenOptions::new()
        .read(true)
        .write(true)
        .open("/dev/tty")
        .unwrap();
    #[cfg(any(target_os = "linux", target_os = "macos"))]
    let mut stdout = tty.try_clone().unwrap().into_raw_mode().unwrap();
    #[cfg(any(target_os = "linux", target_os = "macos"))]
    let stdin = tty;
    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    let mut stdout = stdout().into_raw_mode().unwrap();
    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    let stdin = stdin();
    let mut result = String::new();
    let mut selected_action = String::new();

    for evt in stdin.events() {
        let evt = evt.unwrap();
        match evt {
            Event::Key(Key::Char(c)) => {
                if c.is_ascii_digit() {
                    result.push(c);
                    write!(stdout, "{}", c).unwrap();
                    stdout.flush().unwrap();

                    if let Ok(idx) = result.parse::<usize>() {
                        if idx >= 1 && idx <= items.len() {
                            selected_action = items[idx - 1].action.clone();
                            break;
                        }
                    }
                } else {
                    // Check for shortcut key in label. Look for e.g. [Y]
                    let mut found = false;
                    for item in items {
                        if let Some(start) = item.label.find('[') {
                            if let Some(end) = item.label[start + 1..].find(']') {
                                let shortcut = &item.label[start + 1..start + 1 + end];
                                if shortcut.eq_ignore_ascii_case(&c.to_string()) {
                                    selected_action = item.action.clone();
                                    found = true;
                                    break;
                                }
                            }
                        }
                    }
                    if found {
                        break;
                    }
                }
            }
            Event::Key(Key::Backspace) => {
                if !result.is_empty() {
                    result.pop();
                    write!(stdout, "\x08 \x08").unwrap(); // Erase last character
                    stdout.flush().unwrap();
                }
            }
            Event::Key(Key::Esc) => {
                // Allow cancelling with ESC
                break;
            }
            Event::Key(Key::Ctrl('c')) | Event::Key(Key::Ctrl('d')) => {
                // Allow cancelling with Ctrl-C or Ctrl-D
                break;
            }
            _ => {}
        }
    }

    if !selected_action.is_empty() {
        Some(selected_action)
    } else {
        None
    }
}

1	use facet_ansi::{Style, Stylize};
2
3	/// A menu item
4	pub struct MenuItem {
5	/// may contain `[]`, like `[Y]es` — that's the shortcut key. pressing it immediately executes the action
6	pub label: String,
7
8	/// style for the action
9	pub style: Style,
10
11	/// returned by show_menu
12	pub action: String,
13	}
14
NEW 15	pub fn show_menu(question: &str, items: &[MenuItem]) -> Option<String> {	×
16	// Requires the 'termion' crate for raw input handling
17	use std::io::{self, Write};
18	use termion::event::{Event, Key};
19	use termion::input::TermRead;
20	use termion::raw::IntoRawMode;
21
22	use termion::color;
NEW 23	println!("{}", question);	×
NEW 24	for item in items.iter() {	×
NEW 25	let label = &item.label;	×
NEW 26	let mut chars = label.chars().peekable();	×
NEW 27	let mut after_colon = false;	×
NEW 28	while let Some(ch) = chars.next() {	×
29	// Check for shortcut
NEW 30	if ch == '[' {	×
NEW 31	let mut shortcut = String::new();	×
NEW 32	while let Some(&next_ch) = chars.peek() {	×
NEW 33	if next_ch == ']' {	×
NEW 34	chars.next(); // consume ']'	×
NEW 35	print!("[{}]", shortcut.style(item.style));	×
NEW 36	break;	×
37	} else {
NEW 38	shortcut.push(next_ch);	×
NEW 39	chars.next();	×
40	}
41	}
NEW 42	continue;	×
43	}
44	// Check for ':'
NEW 45	if !after_colon && ch == ':' {	×
NEW 46	after_colon = true;	×
NEW 47	print!("{}", color::Fg(color::LightBlack));	×
NEW 48	print!("{}", ch);	×
NEW 49	continue;	×
50	}
51	// After colon? Dim color, otherwise normal
NEW 52	if after_colon {	×
NEW 53	print!("{}", ch.to_string().dim());	×
54	} else {
NEW 55	print!("{}", ch);	×
56	}
57	}
NEW 58	if after_colon {	×
NEW 59	print!("{}", color::Fg(color::Reset));	×
60	}
NEW 61	println!();	×
62	}
NEW 63	print!("Enter your choice: ");	×
NEW 64	io::stdout().flush().unwrap();	×
65
66	#[cfg(any(target_os = "linux", target_os = "macos"))]
NEW 67	let tty = std::fs::OpenOptions::new()	×
68	.read(true)
69	.write(true)
70	.open("/dev/tty")
71	.unwrap();
72	#[cfg(any(target_os = "linux", target_os = "macos"))]
NEW 73	let mut stdout = tty.try_clone().unwrap().into_raw_mode().unwrap();	×
74	#[cfg(any(target_os = "linux", target_os = "macos"))]
NEW 75	let stdin = tty;	×
76	#[cfg(not(any(target_os = "linux", target_os = "macos")))]
NEW 77	let mut stdout = stdout().into_raw_mode().unwrap();	×
78	#[cfg(not(any(target_os = "linux", target_os = "macos")))]
NEW 79	let stdin = stdin();	×
NEW 80	let mut result = String::new();	×
NEW 81	let mut selected_action = String::new();	×
82
NEW 83	for evt in stdin.events() {	×
NEW 84	let evt = evt.unwrap();	×
NEW 85	match evt {	×
NEW 86	Event::Key(Key::Char(c)) => {	×
NEW 87	if c.is_ascii_digit() {	×
NEW 88	result.push(c);	×
NEW 89	write!(stdout, "{}", c).unwrap();	×
NEW 90	stdout.flush().unwrap();	×
91
NEW 92	if let Ok(idx) = result.parse::<usize>() {	×
NEW 93	if idx >= 1 && idx <= items.len() {	×
NEW 94	selected_action = items[idx - 1].action.clone();	×
NEW 95	break;	×
96	}
97	}
98	} else {
99	// Check for shortcut key in label. Look for e.g. [Y]
NEW 100	let mut found = false;	×
NEW 101	for item in items {	×
NEW 102	if let Some(start) = item.label.find('[') {	×
NEW 103	if let Some(end) = item.label[start + 1..].find(']') {	×
NEW 104	let shortcut = &item.label[start + 1..start + 1 + end];	×
NEW 105	if shortcut.eq_ignore_ascii_case(&c.to_string()) {	×
NEW 106	selected_action = item.action.clone();	×
NEW 107	found = true;	×
NEW 108	break;	×
109	}
110	}
111	}
112	}
NEW 113	if found {	×
NEW 114	break;	×
115	}
116	}
117	}
118	Event::Key(Key::Backspace) => {
NEW 119	if !result.is_empty() {	×
NEW 120	result.pop();	×
NEW 121	write!(stdout, "\x08 \x08").unwrap(); // Erase last character	×
NEW 122	stdout.flush().unwrap();	×
123	}
124	}
125	Event::Key(Key::Esc) => {
126	// Allow cancelling with ESC
NEW 127	break;	×
128	}
129	Event::Key(Key::Ctrl('c')) \| Event::Key(Key::Ctrl('d')) => {
130	// Allow cancelling with Ctrl-C or Ctrl-D
NEW 131	break;	×
132	}
NEW 133	_ => {}	×
134	}
135	}
136
NEW 137	if !selected_action.is_empty() {	×
NEW 138	Some(selected_action)	×
139	} else {
NEW 140	None	×
141	}
142	}

facet-rs / facet / 14468617911

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous