tyson 0.1.0

Typed Simple Object Notation
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

use pest::iterators::Pair;
use pest::Parser;
use crate::errors::TySONError;

use crate::value::{Primitive, TySONDocument, TySONValue};

#[derive(Parser)]
#[grammar = "tyson.pest"]
struct TysonParser;


pub fn deserialize(data: String) -> Result<TySONDocument, TySONError> {
    let pair = TysonParser::parse(Rule::document, data.as_str())?.next().ok_or(TySONError::unexpected_parsing())?;

    let mut result: TySONDocument = TySONDocument::new();

    fn deserialize_value(pair: Pair<Rule>) -> Result<TySONValue, TySONError> {
        return match pair.as_rule() {
            Rule::map => {
                let mut data: Vec<(Primitive, TySONValue)> = vec![];
                let mut prefix: String = String::new();
                for pair in pair.into_inner()
                {
                    match pair.as_rule() {
                        Rule::prefix => {
                            prefix = pair.as_str().to_string();
                        }
                        _ => {
                            let mut inner_rules = pair.into_inner();
                            if let TySONValue::Primitive(left) = deserialize_value(inner_rules.next().ok_or(TySONError::unexpected_parsing())?)? {
                                data.push((left, deserialize_value(inner_rules.next().ok_or(TySONError::unexpected_parsing())?)?))
                            }
                        }
                    }
                };
                Ok(TySONValue::Map(prefix, data))
            }
            Rule::vector => {
                {
                    let mut data: Vec<TySONValue> = vec![];
                    let mut prefix: String = String::new();
                    for pair in pair.into_inner()
                    {
                        match pair.as_rule() {
                            Rule::prefix => {
                                prefix = pair.as_str().to_string();
                            }
                            _ => {
                                data.push(deserialize_value(pair)?);
                            }
                        }
                    };
                    Ok(TySONValue::Vector(prefix, data))
                }
            }
            Rule::primitive => {
                let mut data: String = String::new();
                let mut prefix: String = String::new();
                for pair in pair.into_inner() {
                    match pair.as_rule() {
                        Rule::prefix => {
                            prefix = pair.as_str().to_string();
                        }
                        _ => {
                            data = pair.as_str().to_string();
                        }
                    }
                };
                Ok(TySONValue::Primitive(Primitive(prefix, data)))
            }
            _ => unreachable!()
        };
    }

    match pair.as_rule() {
        Rule::document => {
            for pair in pair.into_inner() {
                let mut inner_rules = pair.into_inner();
                match inner_rules.next() {
                    Some(v) => {
                        if let TySONValue::Primitive(key) = deserialize_value(v)? {
                            match inner_rules.next() {
                                Some(v) => {
                                    result.push((key, deserialize_value(v)?));
                                }
                                _ => unreachable!()
                            }
                        }
                    }
                    _ => {}
                }
            }
            Ok(result)
        }
        _ => unreachable!()
    }
}