Use Option<f32> for rgb components as well.

Author: tiaanl

src/color.rs

@@ -63,101 +63,49 @@ fn normalize_hue(hue: f32) -> f32 {
 #[repr(C)]
 pub struct RGBA {
     /// The red component.
-    pub red: u8,
+    pub red: Option<u8>,
     /// The green component.
-    pub green: u8,
+    pub green: Option<u8>,
     /// The blue component.
-    pub blue: u8,
+    pub blue: Option<u8>,
     /// The alpha component.
-    pub alpha: f32,
+    pub alpha: Option<f32>,
 }
 
 impl RGBA {
     /// Constructs a new RGBA value from float components. It expects the red,
     /// green, blue and alpha channels in that order, and all values will be
     /// clamped to the 0.0 ... 1.0 range.
     #[inline]
-    pub fn from_floats(red: f32, green: f32, blue: f32, alpha: f32) -> Self {
+    pub fn from_floats(
+        red: Option<f32>,
+        green: Option<f32>,
+        blue: Option<f32>,
+        alpha: Option<f32>,
+    ) -> Self {
         Self::new(
-            clamp_unit_f32(red),
-            clamp_unit_f32(green),
-            clamp_unit_f32(blue),
-            alpha.max(0.0).min(1.0),
+            red.map(|r| clamp_unit_f32(r)),
+            green.map(|g| clamp_unit_f32(g)),
+            blue.map(|b| clamp_unit_f32(b)),
+            alpha.map(|a| a.clamp(0.0, OPAQUE)),
         )
     }
 
-    /// Returns a transparent color.
-    #[inline]
-    pub fn transparent() -> Self {
-        Self::new(0, 0, 0, 0.0)
-    }
-
     /// Same thing, but with `u8` values instead of floats in the 0 to 1 range.
     #[inline]
-    pub const fn new(red: u8, green: u8, blue: u8, alpha: f32) -> Self {
+    pub const fn new(
+        red: Option<u8>,
+        green: Option<u8>,
+        blue: Option<u8>,
+        alpha: Option<f32>,
+    ) -> Self {
         Self {
             red,
             green,
             blue,
             alpha,
         }
     }
-
-    /// Returns the red channel in a floating point number form, from 0 to 1.
-    #[inline]
-    pub fn red_f32(&self) -> f32 {
-        self.red as f32 / 255.0
-    }
-
-    /// Returns the green channel in a floating point number form, from 0 to 1.
-    #[inline]
-    pub fn green_f32(&self) -> f32 {
-        self.green as f32 / 255.0
-    }
-
-    /// Returns the blue channel in a floating point number form, from 0 to 1.
-    #[inline]
-    pub fn blue_f32(&self) -> f32 {
-        self.blue as f32 / 255.0
-    }
-
-    /// Returns the alpha channel in a floating point number form, from 0 to 1.
-    #[inline]
-    pub fn alpha_f32(&self) -> f32 {
-        self.alpha
-    }
-
-    /// Parse a color hash, without the leading '#' character.
-    #[inline]
-    pub fn parse_hash(value: &[u8]) -> Result<Self, ()> {
-        Ok(match value.len() {
-            8 => Self::new(
-                from_hex(value[0])? * 16 + from_hex(value[1])?,
-                from_hex(value[2])? * 16 + from_hex(value[3])?,
-                from_hex(value[4])? * 16 + from_hex(value[5])?,
-                (from_hex(value[6])? * 16 + from_hex(value[7])?) as f32 / 255.0,
-            ),
-            6 => Self::new(
-                from_hex(value[0])? * 16 + from_hex(value[1])?,
-                from_hex(value[2])? * 16 + from_hex(value[3])?,
-                from_hex(value[4])? * 16 + from_hex(value[5])?,
-                OPAQUE,
-            ),
-            4 => Self::new(
-                from_hex(value[0])? * 17,
-                from_hex(value[1])? * 17,
-                from_hex(value[2])? * 17,
-                (from_hex(value[3])? * 17) as f32 / 255.0,
-            ),
-            3 => Self::new(
-                from_hex(value[0])? * 17,
-                from_hex(value[1])? * 17,
-                from_hex(value[2])? * 17,
-                OPAQUE,
-            ),
-            _ => return Err(()),
-        })
-    }
 }
 
 #[cfg(feature = "serde")]
@@ -186,17 +134,17 @@ impl ToCss for RGBA {
     where
         W: fmt::Write,
     {
-        let has_alpha = self.alpha != OPAQUE;
+        let has_alpha = self.alpha.unwrap_or(0.0) != OPAQUE;
 
         dest.write_str(if has_alpha { "rgba(" } else { "rgb(" })?;
-        self.red.to_css(dest)?;
+        self.red.unwrap_or(0).to_css(dest)?;
         dest.write_str(", ")?;
-        self.green.to_css(dest)?;
+        self.green.unwrap_or(0).to_css(dest)?;
         dest.write_str(", ")?;
-        self.blue.to_css(dest)?;
+        self.blue.unwrap_or(0).to_css(dest)?;
 
         // Legacy syntax does not allow none components.
-        serialize_alpha(dest, Some(self.alpha), true)?;
+        serialize_alpha(dest, Some(self.alpha.unwrap_or(0.0)), true)?;
 
         dest.write_char(')')
     }
@@ -242,7 +190,7 @@ impl ToCss for Hsl {
             self.lightness.unwrap_or(0.0),
         );
 
-        RGBA::from_floats(red, green, blue, self.alpha.unwrap_or(0.0)).to_css(dest)
+        RGBA::from_floats(Some(red), Some(green), Some(blue), self.alpha).to_css(dest)
     }
 }
 
@@ -307,7 +255,7 @@ impl ToCss for Hwb {
             self.blackness.unwrap_or(0.0),
         );
 
-        RGBA::from_floats(red, green, blue, self.alpha.unwrap_or(0.0)).to_css(dest)
+        RGBA::from_floats(Some(red), Some(green), Some(blue), self.alpha).to_css(dest)
     }
 }
 
