feat(layout): Support environment variables in cwd (#2288)

zellij-utils/Cargo.toml

@@ -38,6 +38,7 @@ miette = { version = "3.3.0", features = ["fancy"] }
 regex = "1.5.5"
 tempfile = "3.2.0"
 kdl = { version = "4.5.0", features = ["span"] }
+shellexpand = "3.0.0"
 
 #[cfg(not(target_family = "wasm"))]
 [target.'cfg(not(target_family = "wasm"))'.dependencies]

zellij-utils/src/input/unit/layout_test.rs

@@ -2031,3 +2031,157 @@ fn run_plugin_location_parsing() {
     };
     assert_eq!(layout, expected_layout);
 }
+
+#[track_caller]
+fn env_test_helper(layout_str: &str, env_vars: Vec<(&str, &str)>, expected_output: Vec<&str>) {
+    for (key, value) in &env_vars {
+        std::env::set_var(key, value);
+    }
+    let layout = Layout::from_kdl(layout_str, "layout_file_name".into(), None, None).unwrap();
+    let layout = format!("{layout:#?}",);
+    for (key, value) in &env_vars {
+        assert!(
+            !layout.contains(&format!("${key}")) && layout.contains(value),
+            "environment variable `{key}={value}` was not properly expanded",
+        );
+    }
+    for s in expected_output {
+        assert!(layout.contains(s), "expected string `{s}` was not found");
+    }
+}
+
+#[test]
+fn env_valid_global_cwd() {
+    env_test_helper(
+        r#"
+        layout {
+            cwd "$Z_VALID_GLOBAL"
+            pane cwd="relative"      // -> /abs/path/relative
+            pane cwd="/another/abs"  // -> /another/abs
+        }
+        "#,
+        vec![("Z_VALID_GLOBAL", "/abs/path")],
+        vec!["/abs/path/relative", "/another/abs"],
+    );
+}
+
+#[test]
+fn env_valid_local_abs_cwd() {
+    env_test_helper(
+        r#"
+        layout {
+            cwd "/abs/path"
+            pane cwd="relative"        // -> /abs/path/relative
+            pane cwd="$Z_VALID_LOCAL"  // -> /another/abs
+        }
+        "#,
+        vec![("Z_VALID_LOCAL", "/another/abs")],
+        vec!["/abs/path/relative", "/another/abs"],
+    );
+}
+
+#[test]
+fn env_valid_local_relative_cwd() {
+    env_test_helper(
+        r#"
+        layout {
+            cwd "/abs/path"
+            pane cwd="relative"            // -> /abs/path/relative
+            pane cwd="$Z_VALID_LOCAL_REL"  // -> /abs/path/relative
+        }
+        "#,
+        vec![("Z_VALID_LOCAL_REL", "relative")],
+        vec!["/abs/path/relative"],
+    );
+}
+
+#[test]
+fn env_command_cwd() {
+    env_test_helper(
+        r#"
+        layout {
+            pane command="ls" cwd="$Z_COMMAND"  // -> some/path
+        }
+        "#,
+        vec![("Z_COMMAND", "some/path")],
+        vec!["some/path"],
+    );
+}
+
+#[test]
+fn env_edit_cwd() {
+    env_test_helper(
+        r#"
+        layout {
+            pane edit="file.rs" cwd="$Z_EDIT"  // -> some/path/file.rs
+        }
+        "#,
+        vec![("Z_EDIT", "some/path")],
+        vec!["some/path/file.rs"],
+    );
+}
+
+#[test]
+fn env_tilde_cwd() {
+    env_test_helper(
+        r#"
+        layout {
+            pane edit="file.rs" cwd="~/my/folder"  // -> /home/aram/my/folder/file.rs
+        }
+        "#,
+        vec![("HOME", "/home/aram")],
+        vec!["/home/aram/my/folder/file.rs"],
+    );
+}
+
+#[test]
+fn env_command() {
+    env_test_helper(
+        r#"
+        layout {
+            pane command="~/backup/executable"  // -> /home/aram/backup/executable
+        }
+        "#,
+        vec![("HOME", "/home/aram")],
+        vec!["/home/aram/backup/executable"],
+    );
+}
+
+#[test]
+fn env_edit() {
+    env_test_helper(
+        r#"
+        layout {
+            pane edit="~/backup/foo.txt"  // -> /home/aram/backup/foo.txt
+        }
+        "#,
+        vec![("HOME", "/home/aram")],
+        vec!["/home/aram/backup/foo.txt"],
+    );
+}
+
+#[test]
+fn env_invalid_global_cwd() {
+    std::env::remove_var("Z_INVALID_GLOBAL");
+    let kdl_layout = r#"
+        layout {
+            cwd "$Z_INVALID_GLOBAL"
+            pane cwd="relative"
+        }
+    "#;
+    let layout = Layout::from_kdl(kdl_layout, "layout_file_name".into(), None, None);
+    assert!(layout.is_err(), "invalid env var lookup should fail");
+}
+
+#[test]
+fn env_invalid_local_cwd() {
+    std::env::remove_var("Z_INVALID_LOCAL");
+    let kdl_layout = r#"
+        layout {
+            cwd "/abs/path"
+            pane cwd="$Z_INVALID_LOCAL"
+        }
+    "#;
+    let layout = Layout::from_kdl(kdl_layout, "layout_file_name".into(), None, None);
+    assert!(layout.is_err(), "invalid env var lookup should fail");
+}

