Feature/log level filter

README.md

@@ -1,7 +1,7 @@
 # clever
 Clever is a simple cli application to view *.clef logs. Written in Rust & powered by Ratatui 
 
-![clever](./images/clever.png)
+![clever](./images/clever.gif)
 
 # Installation
 

src/app.rs

@@ -1,17 +1,30 @@
-use ratatui::widgets::{Row, TableState};
+use crate::{clef::ClefLine, event_log_level::EventLogLevel};
+use ratatui::widgets::{ListState, Row, TableState};
 
-use crate::clef::ClefLine;
+#[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<EventLogLevel>,
+    pub app_state: AppState,
 }
 
-
 impl<'a> App<'a> {
     pub fn new() -> Self {
         Self::default()
@@ -20,38 +33,73 @@ 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.iter().any(|t| t.value == event.level) {
+                    self.event_types.push(EventLogLevel {
+                        selected: true,
+                        value: event.level.to_string(),
+                    });
+            }
+        }
+        self.event_types
+            .iter()
+            .for_each(|v| println!("{}", v.value));
+    }
+
     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 selected >= range {
-                self.table_state.select(Some(selected - range));
+        if let Some(selected) = self.event_table_state.selected() {
+            if selected >= range +1 {
+                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/event_log_level.rs

@@ -0,0 +1,16 @@
+
+#[derive(Debug,PartialEq)]
+pub struct EventLogLevel {
+    pub selected: bool,
+    pub value: String,
+}
+
+impl ToString for EventLogLevel {
+    fn to_string(&self) -> String {
+        if !self.selected {
+            self.value.to_string()
+        }else {
+            format!("* {}",self.value)
+        }
+    }
+}

src/main.rs

@@ -16,20 +16,26 @@ pub mod update;
 // clef parser
 pub mod clef;
 
-use std::{ fs, io::{self}};
+pub mod event_log_level;
+
+use std::{
+    fs,
+    io::{self},
+};
 
-use app::App;
-use clap::Parser;
-use event::{Event, EventHandler};
-use ratatui::{backend::CrosstermBackend, widgets::TableState, Terminal};
-use tui::Tui;
-use update::update;
 #[derive(Parser, Debug)]
 #[command(author, version, about)]
 struct Args {
     file: Option<String>,
 }
 
+use app::App;
+use clap::Parser;
+use event::{Event, EventHandler};
+use ratatui::{backend::CrosstermBackend, widgets::{ListState, TableState}, Terminal};
+use tui::Tui;
+use update::update;
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args = Args::parse();
     let path: String;
@@ -70,8 +76,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)
 }