Cleaned up some code with some macros

src/models/mod.rs

@@ -27,172 +27,106 @@ pub trait Scrollable {
   fn scroll_to_bottom(&mut self);
 }
 
-pub struct StatefulList<T> {
-  pub state: ListState,
-  pub items: Vec<T>,
-}
-
-impl<T> Default for StatefulList<T> {
-  fn default() -> StatefulList<T> {
-    StatefulList {
-      state: ListState::default(),
-      items: Vec::new(),
+macro_rules! stateful_iterable {
+  ($name:ident, $state:ty) => {
+    pub struct $name<T> {
+      pub state: $state,
+      pub items: Vec<T>,
     }
-  }
-}
 
-impl<T> Scrollable for StatefulList<T> {
-  fn scroll_down(&mut self) {
-    let selected_row = match self.state.selected() {
-      Some(i) => {
-        if i >= self.items.len() - 1 {
-          0
-        } else {
-          i + 1
+    impl<T> Default for $name<T> {
+      fn default() -> $name<T> {
+        $name {
+          state: <$state>::default(),
+          items: Vec::new(),
         }
       }
-      None => 0,
-    };
+    }
 
-    self.state.select(Some(selected_row));
-  }
+    impl<T> Scrollable for $name<T> {
+      fn scroll_down(&mut self) {
+        let selected_row = match self.state.selected() {
+          Some(i) => {
+            if i >= self.items.len() - 1 {
+              0
+            } else {
+              i + 1
+            }
+          }
+          None => 0,
+        };
 
-  fn scroll_up(&mut self) {
-    let selected_row = match self.state.selected() {
-      Some(i) => {
-        if i == 0 {
-          self.items.len() - 1
-        } else {
-          i - 1
+        self.state.select(Some(selected_row));
+      }
+
+      fn scroll_up(&mut self) {
+        let selected_row = match self.state.selected() {
+          Some(i) => {
+            if i == 0 {
+              self.items.len() - 1
+            } else {
+              i - 1
+            }
+          }
+          None => 0,
+        };
+
+        self.state.select(Some(selected_row));
+      }
+
+      fn scroll_to_top(&mut self) {
+        self.state.select(Some(0));
+      }
+
+      fn scroll_to_bottom(&mut self) {
+        self.state.select(Some(self.items.len() - 1));
+      }
+    }
+
+    impl<T> $name<T>
+    where
+      T: Clone + PartialEq + Eq + Debug,
+    {
+      pub fn set_items(&mut self, items: Vec<T>) {
+        let items_len = items.len();
+        self.items = items;
+        if !self.items.is_empty() {
+          let selected_row = self.state.selected().map_or(0, |i| {
+            if i > 0 && i < items_len {
+              i
+            } else if i >= items_len {
+              items_len - 1
+            } else {
+              0
+            }
+          });
+          self.state.select(Some(selected_row));
         }
       }
-      None => 0,
-    };
 
-    self.state.select(Some(selected_row));
-  }
+      pub fn current_selection(&self) -> &T {
+        &self.items[self.state.selected().unwrap_or(0)]
+      }
 
-  fn scroll_to_top(&mut self) {
-    self.state.select(Some(0));
-  }
-
-  fn scroll_to_bottom(&mut self) {
-    self.state.select(Some(self.items.len() - 1));
-  }
-}
-
-impl<T: Clone + PartialEq + Eq + Debug> StatefulList<T> {
-  pub fn set_items(&mut self, items: Vec<T>) {
-    let items_len = items.len();
-    self.items = items;
-    if !self.items.is_empty() {
-      let selected_row = self.state.selected().map_or(0, |i| {
-        if i > 0 && i < items_len {
-          i
-        } else if i >= items_len {
-          items_len - 1
-        } else {
-          0
-        }
-      });
-      self.state.select(Some(selected_row));
+      pub fn current_selection_clone(&self) -> T {
+        self.items[self.state.selected().unwrap_or(0)].clone()
+      }
     }
-  }
-
-  pub fn current_selection(&self) -> &T {
-    &self.items[self.state.selected().unwrap_or(0)]
-  }
-
-  pub fn current_selection_clone(&self) -> T {
-    self.items[self.state.selected().unwrap_or(0)].clone()
-  }
+  };
 }
 
-pub struct StatefulTable<T> {
-  pub state: TableState,
-  pub items: Vec<T>,
-}
-
-impl<T> Default for StatefulTable<T> {
-  fn default() -> StatefulTable<T> {
-    StatefulTable {
-      state: TableState::default(),
-      items: Vec::new(),
-    }
-  }
-}
-
-impl<T: Clone + PartialEq + Eq + Debug> StatefulTable<T> {
-  pub fn set_items(&mut self, items: Vec<T>) {
-    let items_len = items.len();
-    self.items = items;
-    if !self.items.is_empty() {
-      let selected_row = self.state.selected().map_or(0, |i| {
-        if i > 0 && i < items_len {
-          i
-        } else if i >= items_len {
-          items_len - 1
-        } else {
-          0
-        }
-      });
-      self.state.select(Some(selected_row));
-    }
-  }
-
-  pub fn current_selection(&self) -> &T {
-    &self.items[self.state.selected().unwrap_or(0)]
-  }
-
-  pub fn current_selection_clone(&self) -> T {
-    self.items[self.state.selected().unwrap_or(0)].clone()
-  }
+stateful_iterable!(StatefulList, ListState);
+stateful_iterable!(StatefulTable, TableState);
 
+impl<T> StatefulTable<T>
+where
+  T: Clone + PartialEq + Eq + Debug,
+{
   pub fn select_index(&mut self, index: Option<usize>) {
     self.state.select(index);
   }
 }
 
-impl<T> Scrollable for StatefulTable<T> {
-  fn scroll_down(&mut self) {
-    let selected_row = match self.state.selected() {
-      Some(i) => {
-        if i >= self.items.len() - 1 {
-          0
-        } else {
-          i + 1
-        }
-      }
-      None => 0,
-    };
-
-    self.state.select(Some(selected_row));
-  }
-
-  fn scroll_up(&mut self) {
-    let selected_row = match self.state.selected() {
-      Some(i) => {
-        if i == 0 {
-          self.items.len() - 1
-        } else {
-          i - 1
-        }
-      }
-      None => 0,
-    };
-
-    self.state.select(Some(selected_row));
-  }
-
-  fn scroll_to_top(&mut self) {
-    self.state.select(Some(0));
-  }
-
-  fn scroll_to_bottom(&mut self) {
-    self.state.select(Some(self.items.len() - 1));
-  }
-}
-
 #[derive(Default)]
 pub struct ScrollableText {
   pub items: Vec<String>,