compare-dir 0.6.9

A high-performance directory comparison tool and library
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

use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
use std::path::Path;
use std::time::Duration;

const SPINNER_STYLE: &str = "{elapsed_precise} {pos:>7} {spinner:.green} {msg}";
const NORMAL_STYLE: &str =
    "{elapsed_precise} +{eta:>3} {percent:>3}% {pos:>7}/{len:7} {bar:40.cyan/blue} {msg}";
const FILE_STYLE: &str = "  {elapsed:>3} +{eta:>3} {percent:>3}% {msg}";

#[derive(Debug, Clone)]
pub(crate) struct Progress {
    inner: Option<ProgressBar>,
    multi: Option<MultiProgress>,
}

impl Progress {
    pub fn none() -> Self {
        Self {
            inner: None,
            multi: None,
        }
    }

    pub fn set_message(&self, msg: impl Into<String>) {
        if let Some(inner) = &self.inner {
            inner.set_message(msg.into());
        }
    }

    pub fn inc(&self, amount: u64) {
        if let Some(inner) = &self.inner {
            inner.inc(amount);
        }
    }

    pub fn length(&self) -> Option<u64> {
        self.inner.as_ref().and_then(|inner| inner.length())
    }

    pub fn set_length(&self, len: u64) {
        if let Some(inner) = &self.inner {
            if len > 0 && inner.length().is_none() {
                inner.set_style(ProgressStyle::with_template(NORMAL_STYLE).unwrap());
            }
            inner.set_length(len);
        }
    }

    pub fn finish(&self) {
        if let Some(inner) = &self.inner {
            inner.finish();
            if let Some(multi) = &self.multi {
                multi.remove(inner);
            }
        }
    }

    pub fn suspend<F, R>(&self, f: F) -> R
    where
        F: FnOnce() -> R,
    {
        if let Some(multi) = &self.multi {
            multi.suspend(f)
        } else if let Some(inner) = &self.inner {
            inner.suspend(f)
        } else {
            f()
        }
    }
}

#[derive(Debug)]
pub struct ProgressBuilder {
    multi: MultiProgress,
    pub is_file_enabled: bool,
}

impl ProgressBuilder {
    pub fn new() -> Self {
        Self {
            multi: MultiProgress::new(),
            is_file_enabled: false,
        }
    }

    pub(crate) fn add_spinner(&self) -> Progress {
        let progress = self.multi.add(ProgressBar::new_spinner());
        progress.enable_steady_tick(Duration::from_millis(120));
        progress.set_style(ProgressStyle::with_template(SPINNER_STYLE).unwrap());
        Progress {
            inner: Some(progress),
            multi: Some(self.multi.clone()),
        }
    }

    pub(crate) fn add_file(&self, path: &Path, file_size: u64) -> Progress {
        if !self.is_file_enabled {
            return Progress::none();
        }
        let progress = self.multi.add(ProgressBar::new(file_size));
        progress.set_style(ProgressStyle::with_template(FILE_STYLE).unwrap());
        if let Some(parent) = path.parent()
            && let Some(file_name) = path.file_name()
        {
            progress.set_message(format!(
                "{} ({})",
                file_name.to_string_lossy(),
                parent.to_string_lossy()
            ));
        } else {
            progress.set_message(path.to_string_lossy().to_string());
        }
        Progress {
            inner: Some(progress),
            multi: Some(self.multi.clone()),
        }
    }
}

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