Clean up warnings and remove printlns

This required some big overhauls. The view model no longer takes records. It only takes the date that it is responsible for, and it will ask the database for records pertaining to that date. This means that once the view model has saved all of its records, it can simply reload those records from the database. This has the effect that as soon as the user moves from DayEdit back to DayDetail, all of the interesting information has been repopulated.

fitnesstrax/app/src/components/day.rs

@@ -17,7 +17,9 @@ You should have received a copy of the GNU General Public License along with Fit
 // use chrono::NaiveDate;
 // use ft_core::TraxRecord;
 use crate::{
-    components::{steps_editor, time_distance_summary, weight_field, ActionGroup, Steps, Weight},
+    components::{
+        steps_editor, time_distance_summary, weight_field, ActionGroup, Steps, WeightLabel,
+    },
     view_models::DayDetailViewModel,
 };
 use emseries::{Record, RecordId};
@@ -145,7 +147,7 @@ impl DayDetail {
         let top_row = gtk::Box::builder()
             .orientation(gtk::Orientation::Horizontal)
             .build();
-        let weight_view = Weight::new(view_model.weight());
+        let weight_view = WeightLabel::new(view_model.weight());
         top_row.append(&weight_view.widget());
 
         let steps_view = Steps::new(view_model.steps());
@@ -339,7 +341,7 @@ fn weight_and_steps_row(view_model: &DayDetailViewModel) -> gtk::Box {
             let view_model = view_model.clone();
             move |w| match w {
                 Some(w) => view_model.set_weight(w),
-                None => unimplemented!("need to delete the weight entry"),
+                None => eprintln!("have not implemented record delete"),
             }
         })
         .widget(),
@@ -350,7 +352,7 @@ fn weight_and_steps_row(view_model: &DayDetailViewModel) -> gtk::Box {
             let view_model = view_model.clone();
             move |s| match s {
                 Some(s) => view_model.set_steps(s),
-                None => unimplemented!("need to delete the steps entry"),
+                None => eprintln!("have not implemented record delete"),
             }
         })
         .widget(),

fitnesstrax/app/src/components/mod.rs

@@ -34,7 +34,7 @@ mod time_distance;
 pub use time_distance::{time_distance_detail, time_distance_summary};
 
 mod weight;
-pub use weight::Weight;
+pub use weight::WeightLabel;
 
 use glib::Object;
 use gtk::{prelude::*, subclass::prelude::*};

fitnesstrax/app/src/components/text_entry.rs

