tidepool-gvm 0.2.2

A simple, high-performance Go version management tool written in Rust with clean architecture and minimal dependencies
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

//! Cross-platform compatibility module
//!
//! Provides unified platform detection and related utility functions.

/// Platform information structure
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PlatformInfo {
    pub os: String,
    pub arch: String,
    pub extension: String,
}

impl PlatformInfo {
    /// Automatically detects the current platform information
    pub fn detect() -> Self {
        let (os, arch) = detect_os_arch();
        let extension = detect_archive_extension();

        Self { os: os.to_string(), arch: arch.to_string(), extension: extension.to_string() }
    }

    /// Generates the Go archive filename
    pub fn archive_filename(&self, version: &str) -> String {
        format!("go{}.{}-{}.{}", version, self.os, self.arch, self.extension)
    }

    /// Gets the Go executable filename (including platform-specific extension)
    pub fn go_executable_name() -> &'static str {
        if cfg!(target_os = "windows") {
            "go.exe"
        } else {
            "go"
        }
    }
}

impl Default for PlatformInfo {
    fn default() -> Self {
        Self::detect()
    }
}

/// Detects the operating system and architecture
fn detect_os_arch() -> (&'static str, &'static str) {
    let os = match std::env::consts::OS {
        "linux" => "linux",
        "macos" => "darwin",
        "windows" => "windows",
        _ => "linux", // Default to linux
    };

    let arch = match std::env::consts::ARCH {
        "x86_64" => "amd64",
        "x86" => "386",
        "aarch64" => "arm64",
        "arm" => "armv6l",
        _ => "amd64", // Default to amd64
    };

    (os, arch)
}

/// Detects the archive file extension
fn detect_archive_extension() -> &'static str {
    if cfg!(target_os = "windows") {
        "zip"
    } else {
        "tar.gz"
    }
}

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

    #[test]
    fn test_platform_detection() {
        let platform = PlatformInfo::detect();
        assert!(!platform.os.is_empty());
        assert!(!platform.arch.is_empty());
        assert!(!platform.extension.is_empty());
    }

    #[test]
    fn test_archive_filename() {
        let platform = PlatformInfo::detect();
        let filename = platform.archive_filename("1.21.0");
        assert!(filename.starts_with("go1.21.0."));
        assert!(filename.contains(&platform.os));
        assert!(filename.contains(&platform.arch));
        assert!(filename.ends_with(&platform.extension));
    }

    #[test]
    fn test_go_executable_name() {
        let exe_name = PlatformInfo::go_executable_name();
        if cfg!(target_os = "windows") {
            assert_eq!(exe_name, "go.exe");
        } else {
            assert_eq!(exe_name, "go");
        }
    }
}