leenfetch 1.0.1

Fast, minimal, customizable system info tool in Rust (Neofetch alternative)
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

use std::process::Command;

use crate::modules::{
    enums::{DiskDisplay, DiskSubtitle},
    utils::get_bar,
};

pub fn get_disks(
    subtitle_mode: DiskSubtitle,
    display_mode: DiskDisplay,
    paths: Option<Vec<&str>>,
) -> Option<Vec<(String, String)>> {
    let args: Vec<&str> = {
        let mut flags = vec!["-P", "-h"];
        if let Some(paths) = &paths {
            flags.extend(paths.iter());
        } else {
            flags.push("/");
        }
        flags
    };

    let output = Command::new("df").args(args).output().ok()?;
    let stdout = String::from_utf8_lossy(&output.stdout);

    Some(parse_disk_output(&stdout, subtitle_mode, display_mode))
}

fn parse_disk_output(
    stdout: &str,
    subtitle_mode: DiskSubtitle,
    display_mode: DiskDisplay,
) -> Vec<(String, String)> {
    let mut lines = stdout.lines().skip(1);
    let mut results = Vec::new();

    while let Some(line) = lines.next() {
        let parts: Vec<&str> = line.split_whitespace().filter(|s| !s.is_empty()).collect();

        if parts.len() < 6 {
            continue;
        }

        let total = parts[1];
        let used = parts[2];
        let perc = parts[4].trim_end_matches('%');
        let mount = parts[5];

        let usage_display = format!("{} / {}", used, total);
        let perc_val = perc.parse::<u8>().unwrap_or(0);

        let final_str = match display_mode {
            DiskDisplay::Info => usage_display,
            DiskDisplay::Percentage => format!("{}% {}", perc, get_bar(perc_val)),
            DiskDisplay::InfoBar => format!("{} {}", usage_display, get_bar(perc_val)),
            DiskDisplay::BarInfo => format!("{} {}", get_bar(perc_val), usage_display),
            DiskDisplay::Bar => get_bar(perc_val),
        };

        let subtitle = match subtitle_mode {
            DiskSubtitle::Name => parts[0].to_string(),
            DiskSubtitle::Dir => mount.split('/').last().unwrap_or("").to_string(),
            DiskSubtitle::None => "".to_string(),
            DiskSubtitle::Mount => mount.to_string(),
        };

        let full_subtitle = if subtitle.is_empty() {
            "Disk".to_string()
        } else {
            format!("Disk ({})", subtitle)
        };

        results.push((full_subtitle, final_str));
    }

    results
}

#[cfg(test)]
mod tests {
    use super::*;

    fn sample_df_output() -> &'static str {
        r#"Filesystem     Size  Used Avail Use% Mounted on
/dev/sda1       100G   40G   60G  40% /
tmpfs           2.0G     0  2.0G   0% /dev/shm
/dev/sdb1       200G  150G   50G  75% /mnt/data
"#
    }

    #[test]
    fn test_parse_info_display_mount_subtitle() {
        let result = parse_disk_output(sample_df_output(), DiskSubtitle::Mount, DiskDisplay::Info);

        assert_eq!(result.len(), 3);
        assert_eq!(result[0].0, "Disk (/)");
        assert_eq!(result[0].1, "40G / 100G");
    }

    #[test]
    fn test_parse_percentage_display_dir_subtitle() {
        let result = parse_disk_output(
            sample_df_output(),
            DiskSubtitle::Dir,
            DiskDisplay::Percentage,
        );

        assert_eq!(result[2].0, "Disk (data)");
        assert!(result[2].1.starts_with("75%"));
    }

    #[test]
    fn test_parse_bar_only() {
        let result = parse_disk_output(sample_df_output(), DiskSubtitle::None, DiskDisplay::Bar);

        assert_eq!(result[0].0, "Disk");
        assert!(result[0].1.starts_with("[") && result[0].1.ends_with("]"));
        assert!(result[0].1.len() > 2); // should contain some kind of bar
    }

    #[test]
    fn test_parse_barinfo_with_name() {
        let result =
            parse_disk_output(sample_df_output(), DiskSubtitle::Name, DiskDisplay::BarInfo);

        assert_eq!(result[2].0, "Disk (/dev/sdb1)");
        assert!(result[2].1.contains("150G / 200G"));
    }
}