ex-cli 1.22.0

Command line tool to find, filter, sort and list files.
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

#[cfg(test)]
pub mod tests {
    use crate::util::time::tests::create_time;
    use chrono::{DateTime, Utc};
    use googletest::description::Description;
    use googletest::matcher::{Matcher, MatcherBase, MatcherResult};
    use std::fmt::Debug;
    use termcolor::{Color, ColorSpec};

    #[derive(MatcherBase)]
    pub struct GenericMatcher<T> {
        expected: T,
    }

    impl<T: Debug + PartialEq> Matcher<&T> for GenericMatcher<T> {
        fn matches(&self, actual: &T) -> MatcherResult {
            (self.expected == *actual).into()
        }

        fn describe(&self, result: MatcherResult) -> Description {
            describe(&self.expected, result, None)
        }
    }

    impl<T: Copy + Debug + PartialEq> Matcher<T> for GenericMatcher<T> {
        fn matches(&self, actual: T) -> MatcherResult {
            (self.expected == actual).into()
        }

        fn describe(&self, result: MatcherResult) -> Description {
            describe(&self.expected, result, None)
        }
    }

    pub fn time_eq(
        year: i32,
        month: u32,
        day: u32,
        hour: u32,
        minute: u32,
        second: u32,
    ) -> GenericMatcher<DateTime<Utc>> {
        let expected = create_time(year, month, day, hour, minute, second).unwrap();
        GenericMatcher { expected }
    }

    pub fn color_eq(
        fg_color: Option<Color>,
        bg_color: Option<Color>,
        bold: bool,
        under: bool,
    ) -> GenericMatcher<ColorSpec> {
        let mut expected = ColorSpec::new();
        expected.set_fg(fg_color);
        expected.set_bg(bg_color);
        expected.set_bold(bold);
        expected.set_underline(under);
        GenericMatcher { expected }
    }

    fn describe<T: Debug>(
        expected: &T,
        result: MatcherResult,
        field: Option<&str>,
    ) -> Description {
        let text = match (field, result) {
            (None, MatcherResult::Match) => format!("is equal to {:?}", expected),
            (None, MatcherResult::NoMatch) => format!("isn't equal to {:?}", expected),
            (Some(field), MatcherResult::Match) => format!("[{}] is equal to {:?}", field, expected),
            (Some(field), MatcherResult::NoMatch) => format!("[{}] isn't equal to {:?}", field, expected),
        };
        Description::new().text(text)
    }
}