Introduce structures for formatting and parsing Duration and Distance values

These aren't in use yet.

fitnesstrax/app/src/components/day.rs

@@ -17,7 +17,7 @@ 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, weight_editor, ActionGroup, Steps, Weight},
+    components::{steps_editor, weight_editor, ActionGroup, Steps, WeightLabel},
     view_models::DayDetailViewModel,
 };
 use glib::Object;
@@ -93,7 +93,7 @@ impl DaySummary {
             .css_classes(["day-summary__weight"])
             .build();
         if let Some(s) = view_model.steps() {
-            label.set_label(&format!("{} steps", s.to_string()));
+            label.set_label(&format!("{} steps", s));
         }
         row.append(&label);
 
@@ -162,7 +162,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());

fitnesstrax/app/src/components/mod.rs

@@ -27,13 +27,13 @@ mod steps;
 pub use steps::{steps_editor, Steps};
 
 mod text_entry;
-pub use text_entry::{ParseError, TextEntry};
+pub use text_entry::TextEntry;
 
 mod time_distance;
 pub use time_distance::TimeDistanceView;
 
 mod weight;
-pub use weight::{weight_editor, Weight};
+pub use weight::{weight_editor, WeightLabel};
 
 use glib::Object;
 use gtk::{prelude::*, subclass::prelude::*};

fitnesstrax/app/src/components/steps.rs

@@ -14,7 +14,7 @@ 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::{ParseError, TextEntry};
+use crate::{components::TextEntry, types::ParseError};
 use gtk::prelude::*;
 
 #[derive(Default)]

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,12 +14,10 @@ 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::ParseError;
 use gtk::prelude::*;
 use std::{cell::RefCell, rc::Rc};
 
-#[derive(Clone, Debug)]
-pub struct ParseError;
-
 type Renderer<T> = dyn Fn(&T) -> String;
 type Parser<T> = dyn Fn(&str) -> Result<T, ParseError>;
 

fitnesstrax/app/src/components/weight.rs

@@ -14,23 +14,25 @@ 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::{ParseError, TextEntry};
+use crate::{
-use dimensioned::si;
+    components::TextEntry,
+    types::{FormatOption, Weight},
+};
 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<Weight>) -> 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"),
         }
 
@@ -42,19 +44,16 @@ impl Weight {
     }
 }
 
-pub fn weight_editor<OnUpdate>(
+pub fn weight_editor<OnUpdate>(weight: Option<Weight>, on_update: OnUpdate) -> TextEntry<Weight>
-    weight: Option<si::Kilogram<f64>>,
-    on_update: OnUpdate,
-) -> TextEntry<si::Kilogram<f64>>
 where
-    OnUpdate: Fn(si::Kilogram<f64>) + 'static,
+    OnUpdate: Fn(Weight) + 'static,
 {
     TextEntry::new(
         "0 kg",
         weight,
-        |val: &si::Kilogram<f64>| val.to_string(),
+        |val: &Weight| val.format(FormatOption::Abbreviated),
         move |v: &str| {
-            let new_weight = v.parse::<f64>().map(|w| w * si::KG).map_err(|_| ParseError);
+            let new_weight = Weight::parse(v);
             match new_weight {
                 Ok(w) => {
                     on_update(w);

fitnesstrax/app/src/types.rs

@@ -1,4 +1,8 @@
-use chrono::{Duration, Local, NaiveDate};
+use chrono::{Local, NaiveDate};
+use dimensioned::si;
+
+#[derive(Clone, Debug)]
+pub struct ParseError;
 
 // This interval doesn't feel right, either. The idea that I have a specific interval type for just
 // NaiveDate is odd. This should be genericized, as should the iterator. Also, it shouldn't live
@@ -12,7 +16,7 @@ pub struct DayInterval {
 impl Default for DayInterval {
     fn default() -> Self {
         Self {
-            start: (Local::now() - Duration::days(7)).date_naive(),
+            start: (Local::now() - chrono::Duration::days(7)).date_naive(),
             end: Local::now().date_naive(),
         }
     }
@@ -38,10 +42,178 @@ impl Iterator for DayIterator {
     fn next(&mut self) -> Option<Self::Item> {
         if self.current <= self.end {
             let val = self.current;
-            self.current += Duration::days(1);
+            self.current += chrono::Duration::days(1);
             Some(val)
         } else {
             None
         }
     }
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum FormatOption {
+    Abbreviated,
+    Full,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+pub struct Weight(si::Kilogram<f64>);
+
+impl Weight {
+    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<Weight, ParseError> {
+        s.parse::<f64>()
+            .map(|w| Weight(w * si::KG))
+            .map_err(|_| ParseError)
+    }
+}
+
+impl std::ops::Add for Weight {
+    type Output = Weight;
+    fn add(self, rside: Self) -> Self::Output {
+        Self::Output::from(self.0 + rside.0)
+    }
+}
+
+impl std::ops::Sub for Weight {
+    type Output = Weight;
+    fn sub(self, rside: Self) -> Self::Output {
+        Self::Output::from(self.0 - rside.0)
+    }
+}
+
+impl std::ops::Deref for Weight {
+    type Target = si::Kilogram<f64>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<si::Kilogram<f64>> for Weight {
+    fn from(value: si::Kilogram<f64>) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+pub struct Distance {
+    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::Full => format!("{} kilometers", self.value.value_unsafe / 1000.),
+        }
+    }
+
+    pub fn parse(s: &str) -> Result<Distance, ParseError> {
+        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.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
+    }
+}
+
+impl From<si::Meter<f64>> for Distance {
+    fn from(value: si::Meter<f64>) -> Self {
+        Self { value }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+pub struct Duration {
+    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"),
+        };
+        if hours > 0 {
+            format!("{}{} {}{}", hours, h, minutes, m)
+        } else {
+            format!("{}{}", minutes, m)
+        }
+    }
+
+    pub fn parse(s: &str) -> Result<Duration, ParseError> {
+        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.value.value_unsafe / 60.).round() as i64;
+        let hours: i64 = minutes / 60;
+        let minutes = minutes - (hours * 60);
+        (hours, minutes)
+    }
+}
+
+impl std::ops::Add for Duration {
+    type Output = Duration;
+    fn add(self, rside: Self) -> Self::Output {
+        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.value - rside.value)
+    }
+}
+
+impl std::ops::Deref for Duration {
+    type Target = si::Second<f64>;
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+impl From<si::Second<f64>> for Duration {
+    fn from(value: si::Second<f64>) -> Self {
+        Self { value }
+    }
+}
+
+fn take_digits(s: String) -> String {
+    s.chars()
+        .take_while(|t| t.is_ascii_digit())
+        .collect::<String>()
+}

fitnesstrax/app/src/view_models/day_detail.rs

@@ -14,8 +14,7 @@ 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::app::App;
+use crate::{app::App, types::Weight};
-use dimensioned::si;
 use emseries::{Record, RecordId, Recordable};
 use ft_core::TraxRecord;
 use std::{
@@ -125,20 +124,22 @@ impl DayDetailViewModel {
         }
     }
 
-    pub fn weight(&self) -> Option<si::Kilogram<f64>> {
+    pub fn weight(&self) -> Option<Weight> {
-        (*self.weight.read().unwrap()).as_ref().map(|w| w.weight)
+        (*self.weight.read().unwrap())
+            .as_ref()
+            .map(|w| Weight::from(w.weight))
     }
 
-    pub fn set_weight(&self, new_weight: si::Kilogram<f64>) {
+    pub fn set_weight(&self, new_weight: Weight) {
         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(ft_core::Weight {
                 date: self.date,
-                weight: new_weight,
+                weight: *new_weight,
             }),
         };
         *record = Some(new_record);