pathfix 0.1.3

Fixes the $PATH variable mess by generating it for you
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

use std::io;
use std::string::ToString;

use serde::{Deserialize, Serialize};
use users::Group;

#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "kebab-case")]
pub enum IncludeAdministrative {
    Always,
    RootOnly,
    Users(Vec<String>),
    Groups(Vec<String>),
    Never,
}

impl IncludeAdministrative {
    /// `check_current_user` will check if the running users qualifies as an administrator.
    ///
    /// The result will be used to includes path's which are marked as admin only.
    ///
    /// # Examples
    ///
    /// ```
    /// use pathfix::config::IncludeAdministrative;
    ///
    /// assert_eq!(IncludeAdministrative::Always.check_current_user().unwrap(), true);
    /// assert_eq!(IncludeAdministrative::Never.check_current_user().unwrap(), false);
    /// assert_eq!(
    ///     IncludeAdministrative::Users(vec!["thisuserdoesnotexist".to_string()]).check_current_user().unwrap(),
    ///     false
    /// );
    /// assert_eq!(IncludeAdministrative::RootOnly.check_current_user().unwrap(), users::get_current_uid() == 0);
    /// ```
    pub fn check_current_user(&self) -> io::Result<bool> {
        Ok(match self {
            IncludeAdministrative::Always => true,
            IncludeAdministrative::RootOnly => users::get_current_uid() == 0,
            IncludeAdministrative::Users(users) => users.contains(
                &users::get_current_username()
                    .ok_or(io::Error::new(io::ErrorKind::NotFound, "could not get current user name"))?
                    .into_string()
                    .ok().ok_or(io::Error::new(io::ErrorKind::InvalidData, "usernam is not valid utf8"))?
            ),
            // TODO add test for Group check
            IncludeAdministrative::Groups(groups) => {
                for group in users::group_access_list()?
                    .iter()
                    .map(Group::name)
                    .filter_map(|g| g.to_str())
                    {
                        if groups.contains(&group.to_string()) {
                            return Ok(true)
                        }
                    }
                false
            }
            IncludeAdministrative::Never => false,
        })
    }
}

impl Default for IncludeAdministrative {
    fn default() -> Self {
        IncludeAdministrative::Groups(vec![
            "wheel".to_string(),
            "sudo".to_string(),
        ])
    }
}

#[cfg(test)]
mod tests {
    use crate::config::IncludeAdministrative;

    #[test]
    fn test_default() {
        let default = IncludeAdministrative::default().clone();
        assert_eq!(
            default,
            IncludeAdministrative::Groups(vec![
                "wheel".to_string(),
                "sudo".to_string(),
            ])
        )
    }
}