frostwalker 0.1.2

A TOML-like configuration language parser with zero dependencies outside of std.
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

//! Module containing the validator which makes sure that a Token list is correct.
use super::{Token, Class};

#[derive(Debug)]
#[derive(PartialEq)]
enum ExpectedClass {
	IDENTIFIER,
	EQUALS,
	NEWLINE,
	LITERALORSEPARATOR,
	LITERAL,
	SEPARATOR,
}

/// Borrows a token list and either outputs None, meaning no error, or Some(String) with an error message inside.
///
/// ```
/// use frostwalker::{validator, Class, Token};
///
/// let ident = Token { class: Class::IDENTIFIER, value: Some("friend".to_string()) };
/// let equals = Token { class: Class::EQUALS, value: None };
/// let val = Token { class: Class::LITERAL, value: Some("ferris".to_string()) };
///
/// assert_eq!(validator::validate(&vec![ident, equals, val]), None);
/// ```
pub fn validate(tree: &Vec<Token>) -> Option<String> {
	let mut expected_token: ExpectedClass = ExpectedClass::IDENTIFIER;
	let mut i = 0;
	let mut line = 1;
	while i < tree.len() {

		if tree[i].class == Class::NEWLINE && i == 0 {
			i = i + 1;
			line = line + 1;
			continue;
		}

		if tree[i].class == Class::NEWLINE && expected_token == ExpectedClass::NEWLINE {
			i = i + 1;
			line = line + 1;
			expected_token = ExpectedClass::IDENTIFIER;
			continue;
		}

		if tree[i].class == Class::IDENTIFIER && expected_token == ExpectedClass::IDENTIFIER {
			i = i + 1;
			if tree.len() - i == 0 {
				return Some(format!("Key left undefined on line {}.", line));
			}
			expected_token = ExpectedClass::EQUALS;
			continue;
		}

		if tree[i].class == Class::EQUALS && expected_token == ExpectedClass::EQUALS {
			i = i + 1;
			expected_token = ExpectedClass::LITERALORSEPARATOR;
			if tree.len() - i == 0 {
				return Some(format!("Key left undefined on line {}.", line));
			}
			continue;
		}

		if (tree[i].class == Class::LITERAL || tree[i].class == Class::BOOLEAN) && expected_token == ExpectedClass::LITERALORSEPARATOR {
			i = i + 1;
			expected_token = ExpectedClass::NEWLINE;
			continue;
		}

		if (tree[i].class == Class::LITERAL || tree[i].class == Class::BOOLEAN) && expected_token == ExpectedClass::LITERAL {
			i = i + 1;
			expected_token = ExpectedClass::SEPARATOR;
			continue;
		}

		if tree[i].class == Class::SEPARATOR && expected_token == ExpectedClass::LITERALORSEPARATOR {
			if tree[i].value.clone().unwrap_or("".to_string()) == "[".to_string() {
				expected_token = ExpectedClass::LITERAL;
				i = i + 1;
				if tree.len() - i == 0 {
					return Some(format!("Key left undefined on line {}.", line));
				}
				continue;
			} else {
				return Some(format!("Invalid use of separator syntax on line {}.", line));
			}
		}

		if tree[i].class == Class::SEPARATOR && expected_token == ExpectedClass::SEPARATOR {
			if tree[i].value.clone().unwrap_or("".to_string()) == "]".to_string() {
				expected_token = ExpectedClass::NEWLINE;
				i = i + 1;
				continue;
			} else if tree[i].value.clone().unwrap_or("".to_string()) == ",".to_string() {
				expected_token = ExpectedClass::LITERAL;
				i = i + 1;
				continue;
			} else {
				return Some(format!("Invalid use of separator syntax on line {}.", line));
			}		
		}

		if tree[i].value.is_none() {
			return Some(format!("{:?} found where {:?} expected at line {}.", tree[i].class, expected_token, line));
		} else {
			return Some(format!("{:?} {} found where {:?} expected at line {}.", tree[i].class, tree[i].value.clone().unwrap_or("None".to_string()), expected_token, line));
		}
	}
	return None;
}