nixify 0.2.0

A simple tool to parse existing configuration files into nix syntax
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
107
108
109

use super::{NixVariable, NixVariableValue, Parser};
use indexmap::IndexMap;
use yaml_rust2::{Yaml, YamlLoader};

pub struct YamlParser {}
impl YamlParser {
    pub fn new() -> YamlParser {
        YamlParser {}
    }
    fn parse_node(node: &Yaml) -> Option<Vec<NixVariable>> {
        match node {
            Yaml::Hash(hashmap) => hashmap
                .iter()
                .map(|f| {
                    Some(NixVariable {
                        name: f.0.to_owned().into_string()?,
                        value: YamlParser::parse_variable(f.1),
                    })
                })
                .collect(),
            _ => None,
        }
    }
    fn parse_variable(variable: &Yaml) -> NixVariableValue {
        match variable {
            Yaml::Real(r) => NixVariableValue::Number(r.to_owned().parse::<f64>().unwrap()),
            Yaml::String(s) => NixVariableValue::String(s.to_owned()),
            Yaml::Integer(i) => NixVariableValue::Number(*i as f64),
            Yaml::Boolean(b) => NixVariableValue::Boolean(*b),
            Yaml::Null => NixVariableValue::Null,
            Yaml::Array(a) => NixVariableValue::List(
                a.into_iter()
                    .map(|f| YamlParser::parse_variable(&f))
                    .collect(),
            ),
            Yaml::Hash(h) => NixVariableValue::AttributeSet(
                h.iter()
                    .map(|(key, value)| {
                        Some((
                            key.to_owned().into_string()?,
                            YamlParser::parse_variable(value),
                        ))
                    })
                    .collect::<Option<IndexMap<String, NixVariableValue>>>()
                    .unwrap(),
            ),
            _ => NixVariableValue::Null,
        }
    }
}

impl Parser for YamlParser {
    fn parse(&self, content: &str) -> Option<Vec<super::NixVariable>> {
        YamlParser::parse_node(&YamlLoader::load_from_str(content).ok()?[0])
    }
}

#[cfg(test)]
mod tests {
    use crate::parser::{yaml::YamlParser, NixVariable, NixVariableValue, Parser};
    use indexmap::IndexMap;

    #[test]
    fn test_yaml() {
        let parser = YamlParser::new();
        let yaml = "
foo:
    bar:
        a: 1
        b: 'test'
this:
    is:
        a:
            float: 0.1
# Comment
            ";
        let expected = vec![
            NixVariable::new(
                "foo",
                &NixVariableValue::AttributeSet(IndexMap::from([(
                    "bar".to_string(),
                    NixVariableValue::AttributeSet(IndexMap::from([
                        ("a".to_string(), NixVariableValue::Number(1.0)),
                        (
                            "b".to_string(),
                            NixVariableValue::String("test".to_string()),
                        ),
                    ])),
                )])),
            ),
            NixVariable::new(
                "this",
                &NixVariableValue::AttributeSet(IndexMap::from([(
                    "is".to_string(),
                    NixVariableValue::AttributeSet(IndexMap::from([(
                        "a".to_string(),
                        NixVariableValue::AttributeSet(IndexMap::from([(
                            "float".to_string(),
                            NixVariableValue::Number(0.1),
                        )])),
                    )])),
                )])),
            ),
        ];
        let parsed = parser.parse(&yaml);
        assert!(parsed.is_some());
        assert_eq!(parsed.unwrap(), expected)
    }
}