ccss 0.1.0

Const CSS parser
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

pub use self::whitespace_char::Whitespace;

use crate::input::Filtered;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct WhitespaceToken<'a>(&'a str);

impl<'a> WhitespaceToken<'a> {
    pub const ONE_SPACE: Self = WhitespaceToken(" ");

    pub const fn consume(stream: Filtered<'a>) -> (Option<Self>, Filtered<'a>) {
        let mut new_stream = stream.copy();
        let original = stream;
        while let Some((_, s)) = Whitespace::consume(new_stream.copy()) {
            new_stream = s
        }

        let v = konst::option::map!(original.str_before_non_empty(&new_stream), Self);

        (v, new_stream)
    }

    #[cfg(test)]
    pub(crate) const fn new(s: &'a str) -> Self {
        let (this, stream) = Self::consume(Filtered::new(s));

        if let Some(this) = this {
            stream.assert_empty();
            this
        } else {
            panic!("expect whitespace")
        }
    }
}

mod whitespace_char {
    use crate::input::{code_points::LF, Filtered};

    /// https://drafts.csswg.org/css-syntax-3/#whitespace
    pub struct Whitespace(char);

    impl Whitespace {
        const fn try_new(c: char) -> Option<Self> {
            // A newline, U+0009 CHARACTER TABULATION, or U+0020 SPACE
            match c {
                LF | '\u{0009}' | '\u{0020}' => Some(Self(c)),
                _ => None,
            }
        }

        pub const fn consume(stream: Filtered) -> Option<(Whitespace, Filtered)> {
            if let Some((fc, stream)) = stream.next() {
                if let Some(this) = Self::try_new(fc.to_char()) {
                    return Some((this, stream));
                }
            }

            None
        }
    }
}