Make phf for color matching optional

Signed-off-by: Nico Burns <nico@nicoburns.com>

Author: nicoburns

Cargo.toml

@@ -23,7 +23,7 @@ encoding_rs = "0.8"
 cssparser-macros = { path = "./macros", version = "0.6.1", optional = true }
 dtoa-short = "0.3"
 itoa = "1.0"
-phf = { version = "0.13.1", features = ["macros"] }
+phf = { version = "0.13.1", features = ["macros"], optional = true }
 serde = { version = "1.0", features = ["derive"], optional = true }
 malloc_size_of = { version = "0.1", default-features = false, optional = true }
 smallvec = "1.0"
@@ -33,9 +33,10 @@ inherits = "release"
 debug = true
 
 [features]
-default = ["fast_match_byte"]
+default = ["fast_match_byte", "fast_match_color"]
 bench = []
 fast_match_byte = ["dep:cssparser-macros"]
+fast_match_color = ["dep:phf"]
 # Useful for skipping tests when execution is slow, e.g., under miri
 skip_long_tests = []
 

src/color.rs

@@ -172,7 +172,7 @@ pub fn parse_hash_color(value: &[u8]) -> Result<(u8, u8, u8, f32), ()> {
     })
 }
 
-ascii_case_insensitive_phf_map! {
+ascii_case_insensitive_map! {
     named_colors -> (u8, u8, u8) = {
         "black" => (0, 0, 0),
         "silver" => (192, 192, 192),

src/lib.rs

@@ -116,6 +116,9 @@ mod mac {
   }
 }
 
+// Re-exporting phf here means that the crate using the ascii_case_insensitive_phf_map macro do
+// do not have to depend on phf directly.
+#[cfg(feature = "fast_match_color")]
 #[doc(hidden)]
 pub use phf as _cssparser_internal_phf;
 

src/macros.rs

@@ -75,6 +75,8 @@ macro_rules! match_ignore_ascii_case {
     };
 }
 
+#[cfg(not(feature = "fast_match_color"))]
+#[macro_export]
 /// Define a function `$name(&str) -> Option<&'static $ValueType>`
 ///
 /// The function finds a match for the input string
@@ -88,7 +90,7 @@ macro_rules! match_ignore_ascii_case {
 /// # fn main() {}  // Make doctest not wrap everything in its own main
 ///
 /// fn color_rgb(input: &str) -> Option<(u8, u8, u8)> {
-///     cssparser::ascii_case_insensitive_phf_map! {
+///     cssparser::ascii_case_insensitive_map! {
 ///         keywords -> (u8, u8, u8) = {
 ///             "red" => (255, 0, 0),
 ///             "green" => (0, 255, 0),
@@ -100,6 +102,71 @@ macro_rules! match_ignore_ascii_case {
 /// ```
 ///
 /// You can also iterate over the map entries by using `keywords::entries()`.
+macro_rules! ascii_case_insensitive_map {
+    ($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr ),+ }) => {
+        ascii_case_insensitive_map!($name -> $ValueType = { $( $key => $value, )+ })
+    };
+    ($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr, )+ }) => {
+
+        // While the obvious choice for this would be an inner module, it's not possible to
+        // reference from types from there, see:
+        // <https://github.com/rust-lang/rust/issues/114369>
+        //
+        // So we abuse a struct with static associated functions instead.
+        #[allow(non_camel_case_types)]
+        struct $name;
+        impl $name {
+            #[allow(dead_code)]
+            fn entries() -> impl Iterator<Item = (&'static &'static str, &'static $ValueType)> {
+                [ $((&$key, &$value),)* ].iter().copied()
+            }
+
+            fn get(input: &str) -> Option<&'static $ValueType> {
+                $crate::match_ignore_ascii_case!(input,
+                    $($key => Some(&$value),)*
+                    _ => None,
+                )
+            }
+        }
+    }
+}
+
+#[cfg(feature = "fast_match_color")]
+#[macro_export]
+/// Define a function `$name(&str) -> Option<&'static $ValueType>`
+///
+/// The function finds a match for the input string
+/// in a [`phf` map](https://github.com/sfackler/rust-phf)
+/// and returns a reference to the corresponding value.
+/// Matching is case-insensitive in the ASCII range.
+///
+/// ## Example:
+///
+/// ```rust
+/// # fn main() {}  // Make doctest not wrap everything in its own main
+///
+/// fn color_rgb(input: &str) -> Option<(u8, u8, u8)> {
+///     cssparser::ascii_case_insensitive_map! {
+///         keywords -> (u8, u8, u8) = {
+///             "red" => (255, 0, 0),
+///             "green" => (0, 255, 0),
+///             "blue" => (0, 0, 255),
+///         }
+///     }
+///     keywords::get(input).cloned()
+/// }
+/// ```
+///
+/// You can also iterate over the map entries by using `keywords::entries()`.
+macro_rules! ascii_case_insensitive_map {
+    ($($any:tt)+) => {
+        $crate::ascii_case_insensitive_phf_map!($($any)+);
+    };
+}
+
+/// Fast implementation of `ascii_case_insensitive_map!` using a phf map.
+/// See `ascii_case_insensitive_map!` above for docs
+#[cfg(feature = "fast_match_color")]
 #[macro_export]
 macro_rules! ascii_case_insensitive_phf_map {
     ($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr ),+ }) => {
@@ -126,7 +193,7 @@ macro_rules! ascii_case_insensitive_phf_map {
             maxlen
         };
 
-        static MAP: phf::Map<&'static str, $ValueType> = phf::phf_map! {
+        static __MAP: phf::Map<&'static str, $ValueType> = phf::phf_map! {
             $(
                 $key => $value,
             )*
@@ -142,12 +209,12 @@ macro_rules! ascii_case_insensitive_phf_map {
         impl $name {
             #[allow(dead_code)]
             fn entries() -> impl Iterator<Item = (&'static &'static str, &'static $ValueType)> {
-                MAP.entries()
+                __MAP.entries()
             }
 
             fn get(input: &str) -> Option<&'static $ValueType> {
                 $crate::_cssparser_internal_to_lowercase!(input, MAX_LENGTH => lowercase);
-                MAP.get(lowercase?)
+                __MAP.get(lowercase?)
             }
         }
     }

src/tests.rs

@@ -1085,7 +1085,7 @@ fn one_component_value_to_json(token: Token, input: &mut Parser) -> Value {
 /// including in string literals.
 #[test]
 fn procedural_masquerade_whitespace() {
-    ascii_case_insensitive_phf_map! {
+    ascii_case_insensitive_map! {
         map -> () = {
             "  \t\n" => ()
         }