cargo-mate 1.0.63

Rust development companion that enhances cargo with intelligent workflows, state management, performance optimization, and comprehensive project monitoring. Pure binary package - no C compiler required!
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

// Cargo Mate - Rust On!

use std::env;
use std::fs;
use std::process::Command;

// Embedded install scripts - these are compiled into the binary
const INSTALL_SCRIPT: &str = include_str!("../sh/install.sh");
const WRAPPER_LINUX: &str = include_str!("../sh/wrapper-linux.sh");
const WRAPPER_MACOS: &str = include_str!("../sh/wrapper-macos.sh");
const WRAPPER_WINDOWS_BAT: &str = include_str!("../sh/wrapper-windows.bat");
const WRAPPER_WINDOWS_PS1: &str = include_str!("../sh/wrapper-windows.ps1");

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚢 Cargo Mate - Rust On!");
    println!("==========================================");
    let temp_dir = std::env::temp_dir().join("cargo-mate-install");
    std::fs::create_dir_all(&temp_dir)?;
    let install_dir = &temp_dir;
    let install_script_path = install_dir.join("install.sh");
    fs::write(&install_script_path, INSTALL_SCRIPT)?;

    // Set executable permissions (Unix-like systems)
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        let mut perms = fs::metadata(&install_script_path)?.permissions();
        perms.set_mode(0o755);
        fs::set_permissions(&install_script_path, perms)?;
    }

    let platform = detect_platform();
    let sh_dir = install_dir.join("sh");
    fs::create_dir_all(&sh_dir)?;

    match platform.as_str() {
        "linux" => {
            let wrapper_path = sh_dir.join("wrapper-linux.sh");
            fs::write(&wrapper_path, WRAPPER_LINUX)?;
            #[cfg(unix)]
            {
                use std::os::unix::fs::PermissionsExt;
                let mut perms = fs::metadata(&wrapper_path)?.permissions();
                perms.set_mode(0o755);
                fs::set_permissions(&wrapper_path, perms)?;
            }
        }
        "macos" => {
            let wrapper_path = sh_dir.join("wrapper-macos.sh");
            fs::write(&wrapper_path, WRAPPER_MACOS)?;
            #[cfg(unix)]
            {
                use std::os::unix::fs::PermissionsExt;
                let mut perms = fs::metadata(&wrapper_path)?.permissions();
                perms.set_mode(0o755);
                fs::set_permissions(&wrapper_path, perms)?;
            }
        }
        "windows" => {
            fs::write(sh_dir.join("wrapper-windows.bat"), WRAPPER_WINDOWS_BAT)?;
            fs::write(sh_dir.join("wrapper-windows.ps1"), WRAPPER_WINDOWS_PS1)?;
        }
        _ => {
            return Err(format!("Unsupported platform: {}", platform).into());
        }
    }
    let status = Command::new("bash")
        .arg(&install_script_path)
        .current_dir(install_dir)
        .status()?;

    if status.success() {
        println!("✅ Installation completed successfully!");
    } else {
        eprintln!("❌ Installation failed with exit code: {}", status.code().unwrap_or(-1));
        show_manual_installation();
    }

    Ok(())
}

fn detect_platform() -> String {
    match env::consts::OS {
        "linux" => "linux".to_string(),
        "macos" => "macos".to_string(),
        "windows" => "windows".to_string(),
        _ => env::consts::OS.to_string(),
    }
}


fn show_manual_installation() {
    eprintln!("🔧 Use one-click installer:");
    eprintln!("curl -fsSL https://get.cargo.do/install.sh | bash");
    eprintln!("");
    eprintln!("📦 The one-click installer will automatically install C compiler and cargo-mate.");
}