parsli 0.0.3

Parallel status lines for Rust
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

use std::sync::Arc;
use std::time::Duration;
use console::style;
use indicatif::{MultiProgress, ProgressBar, ProgressStyle};

/// The state that a bar should be updated to
#[derive(PartialEq, Clone)]
pub enum LineStatus { Idle, Busy }


/// A wrapper for a progress bar providing convenient methods
#[derive(Debug, Clone)]
pub struct Line {
    /// The inner progress bar
    bar: ProgressBar,
}


impl Line {
    /// Creates a new stat bar and adds it to the multi progress display
    pub fn new(progress: Arc<MultiProgress>) -> Self {
        Self { bar: progress.add(ProgressBar::new(0)) }
    }

    /*
    /// Finishes with a generic success message
    pub fn okay(&self) {
        self.update_message(LineStatus::Okay, "Success!".to_string());
    }

    /// Finishes with a specific success message
    pub fn okay_with_message(&self, message: String) {
        self.update_message(LineStatus::Okay, format!("Success: {}!", message));
    }

    /// Finishes with a generic failure message
    pub fn fail(&self) {
        self.update_message(LineStatus::Fail, "Failure!".to_string());
    }

    /// Finishes with a specific failure message
    pub fn fail_with_message(&self, message: String) {
        self.update_message(LineStatus::Fail, format!("Failure: {}!", message));
    }
    */

    /// Print line above stat bar
    pub fn println(&self, message: String) {
        self.bar.println(message);
    }

    /*
    pub fn println_okay(&self, message: String) {
        self.bar.println(format!("{}{}", style("✔ ").green(), message));
    }

    pub fn println_fail(&self, message: String) {
    }
    */

    /// Updates the highlighted text in front of the displayed message
    pub fn update_prefix(&self, prefix: String) {
        self.bar.set_prefix(prefix);
    }

    /// Updates the status and the displayed message
    pub fn update_message(&self, status: LineStatus, message: String) {
        // Update ticking
        if status == LineStatus::Busy {
            self.bar.enable_steady_tick(Duration::from_millis(1000 / 30));
        } else {
            self.bar.disable_steady_tick()
        }

        // Update style
        let mut progress_style = ProgressStyle::default_spinner().template("{prefix:.bold.dim} {wide_msg}").unwrap();
        if status == LineStatus::Busy {
            progress_style = progress_style
                .tick_chars("⠈⠐⠠⢀⡀⠄⠂⠁ ")
                .template("{prefix:.bold.dim} {spinner:.yellow} {wide_msg} {binary_bytes_per_sec}").unwrap();
        }
        self.bar.set_style(progress_style);

        // Compose message
        let message = format!(
            "{}{}",
            match status {
                LineStatus::Idle => style("- ").yellow(),
                LineStatus::Busy => style("").white(),
            },
            message
        );
        self.bar.set_message(message);
    }

    /// Updates the position of the stat bar, currently used for download speed
    pub fn update_position(&self, position: usize) {
        self.bar.set_position(position as u64);
    }

    /// Temporarily suspend
    pub fn suspend<F: FnOnce() -> R, R>(&self, f: F) -> R {
        self.bar.suspend(f)
    }
}