cli-ui 0.1.0

Styled CLI framework — typed argument parsing, themed help, and clack-style interactive prompts
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! Boolean confirmation prompt — built on the [`Prompt`] trait.

use crate::styles::{paint, ACCENT, DIM, WHITE};
use std::io::Write;

use super::core::{Frame, Key, Prompt, RenderCtx, Step};
use super::error::{PromptError, Result};
use super::theme;

/// Builder returned by [`confirm()`].
pub struct ConfirmPrompt {
    label: String,
    default: Option<bool>,
    value: bool,
}

/// Ask the user a yes/no question. Returns `true` for Yes.
///
/// ```no_run
/// use cli_ui::prompt::confirm;
///
/// let init_git = confirm("Initialise git?").default(true).run()?;
/// # Ok::<(), cli_ui::prompt::PromptError>(())
/// ```
pub fn confirm(label: impl Into<String>) -> ConfirmPrompt {
    ConfirmPrompt {
        label: label.into(),
        default: None,
        value: true,
    }
}

impl ConfirmPrompt {
    /// Initial selection — also accepted as the value when the user just
    /// hits Enter without choosing.
    pub fn default(mut self, v: bool) -> Self {
        self.default = Some(v);
        self.value = v;
        self
    }

    /// Run the prompt to completion.
    pub fn run(self) -> Result<bool> {
        super::core::run(self)
    }
}

impl Prompt for ConfirmPrompt {
    type Output = bool;

    fn handle(&mut self, key: Key) -> Step<bool> {
        match key {
            Key::Left | Key::Right => {
                self.value = !self.value;
                Step::Continue
            }
            Key::Char('y') | Key::Char('Y') => Step::Submit(true),
            Key::Char('n') | Key::Char('N') => Step::Submit(false),
            Key::Enter => Step::Submit(self.value),
            Key::Escape | Key::Interrupt => Step::Cancel,
            _ => Step::Continue,
        }
    }

    fn render(&self, _ctx: RenderCtx) -> Frame {
        vec![
            theme::label(&self.label),
            theme::confirm_line(self.value),
            theme::frame_bot(None),
        ]
    }

    fn render_answered(&self, value: &bool) -> Frame {
        theme::answered(&self.label, if *value { "Yes" } else { "No" })
            .split("\r\n")
            .map(String::from)
            .collect()
    }

    fn run_fallback(self) -> Result<bool> {
        let hint = match self.default {
            Some(true) => "Y/n",
            Some(false) => "y/N",
            None => "y/n",
        };
        eprint!(
            "{}  {} [{}]: ",
            paint(ACCENT, "◆"),
            paint(WHITE, &self.label),
            paint(DIM, hint)
        );
        std::io::stderr().flush().map_err(PromptError::Io)?;
        loop {
            let line = super::engine::fallback::read_line_raw()?;
            match line.to_lowercase().as_str() {
                "y" | "yes" => return Ok(true),
                "n" | "no" => return Ok(false),
                "" if self.default.is_some() => return Ok(self.default.unwrap()),
                _ => {
                    eprint!("  Please enter y or n: ");
                    std::io::stderr().flush().map_err(PromptError::Io)?;
                }
            }
        }
    }
}