rip-settings 0.1.2

Core runtime for rip-settings - repository, backends, validation, backup, migration, undo/redo, reset
Documentation
use crate::field::ValidationRules;

#[derive(Clone, Debug, PartialEq)]
pub enum ValidationResult {
    Valid,
    Invalid(String),
}

impl ValidationResult {
    #[must_use]
    pub fn is_valid(&self) -> bool {
        matches!(self, Self::Valid)
    }
}

pub fn validate_value(value: &serde_json::Value, rules: &ValidationRules) -> ValidationResult {
    if rules.required {
        let is_empty = match value {
            serde_json::Value::Null => true,
            serde_json::Value::String(s) => s.trim().is_empty(),
            serde_json::Value::Array(a) => a.is_empty(),
            _ => false,
        };
        if is_empty {
            return ValidationResult::Invalid(
                rules
                    .error_message
                    .clone()
                    .unwrap_or_else(|| "This field is required".into()),
            );
        }
    }

    if let Some((min, max)) = rules.range {
        if let Some(num) = value.as_f64() {
            if num < min || num > max {
                return ValidationResult::Invalid(
                    rules
                        .error_message
                        .clone()
                        .unwrap_or_else(|| format!("Value must be between {} and {}", min, max)),
                );
            }
        }
    }

    if let Some((min_len, max_len)) = rules.length {
        if let Some(s) = value.as_str() {
            let len = s.chars().count();
            if len < min_len || len > max_len {
                return ValidationResult::Invalid(rules.error_message.clone().unwrap_or_else(
                    || format!("Length must be between {} and {}", min_len, max_len),
                ));
            }
        }
    }

    if let Some(ref pattern) = rules.pattern {
        if let Some(s) = value.as_str() {
            match regex::Regex::new(pattern) {
                Ok(re) => {
                    if !re.is_match(s) {
                        return ValidationResult::Invalid(
                            rules
                                .error_message
                                .clone()
                                .unwrap_or_else(|| "Value does not match required pattern".into()),
                        );
                    }
                }
                Err(e) => {
                    return ValidationResult::Invalid(format!("Invalid validation pattern: {}", e));
                }
            }
        }
    }

    ValidationResult::Valid
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_required_validation() {
        let rules = ValidationRules {
            required: true,
            ..Default::default()
        };

        assert_eq!(
            validate_value(&serde_json::Value::Null, &rules),
            ValidationResult::Invalid("This field is required".into())
        );

        assert_eq!(
            validate_value(&serde_json::json!("hello"), &rules),
            ValidationResult::Valid
        );

        assert_eq!(
            validate_value(&serde_json::json!(""), &rules),
            ValidationResult::Invalid("This field is required".into())
        );
    }

    #[test]
    fn test_range_validation() {
        let rules = ValidationRules {
            range: Some((0.0, 100.0)),
            ..Default::default()
        };

        assert_eq!(
            validate_value(&serde_json::json!(50), &rules),
            ValidationResult::Valid
        );
        assert_eq!(
            validate_value(&serde_json::json!(150), &rules),
            ValidationResult::Invalid("Value must be between 0 and 100".into())
        );
        assert_eq!(
            validate_value(&serde_json::json!(-1), &rules),
            ValidationResult::Invalid("Value must be between 0 and 100".into())
        );
    }

    #[test]
    fn test_length_validation_char_count() {
        let rules = ValidationRules {
            length: Some((3, 10)),
            ..Default::default()
        };

        assert_eq!(
            validate_value(&serde_json::json!("hello"), &rules),
            ValidationResult::Valid
        );
        assert_eq!(
            validate_value(&serde_json::json!("hi"), &rules),
            ValidationResult::Invalid("Length must be between 3 and 10".into())
        );
        assert_eq!(
            validate_value(&serde_json::json!("🎉"), &rules),
            ValidationResult::Invalid("Length must be between 3 and 10".into())
        );
        assert_eq!(
            validate_value(&serde_json::json!("café"), &rules),
            ValidationResult::Valid
        );
    }

    #[test]
    fn test_pattern_validation() {
        let rules = ValidationRules {
            pattern: Some(r"^\d{3}-\d{4}$".into()),
            ..Default::default()
        };

        assert_eq!(
            validate_value(&serde_json::json!("123-4567"), &rules),
            ValidationResult::Valid
        );
        assert_eq!(
            validate_value(&serde_json::json!("abc"), &rules),
            ValidationResult::Invalid("Value does not match required pattern".into())
        );
    }

    #[test]
    fn test_custom_error_message() {
        let rules = ValidationRules {
            range: Some((0.0, 10.0)),
            error_message: Some("Custom error".into()),
            ..Default::default()
        };

        assert_eq!(
            validate_value(&serde_json::json!(20), &rules),
            ValidationResult::Invalid("Custom error".into())
        );
    }
}