niko/oxkerclone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: variable name changes

Browse Source
This commit is contained in:
Jack Wills
2023-11-19 23:03:41 +00:00
parent cd1da2ad96
commit 56dba91e9a
6 changed files with 42 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/app_data/mod.rs
+10 -6
View File
@@ -163,12 +163,16 @@ impl AppData {
let sort_closure = |a: &ContainerItem, b: &ContainerItem| -> std::cmp::Ordering { let sort_closure = |a: &ContainerItem, b: &ContainerItem| -> std::cmp::Ordering {
match head { match head {
Header::State => match ord { Header::State => match ord {
SortedOrder::Asc => { SortedOrder::Asc => a
a.state.order().cmp(&b.state.order()).then_with(|| a.name.cmp(&b.name)) .state
} .order()
SortedOrder::Desc => { .cmp(&b.state.order())
b.state.order().cmp(&a.state.order()).then_with(|| b.name.cmp(&a.name)) .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 { Header::Status => match ord {
SortedOrder::Asc => { SortedOrder::Asc => {
src/docker_data/mod.rs
+2 -2
View File
@@ -339,8 +339,8 @@ impl DockerData {
let uuid = Uuid::new_v4(); let uuid = Uuid::new_v4();
// TODO need to refactor these // TODO need to refactor these
match message { match message {
DockerMessage::Exec(sender) => { DockerMessage::Exec(docker_tx) => {
sender.send(Arc::clone(&self.docker)).ok(); docker_tx.send(Arc::clone(&self.docker)).ok();
} }
DockerMessage::Pause(id) => { DockerMessage::Pause(id) => {
tokio::spawn(async move { tokio::spawn(async move {
src/exec.rs
+1 -3
View File
@@ -297,9 +297,7 @@ impl ExecMode {
} }
// RESET TERMINAL BEFROEHAND // RESET TERMINAL BEFROEHAND
pub async fn run( pub async fn run(&self) -> Result<(), AppError> {
&self,
) -> Result<(), AppError> {
match self { match self {
Self::External(id) => { Self::External(id) => {
Self::exec_external(id); Self::exec_external(id);
src/input_handler/mod.rs
+19 -26
View File
@@ -34,7 +34,7 @@ pub use message::InputMessages;
#[derive(Debug)] #[derive(Debug)]
pub struct InputHandler { pub struct InputHandler {
app_data: Arc<Mutex<AppData>>, app_data: Arc<Mutex<AppData>>,
docker_sender: Sender<DockerMessage>, docker_tx: Sender<DockerMessage>,
gui_state: Arc<Mutex<GuiState>>, gui_state: Arc<Mutex<GuiState>>,
is_running: Arc<AtomicBool>, is_running: Arc<AtomicBool>,
mouse_capture: bool, mouse_capture: bool,
@@ -46,13 +46,13 @@ impl InputHandler {
pub async fn init( pub async fn init(
app_data: Arc<Mutex<AppData>>, app_data: Arc<Mutex<AppData>>,
rec: Receiver<InputMessages>, rec: Receiver<InputMessages>,
docker_sender: Sender<DockerMessage>, docker_tx: Sender<DockerMessage>,
gui_state: Arc<Mutex<GuiState>>, gui_state: Arc<Mutex<GuiState>>,
is_running: Arc<AtomicBool>, is_running: Arc<AtomicBool>,
) { ) {
let mut inner = Self { let mut inner = Self {
app_data, app_data,
docker_sender, docker_tx,
gui_state, gui_state,
is_running, is_running,
rec, rec,
@@ -101,7 +101,7 @@ impl InputHandler {
.gui_state .gui_state
.lock() .lock()
.status_contains(&[Status::Error, Status::Init]); .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 self.is_running
.store(false, std::sync::atomic::Ordering::SeqCst); .store(false, std::sync::atomic::Ordering::SeqCst);
} }
@@ -111,10 +111,7 @@ impl InputHandler {
async fn confirm_delete(&self) { async fn confirm_delete(&self) {
let id = self.gui_state.lock().get_delete_container(); let id = self.gui_state.lock().get_delete_container();
if let Some(id) = id { if let Some(id) = id {
self.docker_sender self.docker_tx.send(DockerMessage::Delete(id)).await.ok();
.send(DockerMessage::Delete(id))
.await
.ok();
} }
} }
@@ -130,7 +127,7 @@ impl InputHandler {
let uuid = Uuid::new_v4(); let uuid = Uuid::new_v4();
let handle = GuiState::start_loading_animation(&self.gui_state, uuid); let handle = GuiState::start_loading_animation(&self.gui_state, uuid);
let (sx, rx) = tokio::sync::oneshot::channel::<Arc<Docker>>(); let (sx, rx) = tokio::sync::oneshot::channel::<Arc<Docker>>();
self.docker_sender.send(DockerMessage::Exec(sx)).await.ok(); self.docker_tx.send(DockerMessage::Exec(sx)).await.ok();
if let Ok(docker) = rx.await { if let Ok(docker) = rx.await {
(ExecMode::new(&self.app_data, &docker).await).map_or_else( (ExecMode::new(&self.app_data, &docker).await).map_or_else(
@@ -185,14 +182,14 @@ impl InputHandler {
async fn save_logs( async fn save_logs(
app_data: &Arc<Mutex<AppData>>, app_data: &Arc<Mutex<AppData>>,
gui_state: &Arc<Mutex<GuiState>>, gui_state: &Arc<Mutex<GuiState>>,
docker_sender: &Sender<DockerMessage>, docker_tx: &Sender<DockerMessage>,
) -> Result<(), Box<dyn std::error::Error>> { ) -> Result<(), Box<dyn std::error::Error>> {
let args = app_data.lock().args.clone(); let args = app_data.lock().args.clone();
let container = app_data.lock().get_selected_container_id_state_name(); let container = app_data.lock().get_selected_container_id_state_name();
if let Some((id, _, name)) = container { if let Some((id, _, name)) = container {
if let Some(log_path) = args.logs_dir { if let Some(log_path) = args.logs_dir {
let (sx, rx) = tokio::sync::oneshot::channel::<Arc<Docker>>(); let (sx, rx) = tokio::sync::oneshot::channel::<Arc<Docker>>();
docker_sender.send(DockerMessage::Exec(sx)).await?; docker_tx.send(DockerMessage::Exec(sx)).await?;
let now = SystemTime::now() let now = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH) .duration_since(SystemTime::UNIX_EPOCH)
@@ -251,7 +248,7 @@ impl InputHandler {
let uuid = Uuid::new_v4(); let uuid = Uuid::new_v4();
let handle = GuiState::start_loading_animation(&self.gui_state, uuid); 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 .await
.is_err() .is_err()
{ {
@@ -282,29 +279,25 @@ impl InputHandler {
if let Some(id) = option_id { if let Some(id) = option_id {
match command { match command {
DockerControls::Delete => self DockerControls::Delete => self
.docker_sender .docker_tx
.send(DockerMessage::ConfirmDelete(id)) .send(DockerMessage::ConfirmDelete(id))
.await .await
.ok(), .ok(),
DockerControls::Pause => { 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 => { DockerControls::Start => {
self.docker_sender.send(DockerMessage::Start(id)).await.ok() self.docker_tx.send(DockerMessage::Start(id)).await.ok()
} }
DockerControls::Stop => { 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(),
}; };
} }
} }
src/main.rs
+2 -2
View File
@@ -132,9 +132,9 @@ async fn main() {
.await; .await;
if args.gui { 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); 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 { } else {
info!("in debug mode\n"); info!("in debug mode\n");
// Debug mode for testing, less pointless now, will display some basic information // Debug mode for testing, less pointless now, will display some basic information
src/ui/mod.rs
+6 -6
View File
@@ -35,9 +35,9 @@ pub struct Ui {
app_data: Arc<Mutex<AppData>>, app_data: Arc<Mutex<AppData>>,
gui_state: Arc<Mutex<GuiState>>, gui_state: Arc<Mutex<GuiState>>,
input_poll_rate: Duration, input_poll_rate: Duration,
input_tx: Sender<InputMessages>,
is_running: Arc<AtomicBool>, is_running: Arc<AtomicBool>,
now: Instant, now: Instant,
sender: Sender<InputMessages>,
terminal: Terminal<CrosstermBackend<Stdout>>, terminal: Terminal<CrosstermBackend<Stdout>>,
cursor_position: (u16, u16), cursor_position: (u16, u16),
} }
@@ -59,21 +59,21 @@ impl Ui {
pub async fn create( pub async fn create(
app_data: Arc<Mutex<AppData>>, app_data: Arc<Mutex<AppData>>,
gui_state: Arc<Mutex<GuiState>>, gui_state: Arc<Mutex<GuiState>>,
input_tx: Sender<InputMessages>,
is_running: Arc<AtomicBool>, is_running: Arc<AtomicBool>,
sender: Sender<InputMessages>,
) { ) {
if let Ok(mut terminal) = Self::setup_terminal() { if let Ok(mut terminal) = Self::setup_terminal() {
// let args = app_data.lock().args.clone(); // let args = app_data.lock().args.clone();
let cursor_position = terminal.get_cursor().unwrap_or_default(); let cursor_position = terminal.get_cursor().unwrap_or_default();
let mut ui = Self { let mut ui = Self {
app_data, app_data,
cursor_position,
gui_state, gui_state,
input_poll_rate: std::time::Duration::from_millis(100), input_poll_rate: std::time::Duration::from_millis(100),
input_tx,
is_running, is_running,
now: Instant::now(), now: Instant::now(),
sender,
terminal, terminal,
cursor_position,
}; };
if let Err(e) = ui.draw_ui().await { if let Err(e) = ui.draw_ui().await {
error!("{e}"); error!("{e}");
@@ -178,7 +178,7 @@ impl Ui {
if crossterm::event::poll(self.input_poll_rate).unwrap_or(false) { if crossterm::event::poll(self.input_poll_rate).unwrap_or(false) {
if let Ok(event) = event::read() { if let Ok(event) = event::read() {
if let Event::Key(key) = event { if let Event::Key(key) = event {
self.sender self.input_tx
.send(InputMessages::ButtonPress((key.code, key.modifiers))) .send(InputMessages::ButtonPress((key.code, key.modifiers)))
.await .await
.ok(); .ok();
@@ -187,7 +187,7 @@ impl Ui {
event::MouseEventKind::Down(_) event::MouseEventKind::Down(_)
| event::MouseEventKind::ScrollDown | event::MouseEventKind::ScrollDown
| event::MouseEventKind::ScrollUp => { | event::MouseEventKind::ScrollUp => {
self.sender.send(InputMessages::MouseEvent(m)).await.ok(); self.input_tx.send(InputMessages::MouseEvent(m)).await.ok();
} }
_ => (), _ => (),
} }