bagex 0.2.3

Manage environment of executables with ease
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

use std::{
    collections::HashMap, os::unix::prelude::PermissionsExt, path::PathBuf,
    str::FromStr,
};

use color_eyre::Report;

use crate::config::BagexConfig;

fn get_home_dir() -> PathBuf {
    PathBuf::from_str(&std::env::var("HOME").unwrap_or("/".to_string()))
        .unwrap_or_default()
}

/// If the environment variable $XDXDG_CONFIG_HOME is set, returns
/// $XDG_CONFIG_HOME/bagex/config.toml, else returns $HOME/.config/bagex/config.toml
pub fn default_config_file() -> PathBuf {
    if let Ok(path) = std::env::var("XDG_CONFIG_HOME") {
        PathBuf::from_str(&path).unwrap()
    } else {
        get_home_dir().join(".config")
    }
    .join("bagex")
    .join("config.toml")
}

pub fn compose_and_set_env_path(
    additional_path: Vec<PathBuf>,
) -> Vec<PathBuf> {
    let mut path = additional_path;
    path = path
        .iter()
        .map(|x| {
            PathBuf::from_str(&shellexpand::tilde(
                &x.to_str().unwrap().to_string(),
            ))
            .unwrap()
        })
        .collect();
    path.extend(
        std::env::var("PATH")
            .unwrap()
            .split(":")
            .map(|x| PathBuf::from_str(x).unwrap())
            .collect::<Vec<PathBuf>>(),
    );
    log::trace!("Paths in composed PATH: {:#?}", path);
    let env_path: String = path
        .iter()
        .map(|x| x.to_str().unwrap().to_string())
        .collect::<Vec<String>>()
        .join(":");
    log::trace!("Composed PATH as environment variable: {:#?}", env_path);
    std::env::set_var("PATH", env_path);

    path
}

pub fn get_exe_abs_path(
    req_exe_name: String,
    path: Vec<PathBuf>,
) -> Result<PathBuf, Report> {
    for p in path {
        let candidate = p.join(&req_exe_name);
        if candidate.is_file()
            && candidate.metadata()?.permissions().mode() & 0o110 == 0o110
        {
            return Ok(candidate);
        }
    }
    Err(color_eyre::eyre::eyre!(
        "Requested executable '{}' cannot be found anywhere in $PATH",
        req_exe_name,
    ))
}

pub fn compose_environments(
    req_exe_name: String,
    config: &BagexConfig,
) -> HashMap<String, String> {
    let mut ret: HashMap<String, String> = HashMap::new();

    log::debug!("Getting envs from env-exe mapping from config file ..");
    if let toml::Value::Table(env_table) = config.env.as_ref().unwrap() {
        for (env_name, info) in env_table {
            if let toml::Value::Table(ref value_exe_pairs) = info {
                for (value, exes) in value_exe_pairs {
                    if let toml::Value::Array(executables) = exes {
                        if executables.contains(&toml::Value::String(
                            req_exe_name.clone(),
                        )) {
                            assert!(
                        !ret.contains_key(env_name),
                        "Environment variable {} is specified multiple times",
                        env_name,
                    );
                            log::debug!(
                                "Setting env: \"{}={}\"",
                                env_name,
                                value
                            );
                            ret.insert(
                                env_name.to_string(),
                                value.to_string(),
                            );
                            break;
                        }
                    }
                }
            }
        }
    }

    log::debug!("Getting envs from exe-env mapping from config file ..");
    if let toml::Value::Table(exe_table) = config.exe.as_ref().unwrap() {
        for (config_exe_name, env_specs) in exe_table {
            if config_exe_name == &req_exe_name {
                if let toml::Value::Table(envs) = env_specs {
                    for (env_name, value_raw) in envs {
                        assert!(
                            !ret.contains_key(env_name),
                            "Environment variable {} is specified multiple times",
                            env_name,
                        );
                        let value = if value_raw.is_str() {
                            value_raw.as_str().unwrap().to_string()
                        } else {
                            value_raw.to_string()
                        };
                        log::debug!("Setting env: {}={}", env_name, value);
                        ret.insert(env_name.to_string(), value);
                    }
                }
            }
        }
    }

    ret
}

// Author: Blurgy <gy@blurgy.xyz>
// Date:   Jul 26 2021, 11:07 [CST]