WIP: move from console to crossterm

Cargo.toml

@@ -28,6 +28,7 @@ console = "0.15.0"
 tempfile = { version = "3", optional = true }
 zeroize = { version = "1.1.1", optional = true }
 fuzzy-matcher = { version = "0.3.7", optional = true }
+crossterm = "0.24.0"
 
 [[example]]
 name = "password"

examples/buffered.rs

@@ -1,4 +1,5 @@
-use console::Term;
+fn main() {} // TODO fix this!
+/*use console::Term;
 use dialoguer::{theme::ColorfulTheme, Confirm, Input, MultiSelect, Select, Sort};
 
 fn main() {
@@ -40,3 +41,4 @@ fn main() {
         .interact_on(&term)
         .unwrap();
 }
+*/

src/lib.rs

@@ -47,5 +47,9 @@ mod edit;
 mod history;
 mod paging;
 mod prompts;
+pub use term::Term;
+mod term;
 pub mod theme;
 mod validate;
+
+const DEFAULT_TERMINAL_SIZE: (u16, u16) = (80, 24);

src/paging.rs

@@ -1,6 +1,8 @@
 use std::io;
 
-use console::Term;
+use crossterm::terminal;
+
+use crate::{term::Term, theme, DEFAULT_TERMINAL_SIZE};
 
 /// Creates a paging module
 ///
