pimalaya-tui 0.2.2

Collection of crossterm widgets shared accross Pimalaya projects
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use std::fmt;
#[cfg(feature = "path")]
use std::path::{Path, PathBuf};

use inquire::{Confirm, Password, PasswordDisplayMode, Select, Text};

use crate::{terminal::validator::*, Error, Result};

pub fn u16(prompt: impl AsRef<str>, default: Option<u16>) -> Result<u16> {
    let prompt = Text::new(prompt.as_ref()).with_validator(U16Validator);

    let number = if let Some(default) = default {
        prompt.with_default(&default.to_string()).prompt()
    } else {
        prompt.prompt()
    };

    match number {
        Ok(number) => Ok(number.parse().unwrap()),
        Err(err) => Err(Error::PromptU16Error(err)),
    }
}

pub fn usize(prompt: impl AsRef<str>, default: Option<usize>) -> Result<usize> {
    let prompt = Text::new(prompt.as_ref()).with_validator(UsizeValidator);

    let number = if let Some(default) = default {
        prompt.with_default(&default.to_string()).prompt()
    } else {
        prompt.prompt()
    };

    match number {
        Ok(number) => Ok(number.parse().unwrap()),
        Err(err) => Err(Error::PromptUsizeError(err)),
    }
}

pub fn secret(prompt: impl AsRef<str>) -> Result<String> {
    Password::new(prompt.as_ref())
        .with_display_mode(PasswordDisplayMode::Masked)
        .without_confirmation()
        .prompt()
        .map_err(Error::PromptSecretError)
}

pub fn some_secret(prompt: impl AsRef<str>) -> Result<Option<String>> {
    Password::new(prompt.as_ref())
        .with_display_mode(PasswordDisplayMode::Masked)
        .without_confirmation()
        .prompt_skippable()
        .map_err(Error::PromptSecretError)
}

pub fn password(prompt: impl AsRef<str>) -> Result<String> {
    Password::new(prompt.as_ref())
        .with_display_mode(PasswordDisplayMode::Masked)
        .with_custom_confirmation_message("Confirm password")
        .prompt()
        .map_err(Error::PromptPasswordError)
}

pub fn text<T: AsRef<str>>(prompt: T, default: Option<T>) -> Result<String> {
    let mut prompt = Text::new(prompt.as_ref());

    if let Some(default) = default.as_ref() {
        prompt = prompt.with_default(default.as_ref())
    }

    prompt.prompt().map_err(Error::PromptTextError)
}

pub fn some_text<T: AsRef<str>>(prompt: T, default: Option<T>) -> Result<Option<String>> {
    let mut prompt = Text::new(prompt.as_ref());

    if let Some(default) = default.as_ref() {
        prompt = prompt.with_default(default.as_ref())
    }

    prompt.prompt_skippable().map_err(Error::PromptTextError)
}

pub fn bool(prompt: impl AsRef<str>, default: bool) -> Result<bool> {
    Confirm::new(prompt.as_ref())
        .with_default(default)
        .prompt()
        .map_err(Error::PromptBoolError)
}

pub fn item<T: fmt::Display + Eq>(
    prompt: impl AsRef<str>,
    items: impl IntoIterator<Item = T>,
    default: Option<T>,
) -> Result<T> {
    let items: Vec<_> = items.into_iter().collect();

    let default = if let Some(default) = default.as_ref() {
        items
            .iter()
            .enumerate()
            .find_map(|(i, item)| if item == default { Some(i) } else { None })
    } else {
        None
    };

    let mut prompt = Select::new(prompt.as_ref(), items);

    if let Some(default) = default.as_ref() {
        prompt = prompt.with_starting_cursor(*default);
    }

    prompt.prompt().map_err(Error::PromptItemError)
}

#[cfg(feature = "path")]
pub fn path(prompt: impl AsRef<str>, default: Option<impl AsRef<Path>>) -> Result<PathBuf> {
    let prompt = Text::new(prompt.as_ref());

    let text = if let Some(default) = default.as_ref() {
        let default = default.as_ref().display().to_string();
        prompt.with_default(&default).prompt()
    } else {
        prompt.prompt()
    };

    let path = PathBuf::from(text.map_err(Error::PromptPathError)?);

    Ok(shellexpand_utils::expand::path(path))
}

#[cfg(feature = "email")]
pub fn email<T: AsRef<str>>(prompt: T, default: Option<T>) -> Result<email_address::EmailAddress> {
    let mut prompt = Text::new(prompt.as_ref()).with_validator(EmailValidator);

    if let Some(default) = default.as_ref() {
        prompt = prompt.with_default(default.as_ref());
    }

    let email = prompt.prompt().map_err(Error::PromptEmailError)?;

    Ok(<email_address::EmailAddress as std::str::FromStr>::from_str(&email).unwrap())
}