peachy/src/colour.rs

use serde_derive::{Serialize, Deserialize};

#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct Colour {
    pub red: u8,
    pub green: u8,
    pub blue: u8,
}

impl From<&str> for Colour {
    fn from(str: &str) -> Self {
        let rgb = hex::decode(&str[str.len() - 6..]).unwrap();

        Colour { red: rgb[0], green: rgb[1], blue: rgb[2] }
    }
}

impl From<Vec<u8>> for Colour {
    fn from(colours: Vec<u8>) -> Self {
        const ZERO: u8 = 0;
        Colour {
            red:   *colours.get(0).unwrap_or(&ZERO),
            green: *colours.get(1).unwrap_or(&ZERO),
            blue:  *colours.get(2).unwrap_or(&ZERO),
        }
    }
}

impl Into<Vec<u8>> for Colour {
    fn into(self) -> Vec<u8> {
        vec![self.red, self.green, self.blue]
    }
}

#[cfg(test)]
mod test {
    use crate::Colour;

    #[test]
    fn test_colour_from_hex() {
        assert_eq!(Colour::from("#ff00ff" ), Colour { red: 255, green: 0,   blue: 255 });
        assert_eq!(Colour::from("0xffffff"), Colour { red: 255, green: 255, blue: 255 });
        assert_eq!(Colour::from("ffffff"  ), Colour { red: 255, green: 255, blue: 255 });
        assert_eq!(Colour::from("#010203" ), Colour { red: 1,   green: 2,   blue: 3   });
        assert_eq!(Colour::from("0xa0b0c0"), Colour { red: 160, green: 176, blue: 192 });
    }

    #[test]
    fn test_colour_from_intermediate() {
        let output = Colour::from(vec![64, 128, 192]);
        let expected = Colour { red: 64, green: 128, blue: 192 };
        assert_eq!(output, expected);
    }

    #[test]
    fn test_colour_to_intermediate() {
        let output: Vec<u8> = Colour { red: 64, green: 128, blue: 192 }.into();
        let expected = vec![64, 128, 192];
        assert_eq!(output, expected);
    }
}