bottom 0.12.3

A customizable cross-platform graphical process/system monitor for the terminal. Supports Linux, macOS, and Windows.
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
129
130
131
132
133
134
135

use regex::Regex;

/// Filters used by widgets to filter out certain entries.
/// TODO: Move this out maybe?
#[derive(Debug, Clone)]
pub struct Filter {
    /// Whether the filter _accepts_ all entries that match `list`,
    /// or _denies_ any entries that match it.
    is_list_ignored: bool, // TODO: Maybe change to "ignore_matches"?

    /// The list of regexes to match against. Whether it goes through
    /// the filter or not depends on `is_list_ignored`.
    list: Vec<Regex>,
}

impl Filter {
    /// Create a new filter.
    #[inline]
    pub(crate) fn new(ignore_matches: bool, list: Vec<Regex>) -> Self {
        Self {
            is_list_ignored: ignore_matches,
            list,
        }
    }

    /// Whether the filter should keep the entry or reject it.
    #[inline]
    pub(crate) fn should_keep(&self, entry: &str) -> bool {
        if self.has_match(entry) {
            // If a match is found, then if we wanted to ignore if we match, return false.
            // If we want to keep if we match, return true. Thus, return the
            // inverse of `is_list_ignored`.
            !self.is_list_ignored
        } else {
            self.is_list_ignored
        }
    }

    /// Whether there is a filter that matches the result.
    #[inline]
    pub(crate) fn has_match(&self, value: &str) -> bool {
        self.list.iter().any(|regex| regex.is_match(value))
    }

    /// Whether entries matching the list should be ignored or kept.
    #[inline]
    pub(crate) fn ignore_matches(&self) -> bool {
        self.is_list_ignored
    }

    /// Check a filter if it exists, otherwise accept if it is [`None`].
    #[inline]
    pub(crate) fn optional_should_keep(filter: &Option<Self>, entry: &str) -> bool {
        filter
            .as_ref()
            .map(|f| f.should_keep(entry))
            .unwrap_or(true)
    }
}

#[cfg(test)]
mod test {
    use regex::Regex;

    use super::*;

    /// Test based on the issue in <https://github.com/ClementTsang/bottom/pull/1037>.
    #[test]
    fn filter_is_list_ignored() {
        let results = [
            "CPU socket temperature",
            "wifi_0",
            "motherboard temperature",
            "amd gpu",
        ];

        let ignore_true = Filter {
            is_list_ignored: true,
            list: vec![Regex::new("temperature").unwrap()],
        };

        assert_eq!(
            results
                .into_iter()
                .filter(|r| ignore_true.should_keep(r))
                .collect::<Vec<_>>(),
            vec!["wifi_0", "amd gpu"]
        );

        let ignore_false = Filter {
            is_list_ignored: false,
            list: vec![Regex::new("temperature").unwrap()],
        };

        assert_eq!(
            results
                .into_iter()
                .filter(|r| ignore_false.should_keep(r))
                .collect::<Vec<_>>(),
            vec!["CPU socket temperature", "motherboard temperature"]
        );

        let multi_true = Filter {
            is_list_ignored: true,
            list: vec![
                Regex::new("socket").unwrap(),
                Regex::new("temperature").unwrap(),
            ],
        };

        assert_eq!(
            results
                .into_iter()
                .filter(|r| multi_true.should_keep(r))
                .collect::<Vec<_>>(),
            vec!["wifi_0", "amd gpu"]
        );

        let multi_false = Filter {
            is_list_ignored: false,
            list: vec![
                Regex::new("socket").unwrap(),
                Regex::new("temperature").unwrap(),
            ],
        };

        assert_eq!(
            results
                .into_iter()
                .filter(|r| multi_false.should_keep(r))
                .collect::<Vec<_>>(),
            vec!["CPU socket temperature", "motherboard temperature"]
        );
    }
}