feat: Add AppStates, Add Filter Dialog and create log level vec on st…

…artup, update input events to be state based

src/app.rs

@@ -1,17 +1,30 @@
-use ratatui::widgets::{Row, TableState};
-
 use crate::clef::ClefLine;
+use ratatui::widgets::{ListState, Row, TableState};
+
+#[derive(Debug)]
+pub enum AppState {
+    FILTERING,
+    ITERATING,
+}
+
+impl Default for AppState {
+    fn default() -> Self {
+        AppState::ITERATING
+    }
+}
 #[derive(Debug, Default)]
 pub struct App<'a> {
     pub should_quit: bool,
     pub counter: u8,
     pub lines: Vec<ClefLine<'a>>,
     pub rows: Vec<Row<'a>>,
-    pub table_state: TableState,
-    pub file_path: String
+    pub event_table_state: TableState,
+    pub filter_list_state: ListState,
+    pub file_path: String,
+    pub event_types: Vec<String>,
+    pub app_state: AppState,
 }
 
-
 impl<'a> App<'a> {
     pub fn new() -> Self {
         Self::default()
@@ -20,38 +33,68 @@ impl<'a> App<'a> {
     pub fn tick(&self) {}
 
     pub fn load_lines(&mut self, lines: &Vec<String>) {
-        self.lines = Self::create_cells_from_line(lines);
+        self.lines = self.create_cells_from_line(lines);
     }
 
-    fn create_cells_from_line(lines: &Vec<String>) -> Vec<ClefLine<'a>> {
+    fn create_cells_from_line(&mut self, lines: &Vec<String>) -> Vec<ClefLine<'a>> {
         let mut clef_lines: Vec<ClefLine<'_>> = vec![];
-      
+
         for line in lines {
             clef_lines.push(ClefLine::new(line).unwrap())
         }
+        self.get_event_types(&clef_lines);
         clef_lines
     }
 
+    pub fn get_event_types(&mut self, events: &Vec<ClefLine>) {
+        for event in events {
+            if !self.event_types.contains(&event.level) && &event.level != "" {
+                self.event_types.push(event.level.to_string());
+            }
+        }
+        println!("{:?}", self.event_types);
+    }
+
     pub fn quit(&mut self) {
         self.should_quit = true;
     }
 
     pub fn move_row_up(&mut self, range: usize) {
-        if let Some(selected) = self.table_state.selected() {
+        if let Some(selected) = self.event_table_state.selected() {
             if selected >= range {
-                self.table_state.select(Some(selected - range));
+                self.event_table_state.select(Some(selected - range));
             } else {
-                self.table_state.select(Some(self.lines.len() - 1));
+                self.event_table_state.select(Some(self.lines.len() - 1));
             }
         }
     }
 
     pub fn move_row_down(&mut self, range: usize) {
-        if let Some(selected) = self.table_state.selected() {
+        if let Some(selected) = self.event_table_state.selected() {
             if selected < self.lines.len() - range {
-                self.table_state.select(Some(selected + range));
+                self.event_table_state.select(Some(selected + range));
+            } else {
+                self.event_table_state.select(Some(0));
+            }
+        }
+    }
+
+    pub fn move_list_up(&mut self) {
+        if let Some(selected) = self.filter_list_state.selected() {
+            if selected >= 1 {
+                self.filter_list_state.select(Some(selected - 1));
+            } else {
+                self.filter_list_state.select(Some(0));
+            }
+        }
+    }
+
+    pub fn move_list_down(&mut self) {
+        if let Some(selected) = self.filter_list_state.selected() {
+            if selected < self.event_types.len() {
+                self.filter_list_state.select(Some(selected + 1));
             } else {
-                self.table_state.select(Some(0));
+                self.filter_list_state.select(Some(0));
             }
         }
     }

src/clef.rs

@@ -43,21 +43,29 @@ pub struct ClefLine<'a> {
 }
 
 impl<'a> ClefLine<'a> {
-
     pub fn new(line: &str) -> Result<Self, Error> {
         let mut clef: ClefLine = serde_json::from_str(line).unwrap();
         clef.data = line.to_string();
         clef.template = clef.render()?;
-        let time  = DateTime::parse_from_rfc3339(clef.time.as_str());
+        let time = DateTime::parse_from_rfc3339(clef.time.as_str());
         clef.time = time.unwrap().format("%d.%m.%y %H:%M:%S").to_string();
         clef.row = Row::new(vec![
-            Cell::from(["[".to_string(),clef.time.to_string(),"|".to_string(), clef.level.to_string(), "]".to_string()].join("")),
+            Cell::from(
+                [
+                    "[".to_string(),
+                    clef.time.to_string(),
+                    "|".to_string(),
+                    clef.level.to_string(),
+                    "]".to_string(),
+                ]
+                .join(""),
+            ),
             Cell::from(clef.template.to_string()),
         ]);
         Ok(clef)
     }
 
-    pub fn render(&mut self) -> Result<String,Error> {
+    pub fn render(&mut self) -> Result<String, Error> {
         let start_bracket = "{";
         let end_bracket = "}";
         let mut base = self.template.clone();

src/main.rs

@@ -16,12 +16,15 @@ pub mod update;
 // clef parser
 pub mod clef;
 
-use std::{ fs, io::{self}};
+use std::{
+    fs,
+    io::{self},
+};
 
 use app::App;
 use clap::Parser;
 use event::{Event, EventHandler};
-use ratatui::{backend::CrosstermBackend, widgets::TableState, Terminal};
+use ratatui::{backend::CrosstermBackend, widgets::{ListState, TableState}, Terminal};
 use tui::Tui;
 use update::update;
 #[derive(Parser, Debug)]
@@ -70,8 +73,10 @@ fn create_app(path: String) -> Result<App<'static>, io::Error> {
     let lines = read_file(path.as_str())?;
     let mut app = App::new();
     app.file_path = path;
-    app.table_state = TableState::new();
-    app.table_state.select(Some(0));
+    app.event_table_state = TableState::new();
+    app.filter_list_state = ListState::default();
+    app.filter_list_state.select(Some(0));
+    app.event_table_state.select(Some(0));
     app.load_lines(&lines);
     Ok(app)
 }