From 56dba91e9a3b72b7547b3e17255a809b16c7ccf2 Mon Sep 17 00:00:00 2001 From: Jack Wills <32690432+mrjackwills@users.noreply.github.com> Date: Sun, 19 Nov 2023 23:03:41 +0000 Subject: [PATCH] refactor: variable name changes --- src/app_data/mod.rs | 16 ++++++++------ src/docker_data/mod.rs | 4 ++-- src/exec.rs | 4 +--- src/input_handler/mod.rs | 45 +++++++++++++++++----------------------- src/main.rs | 8 +++---- src/ui/mod.rs | 12 +++++------ 6 files changed, 42 insertions(+), 47 deletions(-) diff --git a/src/app_data/mod.rs b/src/app_data/mod.rs index 10b4532..745572f 100644 --- a/src/app_data/mod.rs +++ b/src/app_data/mod.rs @@ -163,12 +163,16 @@ impl AppData { let sort_closure = |a: &ContainerItem, b: &ContainerItem| -> std::cmp::Ordering { match head { Header::State => match ord { - SortedOrder::Asc => { - a.state.order().cmp(&b.state.order()).then_with(|| a.name.cmp(&b.name)) - } - SortedOrder::Desc => { - b.state.order().cmp(&a.state.order()).then_with(|| b.name.cmp(&a.name)) - } + SortedOrder::Asc => a + .state + .order() + .cmp(&b.state.order()) + .then_with(|| a.name.cmp(&b.name)), + SortedOrder::Desc => b + .state + .order() + .cmp(&a.state.order()) + .then_with(|| b.name.cmp(&a.name)), }, Header::Status => match ord { SortedOrder::Asc => { diff --git a/src/docker_data/mod.rs b/src/docker_data/mod.rs index 2817930..99d0bcf 100644 --- a/src/docker_data/mod.rs +++ b/src/docker_data/mod.rs @@ -339,8 +339,8 @@ impl DockerData { let uuid = Uuid::new_v4(); // TODO need to refactor these match message { - DockerMessage::Exec(sender) => { - sender.send(Arc::clone(&self.docker)).ok(); + DockerMessage::Exec(docker_tx) => { + docker_tx.send(Arc::clone(&self.docker)).ok(); } DockerMessage::Pause(id) => { tokio::spawn(async move { diff --git a/src/exec.rs b/src/exec.rs index 7092505..6dcc5db 100644 --- a/src/exec.rs +++ b/src/exec.rs @@ -297,9 +297,7 @@ impl ExecMode { } // RESET TERMINAL BEFROEHAND - pub async fn run( - &self, - ) -> Result<(), AppError> { + pub async fn run(&self) -> Result<(), AppError> { match self { Self::External(id) => { Self::exec_external(id); diff --git a/src/input_handler/mod.rs b/src/input_handler/mod.rs index 4d19829..a84b0d4 100644 --- a/src/input_handler/mod.rs +++ b/src/input_handler/mod.rs @@ -34,7 +34,7 @@ pub use message::InputMessages; #[derive(Debug)] pub struct InputHandler { app_data: Arc>, - docker_sender: Sender, + docker_tx: Sender, gui_state: Arc>, is_running: Arc, mouse_capture: bool, @@ -46,13 +46,13 @@ impl InputHandler { pub async fn init( app_data: Arc>, rec: Receiver, - docker_sender: Sender, + docker_tx: Sender, gui_state: Arc>, is_running: Arc, ) { let mut inner = Self { app_data, - docker_sender, + docker_tx, gui_state, is_running, rec, @@ -101,7 +101,7 @@ impl InputHandler { .gui_state .lock() .status_contains(&[Status::Error, Status::Init]); - if error_init || self.docker_sender.send(DockerMessage::Quit).await.is_err() { + if error_init || self.docker_tx.send(DockerMessage::Quit).await.is_err() { self.is_running .store(false, std::sync::atomic::Ordering::SeqCst); } @@ -111,10 +111,7 @@ impl InputHandler { async fn confirm_delete(&self) { let id = self.gui_state.lock().get_delete_container(); if let Some(id) = id { - self.docker_sender - .send(DockerMessage::Delete(id)) - .await - .ok(); + self.docker_tx.send(DockerMessage::Delete(id)).await.ok(); } } @@ -130,7 +127,7 @@ impl InputHandler { let uuid = Uuid::new_v4(); let handle = GuiState::start_loading_animation(&self.gui_state, uuid); let (sx, rx) = tokio::sync::oneshot::channel::>(); - self.docker_sender.send(DockerMessage::Exec(sx)).await.ok(); + self.docker_tx.send(DockerMessage::Exec(sx)).await.ok(); if let Ok(docker) = rx.await { (ExecMode::new(&self.app_data, &docker).await).map_or_else( @@ -185,14 +182,14 @@ impl InputHandler { async fn save_logs( app_data: &Arc>, gui_state: &Arc>, - docker_sender: &Sender, + docker_tx: &Sender, ) -> Result<(), Box> { let args = app_data.lock().args.clone(); let container = app_data.lock().get_selected_container_id_state_name(); if let Some((id, _, name)) = container { if let Some(log_path) = args.logs_dir { let (sx, rx) = tokio::sync::oneshot::channel::>(); - docker_sender.send(DockerMessage::Exec(sx)).await?; + docker_tx.send(DockerMessage::Exec(sx)).await?; let now = SystemTime::now() .duration_since(SystemTime::UNIX_EPOCH) @@ -251,7 +248,7 @@ impl InputHandler { let uuid = Uuid::new_v4(); let handle = GuiState::start_loading_animation(&self.gui_state, uuid); - if save_logs(&self.app_data, &self.gui_state, &self.docker_sender) + if save_logs(&self.app_data, &self.gui_state, &self.docker_tx) .await .is_err() { @@ -282,29 +279,25 @@ impl InputHandler { if let Some(id) = option_id { match command { DockerControls::Delete => self - .docker_sender + .docker_tx .send(DockerMessage::ConfirmDelete(id)) .await .ok(), DockerControls::Pause => { - self.docker_sender.send(DockerMessage::Pause(id)).await.ok() + self.docker_tx.send(DockerMessage::Pause(id)).await.ok() + } + DockerControls::Unpause => { + self.docker_tx.send(DockerMessage::Unpause(id)).await.ok() } - DockerControls::Unpause => self - .docker_sender - .send(DockerMessage::Unpause(id)) - .await - .ok(), DockerControls::Start => { - self.docker_sender.send(DockerMessage::Start(id)).await.ok() + self.docker_tx.send(DockerMessage::Start(id)).await.ok() } DockerControls::Stop => { - self.docker_sender.send(DockerMessage::Stop(id)).await.ok() + self.docker_tx.send(DockerMessage::Stop(id)).await.ok() + } + DockerControls::Restart => { + self.docker_tx.send(DockerMessage::Restart(id)).await.ok() } - DockerControls::Restart => self - .docker_sender - .send(DockerMessage::Restart(id)) - .await - .ok(), }; } } diff --git a/src/main.rs b/src/main.rs index c3199da..d976325 100644 --- a/src/main.rs +++ b/src/main.rs @@ -109,8 +109,8 @@ async fn main() { let args = CliArgs::new(); - // If running via Docker image, need to sleep else program will just quit straight away, no real idea why - // So just sleep for small while + // If running via Docker image, need to sleep else program will just quit straight away, no real idea why + // So just sleep for small while if args.in_container { std::thread::sleep(std::time::Duration::from_millis(250)); } @@ -132,9 +132,9 @@ async fn main() { .await; if args.gui { - let (sx, input_rx) = tokio::sync::mpsc::channel(32); + let (input_tx, input_rx) = tokio::sync::mpsc::channel(32); handler_init(&app_data, &docker_tx, &gui_state, input_rx, &is_running); - Ui::create(app_data, gui_state, is_running, sx).await; + Ui::create(app_data, gui_state, input_tx, is_running).await; } else { info!("in debug mode\n"); // Debug mode for testing, less pointless now, will display some basic information diff --git a/src/ui/mod.rs b/src/ui/mod.rs index e49c435..867e0d2 100644 --- a/src/ui/mod.rs +++ b/src/ui/mod.rs @@ -35,9 +35,9 @@ pub struct Ui { app_data: Arc>, gui_state: Arc>, input_poll_rate: Duration, + input_tx: Sender, is_running: Arc, now: Instant, - sender: Sender, terminal: Terminal>, cursor_position: (u16, u16), } @@ -59,21 +59,21 @@ impl Ui { pub async fn create( app_data: Arc>, gui_state: Arc>, + input_tx: Sender, is_running: Arc, - sender: Sender, ) { if let Ok(mut terminal) = Self::setup_terminal() { // let args = app_data.lock().args.clone(); let cursor_position = terminal.get_cursor().unwrap_or_default(); let mut ui = Self { app_data, + cursor_position, gui_state, input_poll_rate: std::time::Duration::from_millis(100), + input_tx, is_running, now: Instant::now(), - sender, terminal, - cursor_position, }; if let Err(e) = ui.draw_ui().await { error!("{e}"); @@ -178,7 +178,7 @@ impl Ui { if crossterm::event::poll(self.input_poll_rate).unwrap_or(false) { if let Ok(event) = event::read() { if let Event::Key(key) = event { - self.sender + self.input_tx .send(InputMessages::ButtonPress((key.code, key.modifiers))) .await .ok(); @@ -187,7 +187,7 @@ impl Ui { event::MouseEventKind::Down(_) | event::MouseEventKind::ScrollDown | event::MouseEventKind::ScrollUp => { - self.sender.send(InputMessages::MouseEvent(m)).await.ok(); + self.input_tx.send(InputMessages::MouseEvent(m)).await.ok(); } _ => (), }