reorganization

README.md

@@ -132,3 +132,4 @@ Memory: 31731MiB (~32GiB)
     - Tree format output for duplicate file listing
     - GUI
     - Packages for different operating system repositories (currently only installable via cargo) 
+    - TUI: Improve Key Handling

src/app.rs

@@ -4,19 +4,22 @@ use std::sync::Arc;
 use anyhow::Result;
 use threadpool::ThreadPool;
 
-use crate::pipeline::{Message, Server};
+use crate::params::Params;
+use crate::server::{Message, Server};
 use crate::tui::Tui;
 
 pub struct App {
     tpool: ThreadPool,
     server: Arc<Server>,
+    app_opts: Arc<Params>,
 }
 
 impl App {
-    pub fn new() -> Self {
+    pub fn new(app_opts: Arc<Params>) -> Self {
         Self {
             tpool: ThreadPool::new(8),
             server: Arc::new(Server::new().expect("server init failed")),
+            app_opts,
         }
     }
 
@@ -25,7 +28,8 @@ impl App {
         let (app_tx, app_rx) = channel::<Message>();
 
         let server_ptr = self.server.clone();
-        let ui = Tui::new(app_tx);
+        let tui_server_ptr = self.server.clone();
+        let ui = Tui::new(app_tx, tui_server_ptr);
 
         self.tpool.execute(move || {
             server_ptr.start(server_rx).expect("server init failed");

src/main.rs

@@ -8,20 +8,21 @@ mod scanner;
 
 /* version 2.0 modules*/
 mod cli;
-mod pipeline;
+mod server;
 mod tui;
 
 use anyhow::Result;
 
 use self::app::App;
-// use clap::Parser;
+use clap::Parser;
+use params::Params;
+use std::sync::Arc;
 // use formatter::Formatter;
-// use params::Params;
 // use processor::Processor;
 // use scanner::Scanner;
 
 fn main() -> Result<()> {
-    // let app_args = Params::parse();
+    let app_args = Params::parse();
     // let scan_results = Scanner::build(&app_args)?.scan()?;
     // let processor = Processor::new(scan_results);
     // let results = processor.sizewise()?.hashwise()?;
@@ -31,7 +32,9 @@ fn main() -> Result<()> {
     //     true => interactive::init(results.files, &app_args)?,
     // }
 
-    App::new().start().expect("app init failed.");
+    App::new(Arc::new(app_args))
+        .start()
+        .expect("app init failed.");
 
     Ok(())
 }

src/server/scanner.rs

@@ -1,7 +1,6 @@
 use super::{FileQueue, Message};
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 use std::fs;
-use std::sync::atomic::{AtomicU32, Ordering::Relaxed};
 use std::sync::mpsc::{self, Receiver};
 use std::sync::Arc;
 use std::sync::Mutex;

src/tui/mod.rs

@@ -6,15 +6,17 @@ use ratatui::crossterm::event::{self, Event, KeyCode};
 use ratatui::widgets::Paragraph;
 use ratatui::{DefaultTerminal, Frame};
 
-use crate::pipeline::Message;
+use crate::server::{Message, Server};
+use std::sync::Arc;
 
 pub struct Tui {
     app_tx: Sender<Message>,
+    server: Arc<Server>,
 }
 
 impl Tui {
-    pub fn new(app_tx: Sender<Message>) -> Self {
-        Self { app_tx }
+    pub fn new(app_tx: Sender<Message>, server: Arc<Server>) -> Self {
+        Self { app_tx, server }
     }
 
     pub fn start(&self) -> Result<()> {
@@ -26,7 +28,7 @@ impl Tui {
     }
 
     fn poll_events() -> Result<Message> {
-        match event::poll(Duration::from_millis(250)).context("event polling failed.")? {
+        match event::poll(Duration::from_millis(50)).context("event polling failed.")? {
             true => match event::read().context("event read failed.")? {
                 Event::Key(key) => match key.code {
                     KeyCode::Char('q') => Ok(Message::Exit),
@@ -39,8 +41,6 @@ impl Tui {
     }
 
     fn handle_events(&self) -> Result<Message> {
-        let handleable_event = Self::poll_events();
-
         match Self::poll_events() {
             Ok(Message::Exit) => {
                 self.app_tx
@@ -52,13 +52,13 @@ impl Tui {
         }
     }
 
-    fn draw(frame: &mut Frame) {
+    fn draw(&self, frame: &mut Frame) {
         frame.render_widget(Paragraph::new("Hello, World"), frame.area());
     }
 
     fn run(&self, mut terminal: DefaultTerminal) -> Result<()> {
         loop {
-            terminal.draw(Self::draw)?;
+            terminal.draw(|f| self.draw(f))?;
             match self.handle_events() {
                 Ok(Message::Exit) => break,
                 _ => {}