14931971708

Committed 09 May 2025 03:08PM UTC coverage: 55.308%. First build

Build # 14931971708

Build Type

Pull #527

github

Committed by

web-flow

Commit Message

Merge 10005e18e into a46b975f2

Pull Request Pull Request #527: Rework type information (Def) — rebased #462

Run Details

1077 of 1985 new or added lines in 50 files covered. (54.26%)

6669 of 12058 relevant lines covered (55.31%)

73.99 hits per line

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

0.0

/facet-dev/src/menu.rs

#![cfg_attr(windows, allow(dead_code))]

use yansi::Style;

/// 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,
}

#[cfg(windows)]
pub fn show_menu(question: &str, items: &[MenuItem]) -> Option<String> {
    _ = (question, items);
    None
}

#[cfg(not(windows))]
pub fn show_menu(question: &str, items: &[MenuItem]) -> Option<String> {
    // Check for environment variable to automatically accept
    if std::env::var("FACET_PRECOMMIT_ACCEPT_ALL").is_ok() {
        // If FACET_PRECOMMIT_ACCEPT_ALL is set, automatically return "apply"
        println!("FACET_PRECOMMIT_ACCEPT_ALL is set, automatically accepting changes");
        return Some("apply".to_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 yansi::Paint as _;

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

facet-rs / facet / 14931971708

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