Method parse

crates/sysusers/src/lib.rs:160–209

(s: &str)

    }

    pub(crate) fn parse(s: &str) -> Result<Option<SysusersEntry>> {
        let err = || Error::ParseFailure(s.to_owned());
        let (ftype, s) = Self::next_token(s).ok_or_else(err)?;
        let r = match ftype {
            "u" | "u!" => {
                let (name, s) = Self::next_token_owned(s).ok_or_else(err)?;
                let (id, s) = Self::next_optional_token(s).unwrap_or_default();
                let (uid, pgid) = id
                    .and_then(|v| v.split_once(':'))
                    .or_else(|| id.map(|id| (id, id)))
                    .map(|(uid, gid)| (Some(uid), Some(gid)))
                    .unwrap_or((None, None));
                let uid = uid
                    .filter(|&v| v != "-")
                    .map(|id| id.parse())
                    .transpose()
                    .map_err(|_| err())?;
                let pgid = pgid.map(|id| id.parse()).transpose().map_err(|_| err())?;
                let (gecos, s) = Self::next_token(s).unwrap_or_default();
                let gecos = gecos.to_owned();
                let (home, s) = Self::next_optional_token_owned(s).unwrap_or_default();
                let (shell, _) = Self::next_optional_token_owned(s).unwrap_or_default();
                SysusersEntry::User {
                    name,
                    uid,
                    pgid,
                    gecos,
                    home,
                    shell,
                }
            }
            "g" => {
                let (name, s) = Self::next_token_owned(s).ok_or_else(err)?;
                let (id, _) = Self::next_optional_token(s).unwrap_or_default();
                let id = id.map(|id| id.parse()).transpose().map_err(|_| err())?;
                SysusersEntry::Group { name, id }
            }
            "r" => {
                let (_, s) = Self::next_optional_token(s).ok_or_else(err)?;
                let (range, _) = Self::next_token(s).ok_or_else(err)?;
                let (start, end) = range.split_once('-').ok_or_else(err)?;
                let start: u32 = start.parse().map_err(|_| err())?;
                let end: u32 = end.parse().map_err(|_| err())?;
                SysusersEntry::Range { start, end }
            }
            // In the case of a sysusers entry that is of unknown type, we skip it out of conservatism
            _ => return Ok(None),
        };
        Ok(Some(r))
    }
}

/// Read all tmpfiles.d entries in the target directory, and return a mapping