starry 2.1.0

Current stars history tells only half the story
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
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

use {
    std::{
        io::{
            self,
            Write,
        },
        time::Instant,
    },
    termimad::{
        crossterm::{
            cursor,
            queue,
            style::{
                style,
                Color,
                Print,
                PrintStyledContent,
                Stylize,
            },
            terminal::{
                Clear,
                ClearType,
            },
        },
        ProgressBar,
    },
};

pub fn print_progress(
    label: &str,
    done: usize,
    total: usize,
    post_label: Option<String>,
) -> anyhow::Result<()> {
    let width = 12;
    let total = total
        .max(done) // avoid overflowing the bar
        .max(1); // avoid division by zero
    let p = ProgressBar::new(done as f32 / (total as f32), width);
    let s = format!("{:width$}", p, width = width);
    let mut stderr = io::stderr();
    queue!(stderr, cursor::SavePosition)?;
    queue!(stderr, Clear(ClearType::CurrentLine))?;
    queue!(stderr, Print(format!("{:>20} ", label)))?;
    queue!(
        stderr,
        PrintStyledContent(style(s).with(Color::Yellow).on(Color::DarkBlue))
    )?;
    if let Some(post_label) = post_label {
        queue!(stderr, Print(format!(" {}", post_label)))?;
    }
    queue!(stderr, cursor::RestorePosition)?;
    stderr.flush()?;
    Ok(())
}

#[allow(dead_code)]
pub fn clear_progress() -> anyhow::Result<()> {
    let mut stderr = io::stderr();
    queue!(stderr, cursor::SavePosition)?;
    queue!(stderr, Clear(ClearType::CurrentLine))?;
    queue!(stderr, cursor::RestorePosition)?;
    stderr.flush()?;
    Ok(())
}

#[derive(Clone)]
pub struct Task {
    pub label: String,
    pub show: bool,
    pub done: usize,
    pub total: usize,
    pub start: Instant,
}
impl Task {
    pub fn new<S: Into<String>>(label: S) -> Self {
        let mut task = Self {
            label: label.into(),
            show: true,
            done: 0,
            total: 1,
            start: Instant::now(),
        };
        task.update(0, 1);
        task
    }
    pub fn with_total(
        mut self,
        total: usize,
    ) -> Self {
        self.total = total;
        self
    }
    pub fn update(
        &mut self,
        done: usize,
        total: usize,
    ) {
        if self.show {
            self.done = done;
            self.total = total;
            let _ = print_progress(&self.label, done, total, None);
        }
    }
    pub fn increment(&mut self) {
        if self.show {
            self.done += 1;
            let _ = print_progress(&self.label, self.done, self.total, None);
        }
    }
    pub fn update_with_label<S: Into<String>>(
        &self,
        done: usize,
        total: usize,
        post_label: S,
    ) {
        if self.show {
            let _ = print_progress(&self.label, done, total, Some(post_label.into()));
        }
    }
    pub fn finish<S: Into<String>>(
        &self,
        post_label: S,
    ) {
        if self.show {
            let post_label = format!(
                "{} in {:.1}s",
                post_label.into(),
                self.start.elapsed().as_secs_f32(),
            );
            let _ = print_progress(&self.label, 1, 1, Some(post_label));
            eprintln!();
        }
    }
}