flowcore/deserializers/
yaml_deserializer.rs

1use std::marker::PhantomData;
2
3use serde::de::DeserializeOwned;
4use url::Url;
5
6use crate::errors::*;
7
8use super::deserializer::Deserializer;
9
10/// Struct representing a Generic deserializer of content stored in Yaml format
11#[derive(Default)]
12pub struct YamlDeserializer<T>
13where
14    T: DeserializeOwned,
15{
16    t: PhantomData<T>,
17}
18
19impl<T> YamlDeserializer<T>
20where
21    T: DeserializeOwned,
22{
23    /// Create a new YamlDeserializer
24    pub fn new() -> Self {
25        YamlDeserializer { t: PhantomData }
26    }
27}
28
29impl<'a, T> Deserializer<'a, T> for YamlDeserializer<T>
30where
31    T: DeserializeOwned,
32{
33    fn deserialize(&self, contents: &'a str, url: Option<&Url>) -> Result<T> {
34        serde_yaml::from_str(contents).chain_err(|| {
35            format!(
36                "Error deserializing Yaml from: '{}'",
37                url.map_or("URL was None".to_owned(), |u| u.to_string())
38            )
39        })
40    }
41
42    fn name(&self) -> &str {
43        "Yaml"
44    }
45}
46
47#[cfg(test)]
48mod test {
49    use serde_derive::{Deserialize, Serialize};
50    use serde_yaml::Error;
51
52    use crate::model::metadata::MetaData;
53
54    use super::super::deserializer::Deserializer;
55    use super::YamlDeserializer;
56
57    #[derive(Serialize, Deserialize, Debug, Clone)]
58    pub struct TestStruct {
59        name: String,
60    }
61
62    #[test]
63    fn invalid_yaml() {
64        let deserializer = YamlDeserializer::<TestStruct>::new();
65
66        assert!(
67            deserializer.deserialize("{}", None).is_err(),
68            "Should not have parsed correctly as is invalid Yaml"
69        );
70    }
71
72    #[test]
73    fn flow() {
74        let flow_with_name = "
75name: 'hello-world-simple-toml'
76";
77
78        let deserializer = YamlDeserializer::<TestStruct>::new();
79
80        assert!(
81            deserializer.deserialize(flow_with_name, None).is_ok(),
82            "Did not parse correctly but is valid Yaml"
83        );
84    }
85
86    #[test]
87    fn metadata() {
88        let metadata = "\
89name: \"me\"
90version: \"1.1.1\"
91description: \"ok\"
92authors: [\"Andrew <andrew@foo.com>\"]
93    ";
94
95        let result: Result<MetaData, Error> = serde_yaml::from_str(metadata);
96        match result {
97            Ok(md) => {
98                assert_eq!(md.name, "me".to_string());
99                assert_eq!(md.version, "1.1.1".to_string());
100                assert_eq!(md.description, "ok".to_string());
101                assert_eq!(md.authors, vec!("Andrew <andrew@foo.com>".to_string()));
102            }
103            Err(e) => panic!("Deserialization error: {e:?}"),
104        }
105    }
106}