style(fmt): rustfmt

22 files changed, 1759 insertions, 493 deletions

diff --git a/zellij-server/src/lib.rs b/zellij-server/src/lib.rs
index 40fa1c36e..6c57e1b32 100644
--- a/zellij-server/src/lib.rs
+++ b/zellij-server/src/lib.rs
@@ -357,7 +357,10 @@ pub fn start_server(mut os_input: Box<dyn ServerOsApi>, socket_path: PathBuf) {
                             Some(tab_layout.clone()),
                             floating_panes_layout.clone(),
                             tab_name,
-                            (layout.swap_tiled_layouts.clone(), layout.swap_floating_layouts.clone())
+                            (
+                                layout.swap_tiled_layouts.clone(),
+                                layout.swap_floating_layouts.clone(),
+                            ),
                         );
                     }
 
@@ -375,7 +378,15 @@ pub fn start_server(mut os_input: Box<dyn ServerOsApi>, socket_path: PathBuf) {
                             .unwrap();
                     }
                 } else {
-                    spawn_tabs(None, layout.template.map(|t| t.1).clone().unwrap_or_default(), None, (layout.swap_tiled_layouts.clone(), layout.swap_floating_layouts.clone()));
+                    spawn_tabs(
+                        None,
+                        layout.template.map(|t| t.1).clone().unwrap_or_default(),
+                        None,
+                        (
+                            layout.swap_tiled_layouts.clone(),
+                            layout.swap_floating_layouts.clone(),
+                        ),
+                    );
                 }
                 session_data
                     .read()
diff --git a/zellij-server/src/os_input_output.rs b/zellij-server/src/os_input_output.rs
index 70a994850..817e5e008 100644
--- a/zellij-server/src/os_input_output.rs
+++ b/zellij-server/src/os_input_output.rs
@@ -371,10 +371,10 @@ pub struct ServerOsInputOutput {
     orig_termios: Arc<Mutex<termios::Termios>>,
     client_senders: Arc<Mutex<HashMap<ClientId, ClientSender>>>,
     terminal_id_to_raw_fd: Arc<Mutex<BTreeMap<u32, Option<RawFd>>>>, // A value of None means the
-                                                                     // terminal_id exists but is
-                                                                     // not connected to an fd (eg.
-                                                                     // a command pane with a
-                                                                     // non-existing command)
+    // terminal_id exists but is
+    // not connected to an fd (eg.
+    // a command pane with a
+    // non-existing command)
     cached_resizes: Arc<Mutex<Option<BTreeMap<u32, (u16, u16)>>>>, // <terminal_id, (cols, rows)>
 }
 
diff --git a/zellij-server/src/panes/floating_panes/floating_pane_grid.rs b/zellij-server/src/panes/floating_panes/floating_pane_grid.rs
index 9f034956d..afeecc8d2 100644
--- a/zellij-server/src/panes/floating_panes/floating_pane_grid.rs
+++ b/zellij-server/src/panes/floating_panes/floating_pane_grid.rs
@@ -743,9 +743,7 @@ impl<'a> FloatingPaneGrid<'a> {
                 a_pane.y().cmp(&b_pane.y())
             }
         });
-        let active_pane_position = panes
-            .iter()
-            .position(|(id, _)| id == current_pane_id)?;
+        let active_pane_position = panes.iter().position(|(id, _)| id == current_pane_id)?;
 
         let last_pane = panes.last()?;
         let previous_active_pane_id = if active_pane_position == 0 {
diff --git a/zellij-server/src/panes/floating_panes/mod.rs b/zellij-server/src/panes/floating_panes/mod.rs
index a96b156a8..cb277729d 100644
--- a/zellij-server/src/panes/floating_panes/mod.rs
+++ b/zellij-server/src/panes/floating_panes/mod.rs
@@ -206,7 +206,9 @@ impl FloatingPanes {
         // returns the focused pane of any client_id - should be safe because the way things are
         // set up at the time of writing, all clients are focused on the same floating pane due to
         // z_index issues
-        client_id.and_then(|client_id| self.active_panes.get(&client_id).copied()).or_else(|| self.panes.keys().next().copied())
+        client_id
+            .and_then(|client_id| self.active_panes.get(&client_id).copied())
+            .or_else(|| self.panes.keys().next().copied())
     }
     pub fn toggle_show_panes(&mut self, should_show_floating_panes: bool) {
         self.show_panes = should_show_floating_panes;
@@ -224,7 +226,8 @@ impl FloatingPanes {
     }
     pub fn add_next_geom(&mut self, next_geom: PaneGeom) {
         // TODO: removeme
-        if true { // TODO: config flag to cancel this behaviour - classic_pane_algorithm?
+        if true {
+            // TODO: config flag to cancel this behaviour - classic_pane_algorithm?
             self.next_geoms.push_back(next_geom);
         }
     }
@@ -241,7 +244,7 @@ impl FloatingPanes {
                     viewport,
                 );
                 floating_pane_grid.find_room_for_new_pane()
-            }
+            },
         }
     }
     pub fn position_floating_pane_layout(
@@ -592,7 +595,12 @@ impl FloatingPanes {
             self.set_force_render();
         }
     }
