uv-platform 0.0.47

This is an internal component crate of uv
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

use crate::Error;
use std::fmt;
use std::fmt::Display;
use std::ops::Deref;
use std::str::FromStr;

#[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)]
pub struct Os(pub(crate) target_lexicon::OperatingSystem);

impl Os {
    pub fn new(os: target_lexicon::OperatingSystem) -> Self {
        Self(os)
    }

    pub fn from_env() -> Self {
        Self(target_lexicon::HOST.operating_system)
    }

    pub fn is_windows(&self) -> bool {
        matches!(self.0, target_lexicon::OperatingSystem::Windows)
    }

    pub fn is_emscripten(&self) -> bool {
        matches!(self.0, target_lexicon::OperatingSystem::Emscripten)
    }

    pub fn is_macos(&self) -> bool {
        matches!(self.0, target_lexicon::OperatingSystem::Darwin(_))
    }

    /// Whether this OS can run the other OS.
    pub fn supports(&self, other: Self) -> bool {
        // Emscripten can run on any OS
        if other.is_emscripten() {
            return true;
        }

        // Otherwise, we require an exact match
        *self == other
    }
}

impl Display for Os {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &**self {
            target_lexicon::OperatingSystem::Darwin(_) => write!(f, "macos"),
            inner => write!(f, "{inner}"),
        }
    }
}

impl FromStr for Os {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let inner = match s {
            "macos" => target_lexicon::OperatingSystem::Darwin(None),
            _ => target_lexicon::OperatingSystem::from_str(s)
                .map_err(|()| Error::UnknownOs(s.to_string()))?,
        };
        if matches!(inner, target_lexicon::OperatingSystem::Unknown) {
            return Err(Error::UnknownOs(s.to_string()));
        }
        Ok(Self(inner))
    }
}

impl Deref for Os {
    type Target = target_lexicon::OperatingSystem;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl From<&uv_platform_tags::Os> for Os {
    fn from(value: &uv_platform_tags::Os) -> Self {
        match value {
            uv_platform_tags::Os::Dragonfly { .. } => {
                Self::new(target_lexicon::OperatingSystem::Dragonfly)
            }
            uv_platform_tags::Os::FreeBsd { .. } => {
                Self::new(target_lexicon::OperatingSystem::Freebsd)
            }
            uv_platform_tags::Os::Haiku { .. } => Self::new(target_lexicon::OperatingSystem::Haiku),
            uv_platform_tags::Os::Illumos { .. } => {
                Self::new(target_lexicon::OperatingSystem::Illumos)
            }
            uv_platform_tags::Os::Macos { .. } => {
                Self::new(target_lexicon::OperatingSystem::Darwin(None))
            }
            uv_platform_tags::Os::Manylinux { .. }
            | uv_platform_tags::Os::Musllinux { .. }
            | uv_platform_tags::Os::Android { .. } => {
                Self::new(target_lexicon::OperatingSystem::Linux)
            }
            uv_platform_tags::Os::NetBsd { .. } => {
                Self::new(target_lexicon::OperatingSystem::Netbsd)
            }
            uv_platform_tags::Os::OpenBsd { .. } => {
                Self::new(target_lexicon::OperatingSystem::Openbsd)
            }
            uv_platform_tags::Os::Windows => Self::new(target_lexicon::OperatingSystem::Windows),
            uv_platform_tags::Os::Pyodide { .. } => {
                Self::new(target_lexicon::OperatingSystem::Emscripten)
            }
            uv_platform_tags::Os::Ios { .. } => {
                Self::new(target_lexicon::OperatingSystem::IOS(None))
            }
        }
    }
}