Analyze dependencies in custom properties

Fixes parcel-bundler#81. Only absolute URLs are allowed since relative paths are ambiguous.

Author: devongovett

node/src/lib.rs

@@ -358,6 +358,14 @@ impl<'i> CompileError<'i> {
   #[cfg(not(target_arch = "wasm32"))]
   fn throw(self, ctx: CallContext, code: Option<&str>) -> napi::Result<JsUnknown> {
     let reason = self.reason();
+    let data = match &self {
+      CompileError::ParseError(Error { kind, .. }) => ctx.env.to_js_value(kind)?,
+      CompileError::PrinterError(Error { kind, .. }) => ctx.env.to_js_value(kind)?,
+      CompileError::MinifyError(Error { kind, .. }) => ctx.env.to_js_value(kind)?,
+      CompileError::BundleError(Error { kind, .. }) => ctx.env.to_js_value(kind)?,
+      _ => ctx.env.get_null()?.into_unknown()
+    };
+
     match self {
       CompileError::ParseError(Error { loc, .. }) |
       CompileError::PrinterError(Error { loc, .. }) |
@@ -382,6 +390,7 @@ impl<'i> CompileError<'i> {
           loc.set_named_property("column", col)?;
           obj.set_named_property("loc", loc)?;
         }
+        obj.set_named_property("data", data)?;
         ctx.env.throw(obj)?;
         Ok(ctx.env.get_undefined()?.into_unknown())
       },

src/bundler.rs

@@ -1,4 +1,5 @@
 use parcel_sourcemap::SourceMap;
+use serde::Serialize;
 use crate::{rules::{Location, layer::{LayerBlockRule, LayerName}}, error::ErrorLocation};
 use std::{fs, path::{Path, PathBuf}, sync::Mutex, collections::HashSet};
 use rayon::prelude::*;
@@ -73,9 +74,9 @@ impl Drop for FileProvider {
   }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub enum BundleErrorKind<'i> {
-  IOError(std::io::Error),
+  IOError(#[serde(skip)] std::io::Error),
   ParserError(ParserError<'i>),
   UnsupportedImportCondition,
   UnsupportedMediaBooleanLogic,

src/error.rs

@@ -3,6 +3,7 @@ use cssparser::{ParseError, ParseErrorKind, BasicParseErrorKind};
 use crate::rules::Location;
 use crate::properties::custom::Token;
 use crate::values::string::CowArcStr;
+use serde::Serialize;
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct Error<T> {
@@ -27,10 +28,11 @@ impl ErrorLocation {
   }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Serialize)]
+#[serde(tag = "type")]
 pub enum ParserError<'i> {
   /// An unexpected token was encountered.
-  UnexpectedToken(Token<'i>),
+  UnexpectedToken(#[serde(skip)] Token<'i>),
   /// The end of the input was encountered unexpectedly.
   EndOfInput,
   /// An `@` rule was encountered that was invalid.
@@ -102,9 +104,10 @@ impl<'i> ParserError<'i> {
   }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Serialize)]
+#[serde(tag = "type")]
 pub enum SelectorError<'i> {
-  NoQualifiedNameInAttributeSelector(Token<'i>),
+  NoQualifiedNameInAttributeSelector(#[serde(skip)] Token<'i>),
   EmptySelector,
   DanglingCombinator,
   NonCompoundSelector,
@@ -114,18 +117,18 @@ pub enum SelectorError<'i> {
   InvalidState,
   MissingNestingSelector,
   MissingNestingPrefix,
-  UnexpectedTokenInAttributeSelector(Token<'i>),
-  PseudoElementExpectedColon(Token<'i>),
-  PseudoElementExpectedIdent(Token<'i>),
-  NoIdentForPseudo(Token<'i>),
+  UnexpectedTokenInAttributeSelector(#[serde(skip)] Token<'i>),
+  PseudoElementExpectedColon(#[serde(skip)] Token<'i>),
+  PseudoElementExpectedIdent(#[serde(skip)] Token<'i>),
+  NoIdentForPseudo(#[serde(skip)] Token<'i>),
   UnsupportedPseudoClassOrElement(CowArcStr<'i>),
   UnexpectedIdent(CowArcStr<'i>),
   ExpectedNamespace(CowArcStr<'i>),
-  ExpectedBarInAttr(Token<'i>),
-  BadValueInAttr(Token<'i>),
-  InvalidQualNameInAttr(Token<'i>),
-  ExplicitNamespaceUnexpectedToken(Token<'i>),
-  ClassNeedsIdent(Token<'i>),
+  ExpectedBarInAttr(#[serde(skip)] Token<'i>),
+  BadValueInAttr(#[serde(skip)] Token<'i>),
+  InvalidQualNameInAttr(#[serde(skip)] Token<'i>),
+  ExplicitNamespaceUnexpectedToken(#[serde(skip)] Token<'i>),
+  ClassNeedsIdent(#[serde(skip)] Token<'i>),
 }
 
 impl<'i> From<SelectorParseErrorKind<'i>> for SelectorError<'i> {
@@ -189,7 +192,8 @@ pub struct ErrorWithLocation<T> {
 
 pub type MinifyError = ErrorWithLocation<MinifyErrorKind>;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Serialize)]
+#[serde(tag = "type")]
 pub enum MinifyErrorKind {
   UnsupportedCustomMediaBooleanLogic { custom_media_loc: Location },
   CustomMediaNotDefined { name: String },
@@ -208,11 +212,13 @@ impl MinifyErrorKind {
 
 pub type PrinterError = Error<PrinterErrorKind>;
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Serialize)]
+#[serde(tag = "type")]
 pub enum PrinterErrorKind {
   FmtError,
   InvalidComposesSelector,
-  InvalidComposesNesting
+  InvalidComposesNesting,
+  AmbiguousUrlInCustomProperty { url: String }
 }
 
 impl From<std::fmt::Error> for PrinterError {
@@ -229,7 +235,8 @@ impl PrinterErrorKind {
     match self {
       PrinterErrorKind::InvalidComposesSelector => "The `composes` property can only be used within a simple class selector.".into(),
       PrinterErrorKind::InvalidComposesNesting => "The `composes` property cannot be used within nested rules.".into(),
-      PrinterErrorKind::FmtError => "Printer error".into()
+      PrinterErrorKind::FmtError => "Printer error".into(),
+      PrinterErrorKind::AmbiguousUrlInCustomProperty { .. } => "Ambiguous url() in custom property. Relative paths are resolved from the location the var() is used, not where the custom property is defined. Use an absolute URL instead.".into()
     }
   }
 }

src/lib.rs

@@ -23,7 +23,7 @@ mod context;
 #[cfg(test)]
 mod tests {
   use crate::dependencies::Dependency;
-  use crate::error::{Error, MinifyErrorKind, ErrorLocation, ParserError};
+  use crate::error::{Error, MinifyErrorKind, ErrorLocation, ParserError, PrinterErrorKind};
   use crate::properties::custom::Token;
   use crate::rules::CssRule;
   use crate::stylesheet::*;
@@ -13178,6 +13178,18 @@ mod tests {
       }
     }
 
+    fn dep_error_test(source: &str, error: PrinterErrorKind) {
+      let stylesheet = StyleSheet::parse("test.css".into(), &source, ParserOptions::default()).unwrap();
+      let res = stylesheet.to_css(PrinterOptions {
+        analyze_dependencies: true,
+        ..PrinterOptions::default()
+      });
+      match res {
+        Err(e) => assert_eq!(e.kind, error),
+        _ => unreachable!()
+      }
+    }
+
     dep_test(
       ".foo { background: image-set('./img12x.png', './img21x.png' 2x)}",
       ".foo{background:image-set(\"hXFI8W\",\"5TkpBa\" 2x)}",
@@ -13195,6 +13207,61 @@ mod tests {
         ("./img21x.png", "5TkpBa")
       ]
     );
+
+    dep_test(
+      ".foo { --test: url(/foo.png) }",
+      ".foo{--test:url(\"lDnnrG\")}",
+      vec![
+        ("/foo.png", "lDnnrG"),
+      ]
+    );
+
+    dep_test(
+      ".foo { --test: url(\"/foo.png\") }",
+      ".foo{--test:url(\"lDnnrG\")}",
+      vec![
+        ("/foo.png", "lDnnrG"),
+      ]
+    );
+
+    dep_test(
+      ".foo { --test: url(\"http://example.com/foo.png\") }",
+      ".foo{--test:url(\"3X1zSW\")}",
+      vec![
+        ("http://example.com/foo.png", "3X1zSW"),
+      ]
+    );
+
+    dep_test(
+      ".foo { --test: url(\"data:image/svg+xml;utf8,<svg></svg>\") }",
+      ".foo{--test:url(\"-vl-rG\")}",
+      vec![
+        ("data:image/svg+xml;utf8,<svg></svg>", "-vl-rG"),
+      ]
+    );
+
+    dep_test(
+      ".foo { background: url(\"foo.png\") var(--test) }",
+      ".foo{background:url(\"Vwkwkq\") var(--test)}",
+      vec![
+        ("foo.png", "Vwkwkq"),
+      ]
+    );
+
+    dep_error_test(
+      ".foo { --test: url(\"foo.png\") }",
+      PrinterErrorKind::AmbiguousUrlInCustomProperty { url: "foo.png".into() }
+    );
+
+    dep_error_test(
+      ".foo { --test: url(foo.png) }",
+      PrinterErrorKind::AmbiguousUrlInCustomProperty { url: "foo.png".into() }
+    );
+
+    dep_error_test(
+      ".foo { --test: url(./foo.png) }",
+      PrinterErrorKind::AmbiguousUrlInCustomProperty { url: "./foo.png".into() }
+    );
   }
 
   #[test]

src/properties/custom.rs

@@ -6,10 +6,11 @@ use crate::traits::{Parse, ToCss};
 use crate::properties::PropertyId;
 use crate::values::color::{CssColor, ColorFallbackKind};
 use crate::values::length::serialize_dimension;
+use crate::values::url::Url;
 use crate::vendor_prefix::VendorPrefix;
 use crate::targets::Browsers;
 use crate::prefixes::Feature;
-use crate::error::{ParserError, PrinterError};
+use crate::error::{ParserError, PrinterError, PrinterErrorKind};
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct CustomProperty<'i> {
@@ -48,7 +49,7 @@ impl<'i> UnparsedProperty<'i> {
     })
   }
 
-  pub fn get_prefixed(&self, targets: Option<Browsers>, feature: Feature) -> UnparsedProperty<'i> {
+  pub(crate) fn get_prefixed(&self, targets: Option<Browsers>, feature: Feature) -> UnparsedProperty<'i> {
     let mut clone = self.clone();
     if self.property_id.prefix().contains(VendorPrefix::None) {
       if let Some(targets) = targets {
@@ -72,7 +73,8 @@ pub struct TokenList<'i>(pub Vec<TokenOrValue<'i>>);
 #[derive(Debug, Clone, PartialEq)]
 pub enum TokenOrValue<'i> {
   Token(Token<'i>),
-  Color(CssColor)
+  Color(CssColor),
+  Url(Url<'i>)
 }
 
 impl<'i> From<Token<'i>> for TokenOrValue<'i> {
@@ -131,6 +133,11 @@ impl<'i> TokenList<'i> {
             tokens.push(TokenOrValue::Color(color));
             last_is_delim = false;
             last_is_whitespace = false;
+          } else if f == "url" {
+            input.reset(&state);
+            tokens.push(TokenOrValue::Url(Url::parse(input)?));
+            last_is_delim = false;
+            last_is_whitespace = false;
           } else {
             tokens.push(Token::Function(f).into()); 
             input.parse_nested_block(|input| {
@@ -150,6 +157,12 @@ impl<'i> TokenList<'i> {
           last_is_delim = false;
           last_is_whitespace = false;
         }
+        Ok(&cssparser::Token::UnquotedUrl(_)) => {
+          input.reset(&state);
+          tokens.push(TokenOrValue::Url(Url::parse(input)?));
+          last_is_delim = false;
+          last_is_whitespace = false;
+        }
         Ok(token @ &cssparser::Token::ParenthesisBlock) | 
         Ok(token @ &cssparser::Token::SquareBracketBlock) | 
         Ok(token @ &cssparser::Token::CurlyBracketBlock) => {
@@ -210,15 +223,23 @@ fn try_parse_color_token<'i, 't>(f: &CowArcStr<'i>, state: &ParserState, input:
   None
 }
 
-impl<'i> ToCss for TokenList<'i> {
-  fn to_css<W>(&self, dest: &mut Printer<W>) -> Result<(), PrinterError> where W: std::fmt::Write {
+impl<'i> TokenList<'i> {
+  pub(crate) fn to_css<W>(&self, dest: &mut Printer<W>, is_custom_property: bool) -> Result<(), PrinterError> where W: std::fmt::Write {
     if !dest.minify && self.0.len() == 1 && matches!(self.0.first(), Some(token) if token.is_whitespace()) {
       return Ok(())
     }
 
     for (i, token_or_value) in self.0.iter().enumerate() {
       match token_or_value {
         TokenOrValue::Color(color) => color.to_css(dest)?,
+        TokenOrValue::Url(url) => {
+          if dest.dependencies.is_some() && is_custom_property && !url.is_absolute() {
+            return Err(dest.error(PrinterErrorKind::AmbiguousUrlInCustomProperty {
+              url: url.url.as_ref().to_owned()
+            }, url.loc))
+          }
+          url.to_css(dest)?
+        },
         TokenOrValue::Token(token) => {
           match token {
             Token::Delim(d) => {

src/properties/mod.rs

@@ -390,10 +390,10 @@ macro_rules! define_properties {
             }
           )+
           Unparsed(unparsed) => {
-            unparsed.value.to_css(dest)
+            unparsed.value.to_css(dest, false)
           }
           Custom(custom) => {
-            custom.value.to_css(dest)
+            custom.value.to_css(dest, true)
           }
           Logical(logical) => {
             logical.to_css(dest)

src/rules/font_face.rs

@@ -411,7 +411,7 @@ impl<'i> ToCss for FontFaceProperty<'i> {
       Custom(custom) => {
         dest.write_str(custom.name.as_ref())?;
         dest.delim(':', false)?;
-        custom.value.to_css(dest)
+        custom.value.to_css(dest, true)
       }
     }
   }

src/rules/mod.rs

@@ -14,6 +14,7 @@ pub mod custom_media;
 pub mod layer;
 pub mod property;
 
+use serde::Serialize;
 use crate::values::string::CowArcStr;
 use media::MediaRule;
 use import::ImportRule;
@@ -51,7 +52,7 @@ pub(crate) struct StyleContext<'a, 'i> {
   pub parent: Option<&'a StyleContext<'a, 'i>>
 }
 
-#[derive(PartialEq, Eq, Debug, Clone, Copy)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy, Serialize)]
 pub struct Location {
   /// The index of the source file within the source map.
   pub source_index: u32,

src/values/string.rs

@@ -1,4 +1,5 @@
 use cssparser::CowRcStr;
+use serde::{Serialize, Serializer};
 use std::marker::PhantomData;
 use std::rc::Rc;
 use std::sync::Arc;
@@ -209,3 +210,9 @@ impl<'a> fmt::Debug for CowArcStr<'a> {
     str::fmt(self, formatter)
   }
 }
+
+impl<'a> Serialize for CowArcStr<'a> {
+  fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+    self.as_ref().serialize(serializer)
+  }
+}