Add the on_update callback to TextEntry, and test the component

fitnesstrax/app/src/components/day.rs

@@ -285,8 +285,9 @@ impl DayEdit {
         top_row.append(
             &weight_editor(view_model.weight(), {
                 let view_model = view_model.clone();
-                move |w| {
+                move |w| match w {
-                    view_model.set_weight(w);
+                    Some(w) => view_model.set_weight(w),
+                    None => eprintln!("have not implemented record delete"),
                 }
             })
             .widget(),
@@ -295,7 +296,10 @@ impl DayEdit {
         top_row.append(
             &steps_editor(view_model.steps(), {
                 let view_model = view_model.clone();
-                move |s| view_model.set_steps(s)
+                move |s| match s {
+                    Some(s) => view_model.set_steps(s),
+                    None => eprintln!("have not implemented record delete"),
+                }
             })
             .widget(),
         );

fitnesstrax/app/src/components/steps.rs

@@ -44,18 +44,13 @@ impl Steps {
 
 pub fn steps_editor<OnUpdate>(value: Option<u32>, on_update: OnUpdate) -> TextEntry<u32>
 where
-    OnUpdate: Fn(u32) + 'static,
+    OnUpdate: Fn(Option<u32>) + 'static,
 {
     TextEntry::new(
         "0",
         value,
         |v| format!("{}", v),
-        move |v| match v.parse::<u32>() {
+        move |v| v.parse::<u32>().map_err(|_| ParseError),
-            Ok(val) => {
+        on_update,
-                on_update(val);
-                Ok(val)
-            }
-            Err(_) => Err(ParseError),
-        },
     )
 }

fitnesstrax/app/src/components/text_entry.rs

@@ -18,16 +18,16 @@ use crate::types::ParseError;
 use gtk::prelude::*;
 use std::{cell::RefCell, rc::Rc};
 
-type Renderer<T> = dyn Fn(&T) -> String;
 type Parser<T> = dyn Fn(&str) -> Result<T, ParseError>;
+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,
-    #[allow(unused)]
-    renderer: Rc<Renderer<T>>,
     parser: Rc<Parser<T>>,
+    on_update: Rc<OnUpdate<T>>,
 }
 
 impl<T: Clone + std::fmt::Debug> std::fmt::Debug for TextEntry<T> {
@@ -42,10 +42,17 @@ impl<T: Clone + std::fmt::Debug> std::fmt::Debug for TextEntry<T> {
 
 // I do not understand why the data should be 'static.
 impl<T: Clone + std::fmt::Debug + 'static> TextEntry<T> {
-    pub fn new<R, V>(placeholder: &str, value: Option<T>, renderer: R, parser: V) -> Self
+    pub fn new<R, V, U>(
+        placeholder: &str,
+        value: Option<T>,
+        renderer: R,
+        parser: V,
+        on_update: U,
+    ) -> Self
     where
         R: Fn(&T) -> String + 'static,
         V: Fn(&str) -> Result<T, ParseError> + 'static,
+        U: Fn(Option<T>) + 'static,
     {
         let widget = gtk::Entry::builder().placeholder_text(placeholder).build();
         if let Some(ref v) = value {
@@ -55,8 +62,8 @@ impl<T: Clone + std::fmt::Debug + 'static> TextEntry<T> {
         let s = Self {
             value: Rc::new(RefCell::new(value)),
             widget,
-            renderer: Rc::new(renderer),
             parser: Rc::new(parser),
+            on_update: Rc::new(on_update),
         };
 
         s.widget.buffer().connect_text_notify({
@@ -71,12 +78,14 @@ 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()) {
             Ok(v) => {
-                *self.value.borrow_mut() = Some(v);
+                *self.value.borrow_mut() = Some(v.clone());
                 self.widget.remove_css_class("error");
+                (self.on_update)(Some(v));
             }
             // need to change the border to provide a visual indicator of an error
             Err(_) => {
@@ -85,25 +94,84 @@ impl<T: Clone + std::fmt::Debug + 'static> TextEntry<T> {
         }
     }
 
-    #[allow(unused)]
-    pub fn value(&self) -> Option<T> {
-        let v = self.value.borrow().clone();
-        self.value.borrow().clone()
-    }
-
-    pub fn set_value(&self, value: Option<T>) {
-        if let Some(ref v) = value {
-            self.widget.set_text(&(self.renderer)(v))
-        }
-        *self.value.borrow_mut() = value;
-    }
-
-    #[allow(unused)]
-    pub fn grab_focus(&self) {
-        self.widget.grab_focus();
-    }
-
     pub fn widget(&self) -> gtk::Widget {
         self.widget.clone().upcast::<gtk::Widget>()
     }
+
+    #[cfg(test)]
+    fn has_parse_error(&self) -> bool {
+        self.widget.has_css_class("error")
+    }
+}
+
+#[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/weight.rs

@@ -49,21 +49,13 @@ pub fn weight_editor<OnUpdate>(
     on_update: OnUpdate,
 ) -> TextEntry<WeightFormatter>
 where
-    OnUpdate: Fn(WeightFormatter) + 'static,
+    OnUpdate: Fn(Option<WeightFormatter>) + 'static,
 {
     TextEntry::new(
         "0 kg",
         weight,
-        |val: &WeightFormatter| val.format(FormatOption::Abbreviated),
+        |val| val.format(FormatOption::Abbreviated),
-        move |v: &str| {
+        WeightFormatter::parse,
-            let new_weight = WeightFormatter::parse(v);
+        on_update,
-            match new_weight {
-                Ok(w) => {
-                    on_update(w);
-                    Ok(w)
-                }
-                Err(err) => Err(err),
-            }
-        },
     )
 }