podcell 0.2.0

A simple Podman-based development environment manager.
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

//
// Copyright (c) 2025-present, Alessandro Gario
// All rights reserved.
//
// This source code is licensed in accordance with the terms specified in
// the LICENSE file found in the root directory of this source tree.
//

use thiserror::Error;

use std::{
    fs::File,
    io::{self, BufRead, BufReader},
    path::Path,
};

#[derive(Error, Debug)]
pub enum EtcGroupError {
    #[error("failed to parse the group file")]
    IOError(#[from] io::Error),

    #[error("invalid group file entry")]
    InvalidEntryFormat,
}

pub struct Group {
    pub name: String,
    pub id: u32,
}

pub struct EtcGroup {
    group_list: Vec<Group>,
}

impl EtcGroup {
    pub fn new<AsPathRef: AsRef<Path>>(path: AsPathRef) -> Result<Self, EtcGroupError> {
        Ok(Self {
            group_list: Self::parse_file(path)?,
        })
    }

    pub fn iter(&self) -> std::slice::Iter<'_, Group> {
        self.group_list.iter()
    }

    fn parse_file<AsPathRef: AsRef<Path>>(path: AsPathRef) -> Result<Vec<Group>, EtcGroupError> {
        let mut group_list = Vec::new();

        let file = File::open(path)?;
        let reader = BufReader::new(file);

        for line in reader.lines() {
            let line = line?;

            let field_list: Vec<&str> = line.split(':').collect();
            if field_list.len() != 4 {
                return Err(EtcGroupError::InvalidEntryFormat);
            }

            let group = Group {
                name: field_list[0].to_string(),
                id: field_list[2].parse().unwrap_or(0),
            };

            group_list.push(group);
        }

        Ok(group_list)
    }
}