refactor: remove ConfigPath struct

- remove handling file paths containing a file, as we will always receive a directory
- inline from_dir
- test cases to handle existing and missing config files

Author: tekumara

crates/typos-lsp/src/config.rs

@@ -3,70 +3,27 @@ use std::path::{Path, PathBuf};
 use anyhow::{anyhow, Context};
 use toml_edit::DocumentMut;
 
-/// Represents a path to a typos_cli config file and, if it contains a configuration file, the file
-/// contents.
-///
-/// When reading a config from a directory, many configuration files are supported, and only one is
-/// chosen in a given order. Shows the name of the config file that is used ("typos.toml",
-/// "_typos.toml", ".typos.toml", "pyproject.toml"). This information is useful when we want to
-/// modify the config file later on.
-#[derive(Debug, Clone)]
-pub struct ConfigPath {
-    pub path: PathBuf,
-    pub config: Option<typos_cli::config::Config>,
-}
-
-impl PartialEq for ConfigPath {
-    fn eq(&self, other: &Self) -> bool {
-        self.path == other.path && format!("{:?}", self.config) == format!("{:?}", other.config)
-    }
-}
-
-impl ConfigPath {
-    pub fn from_file_path_or_default(path: &Path) -> ConfigPath {
-        let config = typos_cli::config::Config::from_file(path).ok().flatten();
-
-        ConfigPath {
-            path: path.to_path_buf(),
-            config,
+pub fn find_config_file_or_default(directory: &Path) -> PathBuf {
+    assert!(
+        directory.is_dir(),
+        "Expected a directory that might contain a configuration file, got {:?}",
+        directory.is_dir()
+    );
+
+    // adapted from typos_cli::config::Config::from_dir
+    for file in typos_cli::config::SUPPORTED_FILE_NAMES {
+        let config_path = directory.join(file);
+        if typos_cli::config::Config::from_file(&config_path)
+            .ok()
+            .flatten()
+            .is_some()
+        {
+            return config_path;
         }
     }
 
-    pub fn from_dir_or_default(path: &Path) -> ConfigPath {
-        let directory = if path.is_dir() {
-            path
-        } else {
-            path.parent().unwrap()
-        };
-        ConfigPath::from_dir(directory).unwrap_or_else(|_| ConfigPath {
-            path: path.join("typos.toml").to_path_buf(),
-            config: None,
-        })
-    }
-
-    // copied from typos_cli::config::Config::from_dir
-    fn from_dir(dir: &Path) -> anyhow::Result<ConfigPath> {
-        assert!(
-            dir.is_dir(),
-            "Expected a directory that might contain a configuration file, got {:?}",
-            dir.is_dir()
-        );
-
-        for file in typos_cli::config::SUPPORTED_FILE_NAMES {
-            let path = dir.join(file);
-            if let Ok(Some(config)) = typos_cli::config::Config::from_file(path.as_path()) {
-                return Ok(ConfigPath {
-                    path,
-                    config: Some(config),
-                });
-            }
-        }
-
-        Err(anyhow::anyhow!(
-            "No typos_cli config file found starting from {:?}",
-            dir
-        ))
-    }
+    //  no config file found in the directory, so provide a default typos.toml path
+    directory.join("typos.toml")
 }
 
 pub fn add_ignore(config_file_path: &Path, typo: &str) -> anyhow::Result<()> {
@@ -104,54 +61,37 @@ pub fn add_ignore(config_file_path: &Path, typo: &str) -> anyhow::Result<()> {
 mod tests {
     use super::*;
     use std::fs::File;
-    use std::io::Write;
     use tempfile::tempdir;
 
     #[test]
-    fn test_from_dir_or_default_with_exact_path() -> anyhow::Result<()> {
-        // when given a path to a configuration file, should resolve it to the same file
-
-        // create a temporary directory on disk
+    fn test_find_config_file_found() -> anyhow::Result<()> {
+        // when a configuration file is found in the directory, should return that file path
         let dir = tempdir()?;
+        let dir_path = dir.path();
+        let config_path = dir_path.join(".typos.toml");
+        File::create(&config_path)?;
 
-        let file_path = dir.path().join("typos.toml");
-        let mut file = File::create(&file_path)?;
-        writeln!(file, "#")?;
-
-        assert_eq!(
-            ConfigPath::from_dir_or_default(&file_path),
-            ConfigPath {
-                path: file_path.to_path_buf(),
-                config: Some(typos_cli::config::Config::default()),
-            }
-        );
+        assert_eq!(find_config_file_or_default(dir_path), config_path);
 
         Ok(())
     }
 
     #[test]
-    fn test_from_dir_or_default_with_directory() -> anyhow::Result<()> {
-        // when given a path to a directory, should resolve it to the first configuration file
-        // found in the directory. This should support all of the supported file names, although
-        // this test only tests one of them.
-
-        // NOTE when `dir` is dropped, the temporary directory is deleted from disk
+    fn test_find_config_file_missing() -> anyhow::Result<()> {
+        // when no configuration file is found in the directory, should return the default typos.toml path
         let dir = tempdir()?;
         let dir_path = dir.path();
 
         assert_eq!(
-            ConfigPath::from_dir_or_default(dir.path()),
-            ConfigPath {
-                path: dir_path.join("typos.toml").to_path_buf(),
-                config: None,
-            }
+            find_config_file_or_default(dir_path),
+            dir_path.join("typos.toml").to_path_buf()
         );
 
         Ok(())
     }
 
     #[test]
-    fn test_add_ignore_to_new_file() -> anyhow::Result<()> {
+    fn test_add_ignore_to_new_config_file() -> anyhow::Result<()> {
         let dir = tempdir()?;
         let file_path = dir.path().join("test.toml");
 
@@ -173,7 +113,7 @@ mod tests {
     }
 
     #[test]
-    fn test_add_ignore_to_existing_file() -> anyhow::Result<()> {
+    fn test_add_ignore_to_existing_config_file() -> anyhow::Result<()> {
         // should preserve comments and formatting
 
         let existing_file = [

crates/typos-lsp/src/lsp.rs

@@ -231,8 +231,7 @@ impl LanguageServer for Backend<'static, 'static> {
                                     [serde_json::to_value(IgnoreInProjectCommandArguments {
                                         typo: typo.to_string(),
                                         config_file_path: value
-                                            .project_root
-                                            .path
+                                            .config_file
                                             .to_string_lossy()
                                             .to_string(),
                                     })
@@ -241,14 +240,14 @@ impl LanguageServer for Backend<'static, 'static> {
                                 ),
                             }));
 
-                            if let Some(explicit_config) = &value.explicit_config {
+                            if let Some(explicit_config) = &value.custom_config {
                                 suggestions.push(CodeActionOrCommand::Command(Command {
                                     title: format!("Ignore `{}` in the configuration file", typo),
                                     command: IGNORE_IN_PROJECT.to_string(),
                                     arguments: Some(
                                         [serde_json::to_value(IgnoreInProjectCommandArguments {
                                             typo: typo.to_string(),
-                                            config_file_path: explicit_config.path.to_string_lossy().to_string(),
+                                            config_file_path: explicit_config.to_string_lossy().to_string(),
                                         })
                                             .unwrap()]
                                             .into(),

crates/typos-lsp/src/typos.rs

@@ -1,20 +1,21 @@
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use bstr::ByteSlice;
-use crate::config::ConfigPath;
 use ignore::overrides::{Override, OverrideBuilder};
 use typos_cli::policy;
 
+use crate::config;
+
 pub struct Instance<'s> {
     /// File path rules to ignore
     pub ignores: Override,
     pub engine: policy::ConfigEngine<'s>,
 
-    /// The path where the LSP server was started
-    pub project_root: ConfigPath,
+    /// The path to the configuration file for the files in this instance
+    pub config_file: PathBuf,
 
     /// The explicit configuration file that was given to the LSP server at startup
-    pub explicit_config: Option<ConfigPath>,
+    pub custom_config: Option<PathBuf>,
 }
 
 impl Instance<'_> {
@@ -31,38 +32,35 @@ impl Instance<'_> {
         // a default config?
 
         let mut c = typos_cli::config::Config::default();
-        let explicit_config = config.map(ConfigPath::from_file_path_or_default);
-
-        if let Some(ConfigPath {
-            config: Some(ref config),
-            ..
-        }) = explicit_config
-        {
-            c.update(config);
-            engine.set_overrides(c);
+        if let Some(config_path) = config {
+            let custom = typos_cli::config::Config::from_file(config_path)?;
+            if let Some(custom) = custom {
+                c.update(&custom);
+                engine.set_overrides(c);
+            }
         }
 
         // initialise an engine and overrides using the config file from path or its parent
         engine.init_dir(path)?;
         let walk_policy = engine.walk(path);
 
-        let mut ignores = OverrideBuilder::new(path);
+        let mut ob = OverrideBuilder::new(path);
         // always ignore the config files like typos cli does
         for f in typos_cli::config::SUPPORTED_FILE_NAMES {
-            ignores.add(&format!("!{f}"))?;
+            ob.add(&format!("!{f}"))?;
         }
 
         // add any explicit excludes
         for pattern in walk_policy.extend_exclude.iter() {
-            ignores.add(&format!("!{pattern}"))?;
+            ob.add(&format!("!{pattern}"))?;
         }
-        let ignore = ignores.build()?;
+        let ignores = ob.build()?;
 
         Ok(Instance {
-            explicit_config,
-            project_root: ConfigPath::from_dir_or_default(path),
-            ignores: ignore,
+            ignores,
             engine,
+            config_file: config::find_config_file_or_default(path),
+            custom_config: config.map(|p| p.to_path_buf()),
         })
     }
 }