espup 0.7.0

Tool for installing and maintaining Espressif Rust ecosystem.
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

//! Host triple variants support.

use crate::error::Error;
use guess_host_triple::guess_host_triple;
use miette::Result;
use std::str::FromStr;
use strum::{Display, EnumString};

#[derive(Display, Debug, Clone, EnumString, Default)]
pub enum HostTriple {
    /// 64-bit Linux
    #[strum(serialize = "x86_64-unknown-linux-gnu")]
    #[default]
    X86_64UnknownLinuxGnu,
    /// ARM64 Linux
    #[strum(serialize = "aarch64-unknown-linux-gnu")]
    Aarch64UnknownLinuxGnu,
    /// 64-bit MSVC
    #[strum(serialize = "x86_64-pc-windows-msvc")]
    X86_64PcWindowsMsvc,
    /// 64-bit MinGW
    #[strum(serialize = "x86_64-pc-windows-gnu")]
    X86_64PcWindowsGnu,
    /// 64-bit macOS
    #[strum(serialize = "x86_64-apple-darwin")]
    X86_64AppleDarwin,
    /// ARM64 macOS
    #[strum(serialize = "aarch64-apple-darwin")]
    Aarch64AppleDarwin,
}

/// Parse the host triple if specified, otherwise guess it.
pub fn get_host_triple(host_triple_arg: Option<String>) -> Result<HostTriple, Error> {
    let host_triple = if let Some(host_triple) = &host_triple_arg {
        host_triple
    } else {
        guess_host_triple().unwrap()
    };

    HostTriple::from_str(host_triple).map_err(|_| Error::UnsupportedHostTriple(host_triple.into()))
}

#[cfg(test)]
mod tests {
    use crate::host_triple::{get_host_triple, HostTriple};

    #[test]
    fn test_get_host_triple() {
        assert!(matches!(
            get_host_triple(Some("x86_64-unknown-linux-gnu".to_string())),
            Ok(HostTriple::X86_64UnknownLinuxGnu)
        ));
        assert!(matches!(
            get_host_triple(Some("aarch64-unknown-linux-gnu".to_string())),
            Ok(HostTriple::Aarch64UnknownLinuxGnu)
        ));
        assert!(matches!(
            get_host_triple(Some("x86_64-pc-windows-msvc".to_string())),
            Ok(HostTriple::X86_64PcWindowsMsvc)
        ));
        assert!(matches!(
            get_host_triple(Some("x86_64-pc-windows-gnu".to_string())),
            Ok(HostTriple::X86_64PcWindowsGnu)
        ));
        assert!(matches!(
            get_host_triple(Some("x86_64-apple-darwin".to_string())),
            Ok(HostTriple::X86_64AppleDarwin)
        ));
        assert!(matches!(
            get_host_triple(Some("aarch64-apple-darwin".to_string())),
            Ok(HostTriple::Aarch64AppleDarwin)
        ));

        assert!(get_host_triple(Some("some-fake-triple".to_string())).is_err());

        // Guessed Host Triples
        #[cfg(all(target_os = "linux", target_arch = "aarch64"))]
        assert!(matches!(
            get_host_triple(None),
            Ok(HostTriple::Aarch64UnknownLinuxGnu)
        ));
        #[cfg(all(target_os = "linux", target_arch = "x86_64"))]
        assert!(matches!(
            get_host_triple(None),
            Ok(HostTriple::X86_64UnknownLinuxGnu)
        ));
        #[cfg(all(target_os = "windows", target_arch = "x86_64", target_env = "msvc"))]
        assert!(matches!(
            get_host_triple(None),
            Ok(HostTriple::X86_64PcWindowsMsvc)
        ));
        #[cfg(all(target_os = "windows", target_arch = "x86_64", target_env = "gnu"))]
        assert!(matches!(
            get_host_triple(None),
            Ok(HostTriple::X86_64PcWindowsGnu)
        ));
        #[cfg(all(target_os = "macos", target_arch = "x86_64"))]
        assert!(matches!(
            get_host_triple(None),
            Ok(HostTriple::X86_64AppleDarwin)
        ));
        #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
        assert!(matches!(
            get_host_triple(None),
            Ok(HostTriple::Aarch64AppleDarwin)
        ));
    }
}