gilt 1.5.2

Fast, beautiful terminal formatting for Rust — styles, tables, trees, syntax highlighting, progress bars, markdown.
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
136
137

//! Time-related columns for progress bars.

use std::collections::HashMap;
use std::sync::Mutex;

use crate::progress::task::TaskId;
use crate::progress::{format_time, ProgressColumn, Task};
use crate::style::Style;
use crate::text::Text;

/// A column that shows elapsed time as `[H:MM:SS]`.
#[derive(Debug, Clone)]
pub struct TimeElapsedColumn;

impl Default for TimeElapsedColumn {
    fn default() -> Self {
        Self
    }
}

impl ProgressColumn for TimeElapsedColumn {
    fn render(&self, task: &Task) -> Text {
        let elapsed = task.elapsed().unwrap_or(0.0);
        let formatted = format_time(elapsed);
        Text::new(&formatted, Style::parse("progress.elapsed"))
    }
}

/// A column that shows estimated remaining time as `[H:MM:SS]` or
/// `-:--:--` when the estimate is unavailable.
///
/// This column rate-limits its ETA calculation to at most every 0.5 s per
/// task (via [`max_refresh`](ProgressColumn::max_refresh)) and caches the
/// last rendered value so the ETA text is not recomputed on every tick.
pub struct TimeRemainingColumn {
    /// Whether to show compact format.
    pub compact: bool,
    /// Whether to show elapsed time when finished.
    pub elapsed_when_finished: bool,
    /// Per-task render cache: `task_id → (last_render_time_secs, cached_text)`.
    cache: Mutex<HashMap<TaskId, (f64, Text)>>,
}

impl std::fmt::Debug for TimeRemainingColumn {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TimeRemainingColumn")
            .field("compact", &self.compact)
            .field("elapsed_when_finished", &self.elapsed_when_finished)
            .finish()
    }
}

impl Clone for TimeRemainingColumn {
    fn clone(&self) -> Self {
        TimeRemainingColumn {
            compact: self.compact,
            elapsed_when_finished: self.elapsed_when_finished,
            // Start with an empty cache in the clone.
            cache: Mutex::new(HashMap::new()),
        }
    }
}

impl TimeRemainingColumn {
    /// Create a new TimeRemainingColumn with default settings.
    pub fn new() -> Self {
        TimeRemainingColumn {
            compact: false,
            elapsed_when_finished: false,
            cache: Mutex::new(HashMap::new()),
        }
    }

    /// Builder: enable compact format.
    #[must_use]
    pub fn with_compact(mut self, compact: bool) -> Self {
        self.compact = compact;
        self
    }

    /// Builder: show elapsed time instead of `0:00` when the task finishes.
    #[must_use]
    pub fn with_elapsed_when_finished(mut self, elapsed_when_finished: bool) -> Self {
        self.elapsed_when_finished = elapsed_when_finished;
        self
    }

    /// Render the ETA text for a task (no caching — always recomputes).
    fn render_fresh(&self, task: &Task) -> Text {
        let style = Style::parse("progress.remaining");

        if task.finished() {
            if self.elapsed_when_finished {
                let elapsed = task.elapsed().unwrap_or(0.0);
                return Text::new(&format_time(elapsed), style);
            }
            return Text::new("0:00", style);
        }

        match task.time_remaining() {
            Some(remaining) if remaining.is_finite() => Text::new(&format_time(remaining), style),
            _ => Text::new("-:--:--", style),
        }
    }
}

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

impl ProgressColumn for TimeRemainingColumn {
    /// Rate-limit ETA recomputation to twice per second.
    fn max_refresh(&self) -> Option<f64> {
        Some(0.5)
    }

    fn render(&self, task: &Task) -> Text {
        // Use the task's elapsed time (or current wall time) as a clock for
        // cache staleness so that the cache is independent of the system clock.
        let now = task
            .elapsed()
            .unwrap_or_else(crate::progress::task::current_time_secs);

        let mut cache = self.cache.lock().unwrap();
        if let Some(&(last_time, ref cached)) = cache.get(&task.id) {
            if now - last_time < self.max_refresh().unwrap_or(0.5) {
                return cached.clone();
            }
        }

        let fresh = self.render_fresh(task);
        cache.insert(task.id, (now, fresh.clone()));
        fresh
    }
}