axl_lib/config/
config_env.rs

1use std::{env, path::PathBuf};
2
3use thiserror::Error;
4use tracing::trace;
5
6use super::constants::{
7    DEFAULT_MULTIPLEXER_KEY, HOME_DIR_KEY, XDG_CONFIG_HOME_DIR_KEY, XDG_DATA_HOME_DIR_KEY,
8    XDG_STATE_HOME_DIR_KEY,
9};
10
11pub enum ConfigEnvKey {
12    Home,
13    XDGConfigHome,
14    XDGDataHome,
15    XDGStateHome,
16    DefaultMultiplexerKey,
17}
18
19impl ConfigEnvKey {
20    pub const fn as_str(&self) -> &'static str {
21        match self {
22            Self::Home => HOME_DIR_KEY,
23            Self::XDGConfigHome => XDG_CONFIG_HOME_DIR_KEY,
24            Self::XDGDataHome => XDG_DATA_HOME_DIR_KEY,
25            Self::XDGStateHome => XDG_STATE_HOME_DIR_KEY,
26            Self::DefaultMultiplexerKey => DEFAULT_MULTIPLEXER_KEY,
27        }
28    }
29
30    pub const fn default_value(&self) -> &'static str {
31        match self {
32            Self::Home => "",
33            Self::XDGConfigHome => "",
34            Self::XDGDataHome => "",
35            Self::XDGStateHome => "",
36            Self::DefaultMultiplexerKey => "",
37        }
38    }
39}
40
41const DEFAULT_PANIC_MSG: &str =
42    "Check the impl block for the type you are trying to use and make sure the key is implemented.";
43
44impl TryFrom<ConfigEnvKey> for PathBuf {
45    type Error = ConfigError;
46    fn try_from(env_key: ConfigEnvKey) -> Result<Self, ConfigError> {
47        match env_key {
48            ConfigEnvKey::Home => Ok(Self::from(
49                env::var(ConfigEnvKey::Home.as_str()).expect("HOME env var should be set"),
50            )),
51            ConfigEnvKey::XDGConfigHome => match env::var(ConfigEnvKey::XDGConfigHome.as_str()) {
52                Ok(config_dir) => Ok(Self::from(config_dir)),
53                Err(_err) => {
54                    let mut home = Self::try_from(ConfigEnvKey::Home)?;
55                    home.push(".config");
56                    trace!(
57                        "Error: error reading ${}. Using [{}]",
58                        ConfigEnvKey::XDGConfigHome.as_str(),
59                        home.as_os_str().to_string_lossy()
60                    );
61                    Ok(home)
62                }
63            },
64            ConfigEnvKey::XDGDataHome => Ok(Self::from(
65                env::var(ConfigEnvKey::XDGDataHome.as_str())
66                    .expect("XDG_DATA_HOME env var should be set"),
67            )),
68            ConfigEnvKey::XDGStateHome => Ok(Self::from(
69                env::var(ConfigEnvKey::XDGStateHome.as_str())
70                    .expect("XDG_STATE_HOME env var should be set"),
71            )),
72            #[allow(unreachable_patterns)]
73            // This is allowed because not all enum variants are guaranteed to be this type in the
74            // futrue.
75            _ => panic!("this key cannot be converted to PathBuf. {DEFAULT_PANIC_MSG}"),
76        }
77    }
78}
79
80#[derive(Error, Debug)]
81pub enum ConfigError {
82    #[error("genertic")]
83    Generic,
84}