WIP: Get tests to pass (except lab/lch)

Author: GPHemsley

src/color.rs

@@ -97,12 +97,18 @@ impl<'de> Deserialize<'de> for RGBA {
         D: Deserializer<'de>,
     {
         let (r, g, b, a) = Deserialize::deserialize(deserializer)?;
-        Ok(RGBA::new(r, g, b, a))
+        Ok(Self::new(r, g, b, a))
     }
 }
 
 // NOTE: `RGBA` should not implement `ToCss` because it is an internal primitive that does not directly represent a CSS value.
 
+#[inline]
+fn f32_to_f64(f: f32) -> f64 {
+    const PRECISION: f64 = 1e6;
+    (f64::from(f) * PRECISION).round() / PRECISION
+}
+
 /// <hue>
 /// <https://w3c.github.io/csswg-drafts/css-color-4/#hue-syntax>
 #[derive(Clone, Copy, PartialEq, Debug)]
@@ -296,10 +302,10 @@ impl SrgbColor {
                 blue,
                 alpha,
             } => (
-                red.unwrap_or(0.),
-                green.unwrap_or(0.),
-                blue.unwrap_or(0.),
-                alpha.unwrap_or(AlphaValue::new(0.)).number,
+                red.unwrap_or(0.).clamp(0., 1.),
+                green.unwrap_or(0.).clamp(0., 1.),
+                blue.unwrap_or(0.).clamp(0., 1.),
+                alpha.unwrap_or(AlphaValue::new(0.)).number.clamp(0., 1.),
             ),
             Self::Hsl {
                 hue,
@@ -308,15 +314,15 @@ impl SrgbColor {
                 alpha,
             } => {
                 let (r, g, b) = hsl_to_rgb(
-                    hue.unwrap_or(Hue::new(0.)).degrees,
-                    saturation.unwrap_or(0.),
-                    lightness.unwrap_or(0.),
+                    hue.unwrap_or(Hue::new(0.)).degrees % 360. / 360.,
+                    saturation.unwrap_or(0.).clamp(0., 1.),
+                    lightness.unwrap_or(0.).clamp(0., 1.),
                 );
                 (
-                    r as f64,
-                    g as f64,
-                    b as f64,
-                    alpha.unwrap_or(AlphaValue::new(0.)).number,
+                    f32_to_f64(r),
+                    f32_to_f64(g),
+                    f32_to_f64(b),
+                    alpha.unwrap_or(AlphaValue::new(0.)).number.clamp(0., 1.),
                 )
             }
             Self::Hwb {
@@ -326,15 +332,15 @@ impl SrgbColor {
                 alpha,
             } => {
                 let (r, g, b) = hwb_to_rgb(
-                    hue.unwrap_or(Hue::new(0.)).degrees,
-                    whiteness.unwrap_or(0.),
-                    blackness.unwrap_or(0.),
+                    hue.unwrap_or(Hue::new(0.)).degrees % 360. / 360.,
+                    whiteness.unwrap_or(0.).clamp(0., 1.),
+                    blackness.unwrap_or(0.).clamp(0., 1.),
                 );
                 (
-                    r as f64,
-                    g as f64,
-                    b as f64,
-                    alpha.unwrap_or(AlphaValue::new(0.)).number,
+                    f32_to_f64(r),
+                    f32_to_f64(g),
+                    f32_to_f64(b),
+                    alpha.unwrap_or(AlphaValue::new(0.)).number.clamp(0., 1.),
                 )
             }
         }
@@ -350,10 +356,10 @@ impl SrgbColor {
         let (red, green, blue, alpha): (f64, f64, f64, f32) = self.to_floats();
 
         RGBA {
-            red: (red.clamp(0., 1.) * 255.).round() as u8,
-            green: (green.clamp(0., 1.) * 255.).round() as u8,
-            blue: (blue.clamp(0., 1.) * 255.).round() as u8,
-            alpha: (alpha.clamp(0., 1.) * 255.).round() as u8,
+            red: (red * 255.).round() as u8,
+            green: (green * 255.).round() as u8,
+            blue: (blue * 255.).round() as u8,
+            alpha: (alpha * 255.).round() as u8,
         }
     }
 }
