draft: impl workspace trust

helix-core/src/config.rs

@@ -30,13 +30,13 @@ impl std::fmt::Display for LanguageLoaderError {
 impl std::error::Error for LanguageLoaderError {}
 
 /// Language configuration based on user configured languages.toml.
-pub fn user_lang_config() -> Result<Configuration, toml::de::Error> {
-    helix_loader::config::user_lang_config()?.try_into()
+pub fn user_lang_config(use_local: bool) -> Result<Configuration, toml::de::Error> {
+    helix_loader::config::user_lang_config(use_local)?.try_into()
 }
 
 /// Language configuration loader based on user configured languages.toml.
-pub fn user_lang_loader() -> Result<Loader, LanguageLoaderError> {
-    let config: Configuration = helix_loader::config::user_lang_config()
+pub fn user_lang_loader(use_local: bool) -> Result<Loader, LanguageLoaderError> {
+    let config: Configuration = helix_loader::config::user_lang_config(use_local)
         .map_err(LanguageLoaderError::DeserializeError)?
         .try_into()
         .map_err(LanguageLoaderError::DeserializeError)?;

helix-loader/Cargo.toml

@@ -32,3 +32,4 @@ threadpool = { version = "1.0" }
 tempfile.workspace = true
 
 tree-house.workspace = true
+fs2 = "0.4.3"

helix-loader/src/config.rs

@@ -8,23 +8,25 @@ pub fn default_lang_config() -> toml::Value {
 }
 
 /// User configured languages.toml file, merged with the default config.
-pub fn user_lang_config() -> Result<toml::Value, toml::de::Error> {
-    let config = [
-        crate::config_dir(),
-        crate::find_workspace().0.join(".helix"),
-    ]
-    .into_iter()
-    .map(|path| path.join("languages.toml"))
-    .filter_map(|file| {
-        std::fs::read_to_string(file)
-            .map(|config| toml::from_str(&config))
-            .ok()
-    })
-    .collect::<Result<Vec<_>, _>>()?
-    .into_iter()
-    .fold(default_lang_config(), |a, b| {
-        crate::merge_toml_values(a, b, 3)
-    });
+pub fn user_lang_config(use_local: bool) -> Result<toml::Value, toml::de::Error> {
+    let mut dirs = vec![crate::config_dir()];
+    if use_local {
+        dirs.push(crate::find_workspace().0.join(".helix"));
+    }
+
+    let config = dirs
+        .into_iter()
+        .map(|path| path.join("languages.toml"))
+        .filter_map(|file| {
+            std::fs::read_to_string(file)
+                .map(|config| toml::from_str(&config))
+                .ok()
+        })
+        .collect::<Result<Vec<_>, _>>()?
+        .into_iter()
+        .fold(default_lang_config(), |a, b| {
+            crate::merge_toml_values(a, b, 3)
+        });
 
     Ok(config)
 }

helix-loader/src/grammar.rs

@@ -87,7 +87,7 @@ pub fn fetch_grammars() -> Result<()> {
     ensure_git_is_available()?;
 
     // We do not need to fetch local grammars.
-    let mut grammars = get_grammar_configs()?;
+    let mut grammars = get_grammar_configs(false)?;
     grammars.retain(|grammar| !matches!(grammar.source, GrammarSource::Local { .. }));
 
     println!("Fetching {} grammars", grammars.len());
@@ -144,10 +144,10 @@ pub fn fetch_grammars() -> Result<()> {
     Ok(())
 }
 
-pub fn build_grammars(target: Option<String>) -> Result<()> {
+pub fn build_grammars(target: Option<String>, use_local_config: bool) -> Result<()> {
     ensure_git_is_available()?;
 
-    let grammars = get_grammar_configs()?;
+    let grammars = get_grammar_configs(use_local_config)?;
     println!("Building {} grammars", grammars.len());
     let results = run_parallel(grammars, move |grammar| {
         build_grammar(grammar, target.as_deref())
@@ -191,8 +191,8 @@ pub fn build_grammars(target: Option<String>) -> Result<()> {
 // Grammars are configured in the default and user `languages.toml` and are
 // merged. The `grammar_selection` key of the config is then used to filter
 // down all grammars into a subset of the user's choosing.
-fn get_grammar_configs() -> Result<Vec<GrammarConfiguration>> {
-    let config: Configuration = crate::config::user_lang_config()
+fn get_grammar_configs(use_local_config: bool) -> Result<Vec<GrammarConfiguration>> {
+    let config: Configuration = crate::config::user_lang_config(use_local_config)
         .context("Could not parse languages.toml")?
         .try_into()?;
 
@@ -213,8 +213,8 @@ fn get_grammar_configs() -> Result<Vec<GrammarConfiguration>> {
     Ok(grammars)
 }
 
-pub fn get_grammar_names() -> Result<Option<HashSet<String>>> {
-    let config: Configuration = crate::config::user_lang_config()
+pub fn get_grammar_names(use_local_config: bool) -> Result<Option<HashSet<String>>> {
+    let config: Configuration = crate::config::user_lang_config(use_local_config)
         .context("Could not parse languages.toml")?
         .try_into()?;
 

helix-loader/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod config;
 pub mod grammar;
+pub mod trust_db;
 
 use helix_stdx::{env::current_working_dir, path};
 
@@ -132,6 +133,14 @@ pub fn cache_dir() -> PathBuf {
     path
 }
 
+pub fn data_dir() -> PathBuf {
+    // TODO: allow env var override
+    let strategy = choose_base_strategy().expect("Unable to find the data directory!");
+    let mut path = strategy.data_dir();
+    path.push("helix");
+    path
+}
+
 pub fn config_file() -> PathBuf {
     CONFIG_FILE.get().map(|path| path.to_path_buf()).unwrap()
 }
@@ -247,14 +256,18 @@ pub fn find_workspace() -> (PathBuf, bool) {
     find_workspace_in(current_dir)
 }
 
+pub fn is_workspace(path: impl AsRef<Path>) -> bool {
+    let path = path.as_ref();
+    path.join(".git").exists()
+        || path.join(".svn").exists()
+        || path.join(".jj").exists()
+        || path.join(".helix").exists()
+}
+
 pub fn find_workspace_in(dir: impl AsRef<Path>) -> (PathBuf, bool) {
     let dir = dir.as_ref();
     for ancestor in dir.ancestors() {
-        if ancestor.join(".git").exists()
-            || ancestor.join(".svn").exists()
-            || ancestor.join(".jj").exists()
-            || ancestor.join(".helix").exists()
-        {
+        if is_workspace(ancestor) {
             return (ancestor.to_owned(), false);
         }
     }

helix-loader/src/trust_db.rs

@@ -0,0 +1,145 @@
+use std::{
+    collections::HashMap,
+    fs::File,
+    io::ErrorKind,
+    path::{Path, PathBuf},
+};
+
+use fs2::FileExt;
+use serde::{Deserialize, Serialize};
+
+use crate::{data_dir, ensure_parent_dir, is_workspace};
+
+#[derive(Serialize, Deserialize, Default)]
+struct TrustDb {
+    trust: Option<HashMap<PathBuf, Trust>>,
+}
+
+#[derive(Serialize, Deserialize, PartialEq)]
+pub enum Trust {
+    Trusted,
+    Untrusted,
+}
+
+impl TrustDb {
+    fn is_workspace_trusted(&self, path: impl AsRef<Path>) -> Option<bool> {
+        self.trust.as_ref().and_then(|map| {
+            path.as_ref().ancestors().find_map(|path| {
+                if is_workspace(path) || path.is_file() {
+                    map.get(path).map(|trust| matches!(trust, Trust::Trusted))
+                } else {
+                    None
+                }
+            })
+        })
+    }
+
+    fn lock() -> std::io::Result<File> {
+        let file = std::fs::OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .truncate(false)
+            .open(trust_db_lock_file())?;
+        file.lock_exclusive()?;
+        Ok(file)
+    }
+
+    fn inspect<F, R>(f: F) -> std::io::Result<R>
+    where
+        F: FnOnce(TrustDb) -> R,
+    {
+        let lock = TrustDb::lock()?;
+        let contents = match std::fs::read_to_string(trust_db_file()) {
+            Ok(s) => s,
+            Err(e) => {
+                if e.kind() == ErrorKind::NotFound {
+                    toml::to_string(&TrustDb::default()).unwrap()
+                } else {
+                    return Err(e);
+                }
+            }
+        };
+        let toml: TrustDb = toml::from_str(&contents).unwrap_or_else(|_| {
+            panic!(
+                "Trust database is corrupted. Try to fix {} or delete it",
+                trust_db_file().display()
+            )
+        });
+        let r = f(toml);
+        drop(lock);
+        Ok(r)
+    }
+
+    fn modify<F, R>(f: F) -> std::io::Result<R>
+    where
+        F: FnOnce(&mut TrustDb) -> R,
+    {
+        let lock = TrustDb::lock()?;
+        let contents = match std::fs::read_to_string(trust_db_file()) {
+            Ok(s) => s,
+            Err(e) => {
+                if e.kind() == ErrorKind::NotFound {
+                    toml::to_string(&TrustDb::default()).unwrap()
+                } else {
+                    return Err(e);
+                }
+            }
+        };
+        let mut toml: TrustDb = toml::from_str(&contents).unwrap_or_else(|_| {
+            panic!(
+                "Trust database is corrupted. Try to fix {} or delete it",
+                trust_db_file().display()
+            )
+        });
+        let r = f(&mut toml);
+        let toml_updated =
+            toml::to_string(&toml).expect("toml serialization of trust database failed?");
+        std::fs::write(trust_db_file(), toml_updated)?;
+        drop(lock);
+        Ok(r)
+    }
+}
+
+fn trust_db_file() -> PathBuf {
+    data_dir().join("trust_db.toml")
+}
+
+fn trust_db_lock_file() -> PathBuf {
+    trust_db_file().with_extension("lock")
+}
+
+pub fn is_workspace_trusted(path: impl AsRef<Path>) -> std::io::Result<Option<bool>> {
+    let Ok(path) = path.as_ref().canonicalize() else {
+        return Ok(Some(false));
+    };
+    TrustDb::inspect(|db| db.is_workspace_trusted(path))
+}
+
+pub fn trust_path(path: impl AsRef<Path>) -> std::io::Result<bool> {
+    let Ok(path) = path.as_ref().canonicalize() else {
+        return Ok(false);
+    };
+    TrustDb::modify(|db| {
+        db.trust
+            .get_or_insert(HashMap::new())
+            .insert(path, Trust::Trusted)
+            != Some(Trust::Trusted)
+    })
+}
+
+pub fn untrust_path(path: impl AsRef<Path>) -> std::io::Result<bool> {
+    let Ok(path) = path.as_ref().canonicalize() else {
+        return Ok(false);
+    };
+    TrustDb::modify(|db| {
+        db.trust
+            .get_or_insert(HashMap::new())
+            .insert(path, Trust::Untrusted)
+            != Some(Trust::Untrusted)
+    })
+}
+
+pub fn initialize_trust_db() {
+    ensure_parent_dir(&trust_db_file());
+}

helix-term/build.rs

@@ -3,7 +3,7 @@ use helix_loader::grammar::{build_grammars, fetch_grammars};
 fn main() {
     if std::env::var("HELIX_DISABLE_AUTO_GRAMMAR_BUILD").is_err() {
         fetch_grammars().expect("Failed to fetch tree-sitter grammars");
-        build_grammars(Some(std::env::var("TARGET").unwrap()))
+        build_grammars(Some(std::env::var("TARGET").unwrap()), true)
             .expect("Failed to compile tree-sitter grammars");
     }
 

helix-term/src/application.rs

@@ -412,10 +412,11 @@ impl Application {
             let default_config = Config::load_default()
                 .map_err(|err| anyhow::anyhow!("Failed to load config: {}", err))?;
 
+            let use_local_lang = doc!(self.editor).is_trusted.unwrap_or_default();
             // Update the syntax language loader before setting the theme. Setting the theme will
             // call `Loader::set_scopes` which must be done before the documents are re-parsed for
             // the sake of locals highlighting.
-            let lang_loader = helix_core::config::user_lang_loader()?;
+            let lang_loader = helix_core::config::user_lang_loader(use_local_lang)?;
             self.editor.syn_loader.store(Arc::new(lang_loader));
             Self::load_configured_theme(
                 &mut self.editor,