Line data    Source code

       1              : //! A serde::Deserialize type for percentages.
       2              : //!
       3              : //! See [`Percent`] for details.
       4              : 
       5              : use serde::{Deserialize, Serialize};
       6              : 
       7              : /// If the value is not an integer between 0 and 100,
       8              : /// deserialization fails with a descriptive error.
       9           18 : #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
      10              : #[serde(transparent)]
      11              : pub struct Percent(#[serde(deserialize_with = "deserialize_pct_0_to_100")] u8);
      12              : 
      13              : impl Percent {
      14          180 :     pub const fn new(pct: u8) -> Option<Self> {
      15          180 :         if pct <= 100 {
      16          180 :             Some(Percent(pct))
      17              :         } else {
      18            0 :             None
      19              :         }
      20          180 :     }
      21              : 
      22          300 :     pub fn get(&self) -> u8 {
      23          300 :         self.0
      24          300 :     }
      25              : }
      26              : 
      27           48 : fn deserialize_pct_0_to_100<'de, D>(deserializer: D) -> Result<u8, D::Error>
      28           48 : where
      29           48 :     D: serde::de::Deserializer<'de>,
      30           48 : {
      31           48 :     let v: u8 = serde::de::Deserialize::deserialize(deserializer)?;
      32           24 :     if v > 100 {
      33            6 :         return Err(serde::de::Error::custom(
      34            6 :             "must be an integer between 0 and 100",
      35            6 :         ));
      36           18 :     }
      37           18 :     Ok(v)
      38           48 : }
      39              : 
      40              : #[cfg(test)]
      41              : mod tests {
      42              :     use super::Percent;
      43              : 
      44          114 :     #[derive(serde::Deserialize, serde::Serialize, Debug, PartialEq, Eq)]
      45              :     struct Foo {
      46              :         bar: Percent,
      47              :     }
      48              : 
      49              :     #[test]
      50            6 :     fn basics() {
      51            6 :         let input = r#"{ "bar": 50 }"#;
      52            6 :         let foo: Foo = serde_json::from_str(input).unwrap();
      53            6 :         assert_eq!(foo.bar.get(), 50);
      54            6 :     }
      55              :     #[test]
      56            6 :     fn null_handling() {
      57            6 :         let input = r#"{ "bar": null }"#;
      58            6 :         let res: Result<Foo, _> = serde_json::from_str(input);
      59            6 :         assert!(res.is_err());
      60            6 :     }
      61              :     #[test]
      62            6 :     fn zero() {
      63            6 :         let input = r#"{ "bar": 0 }"#;
      64            6 :         let foo: Foo = serde_json::from_str(input).unwrap();
      65            6 :         assert_eq!(foo.bar.get(), 0);
      66            6 :     }
      67              :     #[test]
      68            6 :     fn out_of_range_above() {
      69            6 :         let input = r#"{ "bar": 101 }"#;
      70            6 :         let res: Result<Foo, _> = serde_json::from_str(input);
      71            6 :         assert!(res.is_err());
      72            6 :     }
      73              :     #[test]
      74            6 :     fn out_of_range_below() {
      75            6 :         let input = r#"{ "bar": -1 }"#;
      76            6 :         let res: Result<Foo, _> = serde_json::from_str(input);
      77            6 :         assert!(res.is_err());
      78            6 :     }
      79              :     #[test]
      80            6 :     fn float() {
      81            6 :         let input = r#"{ "bar": 50.5 }"#;
      82            6 :         let res: Result<Foo, _> = serde_json::from_str(input);
      83            6 :         assert!(res.is_err());
      84            6 :     }
      85              :     #[test]
      86            6 :     fn string() {
      87            6 :         let input = r#"{ "bar": "50 %" }"#;
      88            6 :         let res: Result<Foo, _> = serde_json::from_str(input);
      89            6 :         assert!(res.is_err());
      90            6 :     }
      91              : }