stree 0.1.0

A directory hierarchy mapping format, similar to mtree
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

use crate::{Result, Error, error};
use std::str::FromStr;
use std::fmt::{self, Display};

#[cfg(feature = "serde")]
use serde::{Serialize, Deserialize};

/// Information about a system user
#[derive(Default, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(rename_all = "kebab-case"))]
pub struct User
{
    pub name: Option<String>,
    pub id: libc::uid_t
}

/// Information about a system group
#[derive(Default, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(rename_all = "kebab-case"))]
pub struct Group
{
    pub name: Option<String>,
    pub id: libc::gid_t
}

impl User
{
    /// Construct a user given an optional name and uid
    pub fn new(name: Option<&str>, id: libc::uid_t) -> Self
    {
        let mut r = Self::default();
        if let Some(name) = name
        {
            r.name = Some(name.to_owned());
        }
        r.id = id;
        r
    }
}

impl Group
{
    /// Construct a group given an optional name and gid
    pub fn new(name: Option<&str>, id: libc::gid_t) -> Self
    {
        let mut r = Self::default();
        if let Some(name) = name
        {
            r.name = Some(name.to_owned());
        }
        r.id = id;
        r
    }
}

impl FromStr for User
{
    type Err = Error;
    fn from_str(s: &str) -> Result<Self>
    {
        let mut r = Self::default();
        match s.split_once(':')
        {
            Some(parts) =>
            {
                if parts.0.starts_with('<')
                && parts.0.ends_with('>')
                {
                    r.name = None
                }
                else
                {
                    r.name = Some(parts.0.to_string())
                }
                r.id = parts.1.parse::<libc::uid_t>()?;
            }
            None => error!("Expected a value separator in 'user' field, got: '{s}'")
        }
        Ok(r)
    }
}

impl FromStr for Group
{
    type Err = Error;
    fn from_str(s: &str) -> Result<Self>
    {
        let mut r = Self::default();
        match s.split_once(':')
        {
            Some(parts) =>
            {
                if parts.0.starts_with('<')
                && parts.0.ends_with('>')
                {
                    r.name = None
                }
                else
                {
                    r.name = Some(parts.0.to_string())
                }
                r.id = parts.1.parse::<libc::gid_t>()?;
            }
            None => error!("Expected a value separator in 'group' field, got: '{s}'")
        }
        Ok(r)
    }
}

impl Display for User
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
    {
        write!(f,
            "{}:{}",
            if let Some(name) = &self.name { &name } else { "<unknown>" },
            self.id
        )
    }
}

impl Display for Group
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
    {
        write!(f,
            "{}:{}",
            if let Some(name) = &self.name { &name } else { "<unknown>" },
            self.id
        )
    }
}