-    pub fn move_active_pane(&mut self, search_backwards: bool, os_api: &mut Box<dyn ServerOsApi>, client_id: ClientId) {
+    pub fn move_active_pane(
+        &mut self,
+        search_backwards: bool,
+        os_api: &mut Box<dyn ServerOsApi>,
+        client_id: ClientId,
+    ) {
         let active_pane_id = self.get_active_pane_id(client_id).unwrap();
 
         let new_position_id = {
@@ -821,7 +829,8 @@ impl FloatingPanes {
         }
     }
     pub fn reapply_pane_focus(&mut self) {
-        if let Some(focused_pane) = self.first_active_floating_pane_id() { // floating pane focus is the same for all clients
+        if let Some(focused_pane) = self.first_active_floating_pane_id() {
+            // floating pane focus is the same for all clients
             self.focus_pane_for_all_clients(focused_pane);
         }
     }
diff --git a/zellij-server/src/panes/plugin_pane.rs b/zellij-server/src/panes/plugin_pane.rs
index 841104214..c6896f90d 100644
--- a/zellij-server/src/panes/plugin_pane.rs
+++ b/zellij-server/src/panes/plugin_pane.rs
@@ -13,10 +13,10 @@ use std::rc::Rc;
 use zellij_utils::pane_size::{Offset, SizeInPixels};
 use zellij_utils::position::Position;
 use zellij_utils::{
-    input::layout::Run,
     channels::SenderWithContext,
     data::{Event, InputMode, Mouse, Palette, PaletteColor, Style},
     errors::prelude::*,
+    input::layout::Run,
     pane_size::PaneGeom,
     shared::make_terminal_title,
     vte,
@@ -277,7 +277,9 @@ impl Pane for PluginPane {
             let mut frame_geom = self.current_geom();
             if !frame_params.should_draw_pane_frames {
                 // in this case the width of the frame needs not include the pane corners
-                frame_geom.cols.set_inner(frame_geom.cols.as_usize().saturating_sub(1));
+                frame_geom
+                    .cols
+                    .set_inner(frame_geom.cols.as_usize().saturating_sub(1));
             }
             let mut frame = PaneFrame::new(
                 frame_geom.into(),
diff --git a/zellij-server/src/panes/terminal_pane.rs b/zellij-server/src/panes/terminal_pane.rs
index 960476d5e..1b9644aa7 100644
--- a/zellij-server/src/panes/terminal_pane.rs
+++ b/zellij-server/src/panes/terminal_pane.rs
@@ -16,9 +16,9 @@ use std::time::{self, Instant};
 use zellij_utils::input::command::RunCommand;
 use zellij_utils::pane_size::Offset;
 use zellij_utils::{
-    input::layout::Run,
     data::{InputMode, Palette, PaletteColor, Style},
     errors::prelude::*,
+    input::layout::Run,
     pane_size::PaneGeom,
     pane_size::SizeInPixels,
     position::Position,
@@ -362,7 +362,9 @@ impl Pane for TerminalPane {
         let mut frame_geom = self.current_geom();
         if !frame_params.should_draw_pane_frames {
             // in this case the width of the frame needs not include the pane corners
-            frame_geom.cols.set_inner(frame_geom.cols.as_usize().saturating_sub(1));
+            frame_geom
+                .cols
+                .set_inner(frame_geom.cols.as_usize().saturating_sub(1));
         }
         let mut frame = PaneFrame::new(
             frame_geom.into(),
diff --git a/zellij-server/src/panes/tiled_panes/mod.rs b/zellij-server/src/panes/tiled_panes/mod.rs
index 6f7d714dd..bd6470c90 100644
--- a/zellij-server/src/panes/tiled_panes/mod.rs
+++ b/zellij-server/src/panes/tiled_panes/mod.rs
@@ -1,6 +1,6 @@
 mod pane_resizer;
-mod tiled_pane_grid;
 mod stacked_panes;
+mod tiled_pane_grid;
 
 use crate::resize_pty;
 use tiled_pane_grid::{split, TiledPaneGrid, RESIZE_PERCENT};
@@ -298,7 +298,9 @@ impl TiledPanes {
         if let Some(active_pane_id) = &self.active_panes.get(&client_id) {
             if let Some(active_pane) = self.panes.get_mut(active_pane_id) {
                 let full_pane_size = active_pane.position_and_size();
-                if full_pane_size.rows.as_usize() < MIN_TERMINAL_HEIGHT * 2 || full_pane_size.is_stacked {
+                if full_pane_size.rows.as_usize() < MIN_TERMINAL_HEIGHT * 2
+                    || full_pane_size.is_stacked
+                {
                     return false;
                 } else {
                     return split(SplitDirection::Horizontal, &full_pane_size).is_some();
@@ -311,7 +313,9 @@ impl TiledPanes {
         if let Some(active_pane_id) = &self.active_panes.get(&client_id) {
             if let Some(active_pane) = self.panes.get_mut(active_pane_id) {
                 let full_pane_size = active_pane.position_and_size();
-                if full_pane_size.cols.as_usize() < MIN_TERMINAL_WIDTH * 2 || full_pane_size.is_stacked {
+                if full_pane_size.cols.as_usize() < MIN_TERMINAL_WIDTH * 2
+                    || full_pane_size.is_stacked
+                {
                     return false;
                 }
                 return split(SplitDirection::Vertical, &full_pane_size).is_some();
@@ -385,8 +389,14 @@ impl TiledPanes {
         let connected_clients: Vec<ClientId> =
             self.connected_clients.borrow().iter().copied().collect();
         for client_id in connected_clients {
-            if self.panes.get(&pane_id).map(|p| p.current_geom().is_stacked).unwrap_or(false) {
-                let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide).focus_pane(&pane_id);
+            if self
+                .panes
+                .get(&pane_id)
+                .map(|p| p.current_geom().is_stacked)
+                .unwrap_or(false)
+            {
+                let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide)
+                    .focus_pane(&pane_id);
             }
             self.active_panes
                 .insert(client_id, pane_id, &mut self.panes);
@@ -401,8 +411,15 @@ impl TiledPanes {
         for client_id in connected_clients {
             match &self.active_panes.get(&client_id).copied() {
                 Some(pane_id) => {
-                    if self.panes.get(&pane_id).map(|p| p.current_geom().is_stacked).unwrap_or(false) {
-                        let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide).focus_pane(&pane_id);
+                    if self
+                        .panes
+                        .get(&pane_id)
+                        .map(|p| p.current_geom().is_stacked)
+                        .unwrap_or(false)
+                    {
+                        let _ =
+                            StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide)
+                                .focus_pane(&pane_id);
                     }
                     self.active_panes
                         .insert(client_id, *pane_id, &mut self.panes);
@@ -411,23 +428,37 @@ impl TiledPanes {
                 None => {
                     if let Some(first_pane_id) = self.first_selectable_pane_id() {
                         let pane_id = first_pane_id; // TODO: combine with above
-                        if self.panes.get(&pane_id).map(|p| p.current_geom().is_stacked).unwrap_or(false) {
-                            let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide).focus_pane(&pane_id);
+                        if self
+                            .panes
+                            .get(&pane_id)
+                            .map(|p| p.current_geom().is_stacked)
+                            .unwrap_or(false)
+                        {
+                            let _ = StackedPanes::new_from_btreemap(
+                                &mut self.panes,
+                                &self.panes_to_hide,
+                            )
+                            .focus_pane(&pane_id);
                         }
                         self.active_panes
                             .insert(client_id, pane_id, &mut self.panes);
                         self.set_pane_active_at(pane_id);
                     }
-
-                }
+                },
             }
         }
         self.set_force_render();
         self.reapply_pane_frames();
     }
     pub fn focus_pane(&mut self, pane_id: PaneId, client_id: ClientId) {
-        if self.panes.get(&pane_id).map(|p| p.current_geom().is_stacked).unwrap_or(false) {
-            let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide).focus_pane(&pane_id);
+        if self
+            .panes
+            .get(&pane_id)
+            .map(|p| p.current_geom().is_stacked)
+            .unwrap_or(false)
+        {
+            let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide)
+                .focus_pane(&pane_id);
             self.reapply_pane_frames();
         }
 
@@ -445,10 +476,17 @@ impl TiledPanes {
         self.reset_boundaries();
     }
     pub fn focus_pane_at_position(&mut self, position_and_size: PaneGeom, client_id: ClientId) {
-        if let Some(pane_id) = self.panes.iter().find(|(_pid, pane)| pane.position_and_size() == position_and_size).map(|(pid, _p)| *pid) {
+        if let Some(pane_id) = self
+            .panes
+            .iter()
+            .find(|(_pid, pane)| pane.position_and_size() == position_and_size)
+            .map(|(pid, _p)| *pid)
+        {
             if let Some(currently_active_pane_id) = self.active_panes.get(&client_id) {
                 let prev_geom = {
-                    if let Some(currently_focused_pane) = self.panes.get_mut(currently_active_pane_id) {
+                    if let Some(currently_focused_pane) =
+                        self.panes.get_mut(currently_active_pane_id)
+                    {
                         let prev_geom = currently_focused_pane.position_and_size();
                         currently_focused_pane.set_geom(position_and_size);
                         Some(prev_geom)
@@ -531,12 +569,16 @@ impl TiledPanes {
         };
         let (stacked_pane_ids_under_flexible_pane, stacked_pane_ids_over_flexible_pane) = {
             // TODO: do not recalculate this every time on render
-            StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide).stacked_pane_ids_under_and_over_flexible_panes().unwrap() // TODO: no unwrap
+            StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide)
+                .stacked_pane_ids_under_and_over_flexible_panes()
+                .unwrap() // TODO: no unwrap
         };
         for (kind, pane) in self.panes.iter_mut() {
             if !self.panes_to_hide.contains(&pane.pid()) {
-                let pane_is_stacked_under = stacked_pane_ids_under_flexible_pane.contains(&pane.pid());
-                let pane_is_stacked_over = stacked_pane_ids_over_flexible_pane.contains(&pane.pid());
+                let pane_is_stacked_under =
+                    stacked_pane_ids_under_flexible_pane.contains(&pane.pid());
+                let pane_is_stacked_over =
+                    stacked_pane_ids_over_flexible_pane.contains(&pane.pid());
                 let should_draw_pane_frames = self.draw_pane_frames;
                 let pane_is_stacked = pane.current_geom().is_stacked;
                 let mut pane_contents_and_ui = PaneContentsAndUi::new(
@@ -750,8 +792,14 @@ impl TiledPanes {
             );
             pane_grid.next_selectable_pane_id(&active_pane_id)
         };
-        if self.panes.get(&next_active_pane_id).map(|p| p.current_geom().is_stacked).unwrap_or(false) {
-            let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide).focus_pane(&next_active_pane_id);
+        if self
+            .panes
+            .get(&next_active_pane_id)
+            .map(|p| p.current_geom().is_stacked)
+            .unwrap_or(false)
+        {
+            let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide)
+                .focus_pane(&next_active_pane_id);
             self.reapply_pane_frames();
         }
 
@@ -776,8 +824,14 @@ impl TiledPanes {
             pane_grid.previous_selectable_pane_id(&active_pane_id)
         };
 
-        if self.panes.get(&next_active_pane_id).map(|p| p.current_geom().is_stacked).unwrap_or(false) {
-            let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide).focus_pane(&next_active_pane_id);
+        if self
+            .panes
+            .get(&next_active_pane_id)
+            .map(|p| p.current_geom().is_stacked)
+            .unwrap_or(false)
+        {
+            let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide)
+                .focus_pane(&next_active_pane_id);
             self.reapply_pane_frames();
         }
         for client_id in connected_clients {
@@ -860,14 +914,16 @@ impl TiledPanes {
                             .get_mut(self.active_panes.get(&client_id).unwrap())
                             .unwrap();
 
-                        let previously_active_pane_is_stacked = previously_active_pane.current_geom().is_stacked;
+                        let previously_active_pane_is_stacked =
+                            previously_active_pane.current_geom().is_stacked;
                         previously_active_pane.set_should_render(true);
                         // we render the full viewport to remove any ui elements that might have been
                         // there before (eg. another user's cursor)
                         previously_active_pane.render_full_viewport();
 
                         let next_active_pane = self.panes.get_mut(&p).unwrap();
-                        let next_active_pane_is_stacked = next_active_pane.current_geom().is_stacked;
+                        let next_active_pane_is_stacked =
+                            next_active_pane.current_geom().is_stacked;
                         next_active_pane.set_should_render(true);
                         // we render the full viewport to remove any ui elements that might have been
                         // there before (eg. another user's cursor)
@@ -900,7 +956,8 @@ impl TiledPanes {
                     *self.display_area.borrow(),
                     *self.viewport.borrow(),
                 );
-                let next_index = pane_grid.next_selectable_pane_id_above(&active_pane_id)
+                let next_index = pane_grid
+                    .next_selectable_pane_id_above(&active_pane_id)
                     .or_else(|| pane_grid.progress_stack_up_if_in_stack(&active_pane_id));
                 match next_index {
                     Some(p) => {
@@ -911,14 +968,16 @@ impl TiledPanes {
                             .get_mut(self.active_panes.get(&client_id).unwrap())
                             .unwrap();
 
-                        let previously_active_pane_is_stacked = previously_active_pane.current_geom().is_stacked;
+                        let previously_active_pane_is_stacked =
+                            previously_active_pane.current_geom().is_stacked;
                         previously_active_pane.set_should_render(true);
                         // we render the full viewport to remove any ui elements that might have been
                         // there before (eg. another user's cursor)
                         previously_active_pane.render_full_viewport();
 
                         let next_active_pane = self.panes.get_mut(&p).unwrap();
-                        let next_active_pane_is_stacked = next_active_pane.current_geom().is_stacked;
+                        let next_active_pane_is_stacked =
+                            next_active_pane.current_geom().is_stacked;
                         next_active_pane.set_should_render(true);
                         // we render the full viewport to remove any ui elements that might have been
                         // there before (eg. another user's cursor)
@@ -1032,8 +1091,14 @@ impl TiledPanes {
                 pane_grid.next_selectable_pane_id(&active_pane_id)
             }
         };
-        if self.panes.get(&new_position_id).map(|p| p.current_geom().is_stacked).unwrap_or(false) {
-            let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide).focus_pane(&new_position_id);
+        if self
+            .panes
+            .get(&new_position_id)
+            .map(|p| p.current_geom().is_stacked)
+            .unwrap_or(false)
+        {
+            let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide)
+                .focus_pane(&new_position_id);
             self.reapply_pane_frames();
         }
 
@@ -1228,11 +1293,16 @@ impl TiledPanes {
             .last()
             .map(|(pane_id, _pane)| **pane_id);
 
-
         match next_active_pane_id {
             Some(next_active_pane_id) => {
-                if self.panes.get(&next_active_pane_id).map(|p| p.current_geom().is_stacked).unwrap_or(false) {
-                    let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide).focus_pane(&next_active_pane_id);
+                if self
+                    .panes
+                    .get(&next_active_pane_id)
+                    .map(|p| p.current_geom().is_stacked)
+                    .unwrap_or(false)
+                {
+                    let _ = StackedPanes::new_from_btreemap(&mut self.panes, &self.panes_to_hide)
+                        .focus_pane(&next_active_pane_id);
                     self.reapply_pane_frames();
                 }
                 for (client_id, active_pane_id) in active_panes {
diff --git a/zellij-server/src/panes/tiled_panes/pane_resizer.rs b/zellij-server/src/panes/tiled_panes/pane_resizer.rs
index cc5e70e19..2a2b5b6f9 100644
--- a/