Add rudimentary css parser

Doesn't actually parse declaration values yet.

src/arena_dom.rs

@@ -58,6 +58,7 @@ pub struct Sink<'arena> {
     quirks_mode: QuirksMode,
 }
 
+#[derive(Debug)]
 pub struct Node<'arena> {
     pub parent: Link<'arena>,
     pub next_sibling: Link<'arena>,
@@ -67,6 +68,7 @@ pub struct Node<'arena> {
     pub data: NodeData<'arena>,
 }
 
+#[derive(Debug)]
 pub enum NodeData<'arena> {
     Document,
     Doctype {

src/css_parser.rs

@@ -0,0 +1,136 @@
+use cssparser::{
+    AtRuleParser, CowRcStr, DeclarationListParser, DeclarationParser, ParseError, Parser,
+    ParserInput, QualifiedRuleParser, RuleListParser, SourceLocation,
+};
+use std::error::Error;
+
+#[derive(Debug)]
+pub struct CssRule {
+    pub selectors: String,
+    pub declarations: Vec<CssDeclaration>,
+}
+
+#[derive(Debug)]
+pub struct CssDeclaration {
+    pub property: String,
+    pub value: String,
+}
+
+#[derive(Debug)]
+pub enum CssError {}
+
+pub type CssParseError<'i> = ParseError<'i, CssError>;
+
+struct CssParser;
+
+impl<'i> AtRuleParser<'i> for CssParser {
+    type PreludeBlock = ();
+    type PreludeNoBlock = ();
+    type AtRule = CssRule;
+    type Error = CssError;
+}
+
+impl<'i> QualifiedRuleParser<'i> for CssParser {
+    type Prelude = String;
+    type QualifiedRule = CssRule;
+    type Error = CssError;
+
+    fn parse_prelude<'t>(
+        &mut self,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self::Prelude, CssParseError<'i>> {
+        let location = input.current_source_location();
+        dbg!(&location);
+        let position = input.position();
+        dbg!(&position);
+        while input.next().is_ok() {}
+        Ok(input.slice_from(position).to_string())
+    }
+
+    fn parse_block<'t>(
+        &mut self,
+        selectors: Self::Prelude,
+        _location: SourceLocation,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<CssRule, CssParseError<'i>> {
+        dbg!(&selectors);
+        Ok(CssRule {
+            selectors,
+            declarations: parse_declarations(input).unwrap(),
+        })
+    }
+}
+
+pub fn parse_css_stylesheet(css: &str) -> Vec<CssRule> {
+    let mut parser_input = ParserInput::new(css);
+    let mut parser = Parser::new(&mut parser_input);
+
+    let rule_list_parser = RuleListParser::new_for_stylesheet(&mut parser, CssParser);
+
+    let mut rules = Vec::new();
+
+    for result in rule_list_parser {
+        let rule = match result {
+            Ok(r) => r,
+            Err((error, string)) => {
+                eprintln!("Rule dropped: {:?}, {:?}", error, string);
+                continue;
+            }
+        };
+        rules.push(rule);
+    }
+
+    rules
+}
+
+pub fn parse_css_style_attribute(css: &str) -> Vec<CssDeclaration> {
+    let mut parser_input = ParserInput::new(css);
+    let mut parser = Parser::new(&mut parser_input);
+
+    parse_declarations(&mut parser).unwrap()
+}
+
+#[derive(Debug)]
+struct CssDeclarationParser;
+
+impl<'i> DeclarationParser<'i> for CssDeclarationParser {
+    type Declaration = Vec<CssDeclaration>;
+    type Error = CssError;
+
+    fn parse_value<'t>(
+        &mut self,
+        name: CowRcStr<'i>,
+        mut input: &mut Parser<'i, 't>,
+    ) -> Result<Self::Declaration, ParseError<'i, CssError>> {
+        Ok(vec![])
+    }
+}
+
+impl<'i> AtRuleParser<'i> for CssDeclarationParser {
+    type PreludeBlock = ();
+    type PreludeNoBlock = ();
+    type AtRule = Vec<CssDeclaration>;
+    type Error = CssError;
+}
+
+pub fn parse_declarations<'i>(
+    input: &mut Parser<'i, '_>,
+) -> Result<Vec<CssDeclaration>, Box<dyn Error>> {
+    let mut declarations = Vec::new();
+    let declaration_list_parser = DeclarationListParser::new(input, CssDeclarationParser);
+
+    for declaration_list in declaration_list_parser {
+        let declaration_list = match declaration_list {
+            Ok(l) => l,
+            Err(e) => {
+                eprintln!("CSS declaration dropped: {:?}", e);
+                continue;
+            }
+        };
+        for declaration in declaration_list {
+            declarations.push(declaration);
+        }
+    }
+
+    Ok(declarations)
+}

src/main.rs

@@ -1,3 +1,4 @@
+#![warn(clippy::all)]
 #[macro_use]
 extern crate lazy_static;
 #[macro_use]
@@ -5,6 +6,7 @@ extern crate html5ever;
 #[macro_use]
 extern crate maplit;
 extern crate typed_arena;
+extern crate cssparser;
 
 use std::collections::HashSet;
 use std::default::Default;
@@ -17,7 +19,9 @@ use url::{ParseError, Url};
 
 mod arena_dom;
 mod config;
+mod css_parser;
 
+use css_parser::{parse_css_style_attribute, parse_css_stylesheet};
 use arena_dom::{create_element, html5ever_parse_slice_into_arena, Arena, NodeData, Ref};
 use config::permissive::{ADD_ATTRIBUTES, ALL_ATTRIBUTES, ATTRIBUTES, ELEMENTS, PROTOCOLS};
 
@@ -66,9 +70,22 @@ fn transform_node<'arena>(node: Ref<'arena>, arena: Arena<'arena>) {
     match node.data {
         NodeData::Document
         | NodeData::Doctype { .. }
-        | NodeData::Text { .. }
         | NodeData::Comment { .. }
         | NodeData::ProcessingInstruction { .. } => {}
+        NodeData::Text { ref contents } => {
+            dbg!(contents);
+            // TODO: seems rather expensive to lookup the parent on every Text node. Better
+            // solution would be to pass some sort of context from the parent that marks that this
+            // Text node is inside a <style>.
+            if let Some(parent) = node.parent.get() {
+                if let NodeData::Element { ref name, .. } = parent.data {
+                    if name.local == local_name!("style") {
+                        let rules = parse_css_stylesheet(&contents.borrow());
+                        dbg!(&rules);
+                    }
+                }
+            }
+        }
         NodeData::Element {
             ref attrs,
             ref name,
@@ -80,7 +97,6 @@ fn transform_node<'arena>(node: Ref<'arena>, arena: Arena<'arena>) {
             if let Some(element_attrs) = ATTRIBUTES.get(&name.local) {
                 allowed_attrs = allowed_attrs
                     .union(element_attrs)
-                    .into_iter()
                     .cloned()
                     .collect();
             }
@@ -89,6 +105,12 @@ fn transform_node<'arena>(node: Ref<'arena>, arena: Arena<'arena>) {
                 if !allowed_attrs.contains(&attrs[i].name.local) {
                     attrs.remove(i);
                 } else {
+                    if attrs[i].name.local == local_name!("style") {
+                        let css_str = &attrs[i].value;
+                        dbg!(&css_str);
+                        let declarations = parse_css_style_attribute(css_str);
+                        dbg!(&declarations);
+                    }
                     i += 1;
                 }
             }