tanzim-parse 0.5.0

Parse configuration bytes into tanzim-value trees
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! Custom parser backed by a closure.
//!
//! # Example
//!
//! ```
//! use tanzim_parse::{closure::Closure, Deserialize};
//! use tanzim_value::{LocatedValue, Location, Value};
//!
//! let parser = Closure::new(
//!     "upper",
//!     "txt",
//!     Box::new(|source, resource, bytes| {
//!         Ok(LocatedValue {
//!             value: Value::String(String::from_utf8_lossy(bytes).to_uppercase()),
//!             location: Location::at(source, resource, None, None, None),
//!         })
//!     }),
//! );
//! let value = parser.parse("file", "test.txt", b"hello").unwrap();
//! assert_eq!(value.value.as_string().unwrap(), "HELLO");
//! ```

use crate::Deserialize;
use tanzim_value::{Error, LocatedValue};

pub type BoxedParseFn = Box<dyn Fn(&str, &str, &[u8]) -> Result<LocatedValue, Error>>;
pub type BoxedValidatorFn = Box<dyn Fn(&[u8]) -> Option<bool>>;

pub struct Closure {
    name: String,
    parser: BoxedParseFn,
    validator: BoxedValidatorFn,
    supported_format_list: Vec<String>,
}

impl Closure {
    pub fn new<N: AsRef<str>, F: AsRef<str>>(
        name: N,
        supported_format: F,
        parser: BoxedParseFn,
    ) -> Self {
        Self {
            name: name.as_ref().to_string(),
            parser,
            validator: Box::new(|_| None),
            supported_format_list: vec![supported_format.as_ref().to_string()],
        }
    }

    pub fn with_validator(mut self, validator: BoxedValidatorFn) -> Self {
        self.validator = validator;
        self
    }

    pub fn with_format_list<N: AsRef<str>>(mut self, format_list: &[N]) -> Self {
        let mut formats = Vec::new();
        for format in format_list {
            formats.push(format.as_ref().to_string());
        }
        self.supported_format_list = formats;
        self
    }
}

impl Deserialize for Closure {
    fn name(&self) -> &str {
        self.name.as_str()
    }

    fn supported_format_list(&self) -> Vec<String> {
        self.supported_format_list.clone()
    }

    fn parse(&self, source: &str, resource: &str, bytes: &[u8]) -> Result<LocatedValue, Error> {
        (self.parser)(source, resource, bytes)
    }

    fn is_format_supported(&self, bytes: &[u8]) -> Option<bool> {
        (self.validator)(bytes)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tanzim_value::{Location, Value};

    #[test]
    fn closure_parser_delegates_to_function() {
        let parser = Closure::new(
            "upper",
            "txt",
            Box::new(|source, resource, bytes| {
                Ok(LocatedValue {
                    value: Value::String(String::from_utf8_lossy(bytes).to_uppercase()),
                    location: Location::at(source, resource, None, None, None),
                })
            }),
        )
        .with_validator(Box::new(|bytes| Some(!bytes.is_empty())));
        let parsed = parser.parse("file", "test.txt", b"hello").unwrap();
        assert_eq!(parsed.value.as_string().unwrap(), "HELLO");
        assert_eq!(parser.is_format_supported(b"x"), Some(true));
        assert_eq!(parser.is_format_supported(b""), Some(false));
    }
}