unin-bin 0.1.3

A universal installer for many languages so you don't have to remember any commands
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

pub mod cmake;
mod comms;
mod confidcure;
mod gleam;
mod go;
mod haskell;
pub mod installer;
mod logging;
pub mod make;
mod meson;
mod rust;
pub mod tools;
pub mod zig;

use crate::tools::*;
use clap::{Parser, ValueEnum};
use colored::Colorize;
use std::{
    io::{self, Write},
    path::PathBuf,
    process::exit,
};
use unin_bin::registry;

#[derive(Parser, Debug)]
#[command(name = "unin", version = "0.1.0", author = "notchapplez")]
struct Cli {
    #[arg(
        long,
        value_enum,
        help = "set up the necessary tools for the compilation"
    )]
    setup: Option<SetupMode>,

    #[arg(
        value_name = "PATH",
        default_value = ".",
        help = "Path to the directory to compile"
    )]
    path: PathBuf,

    #[arg(long, default_value = "false", help = "Skip the install step")]
    noinstall: bool,

    #[arg(
        long,
        default_value = "false",
        help = "debug purposes",
        required = false
    )]
    test: bool,

    #[arg(
        long,
        num_args = 0..=1,
        default_missing_value = ".",
        help = "Clean artefacts built",
        required = false,
        conflicts_with_all = ["setup", "noinstall", "test", "path", "uninstall"]
    )]
    clean: Option<PathBuf>,

    #[arg(
        long,
        required = false,
        help = "Uninstall a package",
        conflicts_with_all = ["setup", "noinstall", "test", "path", "clean"]

    )]
    uninstall: Option<String>,

    #[arg(
        long,
        num_args = 0..=1,
        default_missing_value = "true",
        required = false,
    )]
    queue_registry: Option<bool>,
}

#[derive(Clone, Debug, ValueEnum)]
enum SetupMode {
    Full,    //done
    Rust,    //done
    Cmake,   //done
    Make,    //done, hell yeah
    Go,      //wait i think i did this -- yeah i did
    Zig,     //somewhat done i guess
    Swift,   //not done yet (todo!())
    Haskell, //not done yet (todo!())
    D,       //what the hell is this anyway (todo!())
}

fn main() {
    let cli = Cli::parse();

    //update and check registry
    registry::update_check_registry();

    if cli.clean.is_some() {
        println!(
            "Cleaning {}",
            cli.clean.clone().unwrap().to_str().unwrap().yellow()
        );
        let _ = io::stdout().flush();
        detect_clean(
            cli.clean
                .clone()
                .unwrap_or_else(|| panic!("Couldn't unwrap."))
                .to_str()
                .unwrap()
                .to_owned(),
        );
        exit(0);
    }
    if cli.test {
        registry::temp_test();
        exit(0)
    }
    if !cli.uninstall.clone().unwrap_or_default().is_empty() {
        registry::registry_uninstall(cli.uninstall.clone().unwrap());
        exit(0);
    }
    if cli.queue_registry.is_some() {
        registry::get_registry();
        exit(0);
    }

    if let Some(mode) = cli.setup {
        match mode {
            SetupMode::Full => installer::setup_files_full(),
            SetupMode::Rust => installer::setup_files_lang("rust".to_owned()),
            SetupMode::Cmake => installer::setup_files_lang("cmake".to_owned()),
            SetupMode::Make => installer::setup_files_lang("make".to_owned()),
            SetupMode::Go => installer::setup_files_lang("go".to_owned()),
            SetupMode::Zig => installer::setup_files_lang("zig".to_owned()),
            SetupMode::Swift => installer::setup_files_lang("swift".to_owned()),
            SetupMode::Haskell => installer::setup_files_lang("haskell".to_owned()),
            SetupMode::D => installer::setup_files_lang("d".to_owned()),
        }
    }

    detect(cli.path.to_str().unwrap().to_owned(), cli.noinstall);
}

//meow!