fitnesstrax/app/src/types.rs

@@ -1,7 +1,7 @@
 use chrono::{Local, NaiveDate};
 use dimensioned::si;
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug)]
 pub struct ParseError;
 
 // This interval doesn't feel right, either. The idea that I have a specific interval type for just
@@ -56,66 +56,6 @@ 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>);
 
@@ -162,51 +102,58 @@ impl From<si::Kilogram<f64>> for Weight {
 }
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
-pub struct Distance(si::Meter<f64>);
+pub struct Distance {
+    value: si::Meter<f64>,
+}
 
 impl Distance {
     pub fn format(&self, option: FormatOption) -> String {
         match option {
-            FormatOption::Abbreviated => format!("{} km", self.0.value_unsafe / 1000.),
-            FormatOption::Full => format!("{} kilometers", self.0.value_unsafe / 1000.),
+            FormatOption::Abbreviated => format!("{} km", self.value.value_unsafe / 1000.),
+            FormatOption::Full => format!("{} kilometers", self.value.value_unsafe / 1000.),
         }
     }
 
     pub fn parse(s: &str) -> Result<Distance, ParseError> {
-        let value = s.parse::<f64>().map_err(|_| ParseError)?;
-        Ok(Distance(value * 1000. * si::M))
+        let digits = take_digits(s.to_owned());
+        let value = digits.parse::<f64>().map_err(|_| ParseError)?;
+        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.0 + rside.0)
+        Self::Output::from(self.value + rside.value)
     }
 }
 
 impl std::ops::Sub for Distance {
     type Output = Distance;
     fn sub(self, rside: Self) -> Self::Output {
-        Self::Output::from(self.0 - rside.0)
+        Self::Output::from(self.value - rside.value)
     }
 }
 
 impl std::ops::Deref for Distance {
     type Target = si::Meter<f64>;
     fn deref(&self) -> &Self::Target {
-        &self.0
+        &self.value
     }
 }
 
 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(si::Second<f64>);
+pub struct Duration {
+    value: si::Second<f64>,
+}
 
 impl Duration {
     pub fn format(&self, option: FormatOption) -> String {
@@ -223,12 +170,15 @@ impl Duration {
     }
 
     pub fn parse(s: &str) -> Result<Duration, ParseError> {
-        let value = s.parse::<f64>().map_err(|_| ParseError)?;
-        Ok(Duration(value * 60. * si::S))
+        let digits = take_digits(s.to_owned());
+        let value = digits.parse::<f64>().map_err(|_| ParseError)?;
+        Ok(Duration {
+            value: value * 60. * si::S,
+        })
     }
 
     fn hours_and_minutes(&self) -> (i64, i64) {
-        let minutes: i64 = (self.0.value_unsafe / 60.).round() as i64;
+        let minutes: i64 = (self.value.value_unsafe / 60.).round() as i64;
         let hours: i64 = minutes / 60;
         let minutes = minutes - (hours * 60);
         (hours, minutes)
@@ -238,117 +188,32 @@ impl Duration {
 impl std::ops::Add for Duration {
     type Output = Duration;
     fn add(self, rside: Self) -> Self::Output {
-        Self::Output::from(self.0 + rside.0)
+        Self::Output::from(self.value + rside.value)
     }
 }
 
 impl std::ops::Sub for Duration {
     type Output = Duration;
     fn sub(self, rside: Self) -> Self::Output {
-        Self::Output::from(self.0 - rside.0)
+        Self::Output::from(self.value - rside.value)
     }
 }
 
 impl std::ops::Deref for Duration {
     type Target = si::Second<f64>;
     fn deref(&self) -> &Self::Target {
-        &self.0
+        &self.value
     }
 }
 
 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());
-    }
-}