genv 0.1.18

global static var from environment
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

pub use const_str;
pub use static_init;
pub use err_exit::err_exit;

pub fn li_no_warn(name: impl AsRef<str>) -> Vec<String> {
  let mut r = Vec::new();
  let name = name.as_ref();
  if let Ok(val) = std::env::var(name) {
    for i in val.split_whitespace() {
      r.push(i.into());
    }
  }
  r
}
pub fn li(name: impl AsRef<str>) -> Vec<String> {
  let name = name.as_ref();
  let r = li_no_warn(name);
  if r.is_empty() {
    log::warn!("⚠️ ENV {name} IS EMPTY");
  }
  r
}

pub fn get<T: std::str::FromStr>(name: &str) -> T
where
  <T as std::str::FromStr>::Err: std::fmt::Debug,
{
  let val = std::env::var(name);
  match val {
    Ok(val) => match val.parse() {
      Ok(r) => r,
      Err(err) => {
        err_exit!("{name}={val} {err:?}");
      }
    },
    Err(err) => {
      err_exit!("{err} {name}");
    }
  }
}

pub fn get_or_default<T: std::str::FromStr>(name: &str, default: T) -> T
where
  <T as std::str::FromStr>::Err: std::fmt::Debug,
{
  if let Ok(i) = std::env::var(name) {
    match i.parse() {
      Ok(i) => return i,
      Err(err) => log::error!("❌ ENV PARSE ERROR {name}={i} : {:?}", err),
    }
  }
  default
}

#[macro_export]
macro_rules! s {
  ($name:ident) => {
    $crate::s!($name: String);
  };
  
  ($name:ident: $ty:ty) => {
    #[allow(non_upper_case_globals)]
    #[$crate::static_init::dynamic]
    pub static $name: $ty = $crate::get(stringify!($name));
    };
    ($($name:ident: $type:ty | $default:expr);+ $(;)?) => {
    $(
      #[$crate::static_init::dynamic]
      pub static $name: $type = {
        let name = stringify!($name);
        std::env::var(name).map(
          |i|{
            match i.parse(){
              Ok(i)=>i,
              Err(err) => {
                $crate::err_exit!("❌ {name}={i} {:?}", err);
              }
            }
          }
        ).unwrap_or($default)
      };
    )+
  };
  ($($name:ident$(:$ty:ty)?),+) => {
    $(
      $crate::s!($name$(: $ty)?);
    )+
  };
}

#[macro_export]
macro_rules! def {
($($name:ident: $type:ty | $default:expr);+ $(;)?) => {
$(
#[allow(non_snake_case)]
pub fn $name() -> $type {
    $crate::get_or_default(stringify!($name), $default)
}
)+
};
($name:ident) => {
#[allow(non_snake_case)]
pub fn $name<T: std::str::FromStr>() -> T
    where <T as std::str::FromStr>::Err: std::fmt::Debug {
        $crate::get(stringify!($name))
}
};
($($name:ident),+) => {
$(
    $crate::def!($name);
)+
};
}