feat(powershell): add dotfiles support

Author: ltrzesniewski

Diff for: crates/atuin-dotfiles/src/shell.rs

@@ -8,6 +8,7 @@ use crate::store::AliasStore;
 
 pub mod bash;
 pub mod fish;
+pub mod powershell;
 pub mod xonsh;
 pub mod zsh;
 

Diff for: crates/atuin-dotfiles/src/shell/powershell.rs

@@ -0,0 +1,68 @@
+use std::path::PathBuf;
+
+use crate::store::{var::VarStore, AliasStore};
+
+async fn cached_aliases(path: PathBuf, store: &AliasStore) -> String {
+    match tokio::fs::read_to_string(path).await {
+        Ok(aliases) => aliases,
+        Err(r) => {
+            // we failed to read the file for some reason, but the file does exist
+            // fallback to generating new aliases on the fly
+
+            store.powershell().await.unwrap_or_else(|e| {
+                format!("echo 'Atuin: failed to read and generate aliases: \n{r}\n{e}'",)
+            })
+        }
+    }
+}
+
+async fn cached_vars(path: PathBuf, store: &VarStore) -> String {
+    match tokio::fs::read_to_string(path).await {
+        Ok(vars) => vars,
+        Err(r) => {
+            // we failed to read the file for some reason, but the file does exist
+            // fallback to generating new vars on the fly
+
+            store.powershell().await.unwrap_or_else(|e| {
+                format!("echo 'Atuin: failed to read and generate vars: \n{r}\n{e}'",)
+            })
+        }
+    }
+}
+
+/// Return powershell dotfile config
+///
+/// Do not return an error. We should not prevent the shell from starting.
+///
+/// In the worst case, Atuin should not function but the shell should start correctly.
+///
+/// While currently this only returns aliases, it will be extended to also return other synced dotfiles
+pub async fn alias_config(store: &AliasStore) -> String {
+    // First try to read the cached config
+    let aliases = atuin_common::utils::dotfiles_cache_dir().join("aliases.ps1");
+
+    if aliases.exists() {
+        return cached_aliases(aliases, store).await;
+    }
+
+    if let Err(e) = store.build().await {
+        return format!("echo 'Atuin: failed to generate aliases: {}'", e);
+    }
+
+    cached_aliases(aliases, store).await
+}
+
+pub async fn var_config(store: &VarStore) -> String {
+    // First try to read the cached config
+    let vars = atuin_common::utils::dotfiles_cache_dir().join("vars.ps1");
+
+    if vars.exists() {
+        return cached_vars(vars, store).await;
+    }
+
+    if let Err(e) = store.build().await {
+        return format!("echo 'Atuin: failed to generate vars: {}'", e);
+    }
+
+    cached_vars(vars, store).await
+}

Diff for: crates/atuin-dotfiles/src/store.rs

