lx-ls 0.8.0

The file lister with personality! 🌟
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

use nu_ansi_term::Style;
use uzers::Users;

use crate::fs::fields as f;
use crate::output::cell::TextCell;


impl f::User {
    /// Render the owner as their name, falling back to the numeric
    /// UID if the name can't be resolved.  Used for the `--user` column.
    pub fn render<C: Colours, U: Users>(self, colours: &C, users: &U) -> TextCell {
        let user_name = match users.get_user_by_uid(self.0) {
            None       => self.0.to_string(),
            Some(user) => user.name().to_string_lossy().into(),
        };

        TextCell::paint(self.style(colours, users), user_name)
    }

    /// Render the owner as the raw numeric UID.  Used for the
    /// `--uid` column.  Uses the dedicated `uid_*` style slots so
    /// themes can distinguish it visually from the name column while
    /// still cascading from the `user_*` slots when unset.
    pub fn render_uid<C: Colours, U: Users>(self, colours: &C, users: &U) -> TextCell {
        TextCell::paint(self.uid_style(colours, users), self.0.to_string())
    }

    fn style<C: Colours, U: Users>(self, colours: &C, users: &U) -> Style {
        if users.get_current_uid() == self.0 { colours.you() }
        else                                  { colours.someone_else() }
    }

    fn uid_style<C: Colours, U: Users>(self, colours: &C, users: &U) -> Style {
        if users.get_current_uid() == self.0 { colours.uid_you() }
        else                                  { colours.uid_someone_else() }
    }
}


pub trait Colours {
    fn you(&self) -> Style;
    fn someone_else(&self) -> Style;

    /// Style for the numeric UID column, for the current user.
    /// Implementations should cascade from `you()` when no explicit
    /// `uid_you` slot is set.
    fn uid_you(&self) -> Style;

    /// Style for the numeric UID column, for a different user.
    /// Cascades from `someone_else()` when unset.
    fn uid_someone_else(&self) -> Style;
}


#[cfg(test)]
#[allow(unused_results)]
pub mod test {
    use super::Colours;
    use crate::fs::fields as f;
    use crate::output::cell::TextCell;

    use uzers::User;
    use uzers::mock::MockUsers;
    use nu_ansi_term::Color::*;
    use nu_ansi_term::Style;


    /// Cascading test colours: the `uid_*` methods return slightly
    /// different styles than the `user_*` methods, so the tests can
    /// verify that `render_uid` picks up the UID slots.  Real cascade
    /// (falling back to user/group when unset) is covered by the
    /// theme-level tests.
    struct TestColours;

    impl Colours for TestColours {
        fn you(&self)              -> Style { Red.bold() }
        fn someone_else(&self)     -> Style { Blue.underline() }
        fn uid_you(&self)          -> Style { Red.normal() }
        fn uid_someone_else(&self) -> Style { Blue.normal() }
    }


    #[test]
    fn named() {
        let mut users = MockUsers::with_current_uid(1000);
        users.add_user(User::new(1000, "enoch", 100));

        let user = f::User(1000);
        let expected = TextCell::paint_str(Red.bold(), "enoch");
        assert_eq!(expected, user.render(&TestColours, &users));

        // render_uid uses the UID-specific style slot.
        let expected = TextCell::paint_str(Red.normal(), "1000");
        assert_eq!(expected, user.render_uid(&TestColours, &users));
    }

    #[test]
    fn unnamed_falls_back_to_uid() {
        let users = MockUsers::with_current_uid(1000);

        let user = f::User(1000);
        // Name column falls back to numeric UID but keeps the name slot's
        // style (Red.bold()).
        let expected_name = TextCell::paint_str(Red.bold(), "1000");
        assert_eq!(expected_name, user.render(&TestColours, &users));
        // UID column always uses the UID slot's style (Red.normal()).
        let expected_uid = TextCell::paint_str(Red.normal(), "1000");
        assert_eq!(expected_uid, user.render_uid(&TestColours, &users));
    }

    #[test]
    fn different_named() {
        let mut users = MockUsers::with_current_uid(0);
        users.add_user(User::new(1000, "enoch", 100));

        let user = f::User(1000);
        let expected = TextCell::paint_str(Blue.underline(), "enoch");
        assert_eq!(expected, user.render(&TestColours, &users));
    }

    #[test]
    fn different_unnamed_uid() {
        let user = f::User(1000);
        let expected = TextCell::paint_str(Blue.normal(), "1000");
        assert_eq!(expected, user.render_uid(&TestColours, &MockUsers::with_current_uid(0)));
    }

    #[test]
    fn overflow() {
        let user = f::User(2_147_483_648);
        let expected = TextCell::paint_str(Blue.normal(), "2147483648");
        assert_eq!(expected, user.render_uid(&TestColours, &MockUsers::with_current_uid(0)));
    }
}