wip fixing filtering

Author: ekump

.github/actions/clippy-annotation-reporter/src/report_generator.rs

@@ -60,33 +60,72 @@ fn add_header(report: &mut String, repository: &str, base_branch: &str, head_bra
 }
 
 /// Add summary table by rule
-/// Add summary table by rule
-fn add_rule_summary(report: &mut String, analysis: &AnalysisResult, rules: &[String], ignored_crate: &str) {
+fn add_rule_summary(
+    report: &mut String,
+    analysis: &AnalysisResult,
+    rules: &[String],
+    ignored_crate: &str,
+) {
     report.push_str("### Summary by Rule\n\n");
     report.push_str("| Rule | Base Branch | PR Branch | Change |\n");
     report.push_str("|------|------------|-----------|--------|\n");
 
     let mut total_base = 0;
     let mut total_head = 0;
 
-    // Use the original counts - these already contain the data we need
-    // We don't need to filter and recalculate for rule summary
-    for rule_str in rules {
-        let rule = Rc::new(rule_str.clone());
-        let base_count = *analysis.base_counts.get(&rule).unwrap_or(&0);
-        let head_count = *analysis.head_counts.get(&rule).unwrap_or(&0);
+    // If we're ignoring a crate, we need to filter and recalculate counts
+    if !ignored_crate.is_empty() {
+        // Filter out annotations from the ignored crate
+        let filtered_base_annotations: Vec<&ClippyAnnotation> = analysis
+            .base_annotations
+            .iter()
+            .filter(|anno| {
+                let file_path = anno.file.as_str();
+                !file_path.contains(&format!(".github/actions/{}/", ignored_crate))
+            })
+            .collect();
+
+        let filtered_head_annotations: Vec<&ClippyAnnotation> = analysis
+            .head_annotations
+            .iter()
+            .filter(|anno| {
+                let file_path = anno.file.as_str();
+                !file_path.contains(&format!(".github/actions/{}/", ignored_crate))
+            })
+            .collect();
+
+        // Count by rule
+        let filtered_base_counts = count_annotations_by_rule_refs(&filtered_base_annotations);
+        let filtered_head_counts = count_annotations_by_rule_refs(&filtered_head_annotations);
+
+        // Generate the rule summary
+        for rule_str in rules {
+            let base_count = filtered_base_counts.get(rule_str).copied().unwrap_or(0);
+            let head_count = filtered_head_counts.get(rule_str).copied().unwrap_or(0);
+
+            total_base += base_count;
+            total_head += head_count;
+
+            add_table_row(report, rule_str, base_count, head_count);
+        }
+    } else {
+        // Use the original counts - this is the test path
+        for rule_str in rules {
+            let rule = Rc::new(rule_str.clone());
+            let base_count = *analysis.base_counts.get(&rule).unwrap_or(&0);
+            let head_count = *analysis.head_counts.get(&rule).unwrap_or(&0);
 
-        total_base += base_count;
-        total_head += head_count;
+            total_base += base_count;
+            total_head += head_count;
 
-        add_table_row(report, rule_str, base_count, head_count);
+            add_table_row(report, rule_str, base_count, head_count);
+        }
     }
 
     // Add total row
     add_table_row(report, "**Total**", total_base, total_head);
     report.push('\n');
 }
-
 // Helper function to count annotations by rule from references
 fn count_annotations_by_rule_refs(annotations: &[&ClippyAnnotation]) -> HashMap<Rc<String>, usize> {
     let mut counts = HashMap::new();