pacsea 0.8.2

A fast, friendly TUI for browsing and installing Arch and AUR packages with built-in news and security scanning
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

/// What: Track the last logged state to avoid repeating identical debug lines.
///
/// Inputs:
/// - `T`: A clonable, comparable state type to track between log attempts.
///
/// Output:
/// - `ChangeLogger`: Helper that indicates whether a new log should be emitted.
///
/// Details:
/// - Calling `should_log` updates the cached state and returns `true` only when
///   the provided state differs from the previous one.
/// - `clear` resets the cached state, forcing the next call to log.
pub struct ChangeLogger<T> {
    /// Last logged state value.
    last: Option<T>,
}

impl<T: PartialEq + Clone> Default for ChangeLogger<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: PartialEq + Clone> ChangeLogger<T> {
    /// What: Create a new `ChangeLogger` with no cached state.
    ///
    /// Inputs:
    /// - None
    ///
    /// Output:
    /// - A `ChangeLogger` ready to track state changes.
    ///
    /// Details:
    /// - The first call to `should_log` after construction will return `true`.
    #[must_use]
    pub const fn new() -> Self {
        Self { last: None }
    }

    /// What: Decide whether a log should be emitted for the provided state.
    ///
    /// Inputs:
    /// - `next`: The next state to compare against the cached state.
    ///
    /// Output:
    /// - `true` when the state differs from the cached value; otherwise `false`.
    ///
    /// Details:
    /// - Updates the cached state when it changes.
    #[must_use]
    pub fn should_log(&mut self, next: &T) -> bool {
        if self.last.as_ref() == Some(next) {
            return false;
        }
        self.last = Some(next.clone());
        true
    }

    /// What: Reset the cached state so the next call logs.
    ///
    /// Inputs:
    /// - None
    ///
    /// Output:
    /// - None
    ///
    /// Details:
    /// - Useful for tests or after major UI transitions.
    pub fn clear(&mut self) {
        self.last = None;
    }
}

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

    #[test]
    /// What: Ensure `ChangeLogger` only triggers when state changes.
    ///
    /// Inputs:
    /// - Sequence of repeated and differing states.
    ///
    /// Output:
    /// - Boolean results from `should_log` reflecting change detection.
    ///
    /// Details:
    /// - First call logs, repeat skips, new value logs, clear resets behavior.
    fn change_logger_emits_only_on_change() {
        let mut logger = ChangeLogger::new();
        assert!(logger.should_log(&"a"));
        assert!(!logger.should_log(&"a"));
        assert!(logger.should_log(&"b"));
        assert!(!logger.should_log(&"b"));
        logger.clear();
        assert!(logger.should_log(&"b"));
    }
}