UI evolution

** Re-evaluating need for users to edit list of hosts at runtime **

src/tui/mode_monitoring.rs

@@ -1,38 +1,37 @@
-use std::collections::BTreeMap;
 use crate::duration_to_string;
+use crate::target_state::TargetState;
+use crate::tui::ratatui_app::RatatuiApp;
 use color_eyre::Result;
 use crossterm::event;
 use crossterm::event::{Event, KeyCode, KeyEventKind};
-use ratatui::prelude::*;
-use ratatui::widgets::{Block, Borders, Cell, Clear, List, ListItem, ListState, Paragraph, Row, Table, TableState, Wrap};
 use ratatui::Frame;
-use std::time::{Duration, SystemTime};
 use ratatui::layout::Flex;
-use crate::target_state::TargetState;
-use crate::tui::ratatui_app::RatatuiApp;
-use crate::tui::ratatui_screens::RatatuiScreens::{Adding, Deleting, Editing};
+use ratatui::prelude::*;
+use ratatui::widgets::{
+    Block, Borders, Cell, Clear, List, ListItem, Paragraph, Row, Table, TableState,
+};
+use std::time::{Duration, SystemTime};
 
 pub struct RatatuiMonitoringMode {}
 
 impl RatatuiMonitoringMode {
     fn render_hosts_list(frame: &mut Frame, state: &mut RatatuiApp, area: Rect) {
-        /// Headers
+        // Headers
         let headers = ["Host", "RTT", "Last Change"]
             .iter()
             .map(|h| Cell::from(*h));
         let header = Row::new(headers)
-            .style(Style::default().fg(Color::Yellow))
+            .style(Style::default().fg(Color::Yellow).bold())
             .bottom_margin(1);
 
-        /// Rows
+        // Rows
         let mut rows = vec![];
 
         for (_, current) in state.state.iter() {
-            let mut name_field = format!("{} ({})", current.name.clone(), current.target.clone());
-
-            while name_field.len() < 40 {
-                name_field.push(' ');
-            }
+            let name_field = format!(
+                "{:<40}",
+                format!("{} ({})", current.name.clone(), current.target.clone())
+            );
 
             let name_style = if current.alive {
                 Style::default().fg(Color::Green)
@@ -40,118 +39,127 @@ impl RatatuiMonitoringMode {
                 Style::default().fg(Color::Red)
             };
 
-            let to_push = vec![
+            rows.push(Row::new(vec![
                 Cell::from(name_field).style(name_style),
                 Cell::from(current.last_rtt.to_string()),
-                Cell::from(
-                    format!("{} ago.",
-                            duration_to_string(
-                                SystemTime::now()
-                                    .duration_since(current.last_alive_change)
-                                    .unwrap()
-                            )
+                Cell::from(format!(
+                    "{} ago.",
+                    duration_to_string(
+                        SystemTime::now()
+                            .duration_since(current.last_alive_change)
+                            .unwrap()
                     )
-                )
-            ];
-
-            rows.push(Row::new(to_push));
+                )),
+            ]));
         }
 
-        /// Table Builder
-        let table = Table::new(rows, vec![Constraint::Min(30), Constraint::Min(6), Constraint::Min(5), Constraint::Min(30)])
-            .header(header)
-            .block(Block::default()
+        // Table Builder
+        let table = Table::new(rows, vec![
+            Constraint::Min(30),
+            Constraint::Min(6),
+            Constraint::Min(5),
+            Constraint::Min(30),
+        ])
+        .header(header)
+        .block(
+            Block::default()
                 .title(Line::from(format!("PP v{}", env!("CARGO_PKG_VERSION"))))
-                .borders(Borders::ALL))
-            .widths(&[
-                Constraint::Fill(3),
-                Constraint::Min(4),
-                Constraint::Min(30)
-            ])
-            .row_highlight_style(
-                Style::default()
-                    .bg(Color::Blue)
-                    .fg(Color::White)
-                    .add_modifier(Modifier::BOLD),
-            )
-            .highlight_symbol(">> ");
+                .borders(Borders::ALL),
+        )
+        .widths(&[
+            Constraint::Fill(2), // Host
+            Constraint::Min(4),  // RTT
+            Constraint::Min(30), // TIme Since
+        ])
+        .row_highlight_style(
+            Style::default()
+                .bg(Color::Blue)
+                .fg(Color::White)
+                .add_modifier(Modifier::BOLD),
+        )
+        .highlight_symbol(">> ");
 
         // frame.render_widget(table, layouts[0]);
-        frame.render_stateful_widget(table, area, &mut make_state(state.selected_host));
+        frame.render_stateful_widget(table, area, &mut make_hosts_list_state(state.selected_host));
     }
 
     fn render_logs(frame: &mut Frame, state: &mut RatatuiApp, logs_layout: Rect) {
-        let mut list_items = vec![];
-        for entry in state.get_log_entries(10) {
-            list_items.push(ListItem::new(entry));
-        }
+        let list_items: Vec<ListItem> = state
+            .get_log_entries(10)
+            .iter()
+            .map(|entry| ListItem::new(entry.clone()))
+            .collect();
 
-        let list = List::new(list_items)
-            .block(Block::default().title("Logs").borders(Borders::ALL))
-            .highlight_style(
-                Style::default()
-                    .fg(Color::Yellow)
-                    .add_modifier(Modifier::BOLD),
-            );
         // Log
-        frame.render_widget(list, logs_layout);
-
+        frame.render_widget(
+            List::new(list_items)
+                .block(Block::default().title("Logs").borders(Borders::ALL))
+                .highlight_style(
+                    Style::default()
+                        .fg(Color::Yellow)
+                        .add_modifier(Modifier::BOLD),
+                ),
+            logs_layout,
+        );
     }
 
     fn render_footer_block(frame: &mut Frame, footer_layout: Rect) {
-        // let footer_text = "Press <ESC> or q to exit";
-        let footer_text = "Press <ESC> or q to exit | Press d to delete host | Press a to add host";
-
         frame.render_widget(
-            Paragraph::new(footer_text)
-                .block(Block::bordered())
-                .centered(),
+            Paragraph::new(
+                "Press <ESC> or q to exit | Press d to delete host | Press a to add host",
+            )
+            .block(Block::bordered())
+            .centered(),
             footer_layout,
         );
-
     }
     pub fn render(frame: &mut Frame, state: &mut RatatuiApp) {
         let layouts = Layout::default()
             .direction(Direction::Vertical)
             .constraints([
-                Constraint::Fill(1),
-                Constraint::Length(10),
-                Constraint::Length(3),
+                Constraint::Fill(1),    // Top Bar
+                Constraint::Length(10), // Hosts
+                Constraint::Length(3),  // Logs
             ])
             .split(frame.area());
 
-        Self::render_hosts_list(frame, state,  layouts[0]);
+        Self::render_hosts_list(frame, state, layouts[0]);
         Self::render_logs(frame, state, layouts[1]);
         Self::render_footer_block(frame, layouts[2]);
 
-        Self::add_popup(state, frame);
-        Self::exit_popup(state, frame);
-        Self::delete_popup(state, frame);
+        Self::add_popup(frame, state);
+        Self::exit_popup(frame, state);
+        Self::delete_popup(frame, state);
     }
 
-    fn add_popup(state: &RatatuiApp, frame: &mut Frame) {
+    fn add_popup(frame: &mut Frame, state: &RatatuiApp) {
         if state.showing_add_popup {
-            let block = Block::bordered().title("Add Host");
-            let area = RatatuiMonitoringMode::popup_area(frame.area(), 60, 20);
+            let area = RatatuiMonitoringMode::popup_area(frame.area(), 10, 40);
 
             frame.render_widget(Clear, area);
-            frame.render_widget(block, area);
+
+            frame.render_widget(
+                Paragraph::new(format!("Host Address : {}", state.add_host_name))
+                    .block(Block::bordered().title("Label")),
+                area,
+            );
         }
     }
 
-    fn exit_popup(state: &RatatuiApp, frame: &mut Frame) {
+    fn exit_popup(frame: &mut Frame, state: &RatatuiApp) {
         if state.trying_to_exit {
-            let block = Paragraph::new("Are you sure? (Y/N)")
-                .block(Block::bordered().title("Exit"));
-            let area = RatatuiMonitoringMode::popup_area(frame.area(), 60, 20);
+            let area = RatatuiMonitoringMode::popup_area(frame.area(), 5, 20);
 
             frame.render_widget(Clear, area);
-            frame.render_widget(block, area);
+            frame.render_widget(
+                Paragraph::new("Are you sure? (Y/N)").block(Block::bordered().title("Exit")),
+                area,
+            );
         }
     }
 
-    fn delete_popup(state: &RatatuiApp, frame: &mut Frame) {
-        if state.trying_to_delete  {
+    fn delete_popup(frame: &mut Frame, state: &RatatuiApp) {
+        if state.trying_to_delete {
             let as_list = state.state.clone();
             let mut host_name = String::new();
             for (index, (label, _)) in as_list.iter().enumerate() {
@@ -179,15 +187,25 @@ impl RatatuiMonitoringMode {
         match key {
             KeyCode::Esc => {
                 app.showing_add_popup = false;
-            },
+            }
             KeyCode::Backspace => {
-                app.add_host_name.remove(app.add_host_name.len());
-            },
+                app.add_host_name.remove(app.add_host_name.len() - 1);
+            }
             KeyCode::Enter => {
-                dbg!("SAVE THE VALUE TO A NEW TARGETSTATE");
-            },
+                app.state.insert(app.add_host_name.clone(), TargetState {
+                    name: app.add_host_name.clone(),
+                    ..Default::default()
+                });
+            }
+            KeyCode::Down => {
+                dbg!("Move down to next field");
+            }
+            KeyCode::Up => {
+                dbg!("Move up to previous field");
+            }
             _ => {
                 app.add_host_name = format!("{}{}", app.add_host_name, key);
+                //dbg!(format!("ADD_HOST_NAME: {}", app.add_host_name.clone()));
             }
         }
     }
@@ -224,11 +242,11 @@ impl RatatuiMonitoringMode {
             KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => {
                 app.trying_to_exit = true;
             }
-            KeyCode::Char('a') |  KeyCode::Char('A') => {
+            KeyCode::Char('a') | KeyCode::Char('A') => {
                 app.showing_add_popup = true;
             }
-             KeyCode::Char('d') | KeyCode::Char('D') => {
-                 app.trying_to_delete = true;
+            KeyCode::Char('d') | KeyCode::Char('D') => {
+                app.trying_to_delete = true;
             }
             _ => {}
         }
@@ -237,12 +255,13 @@ impl RatatuiMonitoringMode {
     fn handle_delete_popup_inputs(app: &mut RatatuiApp, key: KeyCode) {
         match key {
             KeyCode::Char('y') | KeyCode::Char('Y') => {
-                // app.remove_selected_host();
-                dbg!("Delete this item.");
-            },
+                app.remove_selected_host();
+                app.trying_to_delete = false;
+            }
             KeyCode::Char('n') | KeyCode::Char('N') => {
                 dbg!("Do not delete this item.");
-            },
+                app.trying_to_delete = false;
+            }
             _ => {}
         }
     }
@@ -269,7 +288,7 @@ impl RatatuiMonitoringMode {
     }
 }
 
-pub fn make_state(selected: usize) -> TableState {
+pub fn make_hosts_list_state(selected: usize) -> TableState {
     let mut state = TableState::default();
     state.select(Some(selected));
     state

src/tui/ratatui_app.rs

@@ -1,9 +1,14 @@
-use crate::tui::ratatui_screens::RatatuiScreens;
 use crate::manager::Manager;
 use crate::ping_result::PingResult;
 use crate::target_state::TargetState;
+use crate::tui::mode_adding::RatatuiAddingMode;
+use crate::tui::mode_deleting::RatatuiDeletingMode;
+use crate::tui::mode_editing::RatatuiEditingMode;
+use crate::tui::mode_monitoring::RatatuiMonitoringMode;
+use crate::tui::ratatui_screens::RatatuiScreens;
 use chrono::{DateTime, Local};
 use color_eyre::Result;
+use log::debug;
 use ratatui::prelude::*;
 use ratatui::{DefaultTerminal, Frame};
 use std::collections::BTreeMap;
@@ -15,11 +20,8 @@ use std::sync::mpsc;
 use std::sync::mpsc::Receiver;
 use std::thread;
 use std::time::{Duration, SystemTime};
-use log::debug;
-use crate::tui::mode_adding::RatatuiAddingMode;
-use crate::tui::mode_deleting::RatatuiDeletingMode;
-use crate::tui::mode_editing::RatatuiEditingMode;
-use crate::tui::mode_monitoring::RatatuiMonitoringMode;
+
+const LOG_ENTRIES_DEFAULT_COUNT: u32 = 10;
 
 #[derive(Default)]
 pub struct RatatuiApp {
@@ -33,11 +35,19 @@ pub struct RatatuiApp {
     pub trying_to_exit: bool,
     pub trying_to_delete: bool,
     pub add_host_cursor_position: usize,
-    pub add_host_name: String
+    pub add_host_name: String,
+    pub num_log_entries: u32
 }
 
 /// Private Methods
 impl RatatuiApp {
+    pub fn remove_selected_host(self: &mut RatatuiApp) {
+        for (index, (name, data)) in self.state.clone().iter().enumerate() {
+            if index == self.selected_host {
+                self.state.remove(name).unwrap();
+            }
+        }
+    }
 
     pub fn set_filename(mut self, new_filename: String) {
         self.filename = Some(new_filename)
@@ -61,10 +71,8 @@ impl RatatuiApp {
             // check for any waiting ping results...
             self.consume_waiting_results(&receiver);
 
-            terminal
-                .draw(|frame| RatatuiMonitoringMode::render(frame, &mut self))?;
+            terminal.draw(|frame| RatatuiMonitoringMode::render(frame, &mut self))?;
             RatatuiMonitoringMode::handle_crossterm_events(&mut self)?;
-
         }
         Ok(())
     }
@@ -133,29 +141,36 @@ impl RatatuiApp {
     fn get_default_targets() -> BTreeMap<String, TargetState> {
         let mut working = BTreeMap::new();
 
-        working.insert("1111 DNS".to_string(), TargetState {
-            name: "1111 DNS".to_string(),
-            target: Ipv4Addr::new(1, 1, 1, 1),
-            ..TargetState::default()
-        });
-        working.insert("Google DNS".to_string(), TargetState {
-            name: "Google DNS".to_string(),
-            target: Ipv4Addr::new(8, 8, 8, 8),
-            ..TargetState::default()
-        });
-        working.insert("Test Site 1".to_string(), TargetState {
-            name: "Test Site 1".to_string(),
-            target: Ipv4Addr::new(216, 234, 202, 122),
-            ..TargetState::default()
-        });
+        working.insert(
+            "1111 DNS".to_string(),
+            TargetState {
+                name: "1111 DNS".to_string(),
+                target: Ipv4Addr::new(1, 1, 1, 1),
+                ..TargetState::default()
+            },
+        );
+        working.insert(
+            "Google DNS".to_string(),
+            TargetState {
+                name: "Google DNS".to_string(),
+                target: Ipv4Addr::new(8, 8, 8, 8),
+                ..TargetState::default()
+            },
+        );
+        working.insert(
+            "Test Site 1".to_string(),
+            TargetState {
+                name: "Test Site 1".to_string(),
+                target: Ipv4Addr::new(216, 234, 202, 122),
+                ..TargetState::default()
+            },
+        );
         working
     }
 }
 
-
 /// Public Methods
 impl RatatuiApp {
-
     fn load_hosts_from_file(file_to_load_from: PathBuf) -> BTreeMap<String, TargetState> {
         let mut working = BTreeMap::new();
 
@@ -163,11 +178,14 @@ impl RatatuiApp {
         let mut rdr = csv::Reader::from_reader(the_file.unwrap());
         for result in rdr.records() {
             let record = result.unwrap();
-            working.insert(record[1].to_string(), TargetState {
-                name: record[1].to_string(),
-                target: Ipv4Addr::from_str(&record[0]).unwrap(),
-                ..TargetState::default()
-            });
+            working.insert(
+                record[1].to_string(),
+                TargetState {
+                    name: record[1].to_string(),
+                    target: Ipv4Addr::from_str(&record[0]).unwrap(),
+                    ..TargetState::default()
+                },
+            );
         }
 
         working
@@ -180,17 +198,17 @@ impl RatatuiApp {
                 working.filename = Some(file.as_os_str().to_string_lossy().parse().unwrap());
             } else {
                 // working.log_event("Passed file doesnt exist looking for hosts.txt".to_string());
-                if !&PathBuf::from_str("hosts.txt").unwrap().exists() {
-                    // working.log_event("Didnt find hosts.txt".to_string());
-                    working.filename = None;
-                } else {
+                if PathBuf::from_str("hosts.txt").unwrap().exists() {
                     // working.log_event("Found hosts.txt.  using it as the default".to_string());
                     working.filename = Some("hosts.txt".to_string());
+                } else {
+                    // working.log_event("Didnt find hosts.txt".to_string());
+                    working.filename = None;
                 }
             }
 
             if let Some(file) = working.filename.clone() {
-                RatatuiApp::load_hosts_from_file(PathBuf::from_str(&*working.filename.clone().unwrap()).unwrap())
+                RatatuiApp::load_hosts_from_file(PathBuf::from_str(file.as_str()).unwrap())
             } else {
                 RatatuiApp::get_default_targets()
             }
@@ -199,7 +217,9 @@ impl RatatuiApp {
             working.filename = Some("hosts.txt".to_string());
             if let Some(ref hosts_file) = working.filename {
                 if PathBuf::from_str(hosts_file).unwrap().exists() {
-                    RatatuiApp::load_hosts_from_file(PathBuf::from_str(&*hosts_file.clone()).unwrap())
+                    RatatuiApp::load_hosts_from_file(
+                        PathBuf::from_str(&*hosts_file.clone()).unwrap(),
+                    )
                 } else {
                     working.filename = None;
                     RatatuiApp::get_default_targets()
@@ -209,6 +229,7 @@ impl RatatuiApp {
             }
         };
         working.state = targets.clone();
+        working.num_log_entries = LOG_ENTRIES_DEFAULT_COUNT;
         working
     }
 
@@ -228,10 +249,11 @@ impl RatatuiApp {
     }
 
     pub fn get_log_entries(&self, how_many: u32) -> Vec<String> {
-        let mut return_value = vec![];
-        for current in self.log_entries.clone().into_iter().rev() {
-            return_value.push(current);
-        }
-        return_value
+        self.log_entries
+            .iter()
+            .rev()
+            .take(how_many as usize)
+            .cloned()
+            .collect()
     }
 }