envio 0.4.0

Envio is a command-line tool that simplifies the management of environment variables across multiple profiles. It allows users to easily switch between different configurations and apply them to their current environment. Envio also encrypts sensitive environment variable values to ensure secure storage and transmission
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

use std::fs::File;
use std::io::Write;
use std::path::PathBuf;

use colored::Colorize;
use indicatif::{ProgressBar, ProgressStyle};
use reqwest::Client;

/*
* Get the home directory of the user

@return PathBuf
*/
pub fn get_homedir() -> PathBuf {
    if home::home_dir().is_none() {
        println!("{}: Home directory not found", "Error".red());
        std::process::exit(1);
    } else {
        home::home_dir().unwrap()
    }
}

/*
* Get the config directory which is located in the home directory
* The directory is called .envio

@return PathBuf
*/
pub fn get_configdir() -> PathBuf {
    let homedir = get_homedir();

    homedir.join(".envio")
}

/*
* Get the current working directory

@return PathBuf
*/
pub fn get_cwd() -> PathBuf {
    if let Err(e) = std::env::current_dir() {
        println!(
            "{}: Current directory not found\n {}: {}",
            "Error".red(),
            "Error info".yellow(),
            e
        );
        std::process::exit(1);
    } else {
        std::env::current_dir().unwrap()
    }
}

/*
* Download a file from a url with a progress bar

@param url &str
@param file_name &str
*/
pub async fn download_file(url: &str, file_name: &str) {
    let client = Client::new();
    let mut resp = if let Err(e) = client.get(url).send().await {
        println!("{}: {}", "Error".red(), e);
        std::process::exit(1);
    } else {
        client.get(url).send().await.unwrap()
    };

    let mut file = if let Err(e) = File::create(file_name) {
        println!("{}: {}", "Error".red(), e);
        std::process::exit(1);
    } else {
        File::create(file_name).unwrap()
    };

    let mut content_length = if resp.content_length().is_none() {
        println!("{}: Can not get content length of ", "Error".red());
        std::process::exit(1);
    } else {
        resp.content_length().unwrap()
    };

    let pb = ProgressBar::new(content_length);

    pb.set_style(ProgressStyle::default_bar()
        .template("{spinner:.green} [{elapsed_precise}] [{bar:40.cyan/blue}] {bytes}/{total_bytes} ({eta})")
        .unwrap()
        .progress_chars("#>-"));

    while let Some(chunk) = resp.chunk().await.unwrap() {
        let chunk_size = chunk.len();
        if let Err(e) = file.write_all(&chunk) {
            println!("{}: {}", "Error".red(), e);
            std::process::exit(1);
        }

        pb.inc(chunk_size as u64);
        content_length -= chunk_size as u64;
    }

    pb.finish();
}