Add a type for managing Time of Day values

fitnesstrax/app/src/types.rs

@@ -1,7 +1,7 @@
 use chrono::{Local, NaiveDate};
 use dimensioned::si;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct ParseError;
 
 // This interval doesn't feel right, either. The idea that I have a specific interval type for just
@@ -56,6 +56,66 @@ pub enum FormatOption {
     Full,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Time(chrono::NaiveTime);
+
+impl Time {
+    fn format(&self, option: FormatOption) -> String {
+        match option {
+            FormatOption::Abbreviated => self.0.format("%H:%M"),
+            FormatOption::Full => self.0.format("%H:%M:%S"),
+        }
+        .to_string()
+    }
+
+    fn parse(s: &str) -> Result<Time, ParseError> {
+        let parts = s
+            .split(':')
+            .map(|part| part.parse::<u32>().map_err(|_| ParseError))
+            .collect::<Result<Vec<u32>, ParseError>>()?;
+        match parts.len() {
+            0 => Err(ParseError),
+            1 => Err(ParseError),
+            2 => Ok(Time(
+                chrono::NaiveTime::from_hms_opt(parts[0], parts[1], 0).unwrap(),
+            )),
+            3 => Ok(Time(
+                chrono::NaiveTime::from_hms_opt(parts[0], parts[1], parts[2]).unwrap(),
+            )),
+            _ => Err(ParseError),
+        }
+    }
+}
+
+/*
+impl std::ops::Add for Time {
+    type Output = Time;
+    fn add(self, rside: chrono::Duration) -> Self::Output {
+        Self::Output::from(self.0 + rside)
+    }
+}
+
+impl std::ops::Sub for Time {
+    type Output = Time;
+    fn sub(self, rside: chrono::Duration) -> Self::Output {
+        Self::Output::from(self.0 - rside)
+    }
+}
+*/
+
+impl std::ops::Deref for Time {
+    type Target = chrono::NaiveTime;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<chrono::NaiveTime> for Time {
+    fn from(value: chrono::NaiveTime) -> Self {
+        Self(value)
+    }
+}
+
 #[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
 pub struct Weight(si::Kilogram<f64>);
 
@@ -102,65 +162,58 @@ impl From<si::Kilogram<f64>> for Weight {
 }
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
-pub struct Distance {
+pub struct Distance(si::Meter<f64>);
-    value: si::Meter<f64>,
-}
 
 impl Distance {
     pub fn format(&self, option: FormatOption) -> String {
         match option {
-            FormatOption::Abbreviated => format!("{} km", self.value.value_unsafe / 1000.),
+            FormatOption::Abbreviated => format!("{} km", self.0.value_unsafe / 1000.),
-            FormatOption::Full => format!("{} kilometers", self.value.value_unsafe / 1000.),
+            FormatOption::Full => format!("{} kilometers", self.0.value_unsafe / 1000.),
         }
     }
 
     pub fn parse(s: &str) -> Result<Distance, ParseError> {
-        let digits = take_digits(s.to_owned());
+        let value = s.parse::<f64>().map_err(|_| ParseError)?;
-        let value = digits.parse::<f64>().map_err(|_| ParseError)?;
+        Ok(Distance(value * 1000. * si::M))
-        Ok(Distance {
-            value: value * 1000. * si::M,
-        })
     }
 }
 
 impl std::ops::Add for Distance {
     type Output = Distance;
     fn add(self, rside: Self) -> Self::Output {
-        Self::Output::from(self.value + rside.value)
+        Self::Output::from(self.0 + rside.0)
     }
 }
 
 impl std::ops::Sub for Distance {
     type Output = Distance;
     fn sub(self, rside: Self) -> Self::Output {
-        Self::Output::from(self.value - rside.value)
+        Self::Output::from(self.0 - rside.0)
     }
 }
 
 impl std::ops::Deref for Distance {
     type Target = si::Meter<f64>;
     fn deref(&self) -> &Self::Target {
-        &self.value
+        &self.0
     }
 }
 
 impl From<si::Meter<f64>> for Distance {
     fn from(value: si::Meter<f64>) -> Self {
-        Self { value }
+        Self(value)
     }
 }
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
-pub struct Duration {
+pub struct Duration(si::Second<f64>);
-    value: si::Second<f64>,
-}
 
 impl Duration {
     pub fn format(&self, option: FormatOption) -> String {
         let (hours, minutes) = self.hours_and_minutes();
         let (h, m) = match option {
             FormatOption::Abbreviated => ("h", "m"),
-            FormatOption::Full => ("hours", "minutes"),
+            FormatOption::Full => (" hours", " minutes"),
         };
         if hours > 0 {
             format!("{}{} {}{}", hours, h, minutes, m)
@@ -170,15 +223,12 @@ impl Duration {
     }
 
     pub fn parse(s: &str) -> Result<Duration, ParseError> {
-        let digits = take_digits(s.to_owned());
+        let value = s.parse::<f64>().map_err(|_| ParseError)?;
-        let value = digits.parse::<f64>().map_err(|_| ParseError)?;
+        Ok(Duration(value * 60. * si::S))
-        Ok(Duration {
-            value: value * 60. * si::S,
-        })
     }
 
     fn hours_and_minutes(&self) -> (i64, i64) {
-        let minutes: i64 = (self.value.value_unsafe / 60.).round() as i64;
+        let minutes: i64 = (self.0.value_unsafe / 60.).round() as i64;
         let hours: i64 = minutes / 60;
         let minutes = minutes - (hours * 60);
         (hours, minutes)
@@ -188,32 +238,117 @@ impl Duration {
 impl std::ops::Add for Duration {
     type Output = Duration;
     fn add(self, rside: Self) -> Self::Output {
-        Self::Output::from(self.value + rside.value)
+        Self::Output::from(self.0 + rside.0)
     }
 }
 
 impl std::ops::Sub for Duration {
     type Output = Duration;
     fn sub(self, rside: Self) -> Self::Output {
-        Self::Output::from(self.value - rside.value)
+        Self::Output::from(self.0 - rside.0)
     }
 }
 
 impl std::ops::Deref for Duration {
     type Target = si::Second<f64>;
     fn deref(&self) -> &Self::Target {
-        &self.value
+        &self.0
     }
 }
 
 impl From<si::Second<f64>> for Duration {
     fn from(value: si::Second<f64>) -> Self {
-        Self { value }
+        Self(value)
     }
 }
 
+/*
 fn take_digits(s: String) -> String {
     s.chars()
         .take_while(|t| t.is_ascii_digit())
         .collect::<String>()
 }
+*/
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use dimensioned::si;
+
+    #[test]
+    fn it_parses_weight_values() {
+        assert_eq!(Weight::parse("15.3"), Ok(Weight(15.3 * si::KG)));
+        assert_eq!(Weight::parse("15.ab"), Err(ParseError));
+    }
+
+    #[test]
+    fn it_formats_weight_values() {
+        assert_eq!(
+            Weight::from(15.3 * si::KG).format(FormatOption::Abbreviated),
+            "15.3 kg"
+        );
+        assert_eq!(
+            Weight::from(15.3 * si::KG).format(FormatOption::Full),
+            "15.3 kilograms"
+        );
+    }
+
+    #[test]
+    fn it_parses_distance_values() {
+        assert_eq!(Distance::parse("70"), Ok(Distance(70000. * si::M)));
+        assert_eq!(Distance::parse("15.ab"), Err(ParseError));
+    }
+
+    #[test]
+    fn it_formats_distance_values() {
+        assert_eq!(
+            Distance::from(70000. * si::M).format(FormatOption::Abbreviated),
+            "70 km"
+        );
+        assert_eq!(
+            Distance::from(70000. * si::M).format(FormatOption::Full),
+            "70 kilometers"
+        );
+    }
+
+    #[test]
+    fn it_parses_duration_values() {
+        assert_eq!(Duration::parse("70"), Ok(Duration(4200. * si::S)));
+        assert_eq!(Duration::parse("15.ab"), Err(ParseError));
+    }
+
+    #[test]
+    fn it_formats_duration_values() {
+        assert_eq!(
+            Duration::from(4200. * si::S).format(FormatOption::Abbreviated),
+            "1h 10m"
+        );
+        assert_eq!(
+            Duration::from(4200. * si::S).format(FormatOption::Full),
+            "1 hours 10 minutes"
+        );
+    }
+
+    #[test]
+    fn it_parses_time_values() {
+        assert_eq!(
+            Time::parse("13:25"),
+            Ok(Time::from(
+                chrono::NaiveTime::from_hms_opt(13, 25, 0).unwrap()
+            )),
+        );
+        assert_eq!(
+            Time::parse("13:25:50"),
+            Ok(Time::from(
+                chrono::NaiveTime::from_hms_opt(13, 25, 50).unwrap()
+            )),
+        );
+    }
+
+    #[test]
+    fn it_formats_time_values() {
+        let time = Time::from(chrono::NaiveTime::from_hms_opt(13, 25, 50).unwrap());
+        assert_eq!(time.format(FormatOption::Abbreviated), "13:25".to_owned());
+        assert_eq!(time.format(FormatOption::Full), "13:25:50".to_owned());
+    }
+}