refactor(code_action): handle serialisation errors

and avoid to_string_lossy by using PathBuf. On serialisation invalid utf-8 paths will produce a serialisation error.

Author: tekumara

crates/typos-lsp/src/lsp.rs

@@ -31,7 +31,7 @@ struct DiagnosticData<'c> {
 struct IgnoreInProjectCommandArguments {
     typo: String,
     /// The configuration file that should be modified to ignore the typo
-    config_file_path: String,
+    config_file_path: PathBuf,
 }
 
 impl LanguageServer for Backend<'static, 'static> {
@@ -225,35 +225,38 @@ impl LanguageServer for Backend<'static, 'static> {
                             .router
                             .at(&uri_path)
                         {
-                            suggestions.push(CodeActionOrCommand::Command(Command {
-                                title: format!("Ignore `{}` in the project", typo),
-                                command: IGNORE_IN_PROJECT.to_string(),
-                                arguments: Some(
-                                    [serde_json::to_value(IgnoreInProjectCommandArguments {
-                                        typo: typo.to_string(),
-                                        config_file_path: instance
-                                            .config_file
-                                            .to_string_lossy()
-                                            .to_string(),
-                                    })
-                                        .unwrap()]
-                                        .into(),
-                                ),
-                            }));
+                            match serde_json::to_value(IgnoreInProjectCommandArguments {
+                                typo: typo.to_string(),
+                                config_file_path: instance.config_file.clone(),
+                            }) {
+                                Ok(args) => {
+                                    suggestions.push(CodeActionOrCommand::Command(Command {
+                                        title: format!("Ignore `{}` in the project", typo),
+                                        command: IGNORE_IN_PROJECT.to_string(),
+                                        arguments: Some(vec![args]),
+                                    }));
+                                }
+                                Err(e) => {
+                                    tracing::error!("Failed to serialize arguments: {}", e);
+                                }
+                            }
 
                             if let Some(explicit_config) = &instance.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.to_string_lossy().to_string(),
-                                        })
-                                            .unwrap()]
-                                            .into(),
-                                    ),
-                                }));
+                                match serde_json::to_value(IgnoreInProjectCommandArguments {
+                                    typo: typo.to_string(),
+                                    config_file_path: explicit_config.clone(),
+                                }) {
+                                    Ok(args) => {
+                                        suggestions.push(CodeActionOrCommand::Command(Command {
+                                            title: format!("Ignore `{}` in the configuration file", typo),
+                                            command: IGNORE_IN_PROJECT.to_string(),
+                                            arguments: Some(vec![args]),
+                                        }));
+                                    }
+                                    Err(e) => {
+                                        tracing::error!("Failed to serialize arguments: {}", e);
+                                    }
+                                }
                             }
                         } else {
                             tracing::warn!(
@@ -305,8 +308,7 @@ impl LanguageServer for Backend<'static, 'static> {
                 ..
             }) = serde_json::from_value::<IgnoreInProjectCommandArguments>(argument)
             {
-                crate::config::add_ignore(PathBuf::from(config_file_path).as_path(), &typo)
-                    .unwrap();
+                crate::config::add_ignore(&config_file_path, &typo).unwrap();
                 // reload the instance so new ignore takes effect
                 self.state.lock().unwrap().update_router().unwrap();
             };

crates/typos-lsp/tests/integration_test.rs

@@ -204,8 +204,6 @@ async fn test_execute_command_ignore_in_project() {
     let config_path = temp_dir.path().join("typos.toml");
 
     let workspace_folder_uri = Uri::from_file_path(temp_dir.path()).unwrap();
-    let config_uri_str = config_path.to_string_lossy();
-
     let mut server = TestServer::new();
     let _ = server
         .request(&initialize_with(Some(&workspace_folder_uri), None, None))
@@ -218,7 +216,7 @@ async fn test_execute_command_ignore_in_project() {
             "command": "ignore-in-project",
             "arguments": [{
                 "typo": "foobar",
-                "config_file_path": config_uri_str
+                "config_file_path": config_path
             }]
         },
         "id": 2