feat: browse questions by topic tag tui

akarsh1995 · akarsh1995 · commit 6b6712fc3614 · 2023-07-16T21:38:59.000+05:30
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,6 +18,4 @@ toml = "0.7.6"
 async-trait = "0.1.71"
 skim = "0.10.4"
 ratatui = { version = "0.21.0", features = ["all-widgets"] }
-anyhow = "1.0.72"
 crossterm = "0.26.1"
-
diff --git a/src/app_ui/app.rs b/src/app_ui/app.rs
@@ -1,4 +1,4 @@
-use crate::{entities::question::Model as QuestionModel, deserializers::question::Question};
+use crate::entities::question::Model as QuestionModel;
 use crate::entities::topic_tag::Model as TopicTagModel;
 use std::{collections::HashMap, error};
 
@@ -12,49 +12,60 @@ pub type SS = (TopicTagModel, Vec<QuestionModel>);
 pub type TTReciever = tokio::sync::mpsc::Receiver<SS>;
 pub type TTSender = tokio::sync::mpsc::Sender<SS>;
 
+#[derive(Debug)]
+pub enum Widget<'a> {
+    QuestionList(&'a mut StatefulList<QuestionModel>),
+    TopicTagList(&'a mut StatefulList<TopicTagModel>),
+}
+
 /// Application.
 #[derive(Debug)]
-pub struct App {
+pub struct App<'a> {
     /// Is the application running?
     pub running: bool,
 
-    pub topic_tags_stateful: StatefulList<TopicTagModel>,
-
-    // multi select logic can be implemented
-    pub questions_stateful: StatefulList<QuestionModel>,
+    pub widgets: &'a mut Vec<Widget<'a>>,
 
-    pub questions_list: HashMap<String, Vec<QuestionModel>>,
+    pub questions_list: &'a HashMap<String, Vec<QuestionModel>>,
 
-    pub questions_recv: TTReciever,
+    pub widget_switcher: i32,
 }
 
-impl App {
+impl<'a> App<'a> {
     /// Constructs a new instance of [`App`].
-    pub fn new(rec: TTReciever) -> Self {
+    pub fn new(
+        wid: &'a mut Vec<Widget<'a>>,
+        questions_list: &'a HashMap<String, Vec<QuestionModel>>,
+    ) -> Self {
         Self {
             running: true,
-            topic_tags_stateful: StatefulList::with_items(vec![]),
-            questions_stateful: StatefulList::with_items(vec![]),
-            questions_list: HashMap::new(),
-            questions_recv: rec,
+            questions_list,
+            widgets: wid,
+            widget_switcher: 0,
         }
     }
 
-    /// Handles the tick event of the terminal.
-    pub fn tick(&mut self) {
-        for _ in 0..100 {
-            if let Some((topic_tag, mut questions)) = self.questions_recv.blocking_recv() {
-                if let Some(name) = &topic_tag.name {
-                    self.questions_list.entry(name.clone()).or_insert(vec![]).append(&mut questions);
-                }
-                self.topic_tags_stateful.add_item(topic_tag);
-            }
-        }
+    pub fn next_widget(&mut self) {
+        let a = self.widget_switcher + 1;
+        let b = self.widgets.len() as i32;
+        self.widget_switcher = ((a % b) + b) % b;
     }
 
+    pub fn prev_widget(&mut self) {
+        let a = self.widget_switcher - 1;
+        let b = self.widgets.len() as i32;
+        self.widget_switcher = ((a % b) + b) % b;
+    }
+
+    pub fn get_current_widget(&self) -> &Widget {
+        &self.widgets[self.widget_switcher as usize]
+    }
+
+    /// Handles the tick event of the terminal.
+    pub fn tick(&mut self) {}
+
     /// Set running to false to quit the application.
     pub fn quit(&mut self) {
         self.running = false;
     }
-
 }
diff --git a/src/app_ui/handler.rs b/src/app_ui/handler.rs
@@ -3,6 +3,7 @@ use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
 
 /// Handles the key events and updates the state of [`App`].
 pub fn handle_key_events(key_event: KeyEvent, app: &mut App) -> AppResult<()> {
+    let curr_widget = &mut app.widgets[app.widget_switcher as usize];
     match key_event.code {
         // Exit application on `ESC` or `q`
         KeyCode::Esc | KeyCode::Char('q') => {
@@ -15,21 +16,39 @@ pub fn handle_key_events(key_event: KeyEvent, app: &mut App) -> AppResult<()> {
             }
         }
         // Counter handlers
-        KeyCode::Up => { 
-            app.topic_tags_stateful.previous();
-        }
-        KeyCode::Down => {
-            app.topic_tags_stateful.next() ;
-        }
+        KeyCode::Up => match curr_widget {
+            super::app::Widget::QuestionList(ql) => ql.previous(),
+            super::app::Widget::TopicTagList(tt) => tt.previous(),
+        },
+        KeyCode::Down => match curr_widget {
+            super::app::Widget::QuestionList(ql) => ql.next(),
+            super::app::Widget::TopicTagList(tt) => tt.next(),
+        },
+        KeyCode::Left => app.prev_widget(),
+        KeyCode::Right => app.next_widget(),
         // Other handlers you could add here.
         _ => {}
     }
 
     // post key event update the question list
-    if let Some(selected_tt) = app.topic_tags_stateful.get_selected_item() {
-        if let Some(ttname) = &selected_tt.name {
-            let questions = app.questions_list.get(ttname).unwrap();
-            app.questions_stateful.items = questions.clone();
+    let mut name: Option<String> = None;
+
+    match &app.widgets[app.widget_switcher as usize] {
+        super::app::Widget::TopicTagList(ttl) => {
+            if let Some(selected_widget) = ttl.get_selected_item() {
+                if let Some(n) = &selected_widget.name {
+                    name = Some(n.clone());
+                }
+            }
+        }
+        _ => {}
+    }
+
+    for w in app.widgets.iter_mut() {
+        if let super::app::Widget::QuestionList(ql) = w {
+            if let Some(name) = &name {
+                ql.items = app.questions_list.get(name).unwrap().clone();
+            }
         }
     }
     Ok(())
diff --git a/src/app_ui/list.rs b/src/app_ui/list.rs
@@ -7,16 +7,13 @@ pub struct StatefulList<T> {
 }
 
 impl<T> StatefulList<T> {
-
     pub fn add_item(&mut self, item: T) {
         self.items.push(item)
     }
 
     pub fn get_selected_item(&self) -> Option<&T> {
         match self.state.selected() {
-            Some(i) => {
-                Some(&self.items[i])
-            }
+            Some(i) => Some(&self.items[i]),
             None => None,
         }
     }
@@ -31,29 +28,25 @@ impl<T> StatefulList<T> {
     pub fn next(&mut self) {
         let i = match self.state.selected() {
             Some(i) => {
-                if i >= self.items.len() - 1 {
-                    0
-                } else {
-                    i + 1
-                }
+                let a = i as i32 + 1;
+                let b = self.items.len() as i32;
+                ((a % b) + b) % b
             }
             None => 0,
         };
-        self.state.select(Some(i));
+        self.state.select(Some(i as usize));
     }
 
     pub fn previous(&mut self) {
         let i = match self.state.selected() {
             Some(i) => {
-                if i == 0 {
-                    self.items.len() - 1
-                } else {
-                    i - 1
-                }
+                let a = i as i32 - 1;
+                let b = self.items.len() as i32;
+                ((a % b) + b) % b
             }
             None => 0,
         };
-        self.state.select(Some(i));
+        self.state.select(Some(i as usize));
     }
 
     pub fn unselect(&mut self) {
diff --git a/src/app_ui/ui.rs b/src/app_ui/ui.rs
@@ -1,78 +1,92 @@
-// use ratatui::{
-//     backend::Backend,
-//     layout::{Alignment, Layout},
-//     style::{Color, Style},
-//     widgets::{Block, BorderType, Borders, Paragraph},
-//     Frame,
-// };
 use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    layout::{Constraint, Corner, Direction, Layout},
+    backend::Backend,
+    layout::{Constraint, Direction, Layout},
     style::{Color, Modifier, Style},
-    text::{Line, Span},
-    widgets::{Block, Borders, List, ListItem, ListState},
-    Frame, Terminal,
+    text::Line,
+    widgets::{Block, Borders, List, ListItem},
+    Frame,
 };
 
 use super::app::App;
 
 /// Renders the user interface widgets.
-pub fn render<B: Backend>(app: &mut App, f: &mut Frame<'_, B>) {
+pub fn render<'a, B: Backend>(app: &'a mut App, f: &mut Frame<'_, B>) {
     // Create two chunks with equal horizontal screen space
     let chunks = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
         .split(f.size());
 
     // Iterate through all elements in the `items` app and append some debug text to it.
-    let items: Vec<ListItem> = app
-        .topic_tags_stateful
-        .items
-        .iter()
-        .map(|tt_model| {
-            if let Some(name) = &tt_model.name {
-                let lines = vec![Line::from(name.as_str())];
-                ListItem::new(lines)
-            } else {
-                ListItem::new(vec![Line::from("")])
-            }
-        })
-        .collect();
-
-    // Create a List from all list items and highlight the currently selected one
-    let items = List::new(items)
-        .block(Block::default().borders(Borders::ALL).title("List"))
-        .highlight_style(
-            Style::default()
-                .bg(Color::White)
-                .fg(Color::Black)
-                .add_modifier(Modifier::BOLD),
-        )
-        .highlight_symbol(">> ");
+    for (i, w) in app.widgets.iter_mut().enumerate() {
+        let is_widget_active = app.widget_switcher as usize == i;
+        let mut border_style = Style::default();
+        if is_widget_active {
+            border_style = border_style.fg(Color::Cyan);
+        }
+        match w {
+            super::app::Widget::TopicTagList(ttl) => {
+                let items: Vec<ListItem> = ttl
+                    .items
+                    .iter()
+                    .map(|tt_model| {
+                        if let Some(name) = &tt_model.name {
+                            let lines = vec![Line::from(name.as_str())];
+                            ListItem::new(lines)
+                        } else {
+                            ListItem::new(vec![Line::from("")])
+                        }
+                    })
+                    .collect();
 
-    // We can now render the item list
-    f.render_stateful_widget(items, chunks[0], &mut app.topic_tags_stateful.state);
+                // Create a List from all list items and highlight the currently selected one
+                let items = List::new(items)
+                    .block(
+                        Block::default()
+                            .borders(Borders::ALL)
+                            .title("Tags")
+                            .border_style(border_style),
+                    )
+                    .highlight_style(
+                        Style::default()
+                            .bg(Color::White)
+                            .fg(Color::Black)
+                            .add_modifier(Modifier::BOLD),
+                    )
+                    .highlight_symbol(">> ");
 
-    let questions: Vec<ListItem> = app
-        .questions_stateful
-        .items
-        .iter()
-        .map(|question| {
-            let lines = vec![Line::from(format!(
-                "{}: {:?}",
-                question.frontend_question_id, question.title
-            ))];
-            ListItem::new(lines)
-        })
-        .collect();
+                // We can now render the item list
+                f.render_stateful_widget(items, chunks[0], &mut ttl.state);
+            }
+            super::app::Widget::QuestionList(ql) => {
+                let questions: Vec<ListItem> = ql
+                    .items
+                    .iter()
+                    .map(|question| {
+                        let lines = vec![Line::from(format!(
+                            "{}: {:?}",
+                            question.frontend_question_id, question.title
+                        ))];
+                        ListItem::new(lines)
+                    })
+                    .collect();
 
-    let items = List::new(questions)
-        .block(Block::default().borders(Borders::ALL).title("Questions"))
-        .highlight_style(
-            Style::default()
-                .bg(Color::LightGreen)
-                .add_modifier(Modifier::BOLD),
-        )
-        .highlight_symbol(">> ");
-    f.render_stateful_widget(items, chunks[1], &mut app.questions_stateful.state);
+                let items = List::new(questions)
+                    .block(
+                        Block::default()
+                            .borders(Borders::ALL)
+                            .title("Questions")
+                            .border_style(border_style),
+                    )
+                    .highlight_style(
+                        Style::default()
+                            .bg(Color::White)
+                            .fg(Color::Black)
+                            .add_modifier(Modifier::BOLD),
+                    )
+                    .highlight_symbol(">> ");
+                f.render_stateful_widget(items, chunks[1], &mut ql.state);
+            }
+        }
+    }
 }
diff --git a/src/entities/mod.rs b/src/entities/mod.rs
@@ -5,6 +5,5 @@ pub mod question;
 pub mod question_topic_tag;
 pub mod topic_tag;
 
-// pub use question::Model as Question;
-// pub use question_topic_tag::Model as QuestionTopicTag;
-// pub use topic_tag::Model as TopicTag;
+pub type QuestionModel = question::Model;
+pub type TopicTagModel = topic_tag::Model;
diff --git a/src/main.rs b/src/main.rs