zellij-utils/src/kdl/kdl_layout_parser.rs

@@ -331,22 +331,27 @@ impl<'a> KdlLayoutParser<'a> {
             (None, None) => None,
         })
     }
-    fn parse_cwd(&self, kdl_node: &KdlNode) -> Result<Option<PathBuf>, ConfigError> {
-        Ok(
-            kdl_get_string_property_or_child_value_with_error!(kdl_node, "cwd")
-                .map(|cwd| PathBuf::from(cwd)),
-        )
+    fn parse_path(
+        &self,
+        kdl_node: &KdlNode,
+        name: &'static str,
+    ) -> Result<Option<PathBuf>, ConfigError> {
+        match kdl_get_string_property_or_child_value_with_error!(kdl_node, name) {
+            Some(s) => match shellexpand::full(s) {
+                Ok(s) => Ok(Some(PathBuf::from(s.as_ref()))),
+                Err(e) => Err(kdl_parsing_error!(e.to_string(), kdl_node)),
+            },
+            None => Ok(None),
+        }
     }
     fn parse_pane_command(
         &self,
         pane_node: &KdlNode,
         is_template: bool,
     ) -> Result<Option<Run>, ConfigError> {
-        let command = kdl_get_string_property_or_child_value_with_error!(pane_node, "command")
-            .map(|c| PathBuf::from(c));
-        let edit = kdl_get_string_property_or_child_value_with_error!(pane_node, "edit")
-            .map(|c| PathBuf::from(c));
-        let cwd = self.parse_cwd(pane_node)?;
+        let command = self.parse_path(pane_node, "command")?;
+        let edit = self.parse_path(pane_node, "edit")?;
+        let cwd = self.parse_path(pane_node, "cwd")?;
         let args = self.parse_args(pane_node)?;
         let close_on_exit =
             kdl_get_bool_property_or_child_value_with_error!(pane_node, "close_on_exit");
@@ -1006,8 +1011,7 @@ impl<'a> KdlLayoutParser<'a> {
         self.assert_valid_tab_properties(kdl_node)?;
         let tab_name =
             kdl_get_string_property_or_child_value!(kdl_node, "name").map(|s| s.to_string());
-        let tab_cwd =
-            kdl_get_string_property_or_child_value!(kdl_node, "cwd").map(|c| PathBuf::from(c));
+        let tab_cwd = self.parse_path(kdl_node, "cwd")?;
         let is_focused = kdl_get_bool_property_or_child_value!(kdl_node, "focus").unwrap_or(false);
         let children_split_direction = self.parse_split_direction(kdl_node)?;
         let mut child_floating_panes = vec![];
@@ -1333,8 +1337,7 @@ impl<'a> KdlLayoutParser<'a> {
     ) -> Result<(), ConfigError> {
         let has_borderless_prop =
             kdl_get_bool_property_or_child_value_with_error!(kdl_node, "borderless").is_some();
-        let has_cwd_prop =
-            kdl_get_string_property_or_child_value_with_error!(kdl_node, "cwd").is_some();
+        let has_cwd_prop = self.parse_path(kdl_node, "cwd")?.is_some();
         let has_non_cwd_run_prop = self
             .parse_command_plugin_or_edit_block(kdl_node)?
             .map(|r| match r {
@@ -1404,8 +1407,7 @@ impl<'a> KdlLayoutParser<'a> {
         // (is_focused, Option<tab_name>, PaneLayout, Vec<FloatingPaneLayout>)
         let tab_name =
             kdl_get_string_property_or_child_value!(kdl_node, "name").map(|s| s.to_string());
-        let tab_cwd =
-            kdl_get_string_property_or_child_value!(kdl_node, "cwd").map(|c| PathBuf::from(c));
+        let tab_cwd = self.parse_path(kdl_node, "cwd")?;
         let is_focused = kdl_get_bool_property_or_child_value!(kdl_node, "focus").unwrap_or(false);
         let children_split_direction = self.parse_split_direction(kdl_node)?;
         match kdl_children_nodes!(kdl_node) {
@@ -1638,11 +1640,7 @@ impl<'a> KdlLayoutParser<'a> {
     fn populate_global_cwd(&mut self, layout_node: &KdlNode) -> Result<(), ConfigError> {
         // we only populate global cwd from the layout file if another wasn't explicitly passed to us
         if self.global_cwd.is_none() {
-            if let Some(global_cwd) =
-                kdl_get_string_property_or_child_value_with_error!(layout_node, "cwd")
-            {
-                self.global_cwd = Some(PathBuf::from(global_cwd));
-            }
+            self.global_cwd = self.parse_path(layout_node, "cwd")?;
         }
         Ok(())
     }