propparse 0.2.5

A library to parse .properties files
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
110
111
112
113
114
115
116
117
118
119

use crate::{error::LibError, types::{Value, Entry, TokenWrapper, Token}};

enum ParsingState {
    Key,
    Value,
}

fn update_current_value(current_value: &Value, character: char) -> Value {
    match current_value {
        Value::Null => return Value::String(character.to_string()),
        Value::String(s) => {
            return Value::String({
                let ref mut this = s.clone();
                this.push(character);
                this.to_string()
            })
        }
        _ => {
            // TODO: fix this for other types. Not used for now
            return Value::Null;
        }
    }
}

/// Returns the result of parsing a lexed `.properties` file.
///
/// # Arguments
///
/// * `tokens` - A `Vec` of `TokenWrapper`s representing a lexed file
pub fn parse_file(tokens: Vec<TokenWrapper>) -> Result<Vec<Entry>, LibError> {
    let mut props = Vec::new();
    let mut current_key = Vec::new();
    let mut current_value = Value::Null;
    let mut parsing_state = ParsingState::Key;
    let mut is_comment_line = false;
    for token in tokens {
        if is_comment_line {
            match token.content {
                Token::Eol => {
                    is_comment_line = false;
                    continue;
                }
                _ => continue,
            };
        }
        match token.content {
            Token::String(val) => {
                match parsing_state {
                    ParsingState::Key => {
                        current_key.push(val);
                    }
                    ParsingState::Value => {
                        match current_value {
                            Value::Null => current_value = Value::String(val),
                            Value::String(s) => {
                                current_value = Value::String({
                                    let this = &mut s.clone();
                                    this.push_str(&val);
                                    this.to_string()
                                })
                            }
                            _ => {}
                        };
                    }
                };
            }
            Token::Number(val) => {
                match parsing_state {
                    ParsingState::Key => {
                        current_key.push(val.to_string());
                    }
                    ParsingState::Value => {
                        current_value = Value::Integer(val);
                    }
                };
            }
            Token::CommentSign => {
                is_comment_line = true;
                continue;
            }
            Token::Equals => {
                match parsing_state {
                    ParsingState::Key => parsing_state = ParsingState::Value,
                    ParsingState::Value => {
                        current_value = update_current_value(&current_value, '=');
                    }
                };
            }
            Token::Dot => {
                match parsing_state {
                    ParsingState::Key => continue,
                    ParsingState::Value => {
                        current_value = update_current_value(&current_value, '.');
                    }
                };
            }
            Token::Eol => {
                parsing_state = ParsingState::Key;
                props.push((current_key.clone(), current_value.clone()));
                // TODO: maybe reset key, value
                current_key = Vec::new();
                current_value = Value::Null;
            }
            Token::Eof => {
                if !current_key.is_empty() {
                    props.push((current_key.clone(), current_value.clone()));
                }
                return Ok(props);
            }
            Token::Space => continue,
            Token::Garbage => {
                println!("Bad token, skipping it");
                continue;
            }
        };
    }

    return Ok(props);
}