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

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

src/lib.rs

@@ -116,9 +116,6 @@ mod mac {
   }
 }
 
-#[doc(hidden)]
-pub use phf as _cssparser_internal_phf;
-
 #[macro_use]
 mod macros;
 

src/macros.rs

@@ -73,6 +73,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
@@ -86,7 +88,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! {
 ///         static KEYWORDS : (u8, u8, u8) = {
 ///             "red" => (255, 0, 0),
 ///             "green" => (0, 255, 0),
@@ -98,13 +100,77 @@ macro_rules! match_ignore_ascii_case {
 /// ```
 ///
 /// You can also iterate over the map entries by using `keywords::entries()`.
+macro_rules! ascii_case_insensitive_map {
+    (static $name:ident : $ValueType:ty = { $( $key:tt => $value:expr ),+ }) => {
+        ascii_case_insensitive_map!(static $name : $ValueType = { $( $key => $value, )+ })
+    };
+    (static $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! {
+///         static 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 {
     (static $name:ident : $ValueType:ty = { $( $key:tt => $value:expr ),+ }) => {
         ascii_case_insensitive_phf_map!(static $name : $ValueType = { $( $key => $value, )+ })
     };
     (static $name:ident : $ValueType:ty = { $( $key:tt => $value:expr, )+ }) => {
-        use $crate::_cssparser_internal_phf as phf;
 
         #[inline(always)]
         const fn const_usize_max(a: usize, b: usize) -> usize {
@@ -124,7 +190,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,
             )*

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! {
         static MAP : () = {
             "  \t\n" => ()
         }