brittle 0.1.1

Simple TOML parser in Rust
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 regex::Regex;

#[derive(PartialEq, Clone, Debug)]
pub enum Token {
    Punctuation(String),

    Scalar(String),

    Comment,
}

// Takes in a string seperated by newlines
// Returns a vector of vectors.
//     Each vector represents a line, containing tokens to be parsed
pub(crate) fn tokenize<'a>(code: &'a str) -> Vec<Vec<Token>> {
    let match_scalar = Regex::new(r#"^[.[^=\{\}\[\]]]+\s?"#).unwrap();
    let match_punc = Regex::new(r#"^[\{\}\[\]=]"#).unwrap();
    let match_comment = Regex::new(r#"#.+"#).unwrap();

    let mut stream: Vec<Vec<Token>> = Vec::new();
    for _ in code.split('\n') {
        stream.push(Vec::new());
    }

    for (idx, mut line) in code.split('\n').into_iter().enumerate() {
        line = line.trim();

        while line.len() >= 1 {
            if match_comment.is_match(line) {
                line = "";
            } else if let Some(result) = match_scalar.captures(line) {
                line = &line[result[0].len()..];
                stream[idx].push(Token::Scalar(result[0].trim().to_string()));
            } else if let Some(result) = match_punc.captures(line) {
                line = &line[1..];
                stream[idx].push(Token::Punctuation(result[0].trim().to_string()));
            } else {
                eprintln!("Unrecognized token in line: {}", line);
            }
        }
    }

    stream
        .iter()
        .filter_map(|item| strip(item.clone()))
        .collect()
}

fn strip(stream: Vec<Token>) -> Option<Vec<Token>> {
    let mut ret = Vec::new();

    for item in stream {
        if Token::Scalar(String::new()) != item {
            ret.push(item);
        }
    }

    if ret.is_empty() {
        None
    } else {
        Some(ret)
    }
}