platform-info 2.1.0

A simple cross-platform interface to get info about a system
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

// "plumbing" setup and connections for `lib.rs`

// spell-checker:ignore (jargon) armv

#![warn(unused_results)] // enable warnings for unused results

#[cfg(target_os = "windows")]
use std::path::Path;
#[cfg(target_os = "windows")]
use std::path::PathBuf;

//=== types

/// Standard thread-safe error type
pub type ThreadSafeStdError = dyn std::error::Error + Send + Sync;
/// Standard thread-safe error type (boxed to allow translation for any `std::error::Error` type)
pub type BoxedThreadSafeStdError = Box<ThreadSafeStdError>;

/// A slice of a path string
/// (akin to [`str`]; aka/equivalent to [`Path`]).
#[cfg(target_os = "windows")]
type PathStr = Path;
/// An owned, mutable path string
/// (akin to [`String`]; aka/equivalent to [`PathBuf`]).
#[cfg(target_os = "windows")]
type PathString = PathBuf;

//=== platform-specific functions

// map_processor
/// *Returns* processor type mapped from machine architecture string.
///
/// Provides GNU coreutils-compatible processor type mappings from machine architecture strings.
/// This function normalizes architecture names to match the output of GNU coreutils' `uname -p`.
///
/// # Difference from `machine()`
///
/// While [`UNameAPI::machine()`] returns the raw architecture string from the OS (e.g., "arm64" on macOS),
/// `processor()` provides a normalized, cross-platform compatible representation:
///
/// | Platform | machine() | processor() | Reason |
/// |----------|-----------|-------------|--------|
/// | macOS ARM | "arm64" | "arm" | GNU coreutils compatibility |
/// | Linux ARM64 | "aarch64" | "aarch64" | Preserve Linux convention |
/// | Windows x86 | "i386"-"i686" | "i686" | Normalize to common name |
///
/// # Architecture Mappings
///
/// * macOS uses "arm64" for ARM-based Macs → maps to "arm"
/// * Linux uses "aarch64" for ARM64 → passes through as "aarch64"
/// * Various i386/i486/i586/i686 variants → normalized to "i686"
/// * ARMv6/v7/v8 variants → mapped to "arm"
/// * Unknown architectures pass through unchanged (better than returning "unknown")
///
/// ref: <https://github.com/uutils/coreutils/issues/8659>
pub(crate) fn map_processor(machine: &str) -> String {
    match machine {
        "arm64" => "arm".to_string(),
        "aarch64" => "aarch64".to_string(),
        "x86_64" | "amd64" => "x86_64".to_string(),
        "i386" | "i486" | "i586" | "i686" => "i686".to_string(),
        "armv7l" | "armv6l" | "armv8l" => "arm".to_string(),
        _ => machine.to_string(),
    }
}

//=== platform-specific const

// HOST_OS_NAME * ref: [`uname` info](https://en.wikipedia.org/wiki/Uname)
const HOST_OS_NAME: &str = if cfg!(all(
    target_os = "linux",
    any(target_env = "gnu", target_env = "")
)) {
    "GNU/Linux"
} else if cfg!(all(
    target_os = "linux",
    not(any(target_env = "gnu", target_env = ""))
)) {
    "Linux"
} else if cfg!(target_os = "android") {
    "Android"
} else if cfg!(target_os = "windows") {
    "MS/Windows" // prior art == `busybox`
} else if cfg!(target_os = "freebsd") {
    "FreeBSD"
} else if cfg!(target_os = "netbsd") {
    "NetBSD"
} else if cfg!(target_os = "openbsd") {
    "OpenBSD"
} else if cfg!(target_vendor = "apple") {
    "Darwin"
} else if cfg!(target_os = "fuchsia") {
    "Fuchsia"
} else if cfg!(target_os = "redox") {
    "Redox"
} else if cfg!(target_os = "illumos") {
    "illumos"
} else if cfg!(target_os = "solaris") {
    "Solaris"
} else if cfg!(target_os = "haiku") {
    "Haiku"
} else if cfg!(target_os = "dragonfly") {
    "DragonFly"
} else if cfg!(target_os = "aix") {
    "AIX"
} else if cfg!(target_os = "cygwin") {
    "Cygwin"
} else if cfg!(target_os = "wasi") {
    "WASI"
} else {
    "unknown"
};

//=== platform-specific module code

#[cfg(all(unix, not(target_os = "wasi")))]
#[path = "platform/unix.rs"]
mod target;
#[cfg(windows)]
#[path = "platform/windows.rs"]
mod target;
#[cfg(target_os = "wasi")]
#[path = "platform/wasi.rs"]
mod target;
#[cfg(not(any(unix, windows, target_os = "wasi")))]
#[path = "platform/unknown.rs"]
mod target;

pub use target::*;

//=== Tests

#[test]
fn test_map_processor_mappings() {
    // ARM variants
    assert_eq!(map_processor("arm64"), "arm");
    assert_eq!(map_processor("aarch64"), "aarch64");
    assert_eq!(map_processor("armv6l"), "arm");
    assert_eq!(map_processor("armv7l"), "arm");
    assert_eq!(map_processor("armv8l"), "arm");

    // x86 variants
    assert_eq!(map_processor("x86_64"), "x86_64");
    assert_eq!(map_processor("amd64"), "x86_64");
    assert_eq!(map_processor("i386"), "i686");
    assert_eq!(map_processor("i486"), "i686");
    assert_eq!(map_processor("i586"), "i686");
    assert_eq!(map_processor("i686"), "i686");

    // Unknown/passthrough architectures
    assert_eq!(map_processor("riscv64"), "riscv64");
    assert_eq!(map_processor("powerpc64"), "powerpc64");
    assert_eq!(map_processor("unknown"), "unknown");
}