Basic support for @page rules

Author: devongovett

src/lib.rs

@@ -1847,4 +1847,16 @@ mod tests {
     minify_test("@font-face {src: url(\"test.woff\") format(woff supports palettes);}", "@font-face{src:url(test.woff)format(woff supports palettes)}");
     minify_test("@font-face {src: url(\"test.woff\") format(woff supports features(opentype) color(sbix));}", "@font-face{src:url(test.woff)format(woff supports features(opentype) color(sbix))}");
   }
+
+  #[test]
+  fn test_page_rule() {
+    minify_test("@page {margin: 0.5cm}", "@page{margin:.5cm}");
+    minify_test("@page :left {margin: 0.5cm}", "@page:left{margin:.5cm}");
+    minify_test("@page :right {margin: 0.5cm}", "@page:right{margin:.5cm}");
+    minify_test("@page LandscapeTable {margin: 0.5cm}", "@page LandscapeTable{margin:.5cm}");
+    minify_test("@page CompanyLetterHead:first {margin: 0.5cm}", "@page CompanyLetterHead:first{margin:.5cm}");
+    minify_test("@page:first {margin: 0.5cm}", "@page:first{margin:.5cm}");
+    minify_test("@page :blank:first {margin: 0.5cm}", "@page:blank:first{margin:.5cm}");
+    minify_test("@page toc, index {margin: 0.5cm}", "@page toc,index{margin:.5cm}");
+  }
 }

src/parser.rs

@@ -9,6 +9,7 @@ use std::fmt::Write;
 use crate::selector::{Selectors, SelectorParser};
 use crate::rules::keyframes::{KeyframeListParser, KeyframesRule};
 use crate::rules::font_face::{FontFaceRule, FontFaceDeclarationParser};
+use crate::rules::page::{PageSelector, PageRule};
 use crate::declaration::{Declaration, DeclarationHandler};
 
 #[derive(Eq, PartialEq, Clone)]
@@ -97,7 +98,7 @@ pub enum AtRulePrelude {
   /// A @keyframes rule, with its animation name and vendor prefix if exists.
   Keyframes(String),//(KeyframesName, Option<VendorPrefix>),
   /// A @page rule prelude.
-  Page,
+  Page(Vec<PageSelector>),
   /// A @document rule, with its conditional.
   Document,//(DocumentCondition),
   /// A @import rule prelude.
@@ -381,7 +382,8 @@ pub enum CssRule {
   Import(ImportRule),
   Style(StyleRule),
   Keyframes(KeyframesRule),
-  FontFace(FontFaceRule)
+  FontFace(FontFaceRule),
+  Page(PageRule)
 }
 
 impl ToCss for CssRule {
@@ -392,6 +394,7 @@ impl ToCss for CssRule {
       CssRule::Style(style) => style.to_css(dest),
       CssRule::Keyframes(keyframes) => keyframes.to_css(dest),
       CssRule::FontFace(font_face) => font_face.to_css(dest),
+      CssRule::Page(font_face) => font_face.to_css(dest),
     }
   }
 }
@@ -491,13 +494,10 @@ impl<'a, 'b, 'i> AtRuleParser<'i> for NestedRuleParser {
 
               Ok(AtRuleType::WithBlock(AtRulePrelude::Keyframes(name.into())))
           },
-          // "page" => {
-          //     if cfg!(feature = "gecko") {
-          //         Ok(AtRuleType::WithBlock(AtRuleBlockPrelude::Page))
-          //     } else {
-          //         Err(input.new_custom_error(StyleParseErrorKind::UnsupportedAtRule(name.clone())))
-          //     }
-          // },
+          "page" => {
+            let selectors = input.try_parse(|input| input.parse_comma_separated(PageSelector::parse)).unwrap_or_default();
+            Ok(AtRuleType::WithBlock(AtRulePrelude::Page(selectors)))
+          },
           // "-moz-document" => {
           //     if !cfg!(feature = "gecko") {
           //         return Err(input.new_custom_error(
@@ -616,19 +616,16 @@ impl<'a, 'b, 'i> AtRuleParser<'i> for NestedRuleParser {
                 // source_location: start.source_location(),
               }))
           },
