von 0.0.0

Virtual 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

use crate::{
    parser::von::{NamespaceNode, NumberNode, SpecialNode, StringNode},
    Text,
};

use super::*;

impl ValueNode {
    pub fn into_von(self) -> VonNode {
        match self {
            ValueNode::SpecialNode(v) => v.into_von(),
            ValueNode::NumberNode(v) => v.into_von(),
            ValueNode::StringNode(v) => v.into_von(),
            ValueNode::TableNode(_) => {
                todo!()
            }
        }
    }
}
impl SpecialNode {
    pub fn into_von(self) -> VonNode {
        match self.string.as_str() {
            "true" => VonNode::Boolean(true),
            "false" => VonNode::Boolean(false),
            _ => VonNode::Keyword("default"),
        }
    }
}

impl NumberNode {
    pub fn into_von(self) -> VonNode {
        VonNode::Number(self.into_num())
    }

    pub fn into_num(self) -> Number {
        let value = BigDecimal::from_str(&self.num.string).unwrap_or_default();
        Number { hint: into_hint(self.hint), value }
    }
    pub fn into_identifier(self) -> Identifier {
        Identifier { name: self.num.string, span: self.position }
    }
}

impl StringNode {
    pub fn into_von(self) -> VonNode {
        VonNode::Text(self.into_str())
    }
    pub fn into_str(self) -> Text {
        Text { hint: into_hint(self.hint), value: Default::default() }
    }
}

impl IdentifierNode {
    pub fn into_identifier(self) -> Identifier {
        Identifier { name: self.string, span: self.position }
    }
}

impl NamespaceNode {
    pub fn into_namespace(self) -> Vec<Identifier> {
        self.path.into_iter().map(|v| v.into_identifier()).collect()
    }
}