style(fmt): rustfmtlayout-fixes

3 files changed, 59 insertions, 58 deletions

diff --git a/zellij-server/src/ui/pane_boundaries_frame.rs b/zellij-server/src/ui/pane_boundaries_frame.rs
index 37f8d8c2b..7f8d80171 100644
--- a/zellij-server/src/ui/pane_boundaries_frame.rs
+++ b/zellij-server/src/ui/pane_boundaries_frame.rs
@@ -343,7 +343,9 @@ impl PaneFrame {
             self.render_my_and_others_focus(max_length)
         } else if !self.other_focused_clients.is_empty() {
             self.render_other_focused_users(max_length)
-        } else if (self.pane_is_stacked_under || self.pane_is_stacked_over) && self.exit_status.is_some() {
+        } else if (self.pane_is_stacked_under || self.pane_is_stacked_over)
+            && self.exit_status.is_some()
+        {
             let (first_part, first_part_len) = self.first_exited_held_title_part_full();
             if first_part_len <= max_length {
                 Some((first_part, first_part_len))
diff --git a/zellij-utils/src/input/unit/layout_test.rs b/zellij-utils/src/input/unit/layout_test.rs
index 0f2dc23f5..670273b0f 100644
--- a/zellij-utils/src/input/unit/layout_test.rs
+++ b/zellij-utils/src/input/unit/layout_test.rs
@@ -1860,13 +1860,7 @@ fn can_define_stacked_children_for_pane_node() {
            }
         }
     "#;
-    let layout = Layout::from_kdl(
-        kdl_layout,
-        "layout_file_name".into(),
-        None,
-        None,
-    )
-    .unwrap();
+    let layout = Layout::from_kdl(kdl_layout, "layout_file_name".into(), None, None).unwrap();
     assert_snapshot!(format!("{:#?}", layout));
 }
 
@@ -1883,13 +1877,7 @@ fn can_define_stacked_children_for_pane_template() {
            }
         }
     "#;
-    let layout = Layout::from_kdl(
-        kdl_layout,
-        "layout_file_name".into(),
-        None,
-        None,
-    )
-    .unwrap();
+    let layout = Layout::from_kdl(kdl_layout, "layout_file_name".into(), None, None).unwrap();
     assert_snapshot!(format!("{:#?}", layout));
 }
 
diff --git a/zellij-utils/src/kdl/kdl_layout_parser.rs b/zellij-utils/src/kdl/kdl_layout_parser.rs
index f58242ace..5d89fab1b 100644
--- a/zellij-utils/src/kdl/kdl_layout_parser.rs
+++ b/zellij-utils/src/kdl/kdl_layout_parser.rs
@@ -169,10 +169,15 @@ impl<'a> KdlLayoutParser<'a> {
             Ok(())
         }
     }
