baskerville 0.3.0

Infer and validate data-type schemas in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use crate::Validator;

#[derive(Default, Debug, Clone)]
pub struct Integer {
    pub min_value: Option<i128>,
    pub max_value: Option<i128>,
    pub leading_plus: bool,
}

impl Validator for Integer {
    fn validate(&mut self, value: &str) -> bool {
        let parsed = value.parse::<i128>();
        if let Ok(parsed) = parsed {
            self.min_value = self
                .min_value
                .map_or(Some(parsed), |min| Some(std::cmp::min(min, parsed)));
            self.max_value = self
                .max_value
                .map_or(Some(parsed), |max| Some(std::cmp::max(max, parsed)));
            self.leading_plus |= value.starts_with('+');
        }
        parsed.is_ok()
    }
}

#[derive(Default, Debug, Clone)]
pub struct Float {
    pub min_value: Option<f64>,
    pub max_value: Option<f64>,
    pub leading_plus: bool,
    pub e_notation: bool,
}

impl Validator for Float {
    fn validate(&mut self, value: &str) -> bool {
        let parsed = value.parse::<f64>();
        if let Ok(parsed) = parsed {
            self.min_value = self
                .min_value
                .map_or(Some(parsed), |min| Some(min.min(parsed)));
            self.max_value = self
                .max_value
                .map_or(Some(parsed), |max| Some(max.max(parsed)));
            self.leading_plus |= value.starts_with('+');
            self.e_notation |= value.contains('e');
        }
        parsed.is_ok()
    }
}

#[cfg(test)]
mod test {
    use crate::{Float, Integer, Validator};

    #[test]
    fn integer() {
        let mut validator = Integer::default();
        assert!(validator.validate("2"));
        assert!(validator.validate("1"));
        assert!(!validator.validate("Ferris"));
        assert_eq!(validator.min_value, Some(1));
        assert!(validator.validate("-1"));
        assert_eq!(validator.min_value, Some(-1));
        assert_eq!(validator.max_value, Some(2));
    }

    #[test]
    fn float() {
        let mut validator = Float::default();
        assert!(validator.validate("0.1"));
        assert!(validator.validate("1.1"));
        assert_eq!(validator.min_value, Some(0.1));
        assert_eq!(validator.max_value, Some(1.1));
        assert!(validator.validate("-1"));
        assert_eq!(validator.min_value, Some(-1.0));
        assert!(!validator.validate("Ferris"));
    }
}