@@ -1,5 +1,5 @@
 /*
-Copyright 2023, Savanni D'Gerinel <savanni@luminescent-dreams.com>
+Copyright 2023-2024, Savanni D'Gerinel <savanni@luminescent-dreams.com>
 
 This file is part of FitnessTrax.
 
@@ -14,8 +14,9 @@ General Public License for more details.
 You should have received a copy of the GNU General Public License along with FitnessTrax. If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::types::{Distance, Duration, FormatOption, ParseError};
+use crate::types::{
-use dimensioned::si;
+    DistanceFormatter, DurationFormatter, FormatOption, ParseError, TimeFormatter, WeightFormatter,
+};
 use gtk::prelude::*;
 use std::{cell::RefCell, rc::Rc};
 
@@ -25,6 +26,7 @@ pub type OnUpdate<T> = dyn Fn(Option<T>);
 #[derive(Clone)]
 pub struct TextEntry<T: Clone + std::fmt::Debug> {
     value: Rc<RefCell<Option<T>>>,
+
     widget: gtk::Entry,
     parser: Rc<Parser<T>>,
     on_update: Rc<OnUpdate<T>>,
@@ -78,6 +80,7 @@ impl<T: Clone + std::fmt::Debug + 'static> TextEntry<T> {
         if buffer.text().is_empty() {
             *self.value.borrow_mut() = None;
             self.widget.remove_css_class("error");
+            (self.on_update)(None);
             return;
         }
         match (self.parser)(buffer.text().as_str()) {
@@ -96,62 +99,144 @@ impl<T: Clone + std::fmt::Debug + 'static> TextEntry<T> {
     pub fn widget(&self) -> gtk::Widget {
         self.widget.clone().upcast::<gtk::Widget>()
     }
-}
 
-pub fn weight_field<OnUpdate>(
+    #[cfg(test)]
-    weight: Option<si::Kilogram<f64>>,
+    fn has_parse_error(&self) -> bool {
-    on_update: OnUpdate,
+        self.widget.has_css_class("error")
-) -> TextEntry<si::Kilogram<f64>>
+    }
-where
-    OnUpdate: Fn(Option<si::Kilogram<f64>>) + 'static,
-{
-    TextEntry::new(
-        "0 kg",
-        weight,
-        |val: &si::Kilogram<f64>| val.to_string(),
-        move |v: &str| v.parse::<f64>().map(|w| w * si::KG).map_err(|_| ParseError),
-        on_update,
-    )
 }
 
 pub fn time_field<OnUpdate>(
-    value: chrono::NaiveTime,
+    value: Option<TimeFormatter>,
     on_update: OnUpdate,
-) -> TextEntry<chrono::NaiveTime>
+) -> TextEntry<TimeFormatter>
 where
-    OnUpdate: Fn(Option<chrono::NaiveTime>) + 'static,
+    OnUpdate: Fn(Option<TimeFormatter>) + 'static,
 {
     TextEntry::new(
-        "hh:mm",
+        "HH:MM",
-        Some(value),
+        value,
-        |v| v.format("%H:%M").to_string(),
+        |val| val.format(FormatOption::Abbreviated),
-        |s| chrono::NaiveTime::parse_from_str(s, "%H:%M").map_err(|_| ParseError),
+        TimeFormatter::parse,
         on_update,
     )
 }
 
-pub fn distance_field<OnUpdate>(value: Option<Distance>, on_update: OnUpdate) -> TextEntry<Distance>
+pub fn distance_field<OnUpdate>(
+    value: Option<DistanceFormatter>,
+    on_update: OnUpdate,
+) -> TextEntry<DistanceFormatter>
 where
-    OnUpdate: Fn(Option<Distance>) + 'static,
+    OnUpdate: Fn(Option<DistanceFormatter>) + 'static,
 {
     TextEntry::new(
         "0 km",
         value,
-        |v| format!("{} km", v.value_unsafe / 1000.),
+        |val| val.format(FormatOption::Abbreviated),
-        Distance::parse,
+        DistanceFormatter::parse,
         on_update,
     )
 }
 
-pub fn duration_field<OnUpdate>(value: Option<Duration>, on_update: OnUpdate) -> TextEntry<Duration>
+pub fn duration_field<OnUpdate>(
+    value: Option<DurationFormatter>,
+    on_update: OnUpdate,
+) -> TextEntry<DurationFormatter>
 where
-    OnUpdate: Fn(Option<Duration>) + 'static,
+    OnUpdate: Fn(Option<DurationFormatter>) + 'static,
 {
     TextEntry::new(
-        "0 minutes",
+        "0 m",
         value,
-        |v| v.format(FormatOption::Abbreviated),
+        |val| val.format(FormatOption::Abbreviated),
-        Duration::parse,
+        DurationFormatter::parse,
         on_update,
     )
 }
+pub fn weight_field<OnUpdate>(
+    weight: Option<WeightFormatter>,
+    on_update: OnUpdate,
+) -> TextEntry<WeightFormatter>
+where
+    OnUpdate: Fn(Option<WeightFormatter>) + 'static,
+{
+    TextEntry::new(
+        "0 kg",
+        weight,
+        |val| val.format(FormatOption::Abbreviated),
+        WeightFormatter::parse,
+        on_update,
+    )
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::gtk_init::gtk_init;
+
+    fn setup_u32_entry() -> (Rc<RefCell<Option<u32>>>, TextEntry<u32>) {
+        let current_value = Rc::new(RefCell::new(None));
+
+        let entry = TextEntry::new(
+            "step count",
+            None,
+            |steps| format!("{}", steps),
+            |v| v.parse::<u32>().map_err(|_| ParseError),
+            {
+                let current_value = current_value.clone();
+                move |v| *current_value.borrow_mut() = v
+            },
+        );
+
+        (current_value, entry)
+    }
+
+    #[test]
+    fn it_responds_to_field_changes() {
+        gtk_init();
+        let (current_value, entry) = setup_u32_entry();
+        let buffer = entry.widget.buffer();
+
+        buffer.set_text("1");
+        assert_eq!(*current_value.borrow(), Some(1));
+
+        buffer.set_text("15");
+        assert_eq!(*current_value.borrow(), Some(15));
+    }
+
+    #[test]
+    fn it_preserves_last_value_in_parse_error() {
+        crate::gtk_init::gtk_init();
+        let (current_value, entry) = setup_u32_entry();
+        let buffer = entry.widget.buffer();
+
+        buffer.set_text("1");
+        assert_eq!(*current_value.borrow(), Some(1));
+
+        buffer.set_text("a5");
+        assert_eq!(*current_value.borrow(), Some(1));
+        assert!(entry.has_parse_error());
+    }
+
+    #[test]
+    fn it_update_on_empty_strings() {
+        gtk_init();
+        let (current_value, entry) = setup_u32_entry();
+        let buffer = entry.widget.buffer();
+
+        buffer.set_text("1");
+        assert_eq!(*current_value.borrow(), Some(1));
+        buffer.set_text("");
+        assert_eq!(*current_value.borrow(), None);
+
+        buffer.set_text("1");
+        assert_eq!(*current_value.borrow(), Some(1));
+        buffer.set_text("1a");
+        assert_eq!(*current_value.borrow(), Some(1));
+        assert!(entry.has_parse_error());
+
+        buffer.set_text("");
+        assert_eq!(*current_value.borrow(), None);
+        assert!(!entry.has_parse_error());
+    }
+}

fitnesstrax/app/src/components/time_distance.rs

@@ -19,7 +19,7 @@ You should have received a copy of the GNU General Public License along with Fit
 // use dimensioned::si;
 use crate::{
     components::{distance_field, duration_field, time_field},
-    types::{Distance, Duration, FormatOption},
+    types::{DistanceFormatter, DurationFormatter, FormatOption, TimeFormatter},
 };
 use dimensioned::si;
 use ft_core::{RecordType, TimeDistance};
@@ -27,7 +27,10 @@ use glib::Object;
 use gtk::{prelude::*, subclass::prelude::*};
 use std::cell::RefCell;
 
-pub fn time_distance_summary(distance: Distance, duration: Duration) -> Option<gtk::Label> {
+pub fn time_distance_summary(
+    distance: DistanceFormatter,
+    duration: DurationFormatter,
+) -> Option<gtk::Label> {
     let text = match (*distance > si::M, *duration > si::S) {
         (true, true) => Some(format!(
             "{} of biking in {}",
@@ -69,7 +72,7 @@ pub fn time_distance_detail(type_: ft_core::RecordType, record: ft_core::TimeDis
             .label(
                 record
                     .distance
-                    .map(|dist| Distance::from(dist).format(FormatOption::Abbreviated))
+                    .map(|dist| DistanceFormatter::from(dist).format(FormatOption::Abbreviated))
                     .unwrap_or("".to_owned()),
             )
             .build(),
@@ -81,7 +84,9 @@ pub fn time_distance_detail(type_: ft_core::RecordType, record: ft_core::TimeDis
             .label(
                 record
                     .duration
-                    .map(|duration| Duration::from(duration).format(FormatOption::Abbreviated))
+                    .map(|duration| {
+                        DurationFormatter::from(duration).format(FormatOption::Abbreviated)
+                    })
                     .unwrap_or("".to_owned()),
             )
             .build(),
@@ -162,23 +167,26 @@ impl TimeDistanceEdit {
             .build();
 
         details_row.append(
-            &time_field(workout.datetime.naive_local().time(), {
+            &time_field(
+                Some(TimeFormatter::from(workout.datetime.naive_local().time())),
+                {
                     let s = s.clone();
                     move |t| s.update_time(t)
+                },
+            )
+            .widget(),
+        );
+        details_row.append(
+            &distance_field(workout.distance.map(DistanceFormatter::from), {
+                let s = s.clone();
+                move |d| s.update_distance(d)
             })
             .widget(),
         );
         details_row.append(
-            &distance_field(workout.distance.map(Distance::from), {
+            &duration_field(workout.duration.map(DurationFormatter::from), {
                 let s = s.clone();
-                move |d| s.update_distance(d.map(|d| *d))
+                move |d| s.update_duration(d)
-            })
-            .widget(),
-        );
-        details_row.append(
-            &duration_field(workout.duration.map(Duration::from), {
-                let s = s.clone();
-                move |d| s.update_duration(d.map(|d| *d))
             })
             .widget(),
         );
@@ -188,19 +196,19 @@ impl TimeDistanceEdit {
         s
     }
 
-    fn update_time(&self, _time: Option<chrono::NaiveTime>) {
+    fn update_time(&self, time: Option<TimeFormatter>) {
         unimplemented!()
     }
 
-    fn update_distance(&self, distance: Option<si::Meter<f64>>) {
+    fn update_distance(&self, distance: Option<DistanceFormatter>) {
         let mut workout = self.imp().workout.borrow_mut();
-        workout.distance = distance;
+        workout.distance = distance.map(|d| *d);
         (self.imp().on_update.borrow())(self.imp().type_.borrow().clone(), workout.clone());
     }
 
-    fn update_duration(&self, duration: Option<si::Second<f64>>) {
+    fn update_duration(&self, duration: Option<DurationFormatter>) {
         let mut workout = self.imp().workout.borrow_mut();
-        workout.duration = duration;
+        workout.duration = duration.map(|d| *d);
         (self.imp().on_update.borrow())(self.imp().type_.borrow().clone(), workout.clone());
     }
 }

fitnesstrax/app/src/components/weight.rs

@@ -1,5 +1,5 @@
 /*
-Copyright 2023, Savanni D'Gerinel <savanni@luminescent-dreams.com>
+Copyright 2023-2024, Savanni D'Gerinel <savanni@luminescent-dreams.com>
 
 This file is part of FitnessTrax.
 
@@ -14,22 +14,26 @@ General Public License for more details.
 You should have received a copy of the GNU General Public License along with FitnessTrax. If not, see <https://www.gnu.org/licenses/>.
 */
 
