rebecca 0.3.0

Cross-platform cleanup CLI and Rust library surface for Rebecca cleanup planning, rules, and platform adapters.
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

use std::io::IsTerminal;
use std::path::Path;
use std::time::{Duration, Instant};

use indicatif::{ProgressBar, ProgressStyle};

use crate::output::format_bytes;

pub(crate) const PROGRESS_PATH_MAX_CHARS: usize = 72;

pub(crate) fn stderr_spinner(enabled: bool, initial_message: &'static str) -> Option<ProgressBar> {
    (enabled && std::io::stderr().is_terminal()).then(|| {
        let bar = ProgressBar::new_spinner();
        apply_progress_style(&bar);
        bar.enable_steady_tick(Duration::from_millis(120));
        bar.set_message(initial_message);
        bar
    })
}

pub(crate) fn apply_progress_style(bar: &ProgressBar) {
    if let Ok(style) = ProgressStyle::with_template("{spinner} {msg}") {
        bar.set_style(style.tick_strings(&["-", "\\", "|", "/"]));
    }
}

pub(crate) fn compact_progress_path(path: &Path, max_chars: usize) -> String {
    compact_progress_text(&path.display().to_string(), max_chars)
}

pub(crate) fn compact_progress_text(text: &str, max_chars: usize) -> String {
    let char_count = text.chars().count();
    if char_count <= max_chars {
        return text.to_string();
    }

    if max_chars <= 3 {
        return ".".repeat(max_chars);
    }

    let tail_len = max_chars - 3;
    let tail = text
        .chars()
        .rev()
        .take(tail_len)
        .collect::<Vec<_>>()
        .into_iter()
        .rev()
        .collect::<String>();
    format!("...{tail}")
}

pub(crate) fn format_file_rate(files_scanned: u64, elapsed: Duration) -> String {
    let seconds = elapsed.as_secs_f64();
    if files_scanned == 0 || seconds <= f64::EPSILON {
        return "0.0 files/s".to_string();
    }

    format!("{:.1} files/s", files_scanned as f64 / seconds)
}

pub(crate) fn format_byte_rate(bytes_scanned: u64, elapsed: Duration) -> String {
    let seconds = elapsed.as_secs_f64();
    if bytes_scanned == 0 || seconds <= f64::EPSILON {
        return "0 B/s".to_string();
    }

    let bytes_per_second = (bytes_scanned as f64 / seconds).round() as u64;
    format!("{}/s", format_bytes(bytes_per_second))
}

#[derive(Debug)]
pub(crate) struct HumanProgressThrottle {
    events_since_refresh: u64,
    last_refresh: Instant,
}

impl HumanProgressThrottle {
    const EVENT_INTERVAL: u64 = 64;
    const TIME_INTERVAL: Duration = Duration::from_millis(250);

    pub(crate) fn new() -> Self {
        Self {
            events_since_refresh: 0,
            last_refresh: Instant::now(),
        }
    }

    pub(crate) fn should_refresh(&mut self) -> bool {
        self.events_since_refresh = self.events_since_refresh.saturating_add(1);
        if self.events_since_refresh < Self::EVENT_INTERVAL
            && self.last_refresh.elapsed() < Self::TIME_INTERVAL
        {
            return false;
        }

        self.events_since_refresh = 0;
        self.last_refresh = Instant::now();
        true
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn compact_progress_text_handles_tiny_widths() {
        assert_eq!(compact_progress_text("abcdef", 2), "..");
        assert_eq!(compact_progress_text("abcdef", 4), "...f");
    }

    #[test]
    fn rate_formatters_handle_zero_elapsed_inputs() {
        assert_eq!(format_file_rate(0, Duration::ZERO), "0.0 files/s");
        assert_eq!(format_byte_rate(0, Duration::ZERO), "0 B/s");
    }
}