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
107
108
109

#![allow(missing_docs)]
//! Progress bar — ports `@clack/prompts` `progress()`.
//!
//! Built on top of the spinner: the bar is rendered into the spinner's message
//! line, so it animates the bullet character while the user calls
//! [`Progress::advance`] from another thread or in a loop.

use super::spinner::{spinner, Spinner};
use crate::styles::{paint, DIM};

#[derive(Clone, Copy)]
pub enum Style {
    Light,
    Heavy,
    Block,
}

impl Style {
    fn ch(self) -> &'static str {
        match self {
            Style::Light => "─",
            Style::Heavy => "━",
            Style::Block => "█",
        }
    }
}

pub struct Progress {
    spin: Spinner,
    style: Style,
    size: usize,
    max: u64,
    value: std::sync::Mutex<u64>,
    msg: std::sync::Mutex<String>,
}

pub fn progress() -> Progress {
    Progress {
        spin: spinner(),
        style: Style::Heavy,
        size: 40,
        max: 100,
        value: std::sync::Mutex::new(0),
        msg: std::sync::Mutex::new(String::new()),
    }
}

impl Progress {
    pub fn style(mut self, s: Style) -> Self {
        self.style = s;
        self
    }
    pub fn size(mut self, n: usize) -> Self {
        self.size = n.max(1);
        self
    }
    pub fn max(mut self, n: u64) -> Self {
        self.max = n.max(1);
        self
    }

    pub fn start(&self, msg: impl Into<String>) {
        let m = msg.into();
        *self.msg.lock().unwrap() = m.clone();
        self.spin.start(self.render(&m));
    }

    pub fn advance(&self, step: u64, msg: Option<String>) {
        let mut v = self.value.lock().unwrap();
        *v = (*v + step).min(self.max);
        let value = *v;
        drop(v);
        if let Some(m) = msg {
            *self.msg.lock().unwrap() = m;
        }
        let m = self.msg.lock().unwrap().clone();
        self.spin.message(self.render_with(&m, value));
    }

    pub fn message(&self, msg: impl Into<String>) {
        self.advance(0, Some(msg.into()));
    }

    pub fn stop(&self, msg: impl Into<String>) {
        self.spin.stop(msg);
    }
    pub fn cancel(&self, msg: impl Into<String>) {
        self.spin.cancel(msg);
    }
    pub fn error(&self, msg: impl Into<String>) {
        self.spin.error(msg);
    }

    fn render(&self, msg: &str) -> String {
        self.render_with(msg, *self.value.lock().unwrap())
    }
    fn render_with(&self, msg: &str, value: u64) -> String {
        let filled = ((value as usize) * self.size) / (self.max as usize);
        let ch = self.style.ch();
        let on = ch.repeat(filled);
        let off = ch.repeat(self.size - filled);
        format!(
            "{}{} {}",
            paint(super::settings::colors().accent, &on),
            paint(DIM, &off),
            msg
        )
    }
}