pub trait Layer {
fn lookup(&self, name: &str) -> Option<String>;
}
impl<F> Layer for F
where
F: Fn(&str) -> Option<String>,
{
fn lookup(&self, name: &str) -> Option<String> {
(self)(name)
}
}
#[derive(Debug, Clone, Copy)]
pub struct EnvLayer;
pub fn env() -> EnvLayer {
EnvLayer
}
impl Layer for EnvLayer {
fn lookup(&self, name: &str) -> Option<String> {
std::env::var(name).ok()
}
}
#[derive(Debug, Clone)]
pub struct MapLayer {
entries: Vec<(String, String)>,
}
pub fn map(iter: impl IntoIterator<Item = (impl Into<String>, impl Into<String>)>) -> MapLayer {
MapLayer {
entries: iter
.into_iter()
.map(|(k, v)| (k.into(), v.into()))
.collect(),
}
}
pub fn map_from(
iter: impl IntoIterator<Item = (impl Into<String>, impl Into<String>)>,
) -> MapLayer {
map(iter)
}
impl Layer for MapLayer {
fn lookup(&self, name: &str) -> Option<String> {
self.entries
.iter()
.find(|(k, _)| k == name)
.map(|(_, v)| v.clone())
}
}
#[cfg(feature = "dotenv")]
mod dotenv_layer {
use super::Layer;
#[derive(Debug, Clone)]
pub struct DotenvLayer {
entries: Vec<(String, String)>,
}
pub fn dotenv() -> DotenvLayer {
dotenv_path(".env")
}
pub fn dotenv_path(path: impl AsRef<std::path::Path>) -> DotenvLayer {
let entries = match std::fs::read_to_string(path) {
Ok(content) => crate::dotenv::parse(&content),
Err(_) => Vec::new(),
};
DotenvLayer { entries }
}
impl Layer for DotenvLayer {
fn lookup(&self, name: &str) -> Option<String> {
self.entries
.iter()
.find(|(k, _)| k == name)
.map(|(_, v)| v.clone())
}
}
}
#[cfg(feature = "dotenv")]
pub use dotenv_layer::{DotenvLayer, dotenv, dotenv_path};
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn env_layer_reads_real_env() {
unsafe {
std::env::set_var("EVIGIL_LAYER_TEST_VAR", "hello");
}
let l = env();
assert_eq!(l.lookup("EVIGIL_LAYER_TEST_VAR"), Some("hello".to_owned()));
assert_eq!(l.lookup("EVIGIL_LAYER_NONEXISTENT"), None);
unsafe {
std::env::remove_var("EVIGIL_LAYER_TEST_VAR");
}
}
#[test]
fn map_layer_basic() {
let l = map([("A", "1"), ("B", "2")]);
assert_eq!(l.lookup("A"), Some("1".to_owned()));
assert_eq!(l.lookup("B"), Some("2".to_owned()));
assert_eq!(l.lookup("C"), None);
}
#[test]
fn map_layer_empty() {
let l = map(std::iter::empty::<(&str, &str)>());
assert_eq!(l.lookup("ANYTHING"), None);
}
#[test]
fn closure_as_layer() {
let l = |name: &str| -> Option<String> {
if name == "X" {
Some("found".to_owned())
} else {
None
}
};
assert_eq!(l.lookup("X"), Some("found".to_owned()));
assert_eq!(l.lookup("Y"), None);
}
#[cfg(feature = "dotenv")]
#[test]
fn dotenv_layer_missing_file_is_empty() {
let l = dotenv_path("/nonexistent/envigil_test/.env");
assert_eq!(l.lookup("ANYTHING"), None);
}
}