Move remaining rules into the proper files

Author: devongovett

src/declaration.rs

@@ -22,6 +22,49 @@ use crate::properties::{
 };
 use crate::properties::prefixes::Browsers;
 
+#[derive(Debug, PartialEq)]
+pub struct DeclarationBlock {
+  pub declarations: Vec<Declaration>
+}
+
+impl ToCss for DeclarationBlock {
+  fn to_css<W>(&self, dest: &mut Printer<W>) -> std::fmt::Result where W: std::fmt::Write {
+    dest.whitespace()?;
+    dest.write_char('{')?;
+    dest.indent();
+    let len = self.declarations.len();
+    for (i, decl) in self.declarations.iter().enumerate() {
+      dest.newline()?;
+      decl.to_css(dest)?;
+      if i != len - 1 || !dest.minify {
+        dest.write_char(';')?;
+      }
+    }
+    dest.dedent();
+    dest.newline()?;
+    dest.write_char('}')
+  }
+}
+
+impl DeclarationBlock {
+  pub fn minify(&mut self, handler: &mut DeclarationHandler, important_handler: &mut DeclarationHandler) {
+    let mut decls: Vec<Declaration> = vec![];
+    for decl in self.declarations.iter() {
+      let handled = 
+        (decl.important && important_handler.handle_property(decl)) ||
+        (!decl.important && handler.handle_property(decl));
+
+      if !handled {
+        decls.push(decl.clone());
+      }
+    }
+
+    decls.extend(handler.finalize());
+    decls.extend(important_handler.finalize());
+    self.declarations = decls;
+  }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct Declaration {
   pub property: Property,
@@ -94,7 +137,7 @@ pub struct DeclarationHandler {
   decls: DeclarationList
 }
 
-impl DeclarationHandler{
+impl DeclarationHandler {
   pub fn new(important: bool, targets: Option<Browsers>) -> Self {
     DeclarationHandler {
       background: BackgroundHandler::new(targets),

src/lib.rs

@@ -22,6 +22,7 @@ use properties::prefixes::{Browsers, Feature};
 use declaration::DeclarationHandler;
 use std::collections::HashMap;
 use parser::TopLevelRuleParser;
+use rules::CssRule;
 
 // ---------------------------------------------
 
@@ -99,7 +100,7 @@ fn compile(code: &str, minify: bool, targets: Option<Browsers>) -> Result<String
     };
     // println!("{:?}", rule);
     let rule = match rule {
-      parser::CssRule::Keyframes(mut keyframes) => {
+      CssRule::Keyframes(mut keyframes) => {
         for keyframe in keyframes.keyframes.iter_mut() {
           keyframe.declarations.minify(&mut handler, &mut important_handler);
         }
@@ -117,7 +118,7 @@ fn compile(code: &str, minify: bool, targets: Option<Browsers>) -> Result<String
         // If there is an existing rule with the same name and identical keyframes,
         // merge the vendor prefixes from this rule into it.
         if let Some(existing_idx) = keyframe_rules.get(&keyframes.name) {
-          if let Some(parser::CssRule::Keyframes(existing)) = &mut rules.get_mut(*existing_idx) {
+          if let Some(CssRule::Keyframes(existing)) = &mut rules.get_mut(*existing_idx) {
             if existing.keyframes == keyframes.keyframes {
               existing.vendor_prefix |= keyframes.vendor_prefix;
               set_prefix!(existing);
@@ -128,20 +129,20 @@ fn compile(code: &str, minify: bool, targets: Option<Browsers>) -> Result<String
 
         set_prefix!(keyframes);
         keyframe_rules.insert(keyframes.name.clone(), rules.len());
-        parser::CssRule::Keyframes(keyframes)
+        CssRule::Keyframes(keyframes)
       }
-      parser::CssRule::Media(mut media) => {
+      CssRule::Media(mut media) => {
         for rule in media.rules.iter_mut() {
           match rule {
-            parser::CssRule::Style(style) => {
+            CssRule::Style(style) => {
               style.declarations.minify(&mut handler, &mut important_handler)
             }
             _ => {}
           }
         }
-        parser::CssRule::Media(media)
+        CssRule::Media(media)
       }
-      parser::CssRule::Style(mut style) => {
+      CssRule::Style(mut style) => {
         for selector in style.selectors.0.iter() {
           for x in selector.iter() {
             match x {
@@ -162,7 +163,7 @@ fn compile(code: &str, minify: bool, targets: Option<Browsers>) -> Result<String
 
         style.declarations.minify(&mut handler, &mut important_handler);
 
-        if let Some(parser::CssRule::Style(last_style_rule)) = rules.last_mut() {
+        if let Some(CssRule::Style(last_style_rule)) = rules.last_mut() {
           if style.selectors == last_style_rule.selectors {
             last_style_rule.declarations.declarations.extend(style.declarations.declarations);
             last_style_rule.declarations.minify(&mut handler, &mut important_handler);
@@ -173,7 +174,7 @@ fn compile(code: &str, minify: bool, targets: Option<Browsers>) -> Result<String
           }
         }
 
-        parser::CssRule::Style(style)
+        CssRule::Style(style)
       },
       r => r
     };

src/parser.rs

@@ -3,21 +3,23 @@ use selectors::SelectorList;
 use std::fmt;
 use std::cell::RefCell;
 use crate::media_query::*;
-use crate::printer::Printer;
-use crate::traits::{Parse, ToCss};
+use crate::traits::Parse;
 use std::fmt::Write;
 use crate::selector::{Selectors, SelectorParser};
 use crate::rules::{
+  CssRule,
   keyframes::{KeyframeListParser, KeyframesRule},
   font_face::{FontFaceRule, FontFaceDeclarationParser},
   page::{PageSelector, PageRule},
   supports::{SupportsCondition, SupportsRule},
   counter_style::CounterStyleRule,
   namespace::NamespaceRule,
-  import::ImportRule
+  import::ImportRule,
+  media::MediaRule,
+  style::StyleRule
 };
 use crate::values::ident::CustomIdent;
-use crate::declaration::{Declaration, DeclarationHandler};
+use crate::declaration::{Declaration, DeclarationBlock};
 use crate::properties::VendorPrefix;
 
 #[derive(Eq, PartialEq, Clone)]
@@ -70,8 +72,7 @@ impl std::cmp::PartialEq<str> for CssString {
 }
 
 /// The parser for the top-level rules in a stylesheet.
-pub struct TopLevelRuleParser {
-}
+pub struct TopLevelRuleParser {}
 
 impl<'b> TopLevelRuleParser {
   fn nested<'a: 'b>(&'a self) -> NestedRuleParser {
@@ -212,116 +213,7 @@ impl<'a, 'i> QualifiedRuleParser<'i> for TopLevelRuleParser {
 }
 
 #[derive(Clone)]
-struct NestedRuleParser {
-}
-
-#[derive(Debug, PartialEq)]
-pub struct MediaRule {
-  pub query: MediaList,
-  pub rules: Vec<CssRule>
-}
-
-impl ToCss for MediaRule {
-  fn to_css<W>(&self, dest: &mut Printer<W>) -> fmt::Result where W: fmt::Write {
-    dest.write_str("@media ")?;
-    self.query.to_css(dest)?;
-    dest.whitespace()?;
-    dest.write_char('{')?;
-    dest.indent();
-    for rule in self.rules.iter() {
-      dest.newline()?;
-      rule.to_css(dest)?;
-    }
-    dest.dedent();
-    dest.newline()?;
-    dest.write_char('}')
-  }
-}
-
-#[derive(Debug, PartialEq)]
-pub struct StyleRule {
-  pub selectors: SelectorList<Selectors>,
-  pub declarations: DeclarationBlock
-}
-
-impl ToCss for StyleRule {
-  fn to_css<W>(&self, dest: &mut Printer<W>) -> fmt::Result where W: fmt::Write {
-    self.selectors.to_css(dest)?;
-    self.declarations.to_css(dest)
-  }
-}
-
-#[derive(Debug, PartialEq)]
-pub struct DeclarationBlock {
-  pub declarations: Vec<Declaration>
-}
-
-impl ToCss for DeclarationBlock {
-  fn to_css<W>(&self, dest: &mut Printer<W>) -> fmt::Result where W: fmt::Write {
-    dest.whitespace()?;
-    dest.write_char('{')?;
-    dest.indent();
-    let len = self.declarations.len();
-    for (i, decl) in self.declarations.iter().enumerate() {
-      dest.newline()?;
-      decl.to_css(dest)?;
-      if i != len - 1 || !dest.minify {
-        dest.write_char(';')?;
-      }
-    }
-    dest.dedent();
-    dest.newline()?;
-    dest.write_char('}')
-  }
-}
-
-impl DeclarationBlock {
-  pub fn minify(&mut self, handler: &mut DeclarationHandler, important_handler: &mut DeclarationHandler) {
-    let mut decls: Vec<Declaration> = vec![];
-    for decl in self.declarations.iter() {
-      let handled = 
-        (decl.important && important_handler.handle_property(decl)) ||
-        (!decl.important && handler.handle_property(decl));
-
-      if !handled {
-        decls.push(decl.clone());
-      }
-    }
-
-    decls.extend(handler.finalize());
-    decls.extend(important_handler.finalize());
-    self.declarations = decls;
-  }
-}
-
-#[derive(Debug, PartialEq)]
-pub enum CssRule {
-  Media(MediaRule),
-  Import(ImportRule),
-  Style(StyleRule),
-  Keyframes(KeyframesRule),
-  FontFace(FontFaceRule),
-  Page(PageRule),
-  Supports(SupportsRule),
-  CounterStyle(CounterStyleRule),
-  Namespace(NamespaceRule)
-}
-
-impl ToCss for CssRule {
-  fn to_css<W>(&self, dest: &mut Printer<W>) -> fmt::Result where W: fmt::Write {
-    match self {
-      CssRule::Media(media) => media.to_css(dest),
-      CssRule::Import(import) => import.to_css(dest),
-      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),
-      CssRule::Supports(supports) => supports.to_css(dest),
-      CssRule::CounterStyle(counter_style) => counter_style.to_css(dest),
-      CssRule::Namespace(namespace) => namespace.to_css(dest)
-    }
-  }
-}
+struct NestedRuleParser {}
 
 impl<'a, 'b> NestedRuleParser {
   fn parse_nested_rules(&mut self, input: &mut Parser) -> Vec<CssRule> {

src/rules/counter_style.rs

@@ -1,5 +1,5 @@
 use crate::traits::ToCss;
-use crate::parser::{DeclarationBlock};
+use crate::declaration::DeclarationBlock;
 use crate::printer::Printer;
 use crate::values::ident::CustomIdent;
 

src/rules/keyframes.rs

@@ -1,7 +1,8 @@
 use cssparser::*;
 use crate::values::percentage::Percentage;
 use crate::traits::{Parse, ToCss};
-use crate::parser::{PropertyDeclarationParser, DeclarationBlock};
+use crate::parser::{PropertyDeclarationParser};
+use crate::declaration::DeclarationBlock;
 use crate::properties::VendorPrefix;
 use crate::printer::Printer;
 use std::fmt::Write;

src/rules/media.rs

@@ -0,0 +1,28 @@
+use crate::media_query::MediaList;
+use crate::traits::ToCss;
+use crate::printer::Printer;
+use std::fmt::Write;
+use super::CssRule;
+
+#[derive(Debug, PartialEq)]
+pub struct MediaRule {
+  pub query: MediaList,
+  pub rules: Vec<CssRule>
+}
+
+impl ToCss for MediaRule {
+  fn to_css<W>(&self, dest: &mut Printer<W>) -> std::fmt::Result where W: std::fmt::Write {
+    dest.write_str("@media ")?;
+    self.query.to_css(dest)?;
+    dest.whitespace()?;
+    dest.write_char('{')?;
+    dest.indent();
+    for rule in self.rules.iter() {
+      dest.newline()?;
+      rule.to_css(dest)?;
+    }
+    dest.dedent();
+    dest.newline()?;
+    dest.write_char('}')
+  }
+}

src/rules/mod.rs

@@ -5,3 +5,46 @@ pub mod supports;
 pub mod counter_style;
 pub mod namespace;
 pub mod import;
+pub mod media;
+pub mod style;
+
+use media::MediaRule;
+use import::ImportRule;
+use style::StyleRule;
+use keyframes::KeyframesRule;
+use font_face::FontFaceRule;
+use page::PageRule;
+use supports::SupportsRule;
+use counter_style::CounterStyleRule;
+use namespace::NamespaceRule;
+use crate::traits::ToCss;
+use crate::printer::Printer;
+
+#[derive(Debug, PartialEq)]
+pub enum CssRule {
+  Media(MediaRule),
+  Import(ImportRule),
+  Style(StyleRule),
+  Keyframes(KeyframesRule),
+  FontFace(FontFaceRule),
+  Page(PageRule),
+  Supports(SupportsRule),
+  CounterStyle(CounterStyleRule),
+  Namespace(NamespaceRule)
+}
+
+impl ToCss for CssRule {
+  fn to_css<W>(&self, dest: &mut Printer<W>) -> std::fmt::Result where W: std::fmt::Write {
+    match self {
+      CssRule::Media(media) => media.to_css(dest),
+      CssRule::Import(import) => import.to_css(dest),
+      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),
+      CssRule::Supports(supports) => supports.to_css(dest),
+      CssRule::CounterStyle(counter_style) => counter_style.to_css(dest),
+      CssRule::Namespace(namespace) => namespace.to_css(dest)
+    }
+  }
+}

src/rules/page.rs

@@ -1,6 +1,6 @@
 use cssparser::*;
 use crate::traits::{Parse, ToCss};
-use crate::parser::{DeclarationBlock};
+use crate::declaration::DeclarationBlock;
 use crate::printer::Printer;
 use crate::macros::enum_property;
 use std::fmt::Write;