tui_breath 0.3.1

Terminal breathing guide built with Rust + Ratatui. Smooth eased animations, 4-7-8 / box / diaphragmatic patterns, JSON session tracking.
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
140
141

use super::patterns::Pattern;

#[derive(Clone, Copy, Debug)]
pub struct BreathingEngine {
    pub pattern: &'static Pattern,
    pub tempo: f64,
    pub current_phase_idx: usize,
    pub phase_elapsed_secs: f64,
    pub cycle_count: u32,
    pub total_elapsed_secs: f64,
    pub duration_target_secs: f64,
    pub is_paused: bool,
    pub pause_count: u32,
}

impl BreathingEngine {
    pub fn new(pattern: &'static Pattern, tempo: f64, duration_target_secs: f64) -> Self {
        Self {
            pattern,
            tempo: tempo.max(0.1).min(2.0), // Clamp tempo to reasonable range
            current_phase_idx: 0,
            phase_elapsed_secs: 0.0,
            cycle_count: 0,
            total_elapsed_secs: 0.0,
            duration_target_secs,
            is_paused: false,
            pause_count: 0,
        }
    }

    pub fn current_phase(&self) -> &'static super::patterns::Phase {
        &self.pattern.phases[self.current_phase_idx]
    }

    pub fn current_phase_duration(&self) -> f64 {
        self.current_phase().duration_secs / self.tempo
    }

    pub fn phase_progress(&self) -> f64 {
        let duration = self.current_phase_duration();
        (self.phase_elapsed_secs / duration).min(1.0)
    }

    pub fn phase_remaining(&self) -> f64 {
        (self.current_phase_duration() - self.phase_elapsed_secs).max(0.0)
    }

    pub fn is_complete(&self) -> bool {
        self.total_elapsed_secs >= self.duration_target_secs
    }

    pub fn completion_percent(&self) -> f64 {
        (self.total_elapsed_secs / self.duration_target_secs * 100.0).min(100.0)
    }

    pub fn toggle_pause(&mut self) {
        self.is_paused = !self.is_paused;
        if self.is_paused {
            self.pause_count += 1;
        }
    }

    fn advance_phase(&mut self) {
        self.current_phase_idx += 1;
        if self.current_phase_idx >= self.pattern.phases.len() {
            self.current_phase_idx = 0;
            self.cycle_count += 1;
        }
        self.phase_elapsed_secs = 0.0;
    }

    pub fn tick(&mut self, delta_secs: f64) {
        if self.is_paused || self.is_complete() {
            return;
        }

        self.phase_elapsed_secs += delta_secs;
        self.total_elapsed_secs += delta_secs;

        if self.phase_elapsed_secs >= self.current_phase_duration() {
            self.advance_phase();
        }

        // Cap at target
        if self.total_elapsed_secs > self.duration_target_secs {
            self.total_elapsed_secs = self.duration_target_secs;
        }
    }
}

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

    #[test]
    fn test_phase_progression() {
        let mut engine = BreathingEngine::new(&PATTERN_BOX, 1.0, 60.0);

        assert_eq!(engine.current_phase_idx, 0);
        assert_eq!(engine.cycle_count, 0);

        // Advance through one phase (4 seconds)
        engine.tick(4.0);
        assert_eq!(engine.current_phase_idx, 1); // Should advance to next phase
    }

    #[test]
    fn test_tempo_affects_duration() {
        let engine = BreathingEngine::new(&PATTERN_BOX, 2.0, 60.0);
        let phase_duration = engine.current_phase_duration();

        // At tempo 2.0, 4 second phase becomes 2 seconds
        assert!((phase_duration - 2.0).abs() < 0.01);
    }

    #[test]
    fn test_completion() {
        let mut engine = BreathingEngine::new(&PATTERN_BOX, 1.0, 10.0);

        assert!(!engine.is_complete());
        engine.tick(10.0);
        assert!(engine.is_complete());
    }

    #[test]
    fn test_pause() {
        let mut engine = BreathingEngine::new(&PATTERN_BOX, 1.0, 60.0);

        engine.toggle_pause();
        assert!(engine.is_paused);
        assert_eq!(engine.pause_count, 1);

        let elapsed_before = engine.total_elapsed_secs;
        engine.tick(1.0);
        let elapsed_after = engine.total_elapsed_secs;

        // Time should not advance while paused
        assert_eq!(elapsed_before, elapsed_after);
    }
}