floem-css-parser 0.2.0

Css parser for floem-css
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use crate::lexer::Token;

pub struct SyntaxError<'a> {
    pub line: usize,
    pub column: usize,
    pub error: &'static str,
    pub value: &'a str,
}

impl std::fmt::Display for SyntaxError<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "error: {}\n {}:{} | {}",
            self.error, self.line, self.column, self.value
        )
    }
}

fn find_line_with_value<'a>(lines: &[&'a str], line: usize, m: &str) -> (usize, &'a str) {
    let line = lines[line - 1];
    let col = line
        .find(m)
        .unwrap_or_else(|| panic!("Analyzer error: cant find column for {m}"));
    (col, line)
}

/// Work in progress
#[must_use]
pub fn analyze_tokens<'a>(tokens: &[Token<'a>], input: &'a str) -> Vec<SyntaxError<'a>> {
    let mut errors: Vec<SyntaxError> = Vec::with_capacity(tokens.len());
    let mut tokens = tokens.iter().peekable();
    let lines = input.lines().collect::<Vec<_>>();
    loop {
        let Some(token) = tokens.next() else {
            break;
        };

        match token {
            Token::Selector { line, value } => {
                let line = *line;
                let (column, value) = find_line_with_value(&lines, line, value);
                if let Some(peek) = tokens.peek() {
                    if !matches!(peek, Token::BlockOpen { .. } | Token::Selector { .. }) {
                        let error = SyntaxError {
                            line,
                            column,
                            error: "Expecting { after selector",
                            value,
                        };
                        errors.push(error);
                    }
                } else {
                    let error = SyntaxError {
                        line,
                        column,
                        error: "Unexpected EOF",
                        value,
                    };
                    errors.push(error);
                }
            }
            Token::Property { line, value } => {
                if let Some(peek) = tokens.peek() {
                    if !matches!(peek, Token::Colon { .. }) {
                        let line = *line;
                        let (column, value) = find_line_with_value(&lines, line, value);
                        let error = SyntaxError {
                            line,
                            column,
                            error: "Unexpected token after property",
                            value,
                        };
                        errors.push(error);
                    }
                } else {
                    todo!()
                }
            }
            Token::Value { value, line } => {
                if let Some(peek) = tokens.peek() {
                    if !matches!(peek, Token::Semicolon { .. }) {
                        let line = *line;
                        let (column, value) = find_line_with_value(&lines, line, value);
                        let error = SyntaxError {
                            line,
                            column,
                            error: "Expecting ; after value",
                            value,
                        };
                        errors.push(error);
                    }
                } else {
                    todo!()
                }
            }
            Token::Semicolon { line } => {
                if let Some(peek) = tokens.peek() {
                    if !matches!(peek, Token::BlockClose { .. } | Token::Property { .. }) {
                        let line = *line;
                        let (column, value) = find_line_with_value(&lines, line, ";");
                        let error = SyntaxError {
                            line,
                            column,
                            error: "Expecting property or } after ;",
                            value,
                        };
                        errors.push(error);
                    }
                } else {
                    todo!()
                }
            }
            Token::Colon { line } => {
                if let Some(peek) = tokens.peek() {
                    if !matches!(peek, Token::Value { .. }) {
                        let line = *line;
                        let (column, value) = find_line_with_value(&lines, line, ":");
                        let error = SyntaxError {
                            line,
                            column,
                            error: "Expecting value after :",
                            value,
                        };
                        errors.push(error);
                    }
                } else {
                    todo!()
                }
            }
            _ => (),
        }
    }

    errors
}