oak-css 0.0.11

CSS stylesheet language parser with support for web styling and layout processing.
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

#![doc = include_str!("readme.md")]
/// CSS element types and role definitions.
pub mod element_type;
use crate::{
    language::CssLanguage,
    lexer::{CssLexer, CssTokenType},
};
pub use element_type::CssElementType;
use oak_core::{
    GreenNode, OakError, TextEdit,
    parser::{ParseCache, ParseOutput, Parser, ParserState, parse_with_lexer},
    source::Source,
};

pub(crate) type State<'a, S> = ParserState<'a, CssLanguage, S>;

/// Parser for the CSS language.
pub struct CssParser<'config> {
    /// Language configuration.
    pub(crate) config: &'config CssLanguage,
}

impl<'config> CssParser<'config> {
    /// Creates a new `CssParser` with the given language configuration.
    pub fn new(config: &'config CssLanguage) -> Self {
        Self { config }
    }
}

impl<'config> Parser<CssLanguage> for CssParser<'config> {
    /// Parses the CSS source code into a green tree.
    fn parse<'a, S: Source + ?Sized>(&self, text: &'a S, edits: &[TextEdit], cache: &'a mut impl ParseCache<CssLanguage>) -> ParseOutput<'a, CssLanguage> {
        let lexer = CssLexer::new(self.config);
        parse_with_lexer(&lexer, text, edits, cache, |state| {
            let cp = state.checkpoint();

            while state.not_at_end() {
                if state.at(CssTokenType::AtRule) || state.at(CssTokenType::AtImport) || state.at(CssTokenType::AtMedia) { self.parse_at_rule(state)? } else { self.parse_ruleset(state)? }
            }

            Ok(state.finish_at(cp, CssElementType::SourceFile))
        })
    }
}

impl<'config> CssParser<'config> {
    /// Parses a CSS at-rule (e.g., `@import`, `@media`).
    fn parse_at_rule<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
        let cp = state.checkpoint();
        state.bump(); // Consume the at-keyword

        while state.not_at_end() && !state.at(CssTokenType::Semicolon) && !state.at(CssTokenType::LeftBrace) {
            state.bump()
        }

        if state.at(CssTokenType::LeftBrace) {
            state.expect(CssTokenType::LeftBrace).ok();
            while state.not_at_end() && !state.at(CssTokenType::RightBrace) {
                self.parse_ruleset(state)?
            }
            state.expect(CssTokenType::RightBrace).ok();
        }
        else if state.at(CssTokenType::Semicolon) {
            state.expect(CssTokenType::Semicolon).ok();
        }

        state.finish_at(cp, CssElementType::AtRule);
        Ok(())
    }

    /// Parses a CSS rule set (selector + declaration block).
    fn parse_ruleset<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
        let cp = state.checkpoint();

        // Parse selector(s)
        self.parse_selectors(state)?;

        // Parse declaration block
        let cp_block = state.checkpoint();
        state.expect(CssTokenType::LeftBrace).ok();
        while state.not_at_end() && !state.at(CssTokenType::RightBrace) {
            self.parse_declaration(state)?;
            if state.at(CssTokenType::Semicolon) {
                state.expect(CssTokenType::Semicolon).ok();
            }
            else if !state.at(CssTokenType::RightBrace) {
                // Potential error, but we try to continue
                break;
            }
        }
        state.expect(CssTokenType::RightBrace).ok();
        state.finish_at(cp_block, CssElementType::DeclarationBlock);

        state.finish_at(cp, CssElementType::RuleSet);
        Ok(())
    }

    /// Parses CSS selectors.
    fn parse_selectors<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
        let cp = state.checkpoint();
        while state.not_at_end() && !state.at(CssTokenType::LeftBrace) {
            state.bump()
        }
        state.finish_at(cp, CssElementType::SelectorList);
        Ok(())
    }

    /// Parses a CSS declaration (property: value).
    fn parse_declaration<'a, S: Source + ?Sized>(&self, state: &mut State<'a, S>) -> Result<(), OakError> {
        let cp = state.checkpoint();

        // Property
        let cp_prop = state.checkpoint();
        while state.not_at_end() && !state.at(CssTokenType::Colon) && !state.at(CssTokenType::Semicolon) && !state.at(CssTokenType::RightBrace) {
            state.bump()
        }
        state.finish_at(cp_prop, CssElementType::Property);

        if state.at(CssTokenType::Colon) {
            state.expect(CssTokenType::Colon).ok();

            // Value
            let cp_val = state.checkpoint();
            while state.not_at_end() && !state.at(CssTokenType::Semicolon) && !state.at(CssTokenType::RightBrace) {
                state.bump()
            }
            state.finish_at(cp_val, CssElementType::Value);
        }

        state.finish_at(cp, CssElementType::Declaration);
        Ok(())
    }
}