gilt 1.4.1

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

//! Spinner column for progress bars.

use crate::progress::{ProgressColumn, Task};
use crate::status::spinner::Spinner;
use crate::style::Style;
use crate::text::Text;

/// A column that renders a spinner animation.
#[derive(Debug, Clone)]
pub struct SpinnerColumn {
    /// Name of the spinner (from the SPINNERS registry).
    pub spinner_name: String,
    /// Style for the spinner frame.
    pub style: Option<Style>,
    /// Text shown when the task is finished.
    pub finished_text: Text,
}

impl SpinnerColumn {
    /// Create a new SpinnerColumn with the given spinner name.
    pub fn new(name: &str) -> Self {
        SpinnerColumn {
            spinner_name: name.to_string(),
            style: None,
            finished_text: Text::styled("\u{2714}", "green"),
        }
    }

    /// Builder: set the style.
    #[must_use]
    pub fn with_style(mut self, style: Style) -> Self {
        self.style = Some(style);
        self
    }

    /// Builder: set the finished text.
    #[must_use]
    pub fn with_finished_text(mut self, text: Text) -> Self {
        self.finished_text = text;
        self
    }
}

impl Default for SpinnerColumn {
    fn default() -> Self {
        Self::new("dots")
    }
}

impl ProgressColumn for SpinnerColumn {
    fn render(&self, task: &Task) -> Text {
        if task.finished() {
            return self.finished_text.clone();
        }

        let mut spinner = match Spinner::new(&self.spinner_name) {
            Ok(s) => s,
            Err(_) => return Text::new("?", Style::null()),
        };
        if let Some(ref style) = self.style {
            spinner = spinner.with_style(style.clone());
        }

        let elapsed = task.elapsed().unwrap_or(0.0);
        spinner.render(elapsed)
    }

    fn max_refresh(&self) -> Option<f64> {
        // Spinners typically update at ~12.5 FPS
        Some(0.08)
    }
}