use std::fmt;
use std::ops::RangeInclusive;
pub trait Validator<T: ?Sized> {
fn validate(&self, value: &T) -> Result<(), String>;
}
impl<T: ?Sized, F> Validator<T> for F
where
F: Fn(&T) -> Result<(), String>,
{
fn validate(&self, value: &T) -> Result<(), String> {
self(value)
}
}
#[derive(Debug, Clone)]
pub struct RangeValidator<T> {
range: RangeInclusive<T>,
description: String,
}
pub fn range<T>(range: RangeInclusive<T>) -> RangeValidator<T>
where
T: PartialOrd + Clone + fmt::Display,
{
let description = format!("{}..={}", range.start(), range.end());
RangeValidator { range, description }
}
impl<T> Validator<T> for RangeValidator<T>
where
T: PartialOrd + Clone + fmt::Display,
{
fn validate(&self, value: &T) -> Result<(), String> {
if self.range.contains(value) {
Ok(())
} else {
Err(format!(
"value {value} is out of range {}",
self.description
))
}
}
}
#[derive(Debug, Clone, Copy)]
pub struct NotEmpty;
pub fn not_empty() -> NotEmpty {
NotEmpty
}
impl Validator<String> for NotEmpty {
fn validate(&self, value: &String) -> Result<(), String> {
if value.is_empty() {
Err("must not be empty".to_owned())
} else {
Ok(())
}
}
}
impl Validator<str> for NotEmpty {
fn validate(&self, value: &str) -> Result<(), String> {
if value.is_empty() {
Err("must not be empty".to_owned())
} else {
Ok(())
}
}
}
#[derive(Debug, Clone)]
pub struct Contains {
substring: String,
}
pub fn contains(substring: impl Into<String>) -> Contains {
Contains {
substring: substring.into(),
}
}
impl Validator<String> for Contains {
fn validate(&self, value: &String) -> Result<(), String> {
if value.contains(&self.substring) {
Ok(())
} else {
Err(format!("must contain {:?}", self.substring))
}
}
}
#[derive(Debug, Clone)]
pub struct StartsWith {
prefix: String,
}
pub fn starts_with(prefix: impl Into<String>) -> StartsWith {
StartsWith {
prefix: prefix.into(),
}
}
impl Validator<String> for StartsWith {
fn validate(&self, value: &String) -> Result<(), String> {
if value.starts_with(&self.prefix) {
Ok(())
} else {
Err(format!("must start with {:?}", self.prefix))
}
}
}
#[derive(Debug, Clone)]
pub struct EndsWith {
suffix: String,
}
pub fn ends_with(suffix: impl Into<String>) -> EndsWith {
EndsWith {
suffix: suffix.into(),
}
}
impl Validator<String> for EndsWith {
fn validate(&self, value: &String) -> Result<(), String> {
if value.ends_with(&self.suffix) {
Ok(())
} else {
Err(format!("must end with {:?}", self.suffix))
}
}
}
#[derive(Debug, Clone)]
pub struct LengthValidator {
range: RangeInclusive<usize>,
description: String,
}
pub fn length(range: RangeInclusive<usize>) -> LengthValidator {
let description = format!("{}..={}", range.start(), range.end());
LengthValidator { range, description }
}
impl LengthValidator {
fn check_len(&self, len: usize) -> Result<(), String> {
if self.range.contains(&len) {
Ok(())
} else {
Err(format!("length {len} is out of range {}", self.description))
}
}
}
impl Validator<String> for LengthValidator {
fn validate(&self, value: &String) -> Result<(), String> {
self.check_len(value.len())
}
}
impl Validator<str> for LengthValidator {
fn validate(&self, value: &str) -> Result<(), String> {
self.check_len(value.len())
}
}
impl<T> Validator<Vec<T>> for LengthValidator {
fn validate(&self, value: &Vec<T>) -> Result<(), String> {
self.check_len(value.len())
}
}
#[derive(Debug, Clone, Copy)]
pub struct Ip;
pub fn ip() -> Ip {
Ip
}
impl Validator<String> for Ip {
fn validate(&self, value: &String) -> Result<(), String> {
if value.parse::<std::net::IpAddr>().is_ok() {
Ok(())
} else {
Err("must be a valid IP address".to_owned())
}
}
}
impl Validator<str> for Ip {
fn validate(&self, value: &str) -> Result<(), String> {
if value.parse::<std::net::IpAddr>().is_ok() {
Ok(())
} else {
Err("must be a valid IP address".to_owned())
}
}
}
#[derive(Debug, Clone, Copy)]
pub struct FileExists;
pub fn file_exists() -> FileExists {
FileExists
}
impl Validator<String> for FileExists {
fn validate(&self, value: &String) -> Result<(), String> {
if std::path::Path::new(value).exists() {
Ok(())
} else {
Err("file does not exist".to_owned())
}
}
}
impl Validator<std::path::PathBuf> for FileExists {
fn validate(&self, value: &std::path::PathBuf) -> Result<(), String> {
if value.exists() {
Ok(())
} else {
Err("file does not exist".to_owned())
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn range_accepts_in_bounds() {
let v = range(1..=65535);
assert!(v.validate(&1u16).is_ok());
assert!(v.validate(&8080u16).is_ok());
assert!(v.validate(&65535u16).is_ok());
}
#[test]
fn range_rejects_out_of_bounds() {
let v = range(1..=65535);
assert!(v.validate(&0u16).is_err());
}
#[test]
fn range_error_message() {
let v = range(1..=100);
let msg = v.validate(&200).unwrap_err();
assert!(msg.contains("200"), "message: {msg}");
assert!(msg.contains("1..=100"), "message: {msg}");
}
#[test]
fn not_empty_accepts_nonempty() {
let v = not_empty();
assert!(v.validate(&"x".to_owned()).is_ok());
}
#[test]
fn not_empty_rejects_empty_string() {
let v = not_empty();
let msg = v.validate(&String::new()).unwrap_err();
assert_eq!(msg, "must not be empty");
}
#[test]
fn not_empty_rejects_empty_str() {
let v = not_empty();
assert!(v.validate("").is_err());
assert!(v.validate("ok").is_ok());
}
#[test]
fn contains_match() {
let v = contains("@");
assert!(v.validate(&"a@b.com".to_owned()).is_ok());
}
#[test]
fn contains_no_match() {
let v = contains("@");
let msg = v.validate(&"nope".to_owned()).unwrap_err();
assert!(msg.contains("@"), "message: {msg}");
}
#[test]
fn starts_with_match() {
let v = starts_with("postgres://");
assert!(v.validate(&"postgres://localhost".to_owned()).is_ok());
}
#[test]
fn starts_with_no_match() {
let v = starts_with("postgres://");
let msg = v.validate(&"mysql://localhost".to_owned()).unwrap_err();
assert!(msg.contains("postgres://"), "message: {msg}");
}
#[test]
fn ends_with_match() {
let v = ends_with(".rs");
assert!(v.validate(&"lib.rs".to_owned()).is_ok());
}
#[test]
fn ends_with_no_match() {
let v = ends_with(".rs");
let msg = v.validate(&"lib.py".to_owned()).unwrap_err();
assert!(msg.contains(".rs"), "message: {msg}");
}
#[test]
fn closure_validator() {
let even = |n: &u32| {
if n % 2 == 0 {
Ok(())
} else {
Err(format!("{n} is odd"))
}
};
assert!(even.validate(&4).is_ok());
assert_eq!(even.validate(&3).unwrap_err(), "3 is odd");
}
#[test]
fn works_as_trait_object() {
let validators: Vec<Box<dyn Validator<String>>> =
vec![Box::new(not_empty()), Box::new(contains("@"))];
let value = "user@example.com".to_owned();
for v in &validators {
assert!(v.validate(&value).is_ok());
}
let bad = String::new();
assert!(validators[0].validate(&bad).is_err());
}
#[test]
fn length_accepts_string_in_range() {
let v = length(1..=5);
assert!(v.validate(&"abc".to_owned()).is_ok());
assert!(v.validate(&"a".to_owned()).is_ok());
assert!(v.validate(&"abcde".to_owned()).is_ok());
}
#[test]
fn length_rejects_too_short() {
let v = length(2..=5);
assert!(v.validate(&"a".to_owned()).is_err());
assert!(v.validate(&String::new()).is_err());
}
#[test]
fn length_rejects_too_long() {
let v = length(1..=3);
assert!(v.validate(&"abcdef".to_owned()).is_err());
}
#[test]
fn length_works_on_str() {
let v = length(1..=5);
assert!(v.validate("abc").is_ok());
assert!(v.validate("").is_err());
}
#[test]
fn length_works_on_vec() {
let v = length(1..=3);
assert!(v.validate(&vec![1, 2]).is_ok());
assert!(v.validate(&Vec::<u8>::new()).is_err());
assert!(v.validate(&vec![1, 2, 3, 4]).is_err());
}
#[test]
fn length_error_message() {
let v = length(2..=5);
let msg = v.validate(&"a".to_owned()).unwrap_err();
assert!(msg.contains("length 1"), "message: {msg}");
assert!(msg.contains("2..=5"), "message: {msg}");
}
#[test]
fn ip_accepts_ipv4() {
let v = ip();
assert!(v.validate(&"127.0.0.1".to_owned()).is_ok());
assert!(v.validate(&"192.168.1.1".to_owned()).is_ok());
assert!(v.validate(&"0.0.0.0".to_owned()).is_ok());
}
#[test]
fn ip_accepts_ipv6() {
let v = ip();
assert!(v.validate(&"::1".to_owned()).is_ok());
assert!(v.validate(&"2001:db8::1".to_owned()).is_ok());
}
#[test]
fn ip_rejects_invalid() {
let v = ip();
assert!(v.validate(&"999.999.999.999".to_owned()).is_err());
assert!(v.validate(&"not-an-ip".to_owned()).is_err());
assert!(v.validate(&"1.2.3".to_owned()).is_err());
assert!(v.validate(&String::new()).is_err());
}
#[test]
fn ip_works_on_str() {
let v = ip();
assert!(v.validate("10.0.0.1").is_ok());
assert!(v.validate("nope").is_err());
}
#[test]
fn ip_error_message() {
let v = ip();
let msg = v.validate(&"bad".to_owned()).unwrap_err();
assert!(msg.contains("IP address"), "message: {msg}");
}
#[test]
fn file_exists_accepts_existing_path() {
let v = file_exists();
assert!(v.validate(&".".to_owned()).is_ok());
}
#[test]
fn file_exists_rejects_missing_path() {
let v = file_exists();
assert!(
v.validate(&"definitely_missing_envigil_file_xyz".to_owned())
.is_err()
);
}
#[test]
fn file_exists_error_message() {
let v = file_exists();
let msg = v
.validate(&"definitely_missing_envigil_file_xyz".to_owned())
.unwrap_err();
assert!(msg.contains("does not exist"), "message: {msg}");
}
#[test]
fn file_exists_works_on_pathbuf() {
let v = file_exists();
assert!(v.validate(&std::path::PathBuf::from(".")).is_ok());
assert!(
v.validate(&std::path::PathBuf::from(
"definitely_missing_envigil_file_xyz"
))
.is_err()
);
}
}