@@ -892,6 +840,42 @@ pub trait FromParsedColor {
     ) -> Self;
 }
 
+/// Parse a color hash, without the leading '#' character.
+#[inline]
+
+pub fn parse_hash_color<'i, 't, P>(value: &[u8]) -> Result<P::Output, ()>
+where
+    P: ColorParser<'i>,
+{
+    Ok(match value.len() {
+        8 => P::Output::from_rgba(
+            from_hex(value[0])? * 16 + from_hex(value[1])?,
+            from_hex(value[2])? * 16 + from_hex(value[3])?,
+            from_hex(value[4])? * 16 + from_hex(value[5])?,
+            (from_hex(value[6])? * 16 + from_hex(value[7])?) as f32 / 255.0,
+        ),
+        6 => P::Output::from_rgba(
+            from_hex(value[0])? * 16 + from_hex(value[1])?,
+            from_hex(value[2])? * 16 + from_hex(value[3])?,
+            from_hex(value[4])? * 16 + from_hex(value[5])?,
+            OPAQUE,
+        ),
+        4 => P::Output::from_rgba(
+            from_hex(value[0])? * 17,
+            from_hex(value[1])? * 17,
+            from_hex(value[2])? * 17,
+            (from_hex(value[3])? * 17) as f32 / 255.0,
+        ),
+        3 => P::Output::from_rgba(
+            from_hex(value[0])? * 17,
+            from_hex(value[1])? * 17,
+            from_hex(value[2])? * 17,
+            OPAQUE,
+        ),
+        _ => return Err(()),
+    })
+}
+
 /// Parse a CSS color with the specified [`ColorComponentParser`] and return a
 /// new color value on success.
 pub fn parse_color_with<'i, 't, P>(
@@ -904,8 +888,9 @@ where
     let location = input.current_source_location();
     let token = input.next()?;
     match *token {
-        Token::Hash(ref value) | Token::IDHash(ref value) => RGBA::parse_hash(value.as_bytes())
-            .map(|rgba| P::Output::from_rgba(rgba.red, rgba.green, rgba.blue, rgba.alpha)),
+        Token::Hash(ref value) | Token::IDHash(ref value) => {
+            parse_hash_color::<P>(value.as_bytes())
+        }
         Token::Ident(ref value) => parse_color_keyword(&*value),
         Token::Function(ref name) => {
             let name = name.clone();
@@ -926,7 +911,7 @@ impl FromParsedColor for Color {
 
     #[inline]
     fn from_rgba(red: u8, green: u8, blue: u8, alpha: f32) -> Self {
-        Color::Rgba(RGBA::new(red, green, blue, alpha))
+        Color::Rgba(RGBA::new(Some(red), Some(green), Some(blue), Some(alpha)))
     }
 
     fn from_hsl(

src/tests.rs

@@ -592,19 +592,19 @@ fn serialize_current_color() {
 
 #[test]
 fn serialize_rgb_full_alpha() {
-    let c = Color::Rgba(RGBA::new(255, 230, 204, 1.0));
+    let c = Color::Rgba(RGBA::new(Some(255), Some(230), Some(204), Some(1.0)));
     assert_eq!(c.to_css_string(), "rgb(255, 230, 204)");
 }
 
 #[test]
 fn serialize_rgba() {
-    let c = Color::Rgba(RGBA::new(26, 51, 77, 0.125));
+    let c = Color::Rgba(RGBA::new(Some(26), Some(51), Some(77), Some(0.125)));
     assert_eq!(c.to_css_string(), "rgba(26, 51, 77, 0.125)");
 }
 
 #[test]
 fn serialize_rgba_two_digit_float_if_roundtrips() {
-    let c = Color::Rgba(RGBA::from_floats(0., 0., 0., 0.5));
+    let c = Color::Rgba(RGBA::from_floats(Some(0.), Some(0.), Some(0.), Some(0.5)));
     assert_eq!(c.to_css_string(), "rgba(0, 0, 0, 0.5)");
 }