code prep

Author: 2bndy5

cpp-linter-lib/src/clang_tools/clang_format.rs

@@ -12,7 +12,7 @@ use serde_xml_rs::de::Deserializer;
 
 // project-specific crates/modules
 use crate::{
-    cli::LinesChangedOnly,
+    cli::ClangParams,
     common_fs::{get_line_cols_from_offset, FileObj},
 };
 
@@ -79,15 +79,14 @@ pub fn tally_format_advice(files: &[Arc<Mutex<FileObj>>]) -> u64 {
 
 /// Run clang-tidy for a specific `file`, then parse and return it's XML output.
 pub fn run_clang_format(
-    cmd: &mut Command,
     file: &mut Arc<Mutex<FileObj>>,
-    style: &str,
-    lines_changed_only: &LinesChangedOnly,
+    clang_params: &ClangParams,
 ) -> Vec<(log::Level, String)> {
+    let mut cmd = Command::new(clang_params.clang_format_command.as_ref().unwrap());
     let mut logs = vec![];
     let mut file = file.lock().unwrap();
-    cmd.args(["--style", style, "--output-replacements-xml"]);
-    let ranges = file.get_ranges(lines_changed_only);
+    cmd.args(["--style", &clang_params.style, "--output-replacements-xml"]);
+    let ranges = file.get_ranges(&clang_params.lines_changed_only);
     for range in &ranges {
         cmd.arg(format!("--lines={}:{}", range.start(), range.end()));
     }

cpp-linter-lib/src/clang_tools/clang_tidy.rs

@@ -14,7 +14,7 @@ use serde::Deserialize;
 
 // project-specific modules/crates
 use crate::{
-    cli::LinesChangedOnly,
+    cli::{ClangParams, LinesChangedOnly},
     common_fs::{normalize_path, FileObj},
 };
 
@@ -184,29 +184,25 @@ pub fn tally_tidy_advice(files: &[Arc<Mutex<FileObj>>]) -> u64 {
 
 /// Run clang-tidy, then parse and return it's output.
 pub fn run_clang_tidy(
-    cmd: &mut Command,
     file: &mut Arc<Mutex<FileObj>>,
-    checks: &str,
-    lines_changed_only: &LinesChangedOnly,
-    database: &Option<PathBuf>,
-    extra_args: &Option<Vec<String>>,
-    database_json: &Option<Vec<CompilationUnit>>,
+    clang_params: &ClangParams,
 ) -> Vec<(log::Level, std::string::String)> {
+    let mut cmd = Command::new(clang_params.clang_tidy_command.as_ref().unwrap());
     let mut logs = vec![];
     let mut file = file.lock().unwrap();
-    if !checks.is_empty() {
-        cmd.args(["-checks", checks]);
+    if !clang_params.tidy_checks.is_empty() {
+        cmd.args(["-checks", &clang_params.tidy_checks]);
     }
-    if let Some(db) = database {
+    if let Some(db) = &clang_params.database {
         cmd.args(["-p", &db.to_string_lossy()]);
     }
-    if let Some(extras) = extra_args {
+    if let Some(extras) = &clang_params.extra_args {
         for arg in extras {
             cmd.args(["--extra-arg", format!("\"{}\"", arg).as_str()]);
         }
     }
-    if *lines_changed_only != LinesChangedOnly::Off {
-        let ranges = file.get_ranges(lines_changed_only);
+    if clang_params.lines_changed_only != LinesChangedOnly::Off {
+        let ranges = file.get_ranges(&clang_params.lines_changed_only);
         let filter = format!(
             "[{{\"name\":{:?},\"lines\":{:?}}}]",
             &file
@@ -249,7 +245,7 @@ pub fn run_clang_tidy(
             ),
         ));
     }
-    file.tidy_advice = parse_tidy_output(&output.stdout, database_json);
+    file.tidy_advice = parse_tidy_output(&output.stdout, &clang_params.database_json);
     logs
 }
 
@@ -258,13 +254,16 @@ mod test {
     use std::{
         env,
         path::PathBuf,
-        process::Command,
         sync::{Arc, Mutex},
     };
 
     use regex::Regex;
 
-    use crate::{clang_tools::get_clang_tool_exe, cli::LinesChangedOnly, common_fs::FileObj};
+    use crate::{
+        clang_tools::get_clang_tool_exe,
+        cli::{ClangParams, LinesChangedOnly},
+        common_fs::FileObj,
+    };
 
     use super::run_clang_tidy;
 
@@ -297,33 +296,41 @@ mod test {
             env::var("CLANG_VERSION").unwrap_or("".to_string()).as_str(),
         )
         .unwrap();
-        let mut cmd = Command::new(exe_path);
         let file = FileObj::new(PathBuf::from("tests/demo/demo.cpp"));
         let mut arc_ref = Arc::new(Mutex::new(file));
         let extra_args = vec!["-std=c++17".to_string(), "-Wall".to_string()];
-        run_clang_tidy(
-            &mut cmd,
-            &mut arc_ref,
-            "",                     // use .clang-tidy config file
-            &LinesChangedOnly::Off, // check all lines
-            &None,                  // no database path
-            &Some(extra_args),      // <---- the reason for this test
-            &None,                  // no deserialized database
-        );
-        // since `cmd` was passed as a mutable reference, we can inspect the args that were added
-        let locked_file = arc_ref.lock().unwrap();
-        let mut args = cmd
-            .get_args()
-            .map(|arg| arg.to_str().unwrap())
+        let clang_params = ClangParams {
+            style: "".to_string(),
+            tidy_checks: "".to_string(), // use .clang-tidy config file
+            lines_changed_only: LinesChangedOnly::Off,
+            database: None,
+            extra_args: Some(extra_args.clone()), // <---- the reason for this test
+            database_json: None,
+            format_filter: None,
+            tidy_filter: None,
+            tidy_review: false,
+            format_review: false,
+            clang_tidy_command: Some(exe_path),
+            clang_format_command: None,
+        };
+        let logs = run_clang_tidy(&mut arc_ref, &clang_params)
+            .into_iter()
+            .filter_map(|(_lvl, msg)| {
+                if msg.contains("Running ") {
+                    return Some(msg);
+                } else {
+                    return None;
+                }
+            })
+            .collect::<Vec<String>>();
+        let args = &logs
+            .first()
+            .expect("expected a log message about invoked clang-tidy command")
+            .split(' ')
             .collect::<Vec<&str>>();
-        assert_eq!(locked_file.name.to_string_lossy(), args.pop().unwrap());
-        assert_eq!(
-            vec!["--extra-arg", "\"-std=c++17\"", "--extra-arg", "\"-Wall\""],
-            args
-        );
-        assert!(!locked_file
-            .tidy_advice
-            .as_ref()
-            .is_some_and(|advice| advice.notes.is_empty()));
+        for arg in &extra_args {
+            let extra_arg = format!("\"{arg}\"");
+            assert!(args.contains(&extra_arg.as_str()));
+        }
     }
 }

cpp-linter-lib/src/clang_tools/mod.rs

@@ -92,20 +92,14 @@ fn analyze_single_file(
     let file_name = file_lock.name.clone();
     drop(file_lock);
     let mut logs = vec![];
-    if let Some(tidy_cmd) = &clang_params.clang_tidy_command {
+    if clang_params.clang_tidy_command.is_some() {
         if clang_params
             .tidy_filter
-            .is_source_or_ignored(file_name.as_path())
+            .as_ref()
+            .is_some_and(|f| f.is_source_or_ignored(file_name.as_path()))
+            || clang_params.tidy_filter.is_none()
         {
-            let tidy_result = run_clang_tidy(
-                &mut Command::new(tidy_cmd),
-                file,
-                clang_params.tidy_checks.as_str(),
-                &clang_params.lines_changed_only,
-                &clang_params.database,
-                &clang_params.extra_args,
-                &clang_params.database_json,
-            );
+            let tidy_result = run_clang_tidy(file, &clang_params);
             logs.extend(tidy_result);
         } else {
             logs.push((
@@ -117,17 +111,14 @@ fn analyze_single_file(
             ))
         }
     }
-    if let Some(format_cmd) = &clang_params.clang_format_command {
+    if clang_params.clang_format_command.is_some() {
         if clang_params
             .format_filter
-            .is_source_or_ignored(file_name.as_path())
+            .as_ref()
+            .is_some_and(|f| f.is_source_or_ignored(file_name.as_path()))
+            || clang_params.format_filter.is_none()
         {
-            let format_result = run_clang_format(
-                &mut Command::new(format_cmd),
-                file,
-                clang_params.style.as_str(),
-                &clang_params.lines_changed_only,
-            );
+            let format_result = run_clang_format(file, &clang_params);
             logs.extend(format_result);
         } else {
             logs.push((