bitbottle 0.10.0

a modern archive file format
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

use std::cell::RefCell;
use std::rc::Rc;
use std::time::{Duration, Instant};
use term_size::dimensions_stderr;
use crate::cli::pad_truncate;

const EIGHT: [char; 9] = [
    ' ',
    '\u{258f}', '\u{258e}', '\u{258d}', '\u{258c}',
    '\u{258b}', '\u{258a}', '\u{2589}', '\u{2588}'
];

pub struct ProgressBar {
    width: usize,
    amount: f64,  // 0.0 -> 1.0
    buffer: String,
}

impl ProgressBar {
    pub fn new(width: usize) -> ProgressBar {
        ProgressBar { width, amount: 0f64, buffer: String::new() }
    }

    pub fn update(&mut self, amount: f64) -> &str {
        self.amount = amount;
        self.render()
    }

    pub fn render(&mut self) -> &str {
        let mut units = (self.amount * self.width as f64 * 8f64).floor() as isize;
        self.buffer.truncate(0);
        for _i in 0..self.width {
            self.buffer.push(EIGHT[units.clamp(0, 8) as usize]);
            units -= 8;
        }
        &self.buffer
    }
}


const BAR_WIDTH: usize = 32;

pub struct ProgressLine {
    bar: ProgressBar,
    start_time: Instant,
    last_update: Instant,
    pub debounce: Duration,
    width: usize,

    // configurable on the fly:
    message: String,
    pub show_bar: bool,
    pub show_ever: bool,
    completion: f64,
}

impl ProgressLine {
    pub fn new() -> ProgressLine {
        let bar = ProgressBar::new(BAR_WIDTH);
        let start_time = Instant::now();
        let last_update = start_time - Duration::from_secs(3600);
        let debounce = Duration::from_millis(100);
        let width = dimensions_stderr().map(|(cols, _rows)| cols - 1).unwrap_or(79);
        let message = String::default();
        let show_bar = true;
        let show_ever = true;
        let completion = 0f64;
        ProgressLine { bar, start_time, last_update, debounce, width, message, show_bar, show_ever, completion }
    }

    pub fn to_shared(self) -> Rc<RefCell<ProgressLine>> {
        Rc::new(RefCell::new(self))
    }

    pub fn update(&mut self, completion: f64, message: String) -> &mut Self {
        self.completion = completion;
        self.message = message;
        self
    }

    pub fn complete(&mut self, completion: f64) -> &mut Self {
        self.completion = completion;
        self
    }

    pub fn force_update(&mut self) -> &mut Self {
        self.last_update -= self.debounce;
        self
    }

    pub fn display(&mut self) {
        if !self.show_ever { return; }

        let now = Instant::now();
        if now.duration_since(self.last_update) < self.debounce {
            return;
        }

        let duration = now.duration_since(self.start_time);
        let seconds = duration.as_secs();
        let minutes = seconds / 60;
        let hours = minutes / 60;
        let time = format!("{:02}:{:02}:{:02}", hours, minutes % 60, seconds % 60);

        let bar = if self.show_bar {
            format!("\u{2507}{}\u{2507} {:>3}% ",
                self.bar.update(self.completion),
                (self.completion * 100f64).floor() as usize
            )
        } else {
            String::new()
        };

        // time: "[hh:mm:ss] " = 11 chars
        let width = 11 + if self.show_bar { BAR_WIDTH + 8 } else { 0 };
        eprint!("\r[{}] {}{}", time, bar, pad_truncate(&self.message, self.width - width));

        self.last_update = now;
    }

    pub fn clear(&mut self) {
        if self.show_ever {
            eprint!("\r{}\r", pad_truncate("", self.width));
        }
        self.force_update();
    }
}

impl Default for ProgressLine {
    fn default() -> Self {
        ProgressLine::new()
    }
}