use consistent path in trust-dialog instead of searching for it multiple times

Author: usering-around

helix-term/src/commands/typed.rs

@@ -2737,7 +2737,7 @@ fn trust_workspace(
     if event != PromptEvent::Validate {
         return Ok(());
     }
-    cx.editor.trust_workspace()
+    cx.editor.trust_current_workspace()
 }
 
 fn untrust_workspace(
@@ -2749,7 +2749,7 @@ fn untrust_workspace(
         return Ok(());
     }
 
-    cx.editor.untrust_workspace()
+    cx.editor.untrust_current_workspace()
 }
 
 fn trust_dialog(

helix-term/src/handlers/trust.rs

@@ -78,8 +78,8 @@ Ensure you trust the source of the {file_or_workspace} before trusting it.");
             }
 
             let maybe_err = match option {
-                TrustOptions::Trust => editor.trust_workspace(),
-                TrustOptions::DoNotTrust => editor.untrust_workspace(),
+                TrustOptions::Trust => editor.trust_workspace(&path_clone),
+                TrustOptions::DoNotTrust => editor.untrust_workspace(&path_clone),
                 TrustOptions::DistrustParent | TrustOptions::TrustParent => {
                     let path = path_clone.clone();
                     let option = option.clone();
@@ -122,9 +122,9 @@ fn choose_parent_dialog(path: impl AsRef<Path>, trust: bool) -> impl Component +
                 path.display()
             ))
         } else if trust {
-            cx.editor.trust_workspace()
+            cx.editor.trust_workspace(path)
         } else {
-            cx.editor.untrust_workspace()
+            cx.editor.untrust_workspace(path)
         };
         if let Err(e) = result {
             cx.editor.set_error(e.to_string());

helix-term/src/main.rs

@@ -1,5 +1,4 @@
 use anyhow::{Context, Error, Result};
-use helix_loader::trust_db::Trust;
 use helix_loader::{trust_db, VERSION_AND_GIT_HASH};
 use helix_term::application::Application;
 use helix_term::args::Args;

helix-view/src/editor.rs

@@ -2382,23 +2382,27 @@ impl Editor {
         self.last_cwd.as_deref()
     }
 
-    pub fn trust_workspace(&mut self) -> anyhow::Result<()> {
+    pub fn trust_current_workspace(&mut self) -> anyhow::Result<()> {
         let Some(path) = doc!(self).path() else {
             bail!("Document does not have a path; you need to add a path to trust it.")
         };
         let workspace = helix_loader::find_workspace_in(path).0;
+        self.trust_workspace(workspace)
+    }
+
+    pub fn trust_workspace(&mut self, workspace: impl AsRef<Path>) -> anyhow::Result<()> {
         match trust_db::trust_path(&workspace) {
             Err(e) => bail!("Couldn't edit trust database: {e}"),
             Ok(is_new_entry) => {
                 if is_new_entry {
                     self.set_status(format!(
                         "Workspace '{}' unrestricted; LSPs, debuggers and formatters available.",
-                        workspace.display()
+                        workspace.as_ref().display()
                     ))
                 } else {
                     self.set_status(format!(
                         "Workspace '{}' is already trusted.",
-                        workspace.display()
+                        workspace.as_ref().display()
                     ));
                 }
                 self.documents_mut()
@@ -2409,23 +2413,27 @@ impl Editor {
         Ok(())
     }
 
-    pub fn untrust_workspace(&mut self) -> anyhow::Result<()> {
+    pub fn untrust_current_workspace(&mut self) -> anyhow::Result<()> {
         let Some(path) = doc!(self).path() else {
             bail!("Document does not have a path; it is already untrusted.")
         };
         let workspace = helix_loader::find_workspace_in(path).0;
+        self.untrust_workspace(workspace)
+    }
+
+    pub fn untrust_workspace(&mut self, workspace: impl AsRef<Path>) -> anyhow::Result<()> {
         match trust_db::untrust_path(&workspace) {
             Err(e) => bail!("Couldn't edit trust database: {e}"),
             Ok(was_removed) => {
                 if was_removed {
                     self.set_status(format!(
                         "Workspace '{}' restricted; LSPs, formatters and debuggers do not work.",
-                        workspace.display()
+                        workspace.as_ref().display()
                     ));
                 } else {
                     self.set_status(format!(
                         "Workspace '{}' was already untrusted.",
-                        workspace.display()
+                        workspace.as_ref().display()
                     ));
                 }
                 self.documents_mut()