use std::any::Any;
use std::collections::HashMap;
use std::fmt;
use crate::error::Error;
use crate::secret::Secret;
use crate::var::VarBuilder;
trait DynVar {
fn name(&self) -> &str;
fn resolve_raw(&self, raw: Option<&str>) -> Result<Option<Box<dyn Any>>, Error>;
}
impl<T: Clone + 'static> DynVar for VarBuilder<T> {
fn name(&self) -> &str {
self.name()
}
fn resolve_raw(&self, raw: Option<&str>) -> Result<Option<Box<dyn Any>>, Error> {
let resolved = self.resolve(raw)?;
match resolved {
Some(v) if self.is_secret() => Ok(Some(Box::new(Secret::new(v)) as Box<dyn Any>)),
Some(v) => Ok(Some(Box::new(v) as Box<dyn Any>)),
None => Ok(None),
}
}
}
pub struct EnvSource {
prefix: String,
vars: Vec<Box<dyn DynVar>>,
layers: Vec<Box<dyn crate::layer::Layer>>,
}
impl EnvSource {
#[must_use]
pub fn new() -> Self {
Self {
prefix: String::new(),
vars: Vec::new(),
layers: Vec::new(),
}
}
#[must_use]
pub fn prefix(mut self, prefix: impl Into<String>) -> Self {
self.prefix = prefix.into();
self
}
#[must_use]
pub fn layer(mut self, layer: impl crate::layer::Layer + 'static) -> Self {
self.layers.push(Box::new(layer));
self
}
#[must_use]
pub fn declare<T: Clone + 'static>(mut self, var: VarBuilder<T>) -> Self {
let var = var.prefixed(&self.prefix);
self.vars.push(Box::new(var));
self
}
#[cfg(feature = "dotenv")]
#[must_use]
pub fn dotenv(self) -> Self {
self.layer(crate::layer::dotenv())
}
#[cfg(feature = "dotenv")]
#[must_use]
pub fn dotenv_path(self, path: impl AsRef<std::path::Path>) -> Self {
self.layer(crate::layer::dotenv_path(path))
}
pub fn from_map(
iter: impl IntoIterator<Item = (impl Into<String>, impl Into<String>)>,
) -> Self {
Self::new()
.layer(crate::layer::env())
.layer(crate::layer::map(iter))
}
pub fn load(self) -> Result<Env, Error> {
let mut values: HashMap<String, Box<dyn Any>> = HashMap::new();
let mut errors: Vec<Error> = Vec::new();
for var in &self.vars {
let raw = if self.layers.is_empty() {
std::env::var(var.name()).ok()
} else {
self.lookup_in_layers(var.name())
};
match var.resolve_raw(raw.as_deref()) {
Ok(Some(v)) => {
values.insert(var.name().to_owned(), v);
}
Ok(None) => {}
Err(e) => {
errors.push(e);
}
}
}
if errors.is_empty() {
Ok(Env { values })
} else if errors.len() == 1 {
Err(errors.into_iter().next().expect("len == 1"))
} else {
Err(Error::multiple(errors))
}
}
fn lookup_in_layers(&self, name: &str) -> Option<String> {
for layer in &self.layers {
if let Some(value) = layer.lookup(name) {
return Some(value);
}
}
None
}
#[must_use]
pub fn load_or_exit(self) -> Env {
match self.load() {
Ok(env) => env,
Err(err) => {
#[cfg(feature = "miette")]
{
let report: miette::Report = err.into();
eprintln!("{report:?}");
}
#[cfg(not(feature = "miette"))]
{
eprintln!("{err}");
}
std::process::exit(1);
}
}
}
}
impl Default for EnvSource {
fn default() -> Self {
Self::new()
}
}
pub struct Env {
values: HashMap<String, Box<dyn Any>>,
}
impl Env {
pub fn get<T: 'static>(&self, name: &str) -> Result<&T, Error> {
let value = self
.values
.get(name)
.ok_or_else(|| Error::not_found(name))?;
value
.downcast_ref::<T>()
.ok_or_else(|| Error::not_found(name))
}
#[must_use]
pub fn contains(&self, name: &str) -> bool {
self.values.contains_key(name)
}
}
impl fmt::Debug for Env {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let keys: Vec<&String> = self.values.keys().collect();
f.debug_struct("Env").field("keys", &keys).finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::validate;
#[test]
fn loads_value_from_env() {
unsafe {
std::env::set_var("EVIGIL_T1_PORT", "9090");
}
let cfg = EnvSource::new()
.declare(VarBuilder::new("EVIGIL_T1_PORT", |v| {
v.parse::<u16>().map_err(|e| e.to_string())
}))
.load()
.unwrap();
assert_eq!(*cfg.get::<u16>("EVIGIL_T1_PORT").unwrap(), 9090);
unsafe {
std::env::remove_var("EVIGIL_T1_PORT");
}
}
#[test]
fn applies_prefix() {
unsafe {
std::env::set_var("MYAPP_PORT", "7070");
}
let cfg = EnvSource::new()
.prefix("MYAPP_")
.declare(VarBuilder::new("PORT", |v| {
v.parse::<u16>().map_err(|e| e.to_string())
}))
.load()
.unwrap();
assert_eq!(*cfg.get::<u16>("MYAPP_PORT").unwrap(), 7070);
unsafe {
std::env::remove_var("MYAPP_PORT");
}
}
#[test]
fn default_when_absent() {
let cfg = EnvSource::new()
.declare(
VarBuilder::new("EVIGIL_T3_MISSING", |v| {
v.parse::<u16>().map_err(|e| e.to_string())
})
.default(3000),
)
.load()
.unwrap();
assert_eq!(*cfg.get::<u16>("EVIGIL_T3_MISSING").unwrap(), 3000);
}
#[test]
fn optional_absent_is_not_in_env() {
let cfg = EnvSource::new()
.declare(VarBuilder::new("EVIGIL_T4_NOPE", |v| Ok(v.to_owned())))
.load()
.unwrap();
assert!(!cfg.contains("EVIGIL_T4_NOPE"));
assert!(cfg.get::<String>("EVIGIL_T4_NOPE").is_err());
}
#[test]
fn required_missing_is_error() {
let err = EnvSource::new()
.declare(VarBuilder::new("EVIGIL_T5_REQUIRED", |v| Ok(v.to_owned())).required())
.load()
.unwrap_err();
let msg = err.to_string();
assert!(msg.contains("EVIGIL_T5_REQUIRED"), "message: {msg}");
}
#[test]
fn multiple_errors_collected() {
let err = EnvSource::new()
.declare(VarBuilder::new("EVIGIL_T6_A", |v| Ok(v.to_owned())).required())
.declare(VarBuilder::new("EVIGIL_T6_B", |v| Ok(v.to_owned())).required())
.load()
.unwrap_err();
let msg = err.to_string();
assert!(msg.contains("2 errors"), "message: {msg}");
assert!(msg.contains("EVIGIL_T6_A"), "message: {msg}");
assert!(msg.contains("EVIGIL_T6_B"), "message: {msg}");
}
#[test]
fn contains_returns_true_for_loaded() {
let cfg = EnvSource::new()
.declare(VarBuilder::new("EVIGIL_T9_X", |v| Ok(v.to_owned())).default("yes".to_owned()))
.load()
.unwrap();
assert!(cfg.contains("EVIGIL_T9_X"));
assert!(!cfg.contains("EVIGIL_T9_Y"));
}
#[test]
fn from_map_loads_value() {
let cfg = EnvSource::from_map([("EVIGIL_FM1_PORT", "9090")])
.declare(VarBuilder::new("EVIGIL_FM1_PORT", |v| {
v.parse::<u16>().map_err(|e| e.to_string())
}))
.load()
.unwrap();
assert_eq!(*cfg.get::<u16>("EVIGIL_FM1_PORT").unwrap(), 9090);
}
#[test]
fn from_map_with_prefix() {
let cfg = EnvSource::from_map([("MYAPP_PORT", "7070")])
.prefix("MYAPP_")
.declare(VarBuilder::new("PORT", |v| {
v.parse::<u16>().map_err(|e| e.to_string())
}))
.load()
.unwrap();
assert_eq!(*cfg.get::<u16>("MYAPP_PORT").unwrap(), 7070);
}
#[test]
fn from_map_env_wins_over_map() {
unsafe {
std::env::set_var("EVIGIL_FM3_PORT", "1111");
}
let cfg = EnvSource::from_map([("EVIGIL_FM3_PORT", "9090")])
.declare(VarBuilder::new("EVIGIL_FM3_PORT", |v| {
v.parse::<u16>().map_err(|e| e.to_string())
}))
.load()
.unwrap();
assert_eq!(*cfg.get::<u16>("EVIGIL_FM3_PORT").unwrap(), 1111);
unsafe {
std::env::remove_var("EVIGIL_FM3_PORT");
}
}
#[test]
fn from_map_wins_over_default() {
let cfg = EnvSource::from_map([("EVIGIL_FM4_PORT", "9090")])
.declare(
VarBuilder::new("EVIGIL_FM4_PORT", |v| {
v.parse::<u16>().map_err(|e| e.to_string())
})
.default(3000),
)
.load()
.unwrap();
assert_eq!(*cfg.get::<u16>("EVIGIL_FM4_PORT").unwrap(), 9090);
}
#[test]
fn from_map_multiple_vars() {
let cfg = EnvSource::from_map([("EVIGIL_FM5_A", "1"), ("EVIGIL_FM5_B", "two")])
.declare(VarBuilder::new("EVIGIL_FM5_A", |v| {
v.parse::<u32>().map_err(|e| e.to_string())
}))
.declare(VarBuilder::new("EVIGIL_FM5_B", |v| Ok(v.to_owned())))
.load()
.unwrap();
assert_eq!(*cfg.get::<u32>("EVIGIL_FM5_A").unwrap(), 1);
assert_eq!(cfg.get::<String>("EVIGIL_FM5_B").unwrap(), "two");
}
#[test]
fn from_map_secret() {
let cfg = EnvSource::from_map([("EVIGIL_FM6_TOKEN", "hunter2")])
.declare(VarBuilder::new("EVIGIL_FM6_TOKEN", |v| Ok(v.to_owned())).secret())
.load()
.unwrap();
let token = cfg.get::<Secret<String>>("EVIGIL_FM6_TOKEN").unwrap();
assert_eq!(token.expose(), "hunter2");
assert_eq!(format!("{token:?}"), "Secret([REDACTED])");
assert!(cfg.get::<String>("EVIGIL_FM6_TOKEN").is_err());
}
#[test]
fn from_map_validation() {
let err = EnvSource::from_map([("EVIGIL_FM7_PORT", "0")])
.declare(
VarBuilder::new("EVIGIL_FM7_PORT", |v| {
v.parse::<u16>().map_err(|e| e.to_string())
})
.validate(validate::range(1..=65535)),
)
.load()
.unwrap_err();
let msg = err.to_string();
assert!(msg.contains("out of range"), "message: {msg}");
}
#[test]
fn from_map_required_missing() {
let err = EnvSource::from_map([("EVIGIL_FM8_OTHER", "x")])
.declare(VarBuilder::new("EVIGIL_FM8_REQUIRED", |v| Ok(v.to_owned())).required())
.load()
.unwrap_err();
let msg = err.to_string();
assert!(msg.contains("EVIGIL_FM8_REQUIRED"), "message: {msg}");
}
}