+use crate::{
+    components::TextEntry,
+    types::{FormatOption, WeightFormatter},
+};
 use dimensioned::si;
 use gtk::prelude::*;
 
-pub struct Weight {
+pub struct WeightLabel {
     label: gtk::Label,
 }
 
-impl Weight {
+impl WeightLabel {
-    pub fn new(weight: Option<si::Kilogram<f64>>) -> Self {
+    pub fn new(weight: Option<WeightFormatter>) -> Self {
         let label = gtk::Label::builder()
             .css_classes(["card", "weight-view"])
             .can_focus(true)
             .build();
 
         match weight {
-            Some(w) => label.set_text(&format!("{:?}", w)),
+            Some(w) => label.set_text(&w.format(FormatOption::Abbreviated)),
             None => label.set_text("No weight recorded"),
         }
 

fitnesstrax/app/src/gtk_init.rs

@@ -0,0 +1,10 @@
+use std::sync::Once;
+
+static INITIALIZED: Once = Once::new();
+
+pub fn gtk_init() {
+    INITIALIZED.call_once(|| {
+        eprintln!("initializing GTK");
+        let _ = gtk::init();
+    });
+}

fitnesstrax/app/src/main.rs

@@ -17,6 +17,8 @@ You should have received a copy of the GNU General Public License along with Fit
 mod app;
 mod app_window;
 mod components;
+#[cfg(test)]
+mod gtk_init;
 mod types;
 mod view_models;
 mod views;

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,66 +56,148 @@ pub enum FormatOption {
     Full,
 }
 
-#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Distance {
+pub struct TimeFormatter(chrono::NaiveTime);
-    value: si::Meter<f64>,
-}
 
-impl Distance {
+impl TimeFormatter {
     pub fn format(&self, option: FormatOption) -> String {
         match option {
-            FormatOption::Abbreviated => format!("{} km", self.value.value_unsafe / 1000.),
+            FormatOption::Abbreviated => self.0.format("%H:%M"),
-            FormatOption::Full => format!("{} kilometers", self.value.value_unsafe / 1000.),
+            FormatOption::Full => self.0.format("%H:%M:%S"),
         }
+        .to_string()
     }
 
-    pub fn parse(s: &str) -> Result<Distance, ParseError> {
+    pub fn parse(s: &str) -> Result<TimeFormatter, ParseError> {
-        let digits = take_digits(s.to_owned());
+        let parts = s
-        let value = digits.parse::<f64>().map_err(|_| ParseError)?;
+            .split(':')
-        Ok(Distance {
+            .map(|part| part.parse::<u32>().map_err(|_| ParseError))
-            value: value * 1000. * si::M,
+            .collect::<Result<Vec<u32>, ParseError>>()?;
-        })
+        match parts.len() {
+            0 => Err(ParseError),
+            1 => Err(ParseError),
+            2 => Ok(TimeFormatter(
+                chrono::NaiveTime::from_hms_opt(parts[0], parts[1], 0).unwrap(),
+            )),
+            3 => Ok(TimeFormatter(
+                chrono::NaiveTime::from_hms_opt(parts[0], parts[1], parts[2]).unwrap(),
+            )),
+            _ => Err(ParseError),
+        }
     }
 }
 
-impl std::ops::Add for Distance {
+impl std::ops::Deref for TimeFormatter {
-    type Output = Distance;
+    type Target = chrono::NaiveTime;
-    fn add(self, rside: Self) -> Self::Output {
-        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.value - rside.value)
-    }
-}
-
-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 {
+impl From<chrono::NaiveTime> for TimeFormatter {
-    fn from(value: si::Meter<f64>) -> Self {
+    fn from(value: chrono::NaiveTime) -> Self {
-        Self { value }
+        Self(value)
     }
 }
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
-pub struct Duration {
+pub struct WeightFormatter(si::Kilogram<f64>);
-    value: si::Second<f64>,
+
+impl WeightFormatter {
+    pub fn format(&self, option: FormatOption) -> String {
+        match option {
+            FormatOption::Abbreviated => format!("{} kg", self.0.value_unsafe),
+            FormatOption::Full => format!("{} kilograms", self.0.value_unsafe),
+        }
+    }
+
+    pub fn parse(s: &str) -> Result<WeightFormatter, ParseError> {
+        s.parse::<f64>()
+            .map(|w| WeightFormatter(w * si::KG))
+            .map_err(|_| ParseError)
+    }
 }
 
-impl Duration {
+impl std::ops::Add for WeightFormatter {
+    type Output = WeightFormatter;
+    fn add(self, rside: Self) -> Self::Output {
+        Self::Output::from(self.0 + rside.0)
+    }
+}
+
+impl std::ops::Sub for WeightFormatter {
+    type Output = WeightFormatter;
+    fn sub(self, rside: Self) -> Self::Output {
+        Self::Output::from(self.0 - rside.0)
+    }
+}
+
+impl std::ops::Deref for WeightFormatter {
+    type Target = si::Kilogram<f64>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<si::Kilogram<f64>> for WeightFormatter {
+    fn from(value: si::Kilogram<f64>) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+pub struct DistanceFormatter(si::Meter<f64>);
+
+impl DistanceFormatter {
+    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.),
+        }
+    }
+
+    pub fn parse(s: &str) -> Result<DistanceFormatter, ParseError> {
+        let value = s.parse::<f64>().map_err(|_| ParseError)?;
+        Ok(DistanceFormatter(value * 1000. * si::M))
+    }
+}
+
+impl std::ops::Add for DistanceFormatter {
+    type Output = DistanceFormatter;
+    fn add(self, rside: Self) -> Self::Output {
+        Self::Output::from(self.0 + rside.0)
+    }
+}
+
+impl std::ops::Sub for DistanceFormatter {
+    type Output = DistanceFormatter;
+    fn sub(self, rside: Self) -> Self::Output {
+        Self::Output::from(self.0 - rside.0)
+    }
+}
+
+impl std::ops::Deref for DistanceFormatter {
+    type Target = si::Meter<f64>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<si::Meter<f64>> for DistanceFormatter {
+    fn from(value: si::Meter<f64>) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+pub struct DurationFormatter(si::Second<f64>);
+
+impl DurationFormatter {
     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)
@@ -124,51 +206,134 @@ impl Duration {
         }
     }
 
-    pub fn parse(s: &str) -> Result<Duration, ParseError> {
+    pub fn parse(s: &str) -> Result<DurationFormatter, 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(DurationFormatter(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)
     }
 }
 
-impl std::ops::Add for Duration {
+impl std::ops::Add for DurationFormatter {
-    type Output = Duration;
+    type Output = DurationFormatter;
     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 {
+impl std::ops::Sub for DurationFormatter {
-    type Output = Duration;
+    type Output = DurationFormatter;
     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 {
+impl std::ops::Deref for DurationFormatter {
     type Target = si::Second<f64>;
     fn deref(&self) -> &Self::Target {
-        &self.value
+        &self.0
     }
 }
 
-impl From<si::Second<f64>> for Duration {
+impl From<si::Second<f64>> for DurationFormatter {
     fn from(value: si::Second<f64>) -> Self {
-        Self { value }
+        Self(value)
     }
 }
 
-fn take_digits(s: String) -> String {
+#[cfg(test)]
-    s.chars()
+mod test {
-        .take_while(|t| t.is_ascii_digit())
+    use super::*;
-        .collect::<String>()
+    use dimensioned::si;
+
+    #[test]
+    fn it_parses_weight_values() {
+        assert_eq!(
+            WeightFormatter::parse("15.3"),
+            Ok(WeightFormatter(15.3 * si::KG))
+        );
+        assert_eq!(WeightFormatter::parse("15.ab"), Err(ParseError));
+    }
+
+    #[test]
+    fn it_formats_weight_values() {
+        assert_eq!(
+            WeightFormatter::from(15.3 * si::KG).format(FormatOption::Abbreviated),
+            "15.3 kg"
+        );
+        assert_eq!(
+            WeightFormatter::from(15.3 * si::KG).format(FormatOption::Full),
+            "15.3 kilograms"
+        );
+    }
+
+    #[test]
+    fn it_parses_distance_values() {
+        assert_eq!(
+            DistanceFormatter::parse("70"),
+            Ok(DistanceFormatter(70000. * si::M))
+        );
+        assert_eq!(DistanceFormatter::parse("15.ab"), Err(ParseError));
+    }
+
+    #[test]
+    fn it_formats_distance_values() {
+        assert_eq!(
+            DistanceFormatter::from(70000. * si::M).format(FormatOption::Abbreviated),
+            "70 km"
+        );
+        assert_eq!(
+            DistanceFormatter::from(70000. * si::M).format(FormatOption::Full),
+            "70 kilometers"
+        );
+    }
+
+    #[test]
+    fn it_parses_duration_values() {
+        assert_eq!(
+            DurationFormatter::parse("70"),
+            Ok(DurationFormatter(4200. * si::S))
+        );
+        assert_eq!(DurationFormatter::parse("15.ab"), Err(ParseError));
+    }
+
+    #[test]
+    fn it_formats_duration_values() {
+        assert_eq!(
+            DurationFormatter::from(4200. * si::S).format(FormatOption::Abbreviated),
+            "1h 10m"
+        );
+        assert_eq!(
+            DurationFormatter::from(4200. * si::S).format(FormatOption::Full),
+            "1 hours 10 minutes"
+        );
+    }
+
+    #[test]
+    fn it_parses_time_values() {
+        assert_eq!(
+            TimeFormatter::parse("13:25"),
+            Ok(TimeFormatter::from(
+                chrono::NaiveTime::from_hms_opt(13, 25, 0).unwrap()
+            )),
+        );
+        assert_eq!(
+            TimeFormatter::parse("13:25:50"),
+            Ok(TimeFormatter::from(
+                chrono::NaiveTime::from_hms_opt(13, 25, 50).unwrap()
+            )),
+        );
+    }
+
+    #[test]
+    fn it_formats_time_values() {
+        let time = TimeFormatter::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());
+    }
 }

fitnesstrax/app/src/view_models/day_detail.rs

@@ -16,9 +16,8 @@ You should have received a copy of the GNU General Public License along with Fit
 
 use crate::{
     app::App,
-    types::{Distance, Duration},
+    types::{DistanceFormatter, DurationFormatter, WeightFormatter},
 };
-use dimensioned::si;
 use emseries::{Record, RecordId, Recordable};
 use ft_core::{RecordType, TimeDistance, TraxRecord};
 use std::{
@@ -116,22 +115,24 @@ impl DayDetailViewModel {
         s
     }
 
-    pub fn weight(&self) -> Option<si::Kilogram<f64>> {
+    pub fn weight(&self) -> Option<WeightFormatter> {
-        (*self.weight.read().unwrap()).as_ref().map(|w| w.weight)
+        (*self.weight.read().unwrap())
+            .as_ref()
+            .map(|w| WeightFormatter::from(w.weight))
     }
 
-    pub fn set_weight(&self, new_weight: si::Kilogram<f64>) {
+    pub fn set_weight(&self, new_weight: WeightFormatter) {
         let mut record = self.weight.write().unwrap();
         let new_record = match *record {
             Some(ref rstate) => rstate.clone().with_value(ft_core::Weight {
                 date: self.date,
-                weight: new_weight,
+                weight: *new_weight,
             }),
             None => RecordState::New(Record {
                 id: RecordId::default(),
                 data: ft_core::Weight {
                     date: self.date,
-                    weight: new_weight,
+                    weight: *new_weight,
                 },
             }),
         };
@@ -160,9 +161,9 @@ impl DayDetailViewModel {
         *record = Some(new_record);
     }
 
-    pub fn biking_summary(&self) -> (Distance, Duration) {
+    pub fn biking_summary(&self) -> (DistanceFormatter, DurationFormatter) {
         self.records.read().unwrap().iter().fold(
-            (Distance::default(), Duration::default()),
+            (DistanceFormatter::default(), DurationFormatter::default()),
             |(acc_distance, acc_duration), (_, record)| match record.data() {
                 Some(Record {
                     data:
@@ -172,10 +173,10 @@ impl DayDetailViewModel {
                     ..
                 }) => (
                     distance
-                        .map(|distance| acc_distance + Distance::from(distance))
+                        .map(|distance| acc_distance + DistanceFormatter::from(distance))
                         .unwrap_or(acc_distance),
                     duration
-                        .map(|duration| acc_duration + Duration::from(duration))
+                        .map(|duration| acc_duration + DurationFormatter::from(duration))
                         .unwrap_or(acc_duration),
                 ),