revue 2.71.1

A Vue-style TUI framework for Rust with CSS styling
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

//! Event logging for debug overlay

use std::collections::VecDeque;
use std::time::Instant;

/// Debug event types
#[derive(Debug, Clone)]
pub enum DebugEvent {
    /// Key press
    KeyPress(String),
    /// Mouse event
    Mouse(String),
    /// State change
    StateChange(String),
    /// Custom event
    Custom(String),
}

/// Event log for debugging
#[derive(Debug, Clone, Default)]
pub struct EventLog {
    /// Logged events
    pub(super) events: VecDeque<(Instant, DebugEvent)>,
    /// Max events to keep
    pub(super) max_events: usize,
}

impl EventLog {
    /// Create new event log
    pub fn new() -> Self {
        Self {
            events: VecDeque::new(),
            max_events: 50,
        }
    }

    /// Log an event
    pub fn log(&mut self, event: DebugEvent) {
        self.events.push_back((Instant::now(), event));
        if self.events.len() > self.max_events {
            self.events.pop_front();
        }
    }

    /// Get recent events
    pub fn recent(&self, count: usize) -> impl Iterator<Item = &(Instant, DebugEvent)> {
        self.events.iter().rev().take(count)
    }

    /// Clear all events
    pub fn clear(&mut self) {
        self.events.clear();
    }
}

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

    #[test]
    fn test_debug_event_key_press() {
        let event = DebugEvent::KeyPress("Enter".to_string());
        assert!(matches!(event, DebugEvent::KeyPress(_)));
    }

    #[test]
    fn test_debug_event_mouse() {
        let event = DebugEvent::Mouse("click".to_string());
        assert!(matches!(event, DebugEvent::Mouse(_)));
    }

    #[test]
    fn test_debug_event_state_change() {
        let event = DebugEvent::StateChange("focus".to_string());
        assert!(matches!(event, DebugEvent::StateChange(_)));
    }

    #[test]
    fn test_debug_event_custom() {
        let event = DebugEvent::Custom("custom".to_string());
        assert!(matches!(event, DebugEvent::Custom(_)));
    }

    #[test]
    fn test_event_log_new() {
        let log = EventLog::new();
        assert!(log.events.is_empty());
        assert_eq!(log.max_events, 50);
    }

    #[test]
    fn test_event_log_default() {
        let log = EventLog::default();
        assert!(log.events.is_empty());
    }

    #[test]
    fn test_event_log_log_and_recent() {
        let mut log = EventLog::new();
        log.log(DebugEvent::KeyPress("a".to_string()));
        log.log(DebugEvent::Mouse("click".to_string()));

        assert_eq!(log.recent(10).count(), 2);
    }

    #[test]
    fn test_event_log_clear() {
        let mut log = EventLog::new();
        log.log(DebugEvent::KeyPress("a".to_string()));
        log.clear();
        assert!(log.events.is_empty());
    }

    #[test]
    fn test_event_log_recent_empty() {
        let log = EventLog::new();
        assert_eq!(log.recent(10).count(), 0);
    }

    #[test]
    fn test_event_log_max_events() {
        let mut log = EventLog::new();
        for i in 0..100 {
            log.log(DebugEvent::KeyPress(i.to_string()));
        }
        assert_eq!(log.events.len(), 50);
    }
}