@@ -142,7 +142,20 @@ impl AliasStore {
 
     pub async fn posix(&self) -> Result<String> {
         let aliases = self.aliases().await?;
+        Ok(Self::format_posix(&aliases))
+    }
+
+    pub async fn xonsh(&self) -> Result<String> {
+        let aliases = self.aliases().await?;
+        Ok(Self::format_xonsh(&aliases))
+    }
 
+    pub async fn powershell(&self) -> Result<String> {
+        let aliases = self.aliases().await?;
+        Ok(Self::format_powershell(&aliases))
+    }
+
+    fn format_posix(aliases: &[Alias]) -> String {
         let mut config = String::new();
 
         for alias in aliases {
@@ -153,28 +166,50 @@ impl AliasStore {
             config.push_str(&format!("alias {}='{}'\n", alias.name, value));
         }
 
-        Ok(config)
+        config
     }
 
-    pub async fn xonsh(&self) -> Result<String> {
-        let aliases = self.aliases().await?;
-
+    fn format_xonsh(aliases: &[Alias]) -> String {
         let mut config = String::new();
 
         for alias in aliases {
             config.push_str(&format!("aliases['{}'] ='{}'\n", alias.name, alias.value));
         }
 
-        Ok(config)
+        config
+    }
+
+    fn format_powershell(aliases: &[Alias]) -> String {
+        let mut config = String::new();
+
+        for alias in aliases {
+            // Set-Alias doesn't support adding implicit arguments, so use a function.
+            // See https://github.com/PowerShell/PowerShell/issues/12962
+            config.push_str(&format!(
+                "\nfunction {} {{\n    {}{} @args\n}}\n",
+                alias.name,
+                if alias.value.starts_with(['"', '\'']) {
+                    "& "
+                } else {
+                    ""
+                },
+                alias.value
+            ));
+        }
+
+        config
     }
 
     pub async fn build(&self) -> Result<()> {
         let dir = atuin_common::utils::dotfiles_cache_dir();
         tokio::fs::create_dir_all(dir.clone()).await?;
 
+        let aliases = self.aliases().await?;
+
         // Build for all supported shells
-        let posix = self.posix().await?;
-        let xonsh = self.xonsh().await?;
+        let posix = Self::format_posix(&aliases);
+        let xonsh = Self::format_xonsh(&aliases);
+        let powershell = Self::format_powershell(&aliases);
 
         // All the same contents, maybe optimize in the future or perhaps there will be quirks
         // per-shell
@@ -183,11 +218,13 @@ impl AliasStore {
         let bash = dir.join("aliases.bash");
         let fish = dir.join("aliases.fish");
         let xsh = dir.join("aliases.xsh");
+        let ps1 = dir.join("aliases.ps1");
 
         tokio::fs::write(zsh, &posix).await?;
         tokio::fs::write(bash, &posix).await?;
         tokio::fs::write(fish, &posix).await?;
         tokio::fs::write(xsh, &xonsh).await?;
+        tokio::fs::write(ps1, &powershell).await?;
 
         Ok(())
     }
@@ -389,6 +426,35 @@ mod tests {
             "alias gp='git push'
 alias k='kubectl'
 alias kgap='kubectl get pods --all-namespaces'
+"
+        )
+    }
+
+    #[test]
+    fn format_powershell() {
+        let aliases = [
+            Alias {
+                name: "gp".to_string(),
+                value: "git push".to_string(),
+            },
+            Alias {
+                name: "spc".to_string(),
+                value: "\"path with spaces\" arg".to_string(),
+            },
+        ];
+
+        let result = AliasStore::format_powershell(&aliases);
+
+        assert_eq!(
+            result,
+            "
+function gp {
+    git push @args
+}
+
+function spc {
+    & \"path with spaces\" arg @args
+}
 "
         )
     }

Diff for: crates/atuin-dotfiles/src/store/var.rs

@@ -117,31 +117,45 @@ impl VarStore {
 
     pub async fn xonsh(&self) -> Result<String> {
         let env = self.vars().await?;
+        Ok(Self::format_xonsh(&env))
+    }
+
+    pub async fn fish(&self) -> Result<String> {
+        let env = self.vars().await?;
+        Ok(Self::format_fish(&env))
+    }
 
+    pub async fn posix(&self) -> Result<String> {
+        let env = self.vars().await?;
+        Ok(Self::format_posix(&env))
+    }
+
+    pub async fn powershell(&self) -> Result<String> {
+        let env = self.vars().await?;
+        Ok(Self::format_powershell(&env))
+    }
+
+    fn format_xonsh(env: &[Var]) -> String {
         let mut config = String::new();
 
         for env in env {
             config.push_str(&format!("${}={}\n", env.name, env.value));
         }
 
-        Ok(config)
+        config
     }
 
-    pub async fn fish(&self) -> Result<String> {
-        let env = self.vars().await?;
-
+    fn format_fish(env: &[Var]) -> String {
         let mut config = String::new();
 
         for env in env {
             config.push_str(&format!("set -gx {} {}\n", env.name, env.value));
         }
 
-        Ok(config)
+        config
     }
 
-    pub async fn posix(&self) -> Result<String> {
-        let env = self.vars().await?;
-
+    fn format_posix(env: &[Var]) -> String {
         let mut config = String::new();
 
         for env in env {
@@ -152,17 +166,34 @@ impl VarStore {
             }
         }
 
-        Ok(config)
+        config
+    }
+
+    fn format_powershell(env: &[Var]) -> String {
+        let mut config = String::new();
+
+        for env in env {
+            config.push_str(&format!(
+                "$env:{} = '{}'\n",
+                env.name,
+                env.value.replace("'", "''")
+            ));
+        }
+
+        config
     }
 
     pub async fn build(&self) -> Result<()> {
         let dir = atuin_common::utils::dotfiles_cache_dir();
         tokio::fs::create_dir_all(dir.clone()).await?;
 
+        let env = self.vars().await?;
+
         // Build for all supported shells
-        let posix = self.posix().await?;
-        let xonsh = self.xonsh().await?;
-        let fsh = self.fish().await?;
+        let posix = Self::format_posix(&env);
+        let xonsh = Self::format_xonsh(&env);
+        let fsh = Self::format_fish(&env);
+        let powershell = Self::format_powershell(&env);
 
         // All the same contents, maybe optimize in the future or perhaps there will be quirks
         // per-shell
@@ -171,11 +202,13 @@ impl VarStore {
         let bash = dir.join("vars.bash");
         let fish = dir.join("vars.fish");
         let xsh = dir.join("vars.xsh");
+        let ps1 = dir.join("vars.ps1");
 
         tokio::fs::write(zsh, &posix).await?;
         tokio::fs::write(bash, &posix).await?;
         tokio::fs::write(fish, &fsh).await?;
         tokio::fs::write(xsh, &xonsh).await?;
+        tokio::fs::write(ps1, &powershell).await?;
 
         Ok(())
     }
@@ -354,4 +387,24 @@ mod tests {
             }
         );
     }
+
+    #[test]
+    fn format_powershell() {
+        let env = [
+            Var {
+                name: "FOO".to_owned(),
+                value: "bar 'baz'".to_owned(),
+                export: true,
+            },
+            Var {
+                name: "TEST".to_owned(),
+                value: "1".to_owned(),
+                export: true,
+            },
+        ];
+
+        let result = VarStore::format_powershell(&env);
+
+        assert_eq!(result, "$env:FOO = 'bar ''baz'''\n$env:TEST = '1'\n");
+    }
 }

Diff for: crates/atuin/src/command/client/init.rs

@@ -162,7 +162,13 @@ $env.config = (
                 .await?;
             }
             Shell::PowerShell => {
-                powershell::init_static(self.disable_up_arrow, self.disable_ctrl_r);
+                powershell::init(
+                    alias_store,
+                    var_store,
+                    self.disable_up_arrow,
+                    self.disable_ctrl_r,
+                )
+                .await?;
             }
         }
 

Diff for: crates/atuin/src/command/client/init/powershell.rs

@@ -1,3 +1,5 @@
+use atuin_dotfiles::store::{var::VarStore, AliasStore};
+
 pub fn init_static(disable_up_arrow: bool, disable_ctrl_r: bool) {
     let base = include_str!("../../../shell/atuin.ps1");
 
@@ -15,6 +17,23 @@ pub fn init_static(disable_up_arrow: bool, disable_ctrl_r: bool) {
     );
 }
 
+pub async fn init(
+    aliases: AliasStore,
+    vars: VarStore,
+    disable_up_arrow: bool,
+    disable_ctrl_r: bool,
+) -> eyre::Result<()> {
+    init_static(disable_up_arrow, disable_ctrl_r);
+
+    let aliases = atuin_dotfiles::shell::powershell::alias_config(&aliases).await;
+    let vars = atuin_dotfiles::shell::powershell::var_config(&vars).await;
+
+    println!("{aliases}");
+    println!("{vars}");
+
+    Ok(())
+}
+
 fn ps_bool(value: bool) -> &'static str {
     if value {
         "$true"