Add property parser

Author: devongovett

src/lib.rs

@@ -8,6 +8,7 @@ extern crate selectors;
 
 mod parser;
 mod media_query;
+mod properties;
 
 use napi::{CallContext, JsObject, JsUndefined};
 use serde::{Deserialize, Serialize};

src/parser.rs

@@ -3,6 +3,7 @@ use selectors::{SelectorList, parser::SelectorImpl};
 use std::fmt;
 use std::cell::RefCell;
 use crate::media_query::*;
+use crate::properties::*;
 
 #[derive(Debug, Clone)]
 pub struct Selectors;
@@ -155,7 +156,7 @@ impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser {
   type PreludeNoBlock = AtRulePrelude;
   type PreludeBlock = AtRulePrelude;
   type AtRule = (SourcePosition, CssRule);
-  type Error = selectors::parser::SelectorParseErrorKind<'i>;
+  type Error = ();
 
   fn parse_prelude<'t>(
       &mut self,
@@ -288,7 +289,7 @@ impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser {
 impl<'a, 'i> QualifiedRuleParser<'i> for TopLevelRuleParser {
   type Prelude = SelectorList<Selectors>;
   type QualifiedRule = (SourcePosition, CssRule);
-  type Error = selectors::parser::SelectorParseErrorKind<'i>;
+  type Error = ();
 
   #[inline]
   fn parse_prelude<'t>(
@@ -358,20 +359,20 @@ impl ToCss for ImportRule {
 #[derive(Debug)]
 pub struct StyleRule {
   pub selectors: SelectorList<Selectors>,
-  pub declarations: Vec<(String, Vec<Value>)>
+  pub declarations: Vec<Property>
 }
 
 impl ToCss for StyleRule {
   fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
     // dest.write_str(&self.selectors)?;
     self.selectors.to_css(dest)?;
     dest.write_str(" { ")?;
-    for (key, val) in self.declarations.iter() {
-      dest.write_str("\n  ")?;
-      dest.write_str(key)?;
-      dest.write_str(": ")?;
-      // dest.write_str(val)?;
-    }
+    // for (key, val) in self.declarations.iter() {
+    //   dest.write_str("\n  ")?;
+    //   dest.write_str(key)?;
+    //   dest.write_str(": ")?;
+    //   // dest.write_str(val)?;
+    // }
     dest.write_str("\n}")
   }
 }
@@ -424,7 +425,7 @@ impl<'a, 'b, 'i> AtRuleParser<'i> for NestedRuleParser {
   type PreludeNoBlock = AtRulePrelude;
   type PreludeBlock = AtRulePrelude;
   type AtRule = CssRule;
-  type Error = selectors::parser::SelectorParseErrorKind<'i>;
+  type Error = ();
 
   fn parse_prelude<'t>(
       &mut self,
@@ -648,33 +649,33 @@ pub enum Value {
   Url(String)
 }
 
-fn exhaust<'i>(input: &mut cssparser::Parser<'i, '_>) -> Vec<Value> {
+// fn exhaust<'i>(input: &mut cssparser::Parser<'i, '_>) -> Vec<Value> {
   // let start = input.position();
   // while input.next().is_ok() {}
   // input.slice_from(start)
-  let mut val = vec![];
-  loop {
-    if let Ok(tok) = input.next() {
-      println!("{:?}", tok);
-      match tok {
-        Token::UnquotedUrl(ref url) => val.push(Value::Url((&**url).into())),
-        Token::Function(ref name) if name.eq_ignore_ascii_case("url") => {
-          let url = input.parse_nested_block(|input| {
-              input.expect_string().map_err(Into::into).map(|s| s.clone())
-          })
-          .map_err(ParseError::<()>::basic);
-          if let Ok(url) = url {
-            val.push(Value::Url((&*url).into()));
-          }
-        },
-        _ => {}
-      }
-    } else {
-      break
-    }
-  }
-  val
-}
+  // let mut val = vec![];
+  // loop {
+  //   if let Ok(tok) = input.next() {
+  //     println!("{:?}", tok);
+  //     match tok {
+  //       Token::UnquotedUrl(ref url) => val.push(Value::Url((&**url).into())),
+  //       Token::Function(ref name) if name.eq_ignore_ascii_case("url") => {
+  //         let url = input.parse_nested_block(|input| {
+  //             input.expect_string().map_err(Into::into).map(|s| s.clone())
+  //         })
+  //         .map_err(ParseError::<()>::basic);
+  //         if let Ok(url) = url {
+  //           val.push(Value::Url((&*url).into()));
+  //         }
+  //       },
+  //       _ => {}
+  //     }
+  //   } else {
+  //     break
+  //   }
+  // }
+  // val
+// }
 
 struct SelectorParser;
 impl<'i> selectors::parser::Parser<'i> for SelectorParser {
@@ -685,7 +686,7 @@ impl<'i> selectors::parser::Parser<'i> for SelectorParser {
 impl<'a, 'b, 'i> QualifiedRuleParser<'i> for NestedRuleParser {
   type Prelude = SelectorList<Selectors>;
   type QualifiedRule = CssRule;
-  type Error = selectors::parser::SelectorParseErrorKind<'i>;
+  type Error = ();
 
   fn parse_prelude<'t>(
       &mut self,
@@ -696,7 +697,10 @@ impl<'a, 'b, 'i> QualifiedRuleParser<'i> for NestedRuleParser {
       //     namespaces: self.namespaces,
       //     url_data: Some(self.context.url_data),
       };
-      SelectorList::parse(&selector_parser, input)
+      match SelectorList::parse(&selector_parser, input) {
+        Ok(x) => Ok(x),
+        Err(_) => Err(input.new_error(BasicParseErrorKind::QualifiedRuleInvalid))
+      }
       // Ok(exhaust(input))
   }
 
@@ -727,22 +731,22 @@ struct PropertyDeclarationParser;
 
 /// Parse a declaration within {} block: `color: blue`
 impl<'i> cssparser::DeclarationParser<'i> for PropertyDeclarationParser {
-  type Declaration = (String, Vec<Value>);
-  type Error = selectors::parser::SelectorParseErrorKind<'i>;
+  type Declaration = Property;
+  type Error = ();
 
   fn parse_value<'t>(
       &mut self,
       name: CowRcStr<'i>,
       input: &mut cssparser::Parser<'i, 't>,
   ) -> Result<Self::Declaration, cssparser::ParseError<'i, Self::Error>> {
-      Ok((name.as_ref().into(), exhaust(input).into()))
+    Property::parse(name, input)
   }
 }
 
 /// Default methods reject all at rules.
 impl<'i> AtRuleParser<'i> for PropertyDeclarationParser {
   type PreludeNoBlock = ();
   type PreludeBlock = ();
-  type AtRule = (String, Vec<Value>);
-  type Error = selectors::parser::SelectorParseErrorKind<'i>;
+  type AtRule = Property;
+  type Error = ();
 }

src/properties/custom.rs

@@ -0,0 +1,36 @@
+use cssparser::*;
+
+#[derive(Debug)]
+pub struct CustomProperty {
+  pub name: String,
+  pub value: String
+}
+
+impl CustomProperty {
+  pub fn parse<'i, 't>(
+    name: CowRcStr<'i>,
+    input: &mut Parser<'i, 't>,
+  ) -> Result<Self, ParseError<'i, ()>> {
+    input.skip_whitespace();
+    input.parse_until_before(Delimiter::Bang | Delimiter::Semicolon, |input| {
+      // Need at least one token
+      let start = input.state();
+      input.next_including_whitespace()?;
+      input.reset(&start);
+
+      // parse_declaration_value_block(input, references, missing_closing_characters)
+      let start = input.position();
+      loop {
+        match input.next_including_whitespace_and_comments() {
+          Ok(_) => {},
+          Err(..) => {
+            return Ok(CustomProperty {
+              name: name.as_ref().into(),
+              value: input.slice_from(start).trim_end().into()
+            })
+          },
+        };
+      }
+    })
+  }
+}

src/properties/mod.rs

@@ -0,0 +1,33 @@
+mod custom;
+
+use cssparser::*;
+use custom::*;
+
+#[derive(Debug)]
+pub enum Property {
+  BackgroundColor(Color),
+  Color(Color),
+  Custom(CustomProperty)
+}
+
+impl Property {
+  pub fn parse<'i, 't>(name: CowRcStr<'i>, input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ()>> {
+    macro_rules! property {
+      ($property: ident, $type: ident) => {
+        if let Ok(c) = $type::parse(input) {
+          return Ok(Property::$property(c))
+        }
+      };
+    }    
+    
+    let state = input.state();
+    match name.as_ref() {
+      "background-color" => property!(BackgroundColor, Color),
+      "color" => property!(Color, Color),
+      _ => {}
+    }
+
+    input.reset(&state);
+    return Ok(Property::Custom(CustomProperty::parse(name, input)?))
+  }
+}

test.js

@@ -7,15 +7,17 @@ css.transform({
 @import "foo.css" print;
 
 .foo + .bar:not(.baz) {
-  background: url(img.png), url('test.jpg');
+  background-color: blue;
+  // background: url(img.png), url('test.jpg');
   color: blue;
 }
 
 .hi {}
 
 @media screen and (max-width: 250px) {
   .baz {
-    background: url(img.png);
+    // background: url(img.png) ;
+    color: var(--test);
   }
 }
 `)})