-          // AtRuleBlockPrelude::Page => {
-          //     let context = ParserContext::new_with_rule_type(
-          //         self.context,
-          //         CssRuleType::Page,
-          //         self.namespaces,
-          //     );
-
-          //     let declarations = parse_property_declaration_list(&context, input, None);
-          //     Ok(CssRule::Page(Arc::new(self.shared_lock.wrap(PageRule {
-          //         block: Arc::new(self.shared_lock.wrap(declarations)),
-          //         source_location: start.source_location(),
-          //     }))))
-          // },
+          AtRulePrelude::Page(selectors) => {
+            let parser = DeclarationListParser::new(input, PropertyDeclarationParser);
+            let declarations: Vec<_> = parser.flatten().collect();
+            Ok(CssRule::Page(PageRule {
+              selectors,
+              declarations: DeclarationBlock {
+                declarations
+              }
+            }))
+          },
           // AtRuleBlockPrelude::Document(condition) => {
           //     if !cfg!(feature = "gecko") {
           //         unreachable!()

src/properties/mod.rs

@@ -1,4 +1,4 @@
-mod custom;
+pub mod custom;
 pub mod margin_padding;
 pub mod background;
 pub mod outline;

src/rules/mod.rs

@@ -1,2 +1,3 @@
 pub mod keyframes;
 pub mod font_face;
+pub mod page;

src/rules/page.rs

@@ -0,0 +1,95 @@
+use cssparser::*;
+use crate::values::percentage::Percentage;
+use crate::traits::{Parse, ToCss};
+use crate::parser::{PropertyDeclarationParser, DeclarationBlock};
+use crate::printer::Printer;
+use crate::macros::enum_property;
+use std::fmt::Write;
+
+/// https://www.w3.org/TR/css-page-3/#typedef-page-selector
+#[derive(Debug, PartialEq)]
+pub struct PageSelector {
+  name: Option<String>,
+  pseudo_classes: Vec<PagePseudoClass>
+}
+
+enum_property!(PagePseudoClass,
+  Left,
+  Right,
+  First,
+  Last,
+  Blank
+);
+
+impl Parse for PageSelector {
+  fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ()>> {
+    let name = input.try_parse(|input| input.expect_ident_cloned()).ok().map(|s| s.as_ref().to_owned());
+    let mut pseudo_classes = vec![];
+    
+    loop {
+      // Whitespace is not allowed between pseudo classes
+      let state = input.state();
+      match input.next_including_whitespace() {
+        Ok(Token::Colon) => {
+          pseudo_classes.push(PagePseudoClass::parse(input)?);
+        }
+        _ => {
+          input.reset(&state);
+          break
+        }
+      }
+    }
+
+    if name.is_none() && pseudo_classes.is_empty() {
+      return Err(input.new_error(BasicParseErrorKind::QualifiedRuleInvalid))
+    }
+
+    Ok(PageSelector {
+      name,
+      pseudo_classes
+    })
+  }
+}
+
+#[derive(Debug, PartialEq)]
+pub struct PageRule {
+  pub selectors: Vec<PageSelector>,
+  pub declarations: DeclarationBlock
+}
+
+impl ToCss for PageRule {
+  fn to_css<W>(&self, dest: &mut Printer<W>) -> std::fmt::Result where W: std::fmt::Write {
+    dest.write_str("@page")?;
+    if let Some(first) = self.selectors.first() {
+      // Space is only required if the first selector has a name.
+      if !dest.minify || first.name.is_some() {
+        dest.write_char(' ')?;
+      }
+      let mut first = true;
+      for selector in &self.selectors {
+        if first {
+          first = false;
+        } else {
+          dest.delim(',', false)?;
+        }
+        selector.to_css(dest)?;
+      }
+    }
+    self.declarations.to_css(dest)
+  }
+}
+
+impl ToCss for PageSelector {
+  fn to_css<W>(&self, dest: &mut Printer<W>) -> std::fmt::Result where W: std::fmt::Write {
+    if let Some(name) = &self.name {
+      dest.write_str(&name)?;
+    }
+
+    for pseudo in &self.pseudo_classes {
+      dest.write_char(':')?;
+      pseudo.to_css(dest)?;
+    }
+
+    Ok(())
+  }
+}