leenfetch 0.2.4

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

use std::{path::Path, process::Command};

pub fn get_shell(show_path: bool, show_version: bool) -> Option<String> {
    let parent_shell_path = detect_parent_shell()?;
    let shell_name = Path::new(&parent_shell_path)
        .file_stem()?
        .to_string_lossy()
        .to_ascii_lowercase();

    let mut shell = if show_path {
        format!("{parent_shell_path} ")
    } else {
        format!("{shell_name} ")
    };

    if !show_version {
        return Some(shell.trim_end().to_string());
    }

    let version = match shell_name.as_str() {
        "cmd" => Some(get_cmd_version()),
        "powershell" => run_version_arg(
            "powershell",
            "-Command",
            "$PSVersionTable.PSVersion.ToString()",
        ),
        "pwsh" => run_version_arg("pwsh", "-Command", "$PSVersionTable.PSVersion.ToString()"),
        "nu" => run_version_arg("nu", "--version", ""),
        "bash" => run_version_arg("bash", "--version", ""),
        _ => None,
    };

    if let Some(ver) = version {
        shell.push_str(&ver);
    }

    Some(clean_shell_string(shell))
}

/// Tries to detect the actual shell that launched this process.
fn detect_parent_shell() -> Option<String> {
    let output = Command::new("wmic")
        .args([
            "process",
            "where",
            &format!("ProcessId={}", std::process::id()),
            "get",
            "ParentProcessId",
            "/value",
        ])
        .output()
        .ok()?;

    let parent_out = String::from_utf8_lossy(&output.stdout);
    let parent_pid_line = parent_out
        .lines()
        .find(|line| line.contains("ParentProcessId="))?;

    let parent_pid = parent_pid_line.trim().split('=').nth(1)?.trim();

    // Get process executable path of parent
    let parent_output = Command::new("wmic")
        .args([
            "process",
            "where",
            &format!("ProcessId={parent_pid}"),
            "get",
            "ExecutablePath",
            "/value",
        ])
        .output()
        .ok()?;

    let parent_exe = String::from_utf8_lossy(&parent_output.stdout);
    let exe_path_line = parent_exe
        .lines()
        .find(|line| line.contains("ExecutablePath="))?;

    let path = exe_path_line.trim().strip_prefix("ExecutablePath=")?.trim();

    Some(path.to_string())
}

fn get_cmd_version() -> String {
    let output = Command::new("cmd")
        .args(["/C", "ver"])
        .output()
        .ok()
        .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
        .unwrap_or_default();

    output
        .lines()
        .find(|line| line.contains("Microsoft"))
        .unwrap_or("cmd")
        .replace("[Version", "")
        .replace("]", "")
        .trim()
        .to_string()
}

fn run_version_arg(shell: &str, arg1: &str, arg2: &str) -> Option<String> {
    let output = Command::new(shell).args([arg1, arg2]).output().ok()?;

    if !output.status.success() {
        return None;
    }

    let out = String::from_utf8_lossy(&output.stdout);
    Some(out.lines().next().unwrap_or("").trim().to_string())
}

fn clean_shell_string(s: String) -> String {
    s.replace(", version", "")
        .replace("Microsoft ", "")
        .replace("Windows ", "")
        .replace("options", "")
        .split('(')
        .next()
        .unwrap_or("")
        .trim()
        .to_string()
}