fix: ctrl-c doesn't restore cursor

jdx · Dec 18, 2024 · 02c5545 · 02c5545
1 parent 5d285c2
commit 02c5545
Show file tree

Hide file tree

Showing 19 changed files with 186 additions and 36 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -13,6 +13,7 @@ console = "0.15"
 fuzzy-matcher = "0.3"
 itertools = "0.13"
 once_cell = "1"
+signal-hook = "0.3"
 termcolor = "1"
 
 [dev-dependencies]

diff --git a/examples/confirm.rs b/examples/confirm.rs
@@ -5,11 +5,11 @@ fn main() {
         .description("This will do a thing.")
         .affirmative("Yes!")
         .negative("No.");
-    let _ = match confirm.run() {
+    match confirm.run() {
         Ok(confirm) => confirm,
         Err(e) => {
             if e.kind() == std::io::ErrorKind::Interrupted {
-                println!("Dialog was cancelled");
+                println!("{}", e);
                 false
             } else {
                 panic!("Error: {}", e);

diff --git a/examples/dialog.rs b/examples/dialog.rs
@@ -9,11 +9,11 @@ fn main() {
             DialogButton::new("Cancel"),
         ])
         .selected_button(1);
-    let _ = match dialog.run() {
+    match dialog.run() {
         Ok(value) => value,
         Err(e) => {
             if e.kind() == std::io::ErrorKind::Interrupted {
-                println!("Dialog was cancelled");
+                println!("{}", e);
                 return;
             } else {
                 panic!("Error: {}", e);

diff --git a/examples/input-password.rs b/examples/input-password.rs
@@ -5,11 +5,11 @@ fn main() {
         .placeholder("Enter password")
         .prompt("Password: ")
         .password(true);
-    let _ = match input.run() {
+    match input.run() {
         Ok(value) => value,
         Err(e) => {
             if e.kind() == std::io::ErrorKind::Interrupted {
-                println!("Input cancelled");
+                println!("{}", e);
                 return;
             } else {
                 panic!("Error: {}", e);

diff --git a/examples/input.rs b/examples/input.rs
@@ -26,15 +26,40 @@ fn main() {
             "Zack Snyder",
         ])
         .validation(notempty_minlen);
-    let _ = match input.run() {
+    match input.run() {
         Ok(value) => value,
-        Err(e) => {
-            if e.kind() == std::io::ErrorKind::Interrupted {
-                println!("Input cancelled");
-                return;
-            } else {
-                panic!("Error: {}", e);
+        Err(_) => "".to_string(),
+        // Err(e) => {
+        //     if e.kind() == std::io::ErrorKind::Interrupted {
+        //         println!("{}", e);
+        //         return;
+        //     } else {
+        //         panic!("Error: {}", e);
+        //     }
+        // }
+    };
+
+    loop {
+        println!("Chose an option: ");
+        let mut input = String::new();
+        println!("Q to quit");
+        println!("C to continue");
+        match std::io::stdin().read_line(&mut input) {
+            Ok(_) => match input.trim() {
+                "Q" | "q" => {
+                    println!("Quitting...");
+                    break;
+                }
+                "C" | "c" => {
+                    println!("Continuing...");
+                }
+                _ => {
+                    println!("Invalid option");
+                }
+            },
+            Err(e) => {
+                println!("Error: {}", e);
             }
         }
-    };
+    }
 }
diff --git a/examples/list.rs b/examples/list.rs
@@ -71,7 +71,7 @@ fn main() {
         Ok(_) => {}
         Err(e) => {
             if e.kind() == io::ErrorKind::Interrupted {
-                println!("Input cancelled");
+                println!("{}", e);
             } else {
                 panic!("Error: {}", e);
             }

diff --git a/examples/multiselect.rs b/examples/multiselect.rs
@@ -13,11 +13,11 @@ fn main() {
         .option(DemandOption::new("Cheese"))
         .option(DemandOption::new("Vegan Cheese"))
         .option(DemandOption::new("Nutella"));
-    let _ = match multiselect.run() {
+    match multiselect.run() {
         Ok(toppings) => toppings,
         Err(e) => {
             if e.kind() == std::io::ErrorKind::Interrupted {
-                println!("Input cancelled");
+                println!("{}", e);
                 return;
             } else {
                 panic!("Error: {}", e);

diff --git a/examples/multiselect_huge.rs b/examples/multiselect_huge.rs
@@ -67,11 +67,11 @@ fn main() {
         .option(DemandOption::new("Starburst"))
         .option(DemandOption::new("Twizzlers"))
         .option(DemandOption::new("Milk Duds"));
-    let _ = match multiselect.run() {
+    match multiselect.run() {
         Ok(value) => value,
         Err(e) => {
             if e.kind() == std::io::ErrorKind::Interrupted {
-                println!("Input cancelled");
+                println!("{}", e);
                 return;
             } else {
                 panic!("Error: {}", e);

diff --git a/examples/select.rs b/examples/select.rs
@@ -47,11 +47,11 @@ fn main() {
         .option(DemandOption::new("EG").label("Egypt"))
         .option(DemandOption::new("SA").label("Saudi Arabia"))
         .option(DemandOption::new("AE").label("United Arab Emirates"));
-    let _ = match ms.run() {
+    match ms.run() {
         Ok(value) => value,
         Err(e) => {
             if e.kind() == std::io::ErrorKind::Interrupted {
-                println!("Input cancelled");
+                println!("{}", e);
                 return;
             } else {
                 panic!("Error: {}", e);

diff --git a/examples/themes.rs b/examples/themes.rs
@@ -2,6 +2,20 @@ use std::env::args;
 
 use demand::{Confirm, DemandOption, Input, MultiSelect, Theme};
 
+fn handle_run<T>(result: Result<T, std::io::Error>) -> T {
+    match result {
+        Ok(value) => value,
+        Err(e) => {
+            if e.kind() == std::io::ErrorKind::Interrupted {
+                println!("{}", e);
+                std::process::exit(0);
+            } else {
+                panic!("Error: {}", e);
+            }
+        }
+    }
+}
+
 fn main() {
     let theme = match args().nth(1).unwrap_or_default().as_str() {
         "base16" => Theme::base16(),
@@ -16,7 +30,7 @@ fn main() {
         .description("Please enter your e-mail address.")
         .placeholder("[email protected]")
         .theme(&theme);
-    i.run().expect("error running input");
+    handle_run(i.run());
 
     let ms = MultiSelect::new("Interests")
         .description("Select your interests")
@@ -31,12 +45,12 @@ fn main() {
         .option(DemandOption::new("Travel"))
         .option(DemandOption::new("Sports"))
         .theme(&theme);
-    ms.run().expect("error running multi select");
+    handle_run(ms.run());
 
     let c = Confirm::new("Confirm privacy policy")
         .description("Do you accept the privacy policy?")
         .affirmative("Yes")
         .negative("No")
         .theme(&theme);
-    c.run().expect("error running confirm");
+    handle_run(c.run());
 }
diff --git a/src/confirm.rs b/src/confirm.rs
@@ -4,8 +4,8 @@ use std::io::Write;
 use console::{Key, Term};
 use termcolor::{Buffer, WriteColor};
 
-use crate::theme;
 use crate::theme::Theme;
+use crate::{ctrlc, theme};
 
 /// Select multiple options from a list
 ///
@@ -95,9 +95,12 @@ impl<'a> Confirm<'a> {
     /// This function will block until the user submits the input. If the user cancels the input,
     /// an error of type `io::ErrorKind::Interrupted` is returned.
     pub fn run(mut self) -> io::Result<bool> {
+        let _ctrlc_handle = ctrlc::show_cursor_after_ctrlc(&self.term)?;
+
         let affirmative_char = self.affirmative.to_lowercase().chars().next().unwrap();
         let negative_char = self.negative.to_lowercase().chars().next().unwrap();
         self.term.clear_line()?;
+        self.term.hide_cursor()?;
         loop {
             self.clear()?;
             let output = self.render()?;
@@ -119,7 +122,7 @@ impl<'a> Confirm<'a> {
                     return self.handle_submit();
                 }
                 Key::Escape => {
-                    self.clear()?;
+                    self.term.show_cursor()?;
                     return Err(io::Error::new(io::ErrorKind::Interrupted, "user cancelled"));
                 }
                 _ => {}
@@ -130,6 +133,7 @@ impl<'a> Confirm<'a> {
     fn handle_submit(mut self) -> io::Result<bool> {
         self.term.clear_to_end_of_screen()?;
         self.clear()?;
+        self.term.show_cursor()?;
         let output = self.render_success()?;
         self.term.write_all(output.as_bytes())?;
         Ok(self.selected)

diff --git a/src/ctrlc.rs b/src/ctrlc.rs
@@ -0,0 +1,86 @@
+use console::Term;
+use once_cell::sync::Lazy;
+use signal_hook::{
+    consts::SIGINT,
+    iterator::{Handle, Signals},
+};
+use std::{
+    io::Error,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Mutex, RwLock,
+    },
+    thread,
+    time::Duration,
+};
+
+static MUTEX: Mutex<()> = Mutex::new(());
+static INIT: AtomicBool = AtomicBool::new(false);
+static HANDLE: Lazy<RwLock<Option<CtrlcHandle>>> = Lazy::new(|| RwLock::new(None));
+
+#[derive(Clone)]
+pub struct CtrlcHandle(Handle);
+
+impl CtrlcHandle {
+    #[allow(dead_code)]
+    pub fn close(&self) {
+        self.0.close();
+    }
+}
+
+impl Drop for CtrlcHandle {
+    fn drop(&mut self) {
+        // let the signal handler finish
+        thread::sleep(Duration::from_millis(100));
+        self.0.close();
+    }
+}
+
+pub fn show_cursor_after_ctrlc(term: &Term) -> Result<CtrlcHandle, Error> {
+    let t = term.clone();
+    match set_ctrlc_handler(move || {
+        println!("Ctrl-C pressed");
+        let _ = t.show_cursor();
+    }) {
+        Ok(Some(handle)) => Ok(handle),
+        _ => Err(Error::new(
+            std::io::ErrorKind::Other,
+            "failed to set Ctrl-C handler",
+        )),
+    }
+}
+
+pub fn set_ctrlc_handler<F>(handler: F) -> Result<Option<CtrlcHandle>, Error>
+where
+    F: FnMut() + 'static + Send,
+{
+    let _mutex = MUTEX.lock();
+    if INIT.load(Ordering::Relaxed) {
+        let handle_guard = HANDLE.read().unwrap();
+        return Ok(handle_guard.clone());
+    }
+    INIT.store(true, Ordering::Relaxed);
+
+    let handle = set_ctrlc_handler_internal(handler)?;
+    {
+        let mut handle_guard = HANDLE.write().unwrap();
+        *handle_guard = Some(CtrlcHandle(handle.clone()));
+    }
+    Ok(Some(CtrlcHandle(handle)))
+}
+
+fn set_ctrlc_handler_internal<F>(mut handler: F) -> Result<Handle, Error>
+where
+    F: FnMut() + 'static + Send,
+{
+    let mut signals = Signals::new([SIGINT])?;
+    let handle = signals.handle();
+    thread::Builder::new()
+        .name("ctrl-c".into())
+        .spawn(move || {
+            for _ in signals.forever() {
+                handler();
+            }
+        })?;
+    Ok(handle)
+}
diff --git a/src/dialog.rs b/src/dialog.rs
@@ -4,8 +4,8 @@ use std::io::Write;
 use console::{Key, Term};
 use termcolor::{Buffer, WriteColor};
 
-use crate::theme;
 use crate::theme::Theme;
+use crate::{ctrlc, theme};
 
 #[derive(Clone, Debug, Default, PartialEq)]
 /// A button to select in a dialog
@@ -131,6 +131,9 @@ impl<'a> Dialog<'a> {
     /// This function will block until the user submits the input. If the user cancels the input,
     /// an error of type `io::ErrorKind::Interrupted` is returned.
     pub fn run(mut self) -> io::Result<String> {
+        let _ctrlc_handle = ctrlc::show_cursor_after_ctrlc(&self.term)?;
+
+        self.term.hide_cursor()?;
         loop {
             self.clear()?;
             let output = self.render()?;
@@ -149,7 +152,7 @@ impl<'a> Dialog<'a> {
                     return self.handle_submit();
                 }
                 Key::Escape => {
-                    self.clear()?;
+                    self.term.show_cursor()?;
                     return Err(io::Error::new(io::ErrorKind::Interrupted, "user cancelled"));
                 }
                 _ => {}
@@ -159,6 +162,7 @@ impl<'a> Dialog<'a> {
 
     fn handle_submit(mut self) -> io::Result<String> {
         self.clear()?;
+        self.term.show_cursor()?;
         let output = self.render_success()?;
         self.term.write_all(output.as_bytes())?;
         let result = if !self.buttons.is_empty() {

diff --git a/src/input.rs b/src/input.rs
@@ -6,6 +6,7 @@ use std::{
 use console::{measure_text_width, Key, Term};
 use termcolor::{Buffer, WriteColor};
 
+use crate::ctrlc;
 use crate::{theme, Theme};
 
 /// Single line text input
@@ -153,6 +154,8 @@ impl<'a> Input<'a> {
     /// This function will block until the user submits the input. If the user cancels the input,
     /// an error of type `io::ErrorKind::Interrupted` is returned.
     pub fn run(mut self) -> io::Result<String> {
+        let _ctrlc_handle = ctrlc::show_cursor_after_ctrlc(&self.term)?;
+
         self.term.hide_cursor()?;
         loop {
             self.clear()?;
@@ -184,7 +187,7 @@ impl<'a> Input<'a> {
                 }
                 Key::Tab => self.handle_tab()?,
                 Key::Escape => {
-                    self.clear()?;
+                    self.term.show_cursor()?;
                     return Err(io::Error::new(io::ErrorKind::Interrupted, "user cancelled"));
                 }
                 _ => {}

diff --git a/src/lib.rs b/src/lib.rs
@@ -13,6 +13,7 @@ pub use spinner::SpinnerStyle;
 pub use theme::Theme;
 
 mod confirm;
+mod ctrlc;
 mod dialog;
 mod input;
 mod list;