use crate::error::{Error, ValidationError};
use crate::validate::Validator;
type Parser<T> = Box<dyn Fn(&str) -> Result<T, String>>;
pub struct VarBuilder<T> {
name: String,
parser: Parser<T>,
default: Option<T>,
required: bool,
secret: bool,
validators: Vec<Box<dyn Validator<T>>>,
}
impl<T> VarBuilder<T>
where
T: Clone + 'static,
{
pub fn new(
name: impl Into<String>,
parser: impl Fn(&str) -> Result<T, String> + 'static,
) -> Self {
Self {
name: name.into(),
parser: Box::new(parser),
default: None,
required: false,
secret: false,
validators: Vec::new(),
}
}
pub fn default(mut self, value: T) -> Self {
self.default = Some(value);
self
}
pub fn required(mut self) -> Self {
self.required = true;
self
}
pub fn secret(mut self) -> Self {
self.secret = true;
self
}
pub fn validate(mut self, validator: impl Validator<T> + 'static) -> Self {
self.validators.push(Box::new(validator));
self
}
pub fn validate_with(mut self, f: impl Fn(&T) -> Result<(), String> + 'static) -> Self {
self.validators.push(Box::new(f));
self
}
pub fn name(&self) -> &str {
&self.name
}
pub fn is_secret(&self) -> bool {
self.secret
}
pub fn resolve(&self, raw: Option<&str>) -> Result<Option<T>, Error> {
let value = match raw {
Some(s) => {
let parsed = (self.parser)(s).map_err(|msg| Error::parse(&self.name, s, msg))?;
self.run_validators(&parsed)?;
parsed
}
None => {
if let Some(d) = &self.default {
d.clone()
} else if self.required {
return Err(Error::missing(&self.name));
} else {
return Ok(None);
}
}
};
Ok(Some(value))
}
fn run_validators(&self, value: &T) -> Result<(), Error> {
let mut errors = Vec::new();
for v in &self.validators {
if let Err(msg) = v.validate(value) {
errors.push(ValidationError::new(&self.name, msg));
}
}
if errors.is_empty() {
Ok(())
} else {
Err(Error::validation(errors))
}
}
pub fn prefixed(mut self, prefix: &str) -> Self {
if !prefix.is_empty() {
self.name = format!("{prefix}{}", self.name);
}
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::validate;
fn port_var() -> VarBuilder<u16> {
VarBuilder::new("PORT", |s| s.parse::<u16>().map_err(|e| e.to_string()))
}
#[test]
fn resolves_raw_value() {
let var = port_var();
assert_eq!(var.resolve(Some("3000")).unwrap(), Some(3000));
}
#[test]
fn falls_back_to_default() {
let var = port_var().default(8080);
assert_eq!(var.resolve(None).unwrap(), Some(8080));
}
#[test]
fn missing_required_is_error() {
let var = port_var().required();
let err = var.resolve(None).unwrap_err();
assert!(matches!(err.kind(), crate::error::ErrorKind::Missing { name } if name == "PORT"));
}
#[test]
fn missing_optional_is_none() {
let var = port_var();
assert_eq!(var.resolve(None).unwrap(), None);
}
#[test]
fn parse_error_includes_name_and_raw() {
let var = port_var();
let err = var.resolve(Some("abc")).unwrap_err();
let msg = err.to_string();
assert!(msg.contains("PORT"), "message: {msg}");
assert!(msg.contains("abc"), "message: {msg}");
}
#[test]
fn validation_error() {
let var = port_var().validate(validate::range(1..=65535));
let err = var.resolve(Some("0")).unwrap_err();
let msg = err.to_string();
assert!(msg.contains("PORT"), "message: {msg}");
assert!(msg.contains("out of range"), "message: {msg}");
}
#[test]
fn multiple_validators_accumulate() {
let var = VarBuilder::new("EMAIL", |s| Ok(s.to_owned()))
.validate(validate::not_empty())
.validate(validate::contains("@"));
let err = var.resolve(Some("")).unwrap_err();
let msg = err.to_string();
assert!(msg.contains("2 errors"), "message: {msg}");
}
#[test]
fn validate_with_closure() {
let var = VarBuilder::new("N", |s| s.parse::<u32>().map_err(|e| e.to_string()))
.validate_with(|n| {
if *n % 2 == 0 {
Ok(())
} else {
Err("must be even".to_owned())
}
});
assert!(var.resolve(Some("4")).unwrap().is_some());
assert!(var.resolve(Some("3")).is_err());
}
#[test]
fn secret_flag() {
let var = VarBuilder::new("TOKEN", |s| Ok(s.to_owned())).secret();
assert!(var.is_secret());
assert!(!port_var().is_secret());
}
#[test]
fn name_accessor() {
assert_eq!(port_var().name(), "PORT");
}
#[test]
fn default_overrides_missing_but_not_present() {
let var = port_var().default(8080);
assert_eq!(var.resolve(Some("9090")).unwrap(), Some(9090));
}
}