Merge pull request #51 from a-kenji/ke-group-rules

report: Group failure logs by rule

Author: a-kenji

src/output.rs

@@ -3,6 +3,7 @@ use crate::error::Result;
 use crate::rules::{Severity, Violation};
 use colored::*;
 use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
 use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 use std::time::Duration;
@@ -109,31 +110,54 @@ impl OutputFormatter {
         elapsed: Duration,
     ) -> Result<()> {
         let mut stdout = io::stdout();
+        let gutter = "┃".dimmed();
 
-        for violation in violations {
-            let severity_icon = match violation.severity {
-                Severity::Error => "✗".red().bold(),
-                Severity::Warning => "⚠".yellow().bold(),
-            };
-            let path_str = self.relative_path(&violation.path);
-            let rule_info = format!(
-                "[{}:{}]",
-                violation.rule_name,
-                match violation.severity {
-                    Severity::Error => "error",
-                    Severity::Warning => "warning",
-                }
-            )
-            .dimmed();
+        let mut by_rule: BTreeMap<&str, Vec<&Violation>> = BTreeMap::new();
+        for v in violations {
+            by_rule.entry(&v.rule_name).or_default().push(v);
+        }
 
-            writeln!(
-                stdout,
-                "{} {}: {} {}",
-                severity_icon,
-                path_str.bold(),
-                violation.message,
-                rule_info
-            )?;
+        for (rule_name, rule_violations) in &by_rule {
+            writeln!(stdout, "{}", rule_name.bold())?;
+            writeln!(stdout, "{gutter}")?;
+
+            let mut errors: Vec<&Violation> = Vec::new();
+            let mut warnings: Vec<&Violation> = Vec::new();
+            for v in rule_violations {
+                match v.severity {
+                    Severity::Error => errors.push(v),
+                    Severity::Warning => warnings.push(v),
+                }
+            }
+            errors.sort_by(|a, b| b.sort_key.cmp(&a.sort_key));
+            warnings.sort_by(|a, b| b.sort_key.cmp(&a.sort_key));
+
+            for (severity_group, marker, color_fn) in [
+                (
+                    &errors,
+                    "[E]",
+                    ColoredString::red as fn(ColoredString) -> ColoredString,
+                ),
+                (&warnings, "[W]", ColoredString::yellow),
+            ] {
+                if severity_group.is_empty() {
+                    continue;
+                }
+                let message = &severity_group[0].message;
+                writeln!(stdout, "{gutter} {} {}", color_fn(marker.bold()), message)?;
+                for v in severity_group {
+                    let path_str = self.relative_path(&v.path);
+                    match &v.actual_value {
+                        Some(actual) => {
+                            writeln!(stdout, "{gutter}     {} ({})", path_str.bold(), actual)?;
+                        }
+                        None => {
+                            writeln!(stdout, "{gutter}     {}", path_str.bold())?;
+                        }
+                    }
+                }
+            }
+            writeln!(stdout)?;
         }
 
         if !self.quiet {

src/rules/mod.rs

@@ -42,6 +42,7 @@ pub struct Violation {
     pub severity: Severity,
     pub actual_value: Option<String>,
     pub expected_value: Option<String>,
+    pub sort_key: u64,
 }
 
 impl Violation {
@@ -58,6 +59,7 @@ impl Violation {
             severity,
             actual_value: None,
             expected_value: None,
+            sort_key: 0,
         }
     }
 
@@ -71,6 +73,11 @@ impl Violation {
         self
     }
 
+    pub fn with_sort_key(mut self, key: u64) -> Self {
+        self.sort_key = key;
+        self
+    }
+
     pub fn diagnostic_code(&self) -> String {
         format!(
             "sizelint::{}::{}",
@@ -444,14 +451,14 @@ impl Rule for ConfigurableRule {
                     path.to_path_buf(),
                     self.name.clone(),
                     format!(
-                        "File size {} exceeds maximum allowed size {}",
-                        format_size(file_size),
+                        "File exceeds maximum allowed size {}",
                         format_size(max_size)
                     ),
                     Severity::Error,
                 )
                 .with_actual_value(format_size(file_size))
-                .with_expected_value(format!("≤ {}", format_size(max_size))),
+                .with_expected_value(format!("≤ {}", format_size(max_size)))
+                .with_sort_key(file_size),
             );
             return Ok(violations);
         }
@@ -464,15 +471,12 @@ impl Rule for ConfigurableRule {
                 Violation::new(
                     path.to_path_buf(),
                     self.name.clone(),
-                    format!(
-                        "File size {} exceeds warning threshold {}",
-                        format_size(file_size),
-                        format_size(warn_size)
-                    ),
+                    format!("File exceeds warning threshold {}", format_size(warn_size)),
                     Severity::Warning,
                 )
                 .with_actual_value(format_size(file_size))
-                .with_expected_value(format!("≤ {}", format_size(warn_size))),
+                .with_expected_value(format!("≤ {}", format_size(warn_size)))
+                .with_sort_key(file_size),
             );
         }