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 std::str::FromStr;

use bigdecimal::BigDecimal;
use peginator::PegParser;

use voml_error::{FileID, Result, Span, Validation, VomlError};

use crate::{
    parser::von::{IdentifierNode, TableNode, ValueNode, VonParser},
    Number, VonNode,
};

mod number;
mod table;
mod value;
mod von;

struct ParserState {
    ast: VonNode,
    file_id: FileID,
    text: String,
    errors: Vec<VomlError>,
}

pub struct Identifier {
    name: String,
    span: Span,
}

pub fn parse(text: &str, id: &FileID) -> Validation<VonNode> {
    match ParserState::parse_text(text.to_string(), id.clone()) {
        Ok(o) => Validation::Success { value: o.ast, diagnostics: o.errors },
        Err(e) => Validation::Failure { fatal: e, diagnostics: vec![] },
    }
}

fn into_hint(v: Option<IdentifierNode>) -> String {
    match v {
        Some(s) => s.string,
        None => String::new(),
    }
}

impl ParserState {
    pub fn parse_text(text: String, file_id: FileID) -> Result<Self> {
        let mut parser = Self { ast: Default::default(), file_id, text, errors: vec![] };
        parser.do_parse()?;
        Ok(parser)
    }

    fn do_parse(&mut self) -> Result {
        let value = VonParser::parse(&self.text)?.value;
        match value {
            ValueNode::NumberNode(v) => self.ast = v.into_von(),
            ValueNode::SpecialNode(v) => self.ast = v.into_von(),
            ValueNode::StringNode(v) => self.ast = v.into_von(),
            ValueNode::TableNode(_) => {
                todo!()
            }
        }
        return Ok(());
    }
}