@@ -19,8 +21,8 @@ pub struct Paging<'a> {
 }
 
 impl<'a> Paging<'a> {
-    pub fn new(term: &'a Term, items_len: usize, max_capacity: Option<usize>) -> Paging<'a> {
-        let term_size = term.size();
+    pub fn new(term: &Term, items_len: usize, max_capacity: Option<usize>) -> Paging {
+        let term_size = terminal::size().unwrap_or(DEFAULT_TERMINAL_SIZE);
         // Subtract -2 because we need space to render the prompt, if paging is active
         let capacity = max_capacity
             .unwrap_or(std::usize::MAX)
@@ -46,7 +48,7 @@ impl<'a> Paging<'a> {
 
     /// Updates all internal based on the current terminal size and cursor position
     pub fn update(&mut self, cursor_pos: usize) -> io::Result<()> {
-        let new_term_size = self.term.size();
+        let new_term_size = terminal::size().unwrap_or(DEFAULT_TERMINAL_SIZE);
 
         if self.current_term_size != new_term_size {
             self.current_term_size = new_term_size;
@@ -64,8 +66,8 @@ impl<'a> Paging<'a> {
         } else {
             self.active = self.pages > 1;
             self.activity_transition = true;
-            // Clear everything to prevent "ghost" lines in terminal when a resize happened
-            self.term.clear_last_lines(self.capacity)?;
+            // Clear everything to prevent "ghost" lines in terminal when a resize happened.
+            theme::clear_last_lines(self.term, self.capacity as u16)?;
         }
 
         if cursor_pos != !0

src/prompts/confirm.rs

@@ -1,8 +1,14 @@
 use std::io;
 
-use crate::theme::{SimpleTheme, TermThemeRenderer, Theme};
+use crate::{
+    term::Term,
+    theme::{SimpleTheme, TermThemeRenderer, Theme},
+};
 
-use console::{Key, Term};
+use crossterm::{
+    event::{read, Event, KeyCode, KeyEvent},
+    terminal,
+};
 
 /// Renders a confirm prompt.
 ///
@@ -102,7 +108,7 @@ impl Confirm<'_> {
     /// This unlike [`interact_opt`](Self::interact_opt) does not allow to quit with 'Esc' or 'q'.
     #[inline]
     pub fn interact(&self) -> io::Result<bool> {
-        self.interact_on(&Term::stderr())
+        self.interact_on(&Term::from_stderr())
     }
 
     /// Enables user interaction and returns the result.
@@ -113,21 +119,20 @@ impl Confirm<'_> {
     /// or `None` if user cancelled with 'Esc' or 'q'.
     #[inline]
     pub fn interact_opt(&self) -> io::Result<Option<bool>> {
-        self.interact_on_opt(&Term::stderr())
+        self.interact_on_opt(&Term::from_stderr())
     }
 
     /// Like [interact](#method.interact) but allows a specific terminal to be set.
     ///
     /// ## Examples
     ///
     /// ```rust,no_run
-    /// use dialoguer::Confirm;
-    /// use console::Term;
+    /// use dialoguer::{Confirm, Term};
     ///
     /// # fn main() -> std::io::Result<()> {
     /// let proceed = Confirm::new()
     ///     .with_prompt("Do you wish to continue?")
-    ///     .interact_on(&Term::stderr())?;
+    ///     .interact_on(&Term::from_stderr())?;
     /// #   Ok(())
     /// # }
     /// ```
@@ -141,12 +146,11 @@ impl Confirm<'_> {
     ///
     /// ## Examples
     /// ```rust,no_run
-    /// use dialoguer::Confirm;
-    /// use console::Term;
+    /// use dialoguer::{Confirm, Term};
     ///
     /// fn main() -> std::io::Result<()> {
     ///     let confirmation = Confirm::new()
-    ///         .interact_on_opt(&Term::stdout())?;
+    ///         .interact_on_opt(&Term::from_stdout())?;
     ///
     ///     match confirmation {
     ///         Some(answer) => println!("User answered {}", if answer { "yes" } else { "no " }),
@@ -176,65 +180,67 @@ impl Confirm<'_> {
         term.flush()?;
 
         let rv;
-
+        terminal::enable_raw_mode()?;
         if self.wait_for_newline {
             // Waits for user input and for the user to hit the Enter key
             // before validation.
             let mut value = default_if_show;
 
             loop {
-                let input = term.read_key()?;
-
-                match input {
-                    Key::Char('y') | Key::Char('Y') => {
-                        value = Some(true);
-                    }
-                    Key::Char('n') | Key::Char('N') => {
-                        value = Some(false);
-                    }
-                    Key::Enter => {
-                        if !allow_quit {
-                            value = value.or(self.default);
+                if let Event::Key(KeyEvent { code, modifiers: _ }) = read().unwrap() {
+                    terminal::disable_raw_mode()?;
+                    match code {
+                        KeyCode::Char('y') | KeyCode::Char('Y') => {
+                            value = Some(true);
+                        }
+                        KeyCode::Char('n') | KeyCode::Char('N') => {
+                            value = Some(false);
                         }
+                        KeyCode::Enter => {
+                            if !allow_quit {
+                                value = value.or(self.default);
+                            }
 
-                        if value.is_some() || allow_quit {
-                            rv = value;
-                            break;
+                            if value.is_some() || allow_quit {
+                                rv = value;
+                                break;
+                            }
+                            continue;
+                        }
+                        KeyCode::Esc | KeyCode::Char('q') if allow_quit => {
+                            value = None;
+                        }
+                        _ => {
+                            continue;
                         }
-                        continue;
-                    }
-                    Key::Escape | Key::Char('q') if allow_quit => {
-                        value = None;
-                    }
-                    _ => {
-                        continue;
                     }
                 };
 
-                term.clear_line()?;
+                render.clear_current_line()?;
                 render.confirm_prompt(&self.prompt, value)?;
             }
         } else {
             // Default behavior: matches continuously on every keystroke,
             // and does not wait for user to hit the Enter key.
             loop {
-                let input = term.read_key()?;
-                let value = match input {
-                    Key::Char('y') | Key::Char('Y') => Some(true),
-                    Key::Char('n') | Key::Char('N') => Some(false),
-                    Key::Enter if self.default.is_some() => Some(self.default.unwrap()),
-                    Key::Escape | Key::Char('q') if allow_quit => None,
-                    _ => {
-                        continue;
-                    }
+                if let Event::Key(KeyEvent { code, modifiers: _ }) = read().unwrap() {
+                    let value = match code {
+                        KeyCode::Char('y') | KeyCode::Char('Y') => Some(true),
+                        KeyCode::Char('n') | KeyCode::Char('N') => Some(false),
+                        KeyCode::Enter if self.default.is_some() => Some(self.default.unwrap()),
+                        KeyCode::Esc | KeyCode::Char('q') if allow_quit => None,
+                        _ => {
+                            continue;
+                        }
+                    };
+                    terminal::disable_raw_mode()?;
+                    rv = value;
+                    break;
                 };
-
-                rv = value;
-                break;
             }
         }
 
-        term.clear_line()?;
+        render.clear_current_line()?;
         if self.report {
             render.confirm_prompt_selection(&self.prompt, rv)?;
         }

src/prompts/dummy.rs

@@ -0,0 +1,13 @@
+use std::io;
+use crate::{paging::Paging, term::Term, theme::{SimpleTheme, TermThemeRenderer}};
+
+fn test(term: Term) -> io::Result<()> {
+  let mut paging = Paging::new(Term::clone(&term), 0, Some(42));
+  let mut render = TermThemeRenderer::new(Term::clone(&term), &SimpleTheme);
+
+  term.hide_cursor()?;
+
+  paging.render_prompt(|paging_info| render.select_prompt("My prompt string", paging_info))?;
+
+  Ok(())
+}