wattop 0.2.0

Hybrid-car style terminal power dashboard for macOS laptops: live watts, charger port and battery flow
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
138
139

//! Battery cell model: fill level plus a pulse that runs while charging or draining.

/// Battery motion, from the battery watts sign.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Motion {
    Charging,
    Draining,
    Holding,
}

/// What one inner battery cell shows.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CellKind {
    Filled,
    Empty,
    /// Charge pulse, in the empty part.
    ChargePulse,
    /// Drain pulse, in the filled part.
    DrainPulse,
}

/// Inner cells for a panel inner width. Leaves room for left border, right border and nub.
pub fn body_cells(inner_width: usize) -> usize {
    inner_width.saturating_sub(3)
}

/// Filled cells for a percent. Rounds up, so 1% still shows one cell.
pub fn filled_cells(width: usize, percent: i64) -> usize {
    (percent.clamp(0, 100) as usize * width).div_ceil(100)
}

/// Cell kinds for one frame. The pulse moves one cell per frame and loops.
/// Charging: starts at the fill edge and sweeps right, toward the nub.
/// Draining: starts at the fill edge and sweeps left, toward the start.
pub fn battery_cells(width: usize, percent: i64, motion: Motion, frame: u64) -> Vec<CellKind> {
    let filled = filled_cells(width, percent);
    let mut cells: Vec<CellKind> = (0..width)
        .map(|i| {
            if i < filled {
                CellKind::Filled
            } else {
                CellKind::Empty
            }
        })
        .collect();
    match motion {
        Motion::Charging if filled < width => {
            let span = (width - filled) as u64;
            cells[filled + (frame % span) as usize] = CellKind::ChargePulse;
        }
        Motion::Draining if filled > 0 => {
            let span = filled as u64;
            cells[filled - 1 - (frame % span) as usize] = CellKind::DrainPulse;
        }
        _ => {}
    }
    cells
}

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

    /// The single pulse cell, if any: its index and kind.
    fn pulse(cells: &[CellKind]) -> Option<(usize, CellKind)> {
        cells.iter().enumerate().find_map(|(i, c)| {
            matches!(c, CellKind::ChargePulse | CellKind::DrainPulse).then_some((i, *c))
        })
    }

    #[test]
    fn charging_pulse_moves_right_inside_empty_part() {
        let (w, p) = (20, 40); // 8 filled, 12 empty
        let filled = filled_cells(w, p);
        for n in 0..36u64 {
            let (a, kind) = pulse(&battery_cells(w, p, Motion::Charging, n)).unwrap();
            let (b, _) = pulse(&battery_cells(w, p, Motion::Charging, n + 1)).unwrap();
            assert_eq!(kind, CellKind::ChargePulse);
            assert!(a >= filled && a < w, "pulse {a} left the empty part");
            assert!(
                b == a + 1 || (a == w - 1 && b == filled),
                "pulse jumped {a} -> {b}"
            );
        }
    }

    #[test]
    fn draining_pulse_moves_left_inside_filled_part() {
        let (w, p) = (20, 40); // 8 filled, 12 empty
        let filled = filled_cells(w, p);
        for n in 0..36u64 {
            let (a, kind) = pulse(&battery_cells(w, p, Motion::Draining, n)).unwrap();
            let (b, _) = pulse(&battery_cells(w, p, Motion::Draining, n + 1)).unwrap();
            assert_eq!(kind, CellKind::DrainPulse);
            assert!(a < filled, "pulse {a} left the filled part");
            assert!(
                b + 1 == a || (a == 0 && b == filled - 1),
                "pulse jumped {a} -> {b}"
            );
        }
    }

    #[test]
    fn drawn_body_fits_inner_width() {
        // Drawn body = left border + cells + right border + nub.
        for inner in [8, 12, 24, 40] {
            let drawn = 1 + body_cells(inner) + 1 + 1;
            assert!(drawn <= inner, "body {drawn} wider than inner {inner}");
        }
    }

    #[test]
    fn holding_has_no_pulse() {
        for n in 0..10 {
            assert!(pulse(&battery_cells(20, 40, Motion::Holding, n)).is_none());
        }
    }

    #[test]
    fn edge_levels_do_not_panic() {
        for motion in [Motion::Charging, Motion::Draining, Motion::Holding] {
            for percent in [-5, 0, 1, 100, 150] {
                for width in [0, 1, 12] {
                    for frame in [0, 1, 999] {
                        assert_eq!(battery_cells(width, percent, motion, frame).len(), width);
                    }
                }
            }
        }
        // Full battery: nothing to sweep into. Empty battery: nothing to drain.
        assert!(pulse(&battery_cells(12, 100, Motion::Charging, 3)).is_none());
        assert!(pulse(&battery_cells(12, 0, Motion::Draining, 3)).is_none());
        // Empty battery charging: the pulse starts at the first cell.
        assert_eq!(
            pulse(&battery_cells(12, 0, Motion::Charging, 0)),
            Some((0, CellKind::ChargePulse))
        );
    }
}