@@ -435,7 +441,7 @@ impl ToCss for CielabColor {
             CielabColor::CieLab(lab_coords) => {
                 dest.write_str("lab(")?;
                 match lab_coords.lightness {
-                    Some(lightness) => lightness.to_css(dest)?,
+                    Some(lightness) => lightness.clamp(0., 100.).to_css(dest)?,
                     None => dest.write_str("none")?,
                 };
                 dest.write_str(" ")?;
@@ -462,7 +468,7 @@ impl ToCss for CielabColor {
             CielabColor::CieLch(lch_coords) => {
                 dest.write_str("lch(")?;
                 match lch_coords.lightness {
-                    Some(lightness) => lightness.to_css(dest)?,
+                    Some(lightness) => lightness.clamp(0., 100.).to_css(dest)?,
                     None => dest.write_str("none")?,
                 };
                 dest.write_str(" ")?;
@@ -542,7 +548,7 @@ impl ToCss for OklabColor {
             OklabColor::OkLab(lab_coords) => {
                 dest.write_str("oklab(")?;
                 match lab_coords.lightness {
-                    Some(lightness) => lightness.to_css(dest)?,
+                    Some(lightness) => lightness.clamp(0., 1.).to_css(dest)?,
                     None => dest.write_str("none")?,
                 };
                 dest.write_str(" ")?;
@@ -569,7 +575,7 @@ impl ToCss for OklabColor {
             OklabColor::OkLch(lch_coords) => {
                 dest.write_str("oklch(")?;
                 match lch_coords.lightness {
-                    Some(lightness) => lightness.to_css(dest)?,
+                    Some(lightness) => lightness.clamp(0., 1.).to_css(dest)?,
                     None => dest.write_str("none")?,
                 };
                 dest.write_str(" ")?;
@@ -1198,15 +1204,15 @@ where
             )))
         })
         .or(arguments.try_parse(|input| {
-            let red = Some(component_parser.parse_percentage(input)? as f64);
+            let red = Some(f32_to_f64(component_parser.parse_percentage(input)?));
 
             input.expect_comma()?;
 
-            let green = Some(component_parser.parse_percentage(input)? as f64);
+            let green = Some(f32_to_f64(component_parser.parse_percentage(input)?));
 
             input.expect_comma()?;
 
-            let blue = Some(component_parser.parse_percentage(input)? as f64);
+            let blue = Some(f32_to_f64(component_parser.parse_percentage(input)?));
 
             let alpha = parse_alpha_component(component_parser, input, true)?;
 
@@ -1276,11 +1282,11 @@ where
 
             input.expect_comma()?;
 
-            let saturation = Some(input.expect_percentage()?);
+            let saturation = Some(component_parser.parse_percentage(input)?);
 
             input.expect_comma()?;
 
-            let lightness = Some(input.expect_percentage()?);
+            let lightness = Some(component_parser.parse_percentage(input)?);
 
             let alpha = parse_alpha_component(component_parser, input, true)?;
 
@@ -2649,6 +2655,16 @@ mod tests {
             .to_floats(),
             (0.75, 0.25, 0.25, 1.0)
         );
+        assert_eq!(
+            SrgbColor::Hsl {
+                hue: Some(Hue { degrees: 60. }),
+                saturation: Some(1.0),
+                lightness: Some(0.375),
+                alpha: Some(AlphaValue { number: 1.0 })
+            }
+            .to_floats(),
+            (0.75, 0.75, 0.0, 1.0)
+        );
         assert_eq!(
             SrgbColor::Hwb {
                 hue: None,
@@ -5505,6 +5521,7 @@ mod tests {
         // assert_eq!(super::hsl_to_rgb(120. / 360., 0.75, 0.85), (0.7375, 0.9625, 0.7375));
         assert_eq!(super::hsl_to_rgb(240. / 360., 1., 0.5), (0., 0., 1.));
         assert_eq!(super::hsl_to_rgb(60. / 360., 1., 0.5), (1., 1., 0.));
+        assert_eq!(super::hsl_to_rgb(60. / 360., 1., 0.375), (0.75, 0.75, 0.));
         assert_eq!(super::hsl_to_rgb(360. / 360., 1., 0.5), (1., 0., 0.));
         assert_eq!(super::hsl_to_rgb(0. / 360., 1., 1.), (1., 1., 1.));
         assert_eq!(super::hsl_to_rgb(0. / 360., 0., 1.), (1., 1., 1.));

src/tests.rs

@@ -13,12 +13,12 @@ use serde_json::{self, json, Map, Value};
 use self::test::Bencher;
 
 use super::{
-    color::{rgb, rgba},
     parse_important, parse_nth, parse_one_declaration, parse_one_rule, stylesheet_encoding,
-    AbsoluteColor, AtRuleParser, BasicParseError, BasicParseErrorKind, Color, CowRcStr,
-    DeclarationListParser, DeclarationParser, Delimiter, EncodingSupport, ParseError,
-    ParseErrorKind, Parser, ParserInput, ParserState, QualifiedRuleParser, RuleListParser,
-    SourceLocation, ToCss, Token, TokenSerializationType, UnicodeRange, RGBA,
+    AtRuleParser, BasicParseError, BasicParseErrorKind, CielabColor, Color, CowRcStr, CurrentColor,
+    DeclarationListParser, DeclarationParser, Delimiter, DeprecatedColor, EncodingSupport,
+    NamedColor, OklabColor, ParseError, ParseErrorKind, Parser, ParserInput, ParserState,
+    QualifiedRuleParser, RuleListParser, SourceLocation, SrgbColor, ToCss, Token,
+    TokenSerializationType, UnicodeRange,
 };
 
 macro_rules! JArray {
@@ -398,7 +398,14 @@ fn color4_lab_lch_oklab_oklch() {
     run_color_tests(
         include_str!("css-parsing-tests/color4_lab_lch_oklab_oklch.json"),
         |c| match c {
-            Ok(color) => Value::Array(vec![color.to_json(), color.to_css_string().to_json()]),
+            Ok(color) => Value::Array(vec![
+                color.to_json(),
+                match color {
+                    Color::CielabColor(cielab_color) => cielab_color.to_css_string().to_json(),
+                    Color::OklabColor(oklab_color) => oklab_color.to_css_string().to_json(),
+                    _ => Value::Null,
+                },
+            ]),
             Err(_) => Value::Null,
         },
     )
@@ -533,25 +540,25 @@ fn serialize_bad_tokens() {
 
 #[test]
 fn serialize_current_color() {
-    let c = Color::CurrentColor;
+    let c = CurrentColor;
     assert!(c.to_css_string() == "currentcolor");
 }
 
 #[test]
 fn serialize_rgb_full_alpha() {
-    let c = rgb(255, 230, 204);
+    let c = SrgbColor::from_ints(255, 230, 204, 255);
     assert_eq!(c.to_css_string(), "rgb(255, 230, 204)");
 }
 
 #[test]
 fn serialize_rgba() {
-    let c = rgba(26, 51, 77, 0.125);
-    assert_eq!(c.to_css_string(), "rgba(26, 51, 77, 0.125)");
+    let c = SrgbColor::from_ints(26, 51, 77, 32);
+    assert_eq!(c.to_css_string(), "rgba(26, 51, 77, 0.12549)");
 }
 
 #[test]
 fn serialize_rgba_two_digit_float_if_roundtrips() {
-    let c = Color::Absolute(AbsoluteColor::Rgba(RGBA::from_floats(0., 0., 0., 0.5)));
+    let c = SrgbColor::from_floats(0., 0., 0., 0.5);
     assert_eq!(c.to_css_string(), "rgba(0, 0, 0, 0.5)");
 }
 
@@ -843,16 +850,43 @@ where
 impl ToJson for Color {
     fn to_json(&self) -> Value {
         match *self {
-            Color::CurrentColor => "currentcolor".to_json(),
-            Color::Absolute(absolute) => match absolute {
-                AbsoluteColor::Rgba(ref rgba) => {
-                    json!([rgba.red, rgba.green, rgba.blue, rgba.alpha])
+            Color::SrgbColor(ref srgb_color)
+            | Color::NamedColor(NamedColor {
+                value: ref srgb_color,
+                ..
+            }) => {
+                let rgba = srgb_color.to_rgba();
+                json!([rgba.red, rgba.green, rgba.blue, srgb_color.to_floats().3])
+            }
+            Color::SystemColor(ref system_color)
+            | Color::DeprecatedColor(DeprecatedColor {
+                same_as: ref system_color,
+                ..
+            }) => system_color.name.to_json(),
+            Color::CurrentColor(CurrentColor) => "currentcolor".to_json(),
+            Color::CielabColor(CielabColor::CieLab(ref lab_coords))
+            | Color::OklabColor(OklabColor::OkLab(ref lab_coords)) => json!([
+                lab_coords.lightness,
+                lab_coords.a,
+                lab_coords.b,
+                match lab_coords.alpha {
+                    Some(alpha) => alpha.number,
+                    None => 0.,
                 }
-                AbsoluteColor::Lab(ref c) => json!([c.lightness, c.a, c.b, c.alpha]),
-                AbsoluteColor::Lch(ref c) => json!([c.lightness, c.chroma, c.hue, c.alpha]),
-                AbsoluteColor::Oklab(ref c) => json!([c.lightness, c.a, c.b, c.alpha]),
-                AbsoluteColor::Oklch(ref c) => json!([c.lightness, c.chroma, c.hue, c.alpha]),
-            },
+            ]),
+            Color::CielabColor(CielabColor::CieLch(ref lch_coords))
+            | Color::OklabColor(OklabColor::OkLch(ref lch_coords)) => json!([
+                lch_coords.lightness,
+                lch_coords.chroma,
+                match lch_coords.hue {
+                    Some(hue) => hue.degrees,
+                    None => 0.,
+                },
+                match lch_coords.alpha {
+                    Some(alpha) => alpha.number,
+                    None => 0.,
+                }
+            ]),
         }
     }
 }