-    fn assert_no_grandchildren_in_stack(&self, children: &[KdlNode], is_part_of_stack: bool) -> Result<(), ConfigError> {
+    fn assert_no_grandchildren_in_stack(
+        &self,
+        children: &[KdlNode],
+        is_part_of_stack: bool,
+    ) -> Result<(), ConfigError> {
         if is_part_of_stack {
             for child in children {
-                if kdl_name!(child) == "pane" || self.pane_templates.get(kdl_name!(child)).is_some() {
+                if kdl_name!(child) == "pane" || self.pane_templates.get(kdl_name!(child)).is_some()
+                {
                     return Err(ConfigError::new_layout_kdl_error(
                         format!("Stacked panes cannot have children"),
                         child.span().offset(),
@@ -425,9 +430,14 @@ impl<'a> KdlLayoutParser<'a> {
         }
         Ok(run)
     }
-    fn parse_pane_node(&self, kdl_node: &KdlNode, is_part_of_stack: bool) -> Result<TiledPaneLayout, ConfigError> {
+    fn parse_pane_node(
+        &self,
+        kdl_node: &KdlNode,
+        is_part_of_stack: bool,
+    ) -> Result<TiledPaneLayout, ConfigError> {
         self.assert_valid_pane_properties(kdl_node)?;
-        let children_are_stacked = kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked").unwrap_or(false);
+        let children_are_stacked =
+            kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked").unwrap_or(false);
         let borderless = kdl_get_bool_property_or_child_value_with_error!(kdl_node, "borderless");
         let focus = kdl_get_bool_property_or_child_value_with_error!(kdl_node, "focus");
         let name = kdl_get_string_property_or_child_value_with_error!(kdl_node, "name")
@@ -435,14 +445,13 @@ impl<'a> KdlLayoutParser<'a> {
         let split_size = self.parse_split_size(kdl_node)?;
         let run = self.parse_command_plugin_or_edit_block(kdl_node)?;
         let children_split_direction = self.parse_split_direction(kdl_node)?;
-        let (external_children_index, children) =
-            match kdl_children_nodes!(kdl_node) {
-                Some(children) => {
-                    self.assert_no_grandchildren_in_stack(&children, is_part_of_stack)?;
-                    self.parse_child_pane_nodes_for_pane(&children, children_are_stacked)?
-                },
-                None => (None, vec![]),
-            };
+        let (external_children_index, children) = match kdl_children_nodes!(kdl_node) {
+            Some(children) => {
+                self.assert_no_grandchildren_in_stack(&children, is_part_of_stack)?;
+                self.parse_child_pane_nodes_for_pane(&children, children_are_stacked)?
+            },
+            None => (None, vec![]),
+        };
         if children_are_stacked && external_children_index.is_none() && children.is_empty() {
             return Err(ConfigError::new_layout_kdl_error(
                 format!("A stacked pane must have children nodes or possibly a \"children\" node if in a swap_layout"),
@@ -501,15 +510,16 @@ impl<'a> KdlLayoutParser<'a> {
         pane_template: &mut TiledPaneLayout,
         pane_template_kdl_node: &KdlNode,
     ) -> Result<(), ConfigError> {
-        let children_are_stacked = kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked").unwrap_or(pane_template.children_are_stacked);
+        let children_are_stacked =
+            kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked")
+                .unwrap_or(pane_template.children_are_stacked);
         let children_split_direction = self.parse_split_direction(kdl_node)?;
-        let (external_children_index, pane_parts) =
-            match kdl_children_nodes!(kdl_node) {
-                Some(children) => {
-                    self.parse_child_pane_nodes_for_pane(&children, children_are_stacked)?
-                }
-                None => (None, vec![]),
-            };
+        let (external_children_index, pane_parts) = match kdl_children_nodes!(kdl_node) {
+            Some(children) => {
+                self.parse_child_pane_nodes_for_pane(&children, children_are_stacked)?
+            },
+            None => (None, vec![]),
+        };
         if pane_parts.len() > 0 {
             let child_panes_layout = TiledPaneLayout {
                 children_split_direction,
@@ -536,10 +546,8 @@ impl<'a> KdlLayoutParser<'a> {
             for (i, child) in pane_child_nodes.iter().enumerate() {
                 if kdl_name!(child) == "children" {
                     if let Some(grand_children) = kdl_children_nodes!(child) {
-                        let grand_children: Vec<&str> = grand_children
-                            .iter()
-                            .map(|g| kdl_name!(g))
-                            .collect();
+                        let grand_children: Vec<&str> =
+                            grand_children.iter().map(|g| kdl_name!(g)).collect();
                         if !grand_children.is_empty() {
                             return Err(ConfigError::new_layout_kdl_error(
                                 format!(
@@ -572,7 +580,8 @@ impl<'a> KdlLayoutParser<'a> {
                 let focus = kdl_get_bool_property_or_child_value_with_error!(kdl_node, "focus");
                 let name = kdl_get_string_property_or_child_value_with_error!(kdl_node, "name")
                     .map(|name| name.to_string());
-                let children_are_stacked = kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked");
+                let children_are_stacked =
+                    kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked");
                 let args = self.parse_args(kdl_node)?;
                 let close_on_exit =
                     kdl_get_bool_property_or_child_value_with_error!(kdl_node, "close_on_exit");
@@ -581,8 +590,7 @@ impl<'a> KdlLayoutParser<'a> {
                 let split_size = self.parse_split_size(kdl_node)?;
                 let run = self.parse_command_plugin_or_edit_block_for_template(kdl_node)?;
 
-                let external_children_index = if should_mark_external_children_index
-                {
+                let external_children_index = if should_mark_external_children_index {
                     self.populate_external_children_index(kdl_node)?
                 } else {
                     None
@@ -621,12 +629,13 @@ impl<'a> KdlLayoutParser<'a> {
                     pane_template.split_size = Some(split_size);
                 }
                 if let Some(index_of_children) = pane_template.external_children_index {
-                    pane_template
-                        .children
-                        .insert(index_of_children, TiledPaneLayout {
+                    pane_template.children.insert(
+                        index_of_children,
+                        TiledPaneLayout {
                             children_are_stacked: children_are_stacked.unwrap_or_default(),
                             ..Default::default()
-                        });
+                        },
+                    );
                 }
                 if let Some(children_are_stacked) = children_are_stacked {
                     pane_template.children_are_stacked = children_are_stacked;
@@ -792,7 +801,8 @@ impl<'a> KdlLayoutParser<'a> {
     ) -> Result<bool, ConfigError> {
         // pane properties
         let borderless = kdl_get_bool_property_or_child_value_with_error!(kdl_node, "borderless");
-        let children_are_stacked = kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked");
+        let children_are_stacked =
+            kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked");
         let split_size = self.parse_split_size(kdl_node)?;
         let split_direction =
             kdl_get_string_property_or_child_value_with_error!(kdl_node, "split_direction");
@@ -825,7 +835,8 @@ impl<'a> KdlLayoutParser<'a> {
 
         // pane properties
         let borderless = kdl_get_bool_property_or_child_value_with_error!(kdl_node, "borderless");
-        let children_are_stacked = kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked");
+        let children_are_stacked =
+            kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked");
         let split_size = self.parse_split_size(kdl_node)?;
         let split_direction =
             kdl_get_string_property_or_child_value_with_error!(kdl_node, "split_direction");
@@ -947,15 +958,17 @@ impl<'a> KdlLayoutParser<'a> {
             let borderless =
                 kdl_get_bool_property_or_child_value_with_error!(kdl_node, "borderless");
             let children_are_stacked =
-                kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked").unwrap_or(false);
+                kdl_get_bool_property_or_child_value_with_error!(kdl_node, "stacked")
+                    .unwrap_or(false);
             let split_size = self.parse_split_size(kdl_node)?;
             let children_split_direction = self.parse_split_direction(kdl_node)?;
             let is_part_of_stack = false;
-            let (external_children_index, pane_parts) =
-                match kdl_children_nodes!(kdl_node) {
-                    Some(children) => self.parse_child_pane_nodes_for_pane(&children, children_are_stacked)?,
-                    None => (None, vec![]),
-                };
+            let (external_children_index, pane_parts) = match kdl_children_nodes!(kdl_node) {
+                Some(children) => {
+                    self.parse_child_pane_nodes_for_pane(&children, children_are_stacked)?
+                },
+                None => (None, vec![]),
+            };
             self.assert_no_mixed_children_and_properties(kdl_node)?;
             self.pane_templates.insert(
                 template_name,
@@ -1074,10 +1087,8 @@ impl<'a> KdlLayoutParser<'a> {
                 nodes.push(self.parse_pane_node(child, is_part_of_stack)?);
             } else if kdl_name!(child) == "children" {
                 if let Some(grand_children) = kdl_children_nodes!(child) {
-                    let grand_children: Vec<&str> = grand_children
-                        .iter()
-                        .map(|g| kdl_name!(g))
-                        .collect();
+                    let grand_children: Vec<&str> =
+                        grand_children.iter().map(|g| kdl_name!(g)).collect();
                     if !grand_children.is_empty() {
                         return Err(ConfigError::new_layout_kdl_error(
                             format!(