💥 Add alpha, rename fields

Author: bash

crates/pycolorsaurus/src/lib.rs

@@ -176,9 +176,10 @@ impl Color {
     #[new]
     fn new(red: u8, green: u8, blue: u8) -> Self {
         Self(imp::Color {
-            r: scale_to_u16(red),
-            g: scale_to_u16(green),
-            b: scale_to_u16(blue),
+            red: scale_to_u16(red),
+            green: scale_to_u16(green),
+            blue: scale_to_u16(blue),
+            alpha: u16::MAX,
         })
     }
 
@@ -218,7 +219,7 @@ impl Color {
 
     #[pyo3(name = "__repr__")]
     fn repr(&self, python: Python<'_>) -> PyResult<String> {
-        let (r, g, b) = self.0.scale_to_8bit();
+        let (r, g, b, _) = self.0.scale_to_8bit();
         let ty = type_name::<Self>(&python)?;
         Ok(format!("<{ty} #{r:02x}{g:02x}{b:02x}>"))
     }

crates/terminal-colorsaurus/examples/bg.rs

@@ -5,7 +5,7 @@ use terminal_colorsaurus::{background_color, Error, QueryOptions};
 fn main() -> Result<(), display::DisplayAsDebug<Error>> {
     let bg = background_color(QueryOptions::default())?;
     let bg_8bit = bg.scale_to_8bit();
-    println!("rgb16({}, {}, {})", bg.r, bg.g, bg.b);
+    println!("rgb16({}, {}, {})", bg.red, bg.green, bg.blue);
     println!("rgb8({}, {}, {})", bg_8bit.0, bg_8bit.1, bg_8bit.2);
     Ok(())
 }

crates/terminal-colorsaurus/examples/fg.rs

@@ -5,7 +5,7 @@ use terminal_colorsaurus::{foreground_color, Error, QueryOptions};
 fn main() -> Result<(), display::DisplayAsDebug<Error>> {
     let fg = foreground_color(QueryOptions::default())?;
     let fg_8bit = fg.scale_to_8bit();
-    println!("rgb16({}, {}, {})", fg.r, fg.g, fg.b);
+    println!("rgb16({}, {}, {})", fg.red, fg.green, fg.blue);
     println!("rgb8({}, {}, {})", fg_8bit.0, fg_8bit.1, fg_8bit.2);
     Ok(())
 }

crates/terminal-colorsaurus/src/color.rs

@@ -4,11 +4,14 @@
 #[allow(clippy::exhaustive_structs)]
 pub struct Color {
     /// Red
-    pub r: u16,
+    pub red: u16,
     /// Green
-    pub g: u16,
+    pub green: u16,
     /// Blue
-    pub b: u16,
+    pub blue: u16,
+    /// Can almost always be ignored as it is rarely set to
+    /// something other than the default (`0xffff`).
+    pub alpha: u16,
 }
 
 impl Color {
@@ -22,29 +25,47 @@ impl Color {
     /// let is_dark = color.perceived_lightness() <= 0.5;
     /// ```
     pub fn perceived_lightness(&self) -> f32 {
-        let color = xterm_color::Color::rgb(self.r, self.g, self.b);
+        let color = xterm_color::Color {
+            red: self.red,
+            green: self.green,
+            blue: self.blue,
+            alpha: self.alpha,
+        };
         color.perceived_lightness()
     }
 
     /// Converts the color to 8 bit precision per channel by scaling each channel.
     ///
     /// ```
     /// # use terminal_colorsaurus::Color;
-    /// let white = Color { r: u16::MAX, g: u16::MAX, b: u16::MAX };
-    /// assert_eq!((u8::MAX, u8::MAX, u8::MAX), white.scale_to_8bit());
+    /// let white = Color { red: u16::MAX, green: u16::MAX, blue: u16::MAX, alpha: u16::MAX };
+    /// assert_eq!((u8::MAX, u8::MAX, u8::MAX, u8::MAX), white.scale_to_8bit());
     ///
-    /// let black = Color { r: 0, g: 0, b: 0 };
-    /// assert_eq!((0, 0, 0), black.scale_to_8bit());
+    /// let black = Color { red: 0, green: 0, blue: 0, alpha: u16::MAX };
+    /// assert_eq!((0, 0, 0, u8::MAX), black.scale_to_8bit());
     /// ```
-    pub fn scale_to_8bit(&self) -> (u8, u8, u8) {
+    pub fn scale_to_8bit(&self) -> (u8, u8, u8, u8) {
         (
-            scale_to_u8(self.r),
-            scale_to_u8(self.g),
-            scale_to_u8(self.b),
+            scale_to_u8(self.red),
+            scale_to_u8(self.green),
+            scale_to_u8(self.blue),
+            scale_to_u8(self.alpha),
         )
     }
 }
 
+#[cfg(test)]
+impl Color {
+    pub(crate) const fn rgb(red: u16, green: u16, blue: u16) -> Self {
+        Self {
+            red,
+            green,
+            blue,
+            alpha: u16::MAX,
+        }
+    }
+}
+
 fn scale_to_u8(channel: u16) -> u8 {
     (channel as u32 * (u8::MAX as u32) / (u16::MAX as u32)) as u8
 }
@@ -53,36 +74,57 @@ fn scale_to_u8(channel: u16) -> u8 {
 impl From<Color> for rgb::RGB16 {
     fn from(value: Color) -> Self {
         rgb::RGB16 {
-            r: value.r,
-            g: value.g,
-            b: value.b,
+            r: value.red,
+            g: value.green,
+            b: value.blue,
+        }
+    }
+}
+
+#[cfg(feature = "rgb")]
+impl From<Color> for rgb::RGBA16 {
+    fn from(value: Color) -> Self {
+        rgb::RGBA16 {
+            r: value.red,
+            g: value.green,
+            b: value.blue,
+            a: value.alpha,
         }
     }
 }
 
 #[cfg(feature = "rgb")]
 impl From<Color> for rgb::RGB8 {
     fn from(value: Color) -> Self {
-        let (r, g, b) = value.scale_to_8bit();
+        let (r, g, b, _) = value.scale_to_8bit();
         rgb::RGB8 { r, g, b }
     }
 }
 
+#[cfg(feature = "rgb")]
+impl From<Color> for rgb::RGBA8 {
+    fn from(value: Color) -> Self {
+        let (r, g, b, a) = value.scale_to_8bit();
+        rgb::RGBA8 { r, g, b, a }
+    }
+}
+
 #[cfg(feature = "rgb")]
 impl From<rgb::RGB16> for Color {
     fn from(value: rgb::RGB16) -> Self {
         Color {
-            r: value.r,
-            g: value.g,
-            b: value.b,
+            red: value.r,
+            green: value.g,
+            blue: value.b,
+            alpha: u16::MAX,
         }
     }
 }
 
 #[cfg(feature = "anstyle")]
 impl From<Color> for anstyle::RgbColor {
     fn from(value: Color) -> Self {
-        let (r, g, b) = value.scale_to_8bit();
+        let (r, g, b, _) = value.scale_to_8bit();
         anstyle::RgbColor(r, g, b)
     }
 }
@@ -100,9 +142,10 @@ mod tests {
     #[test]
     fn white_has_perceived_lightness_100() {
         let white = Color {
-            r: u16::MAX,
-            g: u16::MAX,
-            b: u16::MAX,
+            red: u16::MAX,
+            green: u16::MAX,
+            blue: u16::MAX,
+            alpha: u16::MAX,
         };
         assert_eq!(1.0, white.perceived_lightness())
     }

crates/terminal-colorsaurus/src/color_scheme_tests.rs

@@ -1,32 +1,12 @@
 use super::*;
 use ColorScheme::*;
 
-const BLACK: Color = Color { r: 0, g: 0, b: 0 };
-const WHITE: Color = Color {
-    r: u16::MAX,
-    g: u16::MAX,
-    b: u16::MAX,
-};
-const DARK_GRAY: Color = Color {
-    r: 0x44ff,
-    g: 0x44ff,
-    b: 0x44ff,
-};
-const DARKER_GRAY: Color = Color {
-    r: 0x22ff,
-    g: 0x22ff,
-    b: 0x22ff,
-};
-const LIGHT_GRAY: Color = Color {
-    r: 0xccff,
-    g: 0xccff,
-    b: 0xccff,
-};
-const LIGHTER_GRAY: Color = Color {
-    r: 0xeeff,
-    g: 0xeeff,
-    b: 0xeeff,
-};
+const BLACK: Color = Color::rgb(0, 0, 0);
+const WHITE: Color = Color::rgb(u16::MAX, u16::MAX, u16::MAX);
+const DARK_GRAY: Color = Color::rgb(0x44ff, 0x44ff, 0x44ff);
+const DARKER_GRAY: Color = Color::rgb(0x22ff, 0x22ff, 0x22ff);
+const LIGHT_GRAY: Color = Color::rgb(0xccff, 0xccff, 0xccff);
+const LIGHTER_GRAY: Color = Color::rgb(0xeeff, 0xeeff, 0xeeff);
 
 mod dark {
     use super::*;

crates/terminal-colorsaurus/src/lib.rs

@@ -32,7 +32,7 @@
 //! use terminal_colorsaurus::{foreground_color, QueryOptions};
 //!
 //! let fg = foreground_color(QueryOptions::default()).unwrap();
-//! println!("rgb({}, {}, {})", fg.r, fg.g, fg.b);
+//! println!("rgb({}, {}, {})", fg.red, fg.green, fg.blue);
 //! ```
 //!
 //! ## Optional Dependencies

crates/terminal-colorsaurus/src/xterm.rs

@@ -79,13 +79,13 @@ fn parse_response(response: Vec<u8>, prefix: &[u8]) -> Result<Color> {
 }
 
 fn xparsecolor(input: &[u8]) -> Option<Color> {
-    let xterm_color::Color {
-        red: r,
-        green: g,
-        blue: b,
-        ..
-    } = xterm_color::Color::parse(input).ok()?;
-    Some(Color { r, g, b })
+    let color = xterm_color::Color::parse(input).ok()?;
+    Some(Color {
+        red: color.red,
+        green: color.green,
+        blue: color.blue,
+        alpha: color.alpha,
+    })
 }
 
 type Reader<'a> = BufReader<TermReader<RawModeGuard<'a>>>;