neofetch 0.2.0

neofetch
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

//! macOS-specific platform implementations
//!
//! Provides macOS-specific helper functions for system information gathering.

use crate::error::Result;
use crate::utils::execute_command;

/// Execute sysctl command to get system information
///
/// # Arguments
/// * `key` - sysctl key to query
///
/// # Returns
/// * `Result<String>` - sysctl value
///
/// # Example
/// ```no_run
/// use neofetch::platform::sysctl;
///
/// # async fn example() -> neofetch::Result<()> {
/// let cpu_brand = sysctl("machdep.cpu.brand_string").await?;
/// # Ok(())
/// # }
/// ```
pub async fn sysctl(key: &str) -> Result<String> {
    execute_command("sysctl", &["-n", key]).await
}

/// Get CPU brand string
pub async fn get_cpu_brand() -> Result<String> {
    sysctl("machdep.cpu.brand_string").await
}

/// Get CPU core count
pub async fn get_cpu_core_count() -> Result<u32> {
    let output = sysctl("hw.ncpu").await?;
    output.trim().parse().map_err(|e: std::num::ParseIntError| {
        crate::error::NeofetchError::parse_error("cpu_count", e.to_string())
    })
}

/// Get CPU frequency in MHz
pub async fn get_cpu_frequency() -> Result<u64> {
    let output = sysctl("hw.cpufrequency").await?;
    let hz: u64 = output
        .trim()
        .parse()
        .map_err(|e: std::num::ParseIntError| {
            crate::error::NeofetchError::parse_error("cpu_frequency", e.to_string())
        })?;
    Ok(hz / 1_000_000) // Convert to MHz
}

/// Get total physical memory in bytes
pub async fn get_memory_total() -> Result<u64> {
    let output = sysctl("hw.memsize").await?;
    output.trim().parse().map_err(|e: std::num::ParseIntError| {
        crate::error::NeofetchError::parse_error("memory_size", e.to_string())
    })
}

/// Get macOS version using sw_vers
pub async fn get_macos_version() -> Result<String> {
    execute_command("sw_vers", &["-productVersion"]).await
}

/// Get macOS build version
pub async fn get_macos_build() -> Result<String> {
    execute_command("sw_vers", &["-buildVersion"]).await
}

/// Execute system_profiler command
///
/// # Arguments
/// * `data_type` - Type of data to profile (e.g., "SPHardwareDataType")
///
/// # Returns
/// * `Result<String>` - Profiler output
pub async fn system_profiler(data_type: &str) -> Result<String> {
    execute_command("system_profiler", &[data_type, "-json"]).await
}

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

    #[tokio::test]
    #[cfg(target_os = "macos")]
    async fn test_sysctl() {
        let result = sysctl("kern.ostype").await;
        assert!(result.is_ok());
        assert_eq!(result.unwrap().trim(), "Darwin");
    }

    #[tokio::test]
    #[cfg(target_os = "macos")]
    async fn test_get_cpu_brand() {
        let result = get_cpu_brand().await;
        assert!(result.is_ok());
    }

    #[tokio::test]
    #[cfg(target_os = "macos")]
    async fn test_get_macos_version() {
        let result = get_macos_version().await;
        assert!(result.is_ok());
    }
}