refactor: use jsonc_to_json instead of serde_jsonrc to add jsonc support

Author: linux-china

Cargo.toml

@@ -25,7 +25,7 @@ path = "src/sq.rs"
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-serde_jsonrc = "0.1"
+jsonc-to-json="0.1.1"
 serde-xml-rs = "0.6"
 toml = "0.8"
 java-properties = "2"

src/runners/fleet.rs

@@ -6,6 +6,7 @@ use crate::errors::KeeperError;
 use crate::models::Task;
 use crate::task;
 use error_stack::{report, Result};
+use jsonc_to_json::jsonc_to_json;
 use crate::command_utils::{is_command_available, run_command_with_env_vars};
 
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -110,7 +111,8 @@ fn parse_run_json() -> FleetRunJson {
     std::env::current_dir()
         .map(|dir| dir.join(".fleet").join("run.json"))
         .map(|path| std::fs::read_to_string(path).unwrap_or("{}".to_owned()))
-        .map(|data| serde_jsonrc::from_str::<FleetRunJson>(&data).unwrap())
+        .map(|data| jsonc_to_json(&data).to_string())
+        .map(|data| serde_json::from_str::<FleetRunJson>(&data).unwrap())
         .unwrap()
 }
 

src/runners/vstasks.rs

@@ -1,10 +1,11 @@
-use std::process::{Output};
+use crate::command_utils::{run_command_by_shell, run_command_line};
 use crate::errors::KeeperError;
-use error_stack::{Result};
 use crate::models::Task;
-use crate::command_utils::{run_command_by_shell, run_command_line};
 use crate::task;
+use error_stack::Result;
+use jsonc_to_json::jsonc_to_json;
 use serde::{Deserialize, Serialize};
+use std::process::Output;
 
 #[derive(Serialize, Deserialize, Debug, Default)]
 struct TasksJson {
@@ -27,36 +28,51 @@ pub fn is_available() -> bool {
 }
 
 pub fn list_tasks() -> Result<Vec<Task>, KeeperError> {
-    Ok(parse_run_json().tasks
+    Ok(parse_run_json()
+        .tasks
         .map(|tasks| {
-            tasks.into_iter().map(|task| {
-                if task.task_type == "shell" {
-                    Some(task!(&task.label.clone().unwrap(), "vscode", "shell", &task.command.clone().unwrap()))
-                } else if let Some(cmd) = task.command {
-                    Some(task!(&task.label.clone().unwrap(), "vscode", &cmd))
-                } else {None}
-            }).flatten().collect()
+            tasks
+                .into_iter()
+                .map(|task| {
+                    if task.task_type == "shell" {
+                        Some(task!(
+                            &task.label.clone().unwrap(),
+                            "vscode",
+                            "shell",
+                            &task.command.clone().unwrap()
+                        ))
+                    } else if let Some(cmd) = task.command {
+                        Some(task!(&task.label.clone().unwrap(), "vscode", &cmd))
+                    } else {
+                        None
+                    }
+                })
+                .flatten()
+                .collect()
         })
-        .unwrap_or_else(|| vec![])
-    )
+        .unwrap_or_else(|| vec![]))
 }
 
-
 fn parse_run_json() -> TasksJson {
     std::env::current_dir()
         .map(|dir| dir.join(".vscode").join("tasks.json"))
         .map(|path| std::fs::read_to_string(path).unwrap_or("{}".to_owned()))
-        .map(|data| serde_jsonrc::from_str::<TasksJson>(&data).expect(".vscode/tasks.json format"))
-        // ! serde_jsonrc has a bug with trailing commas inside objects (but the repo has no issues enabled). - the above fails with `Error("key must be a string", line: 123, column: 123)`
-        // Would need some investigation into the code around here: https://github.com/serde-rs/json/commit/e34885f6ec5218c721ce33b5f27eaf8bfac9649d
+        .map(|data| jsonc_to_json(&data).to_string())
+        .map(|data| serde_json::from_str::<TasksJson>(&data).expect(".vscode/tasks.json format"))
         .unwrap()
 }
 
-pub fn run_task(task: &str, _task_args: &[&str], _global_args: &[&str], verbose: bool) -> Result<Output, KeeperError> {
+pub fn run_task(
+    task: &str,
+    _task_args: &[&str],
+    _global_args: &[&str],
+    verbose: bool,
+) -> Result<Output, KeeperError> {
     let tasks = list_tasks()?;
-    let task = tasks.iter().find(|t| t.name == task).ok_or_else(|| {
-        KeeperError::TaskNotFound(task.to_string())
-    })?;
+    let task = tasks
+        .iter()
+        .find(|t| t.name == task)
+        .ok_or_else(|| KeeperError::TaskNotFound(task.to_string()))?;
     if let Some(_runner2) = &task.runner2 {
         run_command_by_shell(&task.description, verbose)
     } else {
@@ -68,7 +84,6 @@ pub fn run_task(task: &str, _task_args: &[&str], _global_args: &[&str], verbose:
 mod tests {
     use super::*;
 
-
     #[test]
     fn test_parse() {
         if let Ok(tasks) = list_tasks() {

src/runners/zed.rs

@@ -7,6 +7,7 @@ use crate::errors::KeeperError;
 use crate::models::Task;
 use crate::task;
 use error_stack::{report, Result};
+use jsonc_to_json::jsonc_to_json;
 use crate::command_utils::{is_command_available, run_command_with_env_vars};
 
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -61,7 +62,8 @@ fn parse_tasks_json() -> Vec<Configuration> {
     std::env::current_dir()
         .map(|dir| dir.join(".zed").join("tasks.json"))
         .map(|path| std::fs::read_to_string(path).unwrap_or("[]".to_owned()))
-        .map(|data| serde_jsonrc::from_str::<Vec<Configuration>>(&data).unwrap())
+        .map(|data| jsonc_to_json(&data).to_string())
+        .map(|data| serde_json::from_str::<Vec<Configuration>>(&data).unwrap())
         .unwrap()
 }