conditionally truncate thread comment length

Author: 2bndy5

cpp-linter-lib/examples/cli_doc.rs

@@ -24,21 +24,20 @@ pub fn main() -> std::io::Result<()> {
         writeln!(&doc_file)?;
     }
     for group in command.get_groups() {
-        writeln!(&doc_file, "\n{}", group.get_id().to_string())?;
+        writeln!(&doc_file, "\n{}", group.get_id())?;
         for _ in group.get_id().to_string().chars() {
             write!(&doc_file, "-")?;
         }
         write!(&doc_file, "\n\n")?;
         for arg_id in group.get_args() {
             let mut arg_match = command.get_arguments().filter(|a| *a.get_id() == *arg_id);
-            let arg = arg_match.next().expect(
-                format!(
+            let arg = arg_match.next().unwrap_or_else(|| {
+                panic!(
                     "arg {} expected in group {}",
                     arg_id.as_str(),
                     group.get_id().as_str()
                 )
-                .as_str(),
-            );
+            });
             writeln!(
                 &doc_file,
                 ".. std:option:: -{}, --{}\n",

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

@@ -60,24 +60,26 @@ impl Clone for Replacement {
     }
 }
 
-/// Get a total count of clang-format advice from the given list of [FormatAdvice].
-pub fn tally_format_advice(format_advice: &[FormatAdvice]) -> u64 {
-    let mut format_checks_failed: u64 = 0;
-    for fmt_advice in format_advice.iter() {
-        if !fmt_advice.replacements.is_empty() {
-            format_checks_failed += 1;
+/// Get a total count of clang-format advice from the given list of [FileObj]s.
+pub fn tally_format_advice(files: &[FileObj]) -> u64 {
+    let mut total = 0;
+    for file in files {
+        if let Some(advice) = &file.format_advice {
+            if !advice.replacements.is_empty() {
+                total += 1;
+            }
         }
     }
-    format_checks_failed
+    total
 }
 
 /// Run clang-tidy for a specific `file`, then parse and return it's XML output.
 pub fn run_clang_format(
     cmd: &mut Command,
-    file: &FileObj,
+    file: &mut FileObj,
     style: &str,
     lines_changed_only: &LinesChangedOnly,
-) -> FormatAdvice {
+) {
     cmd.args(["--style", style, "--output-replacements-xml"]);
     let ranges = file.get_ranges(lines_changed_only);
     for range in &ranges {
@@ -104,9 +106,7 @@ pub fn run_clang_format(
     //     String::from_utf8(output.stdout.clone()).unwrap()
     // );
     if output.stdout.is_empty() {
-        return FormatAdvice {
-            replacements: vec![],
-        };
+        return;
     }
     let xml = String::from_utf8(output.stdout)
         .unwrap()
@@ -118,8 +118,8 @@ pub fn run_clang_format(
         .whitespace_to_characters(true)
         .ignore_root_level_whitespace(true);
     let event_reader = serde_xml_rs::EventReader::new_with_config(xml.as_bytes(), config);
-    let mut format_advice: FormatAdvice =
-        FormatAdvice::deserialize(&mut Deserializer::new(event_reader)).unwrap_or(FormatAdvice {
+    let mut format_advice = FormatAdvice::deserialize(&mut Deserializer::new(event_reader))
+        .unwrap_or(FormatAdvice {
             replacements: vec![],
         });
     if !format_advice.replacements.is_empty() {
@@ -141,7 +141,7 @@ pub fn run_clang_format(
         }
         format_advice.replacements = filtered_replacements;
     }
-    format_advice
+    file.format_advice = Some(format_advice)
 }
 
 #[cfg(test)]

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

@@ -44,6 +44,7 @@ struct CompilationUnit {
 }
 
 /// A structure that represents a single notification parsed from clang-tidy's stdout.
+#[derive(Debug)]
 pub struct TidyNotification {
     /// The file's path and name (supposedly relative to the repository root folder).
     pub filename: String,
@@ -86,6 +87,7 @@ impl TidyNotification {
 }
 
 /// A struct to hold notification from clang-tidy about a single file
+#[derive(Debug)]
 pub struct TidyAdvice {
     /// A list of notifications parsed from clang-tidy stdout.
     pub notes: Vec<TidyNotification>,
@@ -98,7 +100,7 @@ pub struct TidyAdvice {
 fn parse_tidy_output(
     tidy_stdout: &[u8],
     database_json: &Option<CompilationDatabase>,
-) -> TidyAdvice {
+) -> Option<TidyAdvice> {
     let note_header = Regex::new(r"^(.+):(\d+):(\d+):\s(\w+):(.*)\[([a-zA-Z\d\-\.]+)\]$").unwrap();
     let mut notification = None;
     let mut result = Vec::new();
@@ -163,19 +165,39 @@ fn parse_tidy_output(
     if let Some(note) = notification {
         result.push(note);
     }
-    TidyAdvice { notes: result }
+    if result.is_empty() {
+        None
+    } else {
+        Some(TidyAdvice { notes: result })
+    }
+}
+
+/// Get a total count of clang-tidy advice from the given list of [FileObj]s.
+pub fn tally_tidy_advice(files: &[FileObj]) -> u64 {
+    let mut total = 0;
+    for file in files {
+        if let Some(advice) = &file.tidy_advice {
+            for tidy_note in &advice.notes {
+                let file_path = PathBuf::from(&tidy_note.filename);
+                if file_path == file.name {
+                    total += 1;
+                }
+            }
+        }
+    }
+    total
 }
 
 /// Run clang-tidy, then parse and return it's output.
 pub fn run_clang_tidy(
     cmd: &mut Command,
-    file: &FileObj,
+    file: &mut FileObj,
     checks: &str,
     lines_changed_only: &LinesChangedOnly,
     database: &Option<PathBuf>,
     extra_args: &Option<Vec<&str>>,
     database_json: &Option<CompilationDatabase>,
-) -> TidyAdvice {
+) {
     if !checks.is_empty() {
         cmd.args(["-checks", checks]);
     }
@@ -222,7 +244,7 @@ pub fn run_clang_tidy(
             String::from_utf8(output.stderr).unwrap()
         );
     }
-    parse_tidy_output(&output.stdout, database_json)
+    file.tidy_advice = parse_tidy_output(&output.stdout, database_json);
 }
 
 #[cfg(test)]
@@ -265,11 +287,11 @@ mod test {
         )
         .unwrap();
         let mut cmd = Command::new(exe_path);
-        let file = FileObj::new(PathBuf::from("tests/demo/demo.cpp"));
+        let mut file = FileObj::new(PathBuf::from("tests/demo/demo.cpp"));
         let extra_args = vec!["-std=c++17", "-Wall"];
-        let tidy_advice = run_clang_tidy(
+        run_clang_tidy(
             &mut cmd,
-            &file,
+            &mut file,
             "",                     // use .clang-tidy config file
             &LinesChangedOnly::Off, // check all lines
             &None,                  // no database path
@@ -286,6 +308,8 @@ mod test {
             vec!["--extra-arg", "\"-std=c++17\"", "--extra-arg", "\"-Wall\""],
             args
         );
-        assert!(!tidy_advice.notes.is_empty());
+        assert!(!file
+            .tidy_advice
+            .is_some_and(|advice| advice.notes.is_empty()));
     }
 }

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

@@ -15,9 +15,9 @@ use crate::{
     logger::{end_log_group, start_log_group},
 };
 pub mod clang_format;
-use clang_format::{run_clang_format, FormatAdvice};
+use clang_format::run_clang_format;
 pub mod clang_tidy;
-use clang_tidy::{run_clang_tidy, CompilationDatabase, TidyAdvice};
+use clang_tidy::{run_clang_tidy, CompilationDatabase};
 
 /// Fetch the path to a clang tool by `name` (ie `"clang-tidy"` or `"clang-format"`) and
 /// `version`.
@@ -79,14 +79,14 @@ pub fn get_clang_tool_exe(name: &str, version: &str) -> Result<PathBuf, &'static
 /// If `tidy_checks` is `"-*"` then clang-tidy is not executed.
 /// If `style` is a blank string (`""`), then clang-format is not executed.
 pub fn capture_clang_tools_output(
-    files: &Vec<FileObj>,
+    files: &mut Vec<FileObj>,
     version: &str,
     tidy_checks: &str,
     style: &str,
     lines_changed_only: &LinesChangedOnly,
     database: Option<PathBuf>,
     extra_args: Option<Vec<&str>>,
-) -> (Vec<FormatAdvice>, Vec<TidyAdvice>) {
+) {
     // find the executable paths for clang-tidy and/or clang-format and show version
     // info as debugging output.
     let clang_tidy_command = if tidy_checks != "-*" {
@@ -129,32 +129,29 @@ pub fn capture_clang_tools_output(
     };
 
     // iterate over the discovered files and run the clang tools
-    let mut all_format_advice: Vec<FormatAdvice> = Vec::with_capacity(files.len());
-    let mut all_tidy_advice: Vec<TidyAdvice> = Vec::with_capacity(files.len());
     for file in files {
         start_log_group(format!("Analyzing {}", file.name.to_string_lossy()));
         if let Some(tidy_cmd) = &clang_tidy_command {
-            all_tidy_advice.push(run_clang_tidy(
+            run_clang_tidy(
                 &mut Command::new(tidy_cmd),
                 file,
                 tidy_checks,
                 lines_changed_only,
                 &database,
                 &extra_args,
                 &database_json,
-            ));
+            );
         }
         if let Some(format_cmd) = &clang_format_command {
-            all_format_advice.push(run_clang_format(
+            run_clang_format(
                 &mut Command::new(format_cmd),
                 file,
                 style,
                 lines_changed_only,
-            ));
+            );
         }
         end_log_group();
     }
-    (all_format_advice, all_tidy_advice)
 }
 
 #[cfg(test)]

cpp-linter-lib/src/common_fs.rs

@@ -5,6 +5,8 @@ use std::path::{Component, Path};
 use std::{fs, io};
 use std::{ops::RangeInclusive, path::PathBuf};
 
+use crate::clang_tools::clang_format::FormatAdvice;
+use crate::clang_tools::clang_tidy::TidyAdvice;
 use crate::cli::LinesChangedOnly;
 
 /// A structure to represent a file's path and line changes.
@@ -21,6 +23,12 @@ pub struct FileObj {
 
     /// The list of ranges that span the lines present in diff chunks.
     pub diff_chunks: Vec<RangeInclusive<u32>>,
+
+    /// The collection of clang-format advice for this file.
+    pub format_advice: Option<FormatAdvice>,
+
+    /// The collection of clang-format advice for this file.
+    pub tidy_advice: Option<TidyAdvice>,
 }
 
 impl FileObj {
@@ -33,6 +41,8 @@ impl FileObj {
             added_lines: Vec::<u32>::new(),
             added_ranges: Vec::<RangeInclusive<u32>>::new(),
             diff_chunks: Vec::<RangeInclusive<u32>>::new(),
+            format_advice: None,
+            tidy_advice: None,
         }
     }
 
@@ -48,6 +58,8 @@ impl FileObj {
             added_lines,
             added_ranges,
             diff_chunks,
+            format_advice: None,
+            tidy_advice: None,
         }
     }
 

cpp-linter-lib/src/git.rs

@@ -304,7 +304,7 @@ rename to /tests/demo/some source.cpp
             )
         }
 
-        fn assert_files_eq(files_from_a: &Vec<FileObj>, files_from_b: &Vec<FileObj>) {
+        fn assert_files_eq(files_from_a: &[FileObj], files_from_b: &[FileObj]) {
             assert_eq!(files_from_a.len(), files_from_b.len());
             for (a, b) in files_from_a.iter().zip(files_from_b) {
                 assert_eq!(a.name, b.name);

cpp-linter-lib/src/main.rs

@@ -1,4 +1,4 @@
-///! This crate is the binary executable's entrypoint.
+/// This crate is the binary executable's entrypoint.
 use std::env;
 
 use cpp_linter_lib::run::run_main;