use std::borrow::Cow;
use crate::parser::{
AtRule, Block, ComponentValue, Declaration, ErrorKind, Item, ParseError, QualifiedRule, Rule,
Stylesheet, Values, looks_like_custom_property, take_tail, unicode_range_tokens, value_plan,
};
use crate::tokenizer::{Span, Token, Tokenizer};
enum Head<'a> {
At {
name: Cow<'a, str>,
prelude: Vec<ComponentValue<'a>>,
start: usize,
},
Qualified {
prelude: Vec<ComponentValue<'a>>,
start: usize,
},
}
struct Open<'a> {
head: Head<'a>,
start: usize,
at: usize,
}
struct Deep<'a> {
src: &'a str,
values: Values<'a>,
open: Vec<Open<'a>>,
items: Vec<Item<'a, Block<'a>>>,
rules: Vec<Rule<'a, Block<'a>>>,
scratch: Vec<ComponentValue<'a>>,
errors: Vec<ParseError>,
}
impl<'a> Deep<'a> {
fn next_token(&mut self) -> Option<(Token<'a>, Span)> {
self.values.tokens.next_token()
}
fn back_to(&mut self, position: usize) {
self.values.tokens.reset(position);
}
fn error(&mut self, kind: ErrorKind, start: usize, end: usize) {
self.errors.push(ParseError {
kind,
span: Span::new(start, end.max(start)),
});
}
fn place(&mut self, rule: Rule<'a, Block<'a>>) {
if self.open.is_empty() {
self.rules.push(rule);
} else {
self.items.push(Item::Rule(rule));
}
}
fn run(mut self) -> Stylesheet<'a, Block<'a>> {
while let Some((token, span)) = self.next_token() {
if self.open.is_empty() {
match token {
Token::Whitespace | Token::Cdo | Token::Cdc => {}
Token::AtKeyword(name) => self.at_rule(name, span, false),
token => self.qualified_rule(token, span, false),
}
continue;
}
match token {
Token::Whitespace | Token::Semicolon => {}
Token::RightBrace => self.close(span.end),
Token::AtKeyword(name) => self.at_rule(name, span, true),
Token::Ident(name) => {
if !self.declaration(name, span) {
self.back_to(span.start);
let (token, span) = self.next_token().unwrap();
self.qualified_rule(token, span, true);
}
}
token => self.qualified_rule(token, span, true),
}
}
while !self.open.is_empty() {
self.close(self.src.len());
}
Stylesheet {
rules: self.rules,
errors: self.errors,
}
}
fn close(&mut self, end: usize) {
let open = self.open.pop().unwrap();
let block = Block {
items: take_tail(&mut self.items, open.at),
span: Span::new(open.start, end),
};
let rule = match open.head {
Head::At {
name,
prelude,
start,
} => Rule::At(AtRule {
name,
prelude,
block: Some(block),
span: Span::new(start, end),
}),
Head::Qualified { prelude, start } => Rule::Qualified(QualifiedRule {
prelude,
block,
span: Span::new(start, end),
}),
};
self.place(rule);
}
fn open_block(&mut self, head: Head<'a>, brace: Span) {
self.open.push(Open {
head,
start: brace.start,
at: self.items.len(),
});
}
fn at_rule(&mut self, name: Cow<'a, str>, keyword: Span, nested: bool) {
let mut end = keyword.end;
self.scratch.clear();
while let Some((token, span)) = self.next_token() {
match token {
Token::Semicolon => break,
Token::RightBrace if nested => {
self.back_to(span.start);
break;
}
Token::LeftBrace => {
let prelude = take_tail(&mut self.scratch, 0);
let head = Head::At {
name,
prelude,
start: keyword.start,
};
return self.open_block(head, span);
}
token => {
let value = self.values.whole(token, span);
end = value.span().end;
self.scratch.push(value);
}
}
}
let rule = Rule::At(AtRule {
name,
prelude: take_tail(&mut self.scratch, 0),
block: None,
span: Span::new(keyword.start, end),
});
self.place(rule);
}
fn qualified_rule(&mut self, token: Token<'a>, span: Span, nested: bool) {
let start = span.start;
let mut end = start;
self.scratch.clear();
let mut next = Some((token, span));
loop {
let Some((token, span)) = next.take().or_else(|| self.next_token()) else {
self.scratch.clear();
return self.error(ErrorKind::InvalidRule, start, end);
};
match token {
Token::Semicolon if nested => {
self.scratch.clear();
return self.error(ErrorKind::InvalidRule, start, end);
}
Token::RightBrace if nested => {
self.back_to(span.start);
self.scratch.clear();
return self.error(ErrorKind::InvalidRule, start, end);
}
Token::LeftBrace => {
let prelude = take_tail(&mut self.scratch, 0);
if looks_like_custom_property(&prelude) {
let end = self.values.whole(Token::LeftBrace, span).span().end;
if nested {
self.bad_declaration_remnants();
}
return self.error(ErrorKind::InvalidRule, start, end);
}
return self.open_block(Head::Qualified { prelude, start }, span);
}
token => {
let value = self.values.whole(token, span);
end = value.span().end;
self.scratch.push(value);
}
}
}
}
fn bad_declaration_remnants(&mut self) {
while let Some((token, span)) = self.next_token() {
match token {
Token::Semicolon => return,
Token::RightBrace => return self.back_to(span.start),
token => drop(self.values.whole(token, span)),
}
}
}
fn declaration(&mut self, name: Cow<'a, str>, ident: Span) -> bool {
let colon_end = loop {
match self.next_token() {
Some((Token::Whitespace, _)) => {}
Some((Token::Colon, span)) => break span.end,
_ => return false,
}
};
self.scratch.clear();
while let Some((token, span)) = self.next_token() {
match token {
Token::Semicolon => break,
Token::RightBrace => {
self.back_to(span.start);
break;
}
token => {
let value = self.values.whole(token, span);
self.scratch.push(value);
}
}
}
let Some(plan) = value_plan(&name, &self.scratch) else {
self.scratch.clear();
return false;
};
let mut value: Vec<_> = self.scratch.drain(plan.start..plan.end).collect();
self.scratch.clear();
if name.eq_ignore_ascii_case("unicode-range") && !value.is_empty() {
let from = value[0].span().start;
let to = value[value.len() - 1].span().end;
value = Values::new(unicode_range_tokens(self.src, from, to)).collect();
}
self.items.push(Item::Declaration(Declaration {
name,
value,
important: plan.important,
span: Span::new(ident.start, plan.last_end.unwrap_or(colon_end)),
}));
true
}
}
pub fn parse_stylesheet_deep(css: &str) -> Stylesheet<'_, Block<'_>> {
Deep {
src: css,
values: Values::new(Tokenizer::new(css)),
open: Vec::new(),
items: Vec::new(),
rules: Vec::new(),
scratch: Vec::new(),
errors: Vec::new(),
}
.run()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn deep_nesting_parses_writes_and_drops() {
let css = format!("{}color: red", "a{".repeat(300_000));
let sheet = parse_stylesheet_deep(&css);
assert_eq!(sheet.rules.len(), 1);
let written = sheet.to_string();
assert!(written.ends_with(&"}".repeat(300_000)));
drop(sheet);
}
#[test]
fn an_ident_that_starts_a_rule_is_read_again_as_one() {
let css = "a { b:hover { c: d } e: f; --x:y { g } h }";
let sheet = parse_stylesheet_deep(css);
let Rule::Qualified(a) = &sheet.rules[0] else {
panic!()
};
let kinds: Vec<_> = a
.block
.items
.iter()
.map(|i| match i {
Item::Declaration(d) => d.span.text(css),
Item::Rule(r) => r.span().text(css),
})
.collect();
assert_eq!(kinds, ["b:hover { c: d }", "e: f", "--x:y { g } h"]);
}
}