catfood-bar 0.3.0

A system bar component of the catfood utility suite
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

use super::sparkline::Sparkline;
use ratatui::{prelude::Stylize, style::Color, text::Span};
use std::time::{Duration, Instant};
use sysinfo::{CpuRefreshKind, RefreshKind, System};

#[derive(Debug)]
pub struct Cpu {
    pub usage: String,
    cached_span_content: String,
    system: System,
    last_update: Instant,
    update_interval: Duration,
    sparkline: Sparkline,
}

impl Cpu {
    pub fn with_config(
        sparkline: bool,
        sparkline_length: usize,
        sparkline_update_freq: u64,
        sparkline_logarithmic: bool,
    ) -> Self {
        let system = System::new_with_specifics(
            RefreshKind::nothing().with_cpu(CpuRefreshKind::everything()),
        );

        let usage = "0".to_string();
        let sparkline = Sparkline::new(sparkline, sparkline_length, sparkline_logarithmic);
        let cached_span_content = if sparkline.enabled {
            format!("󰻠 {}", sparkline.render_with_spaces())
        } else {
            format!("󰻠 {}%", usage)
        };

        Self {
            usage,
            cached_span_content,
            system,
            last_update: Instant::now(),
            update_interval: Duration::from_secs(sparkline_update_freq),
            sparkline,
        }
    }

    pub fn update(&mut self) {
        let now = Instant::now();
        if now.duration_since(self.last_update) >= self.update_interval {
            self.system.refresh_cpu_all();

            let iter = self.system.cpus().iter();
            let count = iter.len() as f32;
            let sum = iter.fold(0.0, |acc, x| acc + x.cpu_usage());
            let avg: u32 = (sum / count) as u32;
            self.usage = avg.to_string();

            if self.sparkline.enabled {
                // Update sparkline data
                self.sparkline.update(avg as u64);

                // Render sparkline
                self.cached_span_content = format!("󰻠 {}", self.sparkline.render());
            } else {
                self.cached_span_content = format!("󰻠 {}%", self.usage);
            }

            self.last_update = now;
        }
    }

    pub fn render_as_spans(&self, colorize: bool) -> Vec<Span<'_>> {
        let span = Span::raw(&self.cached_span_content);
        if colorize {
            let color = if let Ok(usage) = self.usage.parse::<u32>() {
                if usage >= 90 {
                    Color::Red // High CPU usage: Red
                } else {
                    Color::White // Normal: White
                }
            } else {
                Color::White
            };
            vec![span.fg(color)]
        } else {
            vec![span]
        }
    }
}