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, WeightLabel},
+    components::{steps_editor, weight_editor, ActionGroup, Steps, Weight},
     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));
+            label.set_label(&format!("{} steps", s.to_string()));
         }
         row.append(&label);
 
@@ -162,7 +162,7 @@ impl DayDetail {
         let top_row = gtk::Box::builder()
             .orientation(gtk::Orientation::Horizontal)
             .build();
-        let weight_view = WeightLabel::new(view_model.weight());
+        let weight_view = Weight::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::TextEntry;
+pub use text_entry::{ParseError, TextEntry};
 
 mod time_distance;
 pub use time_distance::TimeDistanceView;
 
 mod weight;
-pub use weight::{weight_editor, WeightLabel};
+pub use weight::{weight_editor, Weight};
 
 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::TextEntry, types::ParseError};
+use crate::components::{ParseError, TextEntry};
 use gtk::prelude::*;
 
 #[derive(Default)]

fitnesstrax/app/src/components/text_entry.rs

@@ -1,5 +1,5 @@
 /*
-Copyright 2023-2024, Savanni D'Gerinel <savanni@luminescent-dreams.com>
+Copyright 2023, Savanni D'Gerinel <savanni@luminescent-dreams.com>
 
 This file is part of FitnessTrax.
 
@@ -14,10 +14,12 @@ 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,25 +14,23 @@ 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::{
+use crate::components::{ParseError, TextEntry};
-    components::TextEntry,
+use dimensioned::si;
-    types::{FormatOption, Weight},
-};
 use gtk::prelude::*;
 
-pub struct WeightLabel {
+pub struct Weight {
     label: gtk::Label,
 }
 
-impl WeightLabel {
+impl Weight {
-    pub fn new(weight: Option<Weight>) -> Self {
+    pub fn new(weight: Option<si::Kilogram<f64>>) -> Self {
         let label = gtk::Label::builder()
             .css_classes(["card", "weight-view"])
             .can_focus(true)
             .build();
 
         match weight {
-            Some(w) => label.set_text(&w.format(FormatOption::Abbreviated)),
+            Some(w) => label.set_text(&format!("{:?}", w)),
             None => label.set_text("No weight recorded"),
         }
 
@@ -44,16 +42,19 @@ impl WeightLabel {
     }
 }
 
-pub fn weight_editor<OnUpdate>(weight: Option<Weight>, on_update: OnUpdate) -> TextEntry<Weight>
+pub fn weight_editor<OnUpdate>(
+    weight: Option<si::Kilogram<f64>>,
+    on_update: OnUpdate,
+) -> TextEntry<si::Kilogram<f64>>
 where
-    OnUpdate: Fn(Weight) + 'static,
+    OnUpdate: Fn(si::Kilogram<f64>) + 'static,
 {
     TextEntry::new(
         "0 kg",
         weight,
-        |val: &Weight| val.format(FormatOption::Abbreviated),
+        |val: &si::Kilogram<f64>| val.to_string(),
         move |v: &str| {
-            let new_weight = Weight::parse(v);
+            let new_weight = v.parse::<f64>().map(|w| w * si::KG).map_err(|_| ParseError);
             match new_weight {
                 Ok(w) => {
                     on_update(w);

fitnesstrax/app/src/types.rs

@@ -1,8 +1,4 @@
-use chrono::{Local, NaiveDate};
+use chrono::{Duration, 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
@@ -16,7 +12,7 @@ pub struct DayInterval {
 impl Default for DayInterval {
     fn default() -> Self {
         Self {
-            start: (Local::now() - chrono::Duration::days(7)).date_naive(),
+            start: (Local::now() - Duration::days(7)).date_naive(),
             end: Local::now().date_naive(),
         }
     }
@@ -42,178 +38,10 @@ impl Iterator for DayIterator {
     fn next(&mut self) -> Option<Self::Item> {
         if self.current <= self.end {
             let val = self.current;
-            self.current += chrono::Duration::days(1);
+            self.current += 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,7 +14,8 @@ 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, types::Weight};
+use crate::app::App;
+use dimensioned::si;
 use emseries::{Record, RecordId, Recordable};
 use ft_core::TraxRecord;
 use std::{
@@ -124,22 +125,20 @@ impl DayDetailViewModel {
         }
     }
 
-    pub fn weight(&self) -> Option<Weight> {
+    pub fn weight(&self) -> Option<si::Kilogram<f64>> {
-        (*self.weight.read().unwrap())
+        (*self.weight.read().unwrap()).as_ref().map(|w| w.weight)
-            .as_ref()
-            .map(|w| Weight::from(w.weight))
     }
 
-    pub fn set_weight(&self, new_weight: Weight) {
+    pub fn set_weight(&self, new_weight: si::Kilogram<f64>) {
         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);