feat: Add keep_at_rules option

Author: kamil-zych

css-inline/src/html/attributes.rs

@@ -123,7 +123,8 @@ pub(crate) fn hash_class_name(name: &[u8]) -> u64 {
 }
 
 /// A collection of HTML attributes.
-#[derive(Debug)]
+// TODO there must be a way for not having to instantiate Attributes class, see serializer.rs
+#[derive(Debug, Default)]
 pub(crate) struct Attributes {
     pub(crate) attributes: Vec<html5ever::Attribute>,
     /// The 'class' attribute value is separated for performance reasons.

css-inline/src/html/document.rs

@@ -288,9 +288,11 @@ impl Document {
         styles: DocumentStyleMap<'_>,
         keep_style_tags: bool,
         keep_link_tags: bool,
+        keep_at_rules: bool,
+        at_rules: Option<String>,
         mode: InliningMode,
     ) -> Result<(), InlineError> {
-        serialize_to(self, writer, styles, keep_style_tags, keep_link_tags, mode)
+        serialize_to(self, writer, styles, keep_style_tags, keep_link_tags, keep_at_rules, at_rules, mode)
     }
 
     /// Filter this node iterator to elements matching the given selectors.
@@ -341,6 +343,8 @@ mod tests {
                 IndexMap::default(),
                 false,
                 false,
+                false,
+                None,
                 InliningMode::Document,
             )
             .expect("Failed to serialize");

css-inline/src/html/serializer.rs

@@ -15,13 +15,17 @@ pub(crate) fn serialize_to<W: Write>(
     styles: DocumentStyleMap<'_>,
     keep_style_tags: bool,
     keep_link_tags: bool,
+    keep_at_rules: bool,
+    at_rules: Option<String>,
     mode: InliningMode,
 ) -> Result<(), InlineError> {
     let sink = Sink::new(
         document,
         NodeId::document_id(),
         keep_style_tags,
         keep_link_tags,
+        keep_at_rules,
+        at_rules,
         mode,
     );
     let mut ser = HtmlSerializer::new(writer, styles);
@@ -34,6 +38,9 @@ struct Sink<'a> {
     node: NodeId,
     keep_style_tags: bool,
     keep_link_tags: bool,
+    // TODO this is not used here but I might need it for simplifying serialization logic below   
+    keep_at_rules: bool,
+    at_rules: Option<String>,
     inlining_mode: InliningMode,
 }
 
@@ -43,13 +50,17 @@ impl<'a> Sink<'a> {
         node: NodeId,
         keep_style_tags: bool,
         keep_link_tags: bool,
+        keep_at_rules: bool,
+        at_rules: Option<String>,
         inlining_mode: InliningMode,
     ) -> Sink<'a> {
         Sink {
             document,
             node,
             keep_style_tags,
             keep_link_tags,
+            keep_at_rules,
+            at_rules,
             inlining_mode,
         }
     }
@@ -60,6 +71,8 @@ impl<'a> Sink<'a> {
             node,
             self.keep_style_tags,
             self.keep_link_tags,
+            self.keep_at_rules,
+            self.at_rules.clone(),
             self.inlining_mode,
         )
     }
@@ -114,6 +127,22 @@ impl<'a> Sink<'a> {
 
                 serializer.start_elem(&element.name, &element.attributes, style_node_id)?;
 
+                // TODO this part is the one that I don't like the most
+                if element.name.local == local_name!("head") {
+                    if let Some(at_rules) = &self.at_rules {
+                        if !at_rules.is_empty() {
+                            serializer.start_elem(
+                                &QualName::new(None, ns!(html), local_name!("style")),
+                                &Attributes::default(),
+                                None,
+                            )?;
+                            serializer.write_text(at_rules)?;
+                            serializer
+                                .end_elem(&QualName::new(None, ns!(html), local_name!("style")))?;
+                        }
+                    }
+                }
+
                 self.serialize_children(serializer)?;
 
                 serializer.end_elem(&element.name)?;
@@ -575,6 +604,8 @@ mod tests {
             IndexMap::default(),
             true,
             false,
+            false,
+            None,
             InliningMode::Document,
         )
         .expect("Should not fail");
@@ -594,6 +625,8 @@ mod tests {
             IndexMap::default(),
             false,
             false,
+            false,
+            None,
             InliningMode::Document,
         )
         .expect("Should not fail");
@@ -613,6 +646,8 @@ mod tests {
             IndexMap::default(),
             false,
             false,
+            false,
+            None,
             InliningMode::Document,
         )
         .expect("Should not fail");
@@ -632,6 +667,8 @@ mod tests {
             IndexMap::default(),
             false,
             false,
+            false,
+            None,
             InliningMode::Document,
         )
         .expect("Should not fail");
@@ -654,9 +691,13 @@ mod tests {
             IndexMap::default(),
             false,
             false,
+            false,
+            None,
             InliningMode::Document,
         )
         .expect("Should not fail");
         assert_eq!(buffer, b"<!DOCTYPE html><html><head></head><body data-foo=\"&amp; &nbsp; &quot;\"></body></html>");
     }
+    
+    // TODO adding a test case for `keep_at_rules` would be nice
 }

css-inline/src/lib.rs

@@ -62,6 +62,8 @@ pub struct InlineOptions<'a> {
     pub keep_style_tags: bool,
     /// Keep "link" tags after inlining.
     pub keep_link_tags: bool,
+    /// Keep "@..." and wrap them into a "style" tag.
+    pub keep_at_rules: bool,
     /// Used for loading external stylesheets via relative URLs.
     pub base_url: Option<Url>,
     /// Whether remote stylesheets should be loaded or not.
@@ -123,6 +125,13 @@ impl<'a> InlineOptions<'a> {
         self
     }
 
+    /// Override whether "@..." rules should be kept after processing.
+    #[must_use]
+    pub fn keep_at_rules(mut self, keep_at_rules: bool) -> Self {
+        self.keep_at_rules = keep_at_rules;
+        self
+    }
+
     /// Set base URL that will be used for loading external stylesheets via relative URLs.
     #[must_use]
     pub fn base_url(mut self, base_url: Option<Url>) -> Self {
@@ -184,6 +193,7 @@ impl Default for InlineOptions<'_> {
             inline_style_tags: true,
             keep_style_tags: false,
             keep_link_tags: false,
+            keep_at_rules: false,
             base_url: None,
             load_remote_stylesheets: true,
             #[cfg(feature = "stylesheet-cache")]
@@ -432,14 +442,29 @@ impl<'a> CSSInliner<'a> {
                 .max(16),
         );
         let mut rule_list = Vec::with_capacity(declarations.capacity() / 3);
-        for rule in cssparser::StyleSheetParser::new(
-            &mut parser,
-            &mut parser::CSSRuleListParser::new(&mut declarations),
-        )
-        .flatten()
-        {
-            rule_list.push(rule);
-        }
+        let at_rules = if self.options.keep_at_rules {
+            let mut at_rules = String::new();
+            for rule in cssparser::StyleSheetParser::new(
+                &mut parser,
+                &mut parser::AtRuleFilteringParser::new(&mut declarations, &mut at_rules),
+            )
+            .flatten()
+            {
+                rule_list.push(rule);
+            }
+            // TODO debug it
+            Some(at_rules)
+        } else {
+            for rule in cssparser::StyleSheetParser::new(
+                &mut parser,
+                &mut parser::CSSRuleListParser::new(&mut declarations),
+            )
+            .flatten()
+            {
+                rule_list.push(rule);
+            }
+            None
+        };
         // This cache is unused but required in the `selectors` API
         let mut caches = SelectorCaches::default();
         for (selectors, (start, end)) in &rule_list {
@@ -496,6 +521,8 @@ impl<'a> CSSInliner<'a> {
             styles,
             self.options.keep_style_tags,
             self.options.keep_link_tags,
+            self.options.keep_at_rules,
+            at_rules,
             mode,
         )?;
         Ok(())

css-inline/src/main.rs

@@ -53,6 +53,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         inline_style_tags: bool,
         keep_style_tags: bool,
         keep_link_tags: bool,
+        keep_at_rules: bool,
         base_url: Option<String>,
         extra_css: Option<String>,
         output_filename_prefix: Option<OsString>,
@@ -70,6 +71,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 inline_style_tags: true,
                 keep_style_tags: false,
                 keep_link_tags: false,
+                keep_at_rules: false,
                 base_url: None,
                 extra_css: None,
                 output_filename_prefix: None,
@@ -199,6 +201,9 @@ OPTIONS:
 
     --keep-link-tags
         Keep "link" tags after inlining.
+        
+    --keep-at-rules
+        Keep "@..." rules after inlining.
 
     --base-url
         Used for loading external stylesheets via relative URLs.
@@ -284,6 +289,7 @@ OPTIONS:
             inline_style_tags: args.inline_style_tags,
             keep_style_tags: args.keep_style_tags,
             keep_link_tags: args.keep_link_tags,
+            keep_at_rules: args.keep_at_rules,
             base_url,
             load_remote_stylesheets: args.load_remote_stylesheets,
             #[cfg(feature = "stylesheet-cache")]

css-inline/src/parser.rs

@@ -98,3 +98,81 @@ impl<'i> cssparser::QualifiedRuleParser<'i> for CSSDeclarationListParser {
     type QualifiedRule = Declaration<'i>;
     type Error = ();
 }
+
+pub(crate) struct AtRuleFilteringParser<'d, 'i, 'o> {
+    declarations: &'d mut Vec<Declaration<'i>>,
+    at_rules: &'o mut String,
+}
+
+impl<'d, 'i, 'o> AtRuleFilteringParser<'d, 'i, 'o> {
+    #[inline]
+    pub(crate) fn new(
+        declarations: &'d mut Vec<Declaration<'i>>,
+        at_rules: &'o mut String,
+    ) -> AtRuleFilteringParser<'d, 'i, 'o> {
+        AtRuleFilteringParser {
+            declarations,
+            at_rules,
+        }
+    }
+}
+
+impl<'i> cssparser::QualifiedRuleParser<'i> for AtRuleFilteringParser<'_, 'i, '_> {
+    type Prelude = &'i str;
+    type QualifiedRule = QualifiedRule<'i>;
+    type Error = ();
+
+    fn parse_prelude<'t>(
+        &mut self,
+        input: &mut cssparser::Parser<'i, 't>,
+    ) -> Result<Self::Prelude, cssparser::ParseError<'i, Self::Error>> {
+        Ok(exhaust(input))
+    }
+
+    fn parse_block<'t>(
+        &mut self,
+        prelude: Self::Prelude,
+        _: &ParserState,
+        input: &mut cssparser::Parser<'i, 't>,
+    ) -> Result<Self::QualifiedRule, cssparser::ParseError<'i, Self::Error>> {
+        let mut parser = CSSDeclarationListParser;
+        let parser = cssparser::RuleBodyParser::new(input, &mut parser);
+        let start = self.declarations.len();
+        for item in parser.flatten() {
+            self.declarations.push(item);
+        }
+        Ok((prelude, (start, self.declarations.len())))
+    }
+}
+
+impl<'i> cssparser::AtRuleParser<'i> for AtRuleFilteringParser<'_, 'i, '_> {
+    type Prelude = &'i str;
+    type AtRule = QualifiedRule<'i>;
+    type Error = ();
+
+    fn parse_prelude<'t>(
+        &mut self,
+        name: cssparser::CowRcStr<'i>,
+        input: &mut cssparser::Parser<'i, 't>,
+    ) -> Result<Self::Prelude, cssparser::ParseError<'i, Self::Error>> {
+        // TODO pushing @ feels odd, there should be a less dumb way of doing it?
+        self.at_rules.push_str("@");
+        self.at_rules.push_str(&name);
+        Ok(exhaust(input))
+    }
+
+    fn parse_block<'t>(
+        &mut self,
+        prelude: Self::Prelude,
+        _start: &ParserState,
+        input: &mut cssparser::Parser<'i, 't>,
+    ) -> Result<Self::AtRule, cssparser::ParseError<'i, Self::Error>> {
+        // TODO same here, pushing braces manually feels odd
+        let start = self.declarations.len();
+        self.at_rules.push_str(prelude);
+        self.at_rules.push_str(" {");
+        self.at_rules.push_str(exhaust(input));
+        self.at_rules.push_str("}");
+        Ok((prelude, (start, self.declarations.len())))
+    }
+}