Tidy up results handling

Author: simoncozens

fontspector-checkapi/src/status.rs

@@ -1,7 +1,9 @@
 use clap::ArgEnum;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, PartialEq, PartialOrd, Ord, Eq, Copy, Clone, ArgEnum, Serialize, Deserialize)]
+#[derive(
+    Debug, PartialEq, PartialOrd, Ord, Eq, Copy, Clone, ArgEnum, Serialize, Deserialize, Hash,
+)]
 pub enum StatusCode {
     Skip,
     Info,

fontspector-cli/src/main.rs

@@ -4,17 +4,17 @@
 mod args;
 mod reporters;
 
-use crate::reporters::terminal::TerminalReporter;
-pub use args::Args;
+use args::Args;
 use clap::Parser;
-use fontspector_checkapi::{Check, CheckResult, Context, Plugin, Registry, StatusCode, Testable};
+use fontspector_checkapi::{Check, Context, Plugin, Registry, Testable};
 use indicatif::ParallelProgressIterator;
 use profile_googlefonts::GoogleFonts;
 use profile_universal::Universal;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
-use reporters::Reporter;
+use reporters::{
+    organize, summary_results, terminal::TerminalReporter, worst_status, Reporter, RunResults,
+};
 use serde_json::Map;
-use std::collections::HashMap;
 
 /// Filter out checks that don't apply
 fn included_excluded(checkname: &str, args: &Args) -> bool {
@@ -124,39 +124,38 @@ fn main() {
         })
         .collect();
 
-    println!("Testing...");
-    let results: Vec<_> = checkorder
+    if !args.quiet {
+        println!(
+            "Running {:} check{} on {:} file{}",
+            checkorder.len(),
+            if checkorder.len() == 1 { "" } else { "s" },
+            testables.len(),
+            if testables.len() == 1 { "" } else { "s" }
+        );
+    }
+
+    let results: RunResults = checkorder
         .par_iter()
         .progress()
         .map(|(sectionname, testable, check, context)| {
             (sectionname, testable, check.run_one(testable, context))
         })
         .collect();
 
-    let worst_status = results
-        .iter()
-        .map(|(_sectionname, _testable, checkresults)| {
-            checkresults
-                .iter()
-                .map(|r| r.status.code)
-                .max()
-                .unwrap_or(StatusCode::Pass)
-        })
-        .max()
-        .unwrap_or(StatusCode::Pass);
+    let worst_status = worst_status(&results);
 
     // Organise results by testable and sectionname
-    let mut organised_results: HashMap<&Testable, HashMap<String, Vec<CheckResult>>> =
-        HashMap::new();
-    for (sectionname, testable, checkresults) in results {
-        // let filename = testable.filename.clone();
-        let section = organised_results.entry(testable).or_default();
-        let results = section.entry(sectionname.clone()).or_default();
-        results.extend(checkresults);
-    }
+    let organised_results = organize(results);
 
     if !args.quiet {
         TerminalReporter {}.report(&organised_results, &args, &registry);
+        // Summary report
+        let summary = summary_results(organised_results);
+        print!("\nSummary:\n  ");
+        for (status, count) in summary.iter() {
+            print!("{:}: {:}  ", status, count);
+        }
+        println!();
     }
     if worst_status >= args.error_code_on {
         std::process::exit(1);

fontspector-cli/src/reporters/mod.rs

@@ -1,14 +1,52 @@
 use crate::Args;
-use fontspector_checkapi::{CheckResult, Registry, Testable};
+use fontspector_checkapi::{CheckResult, Registry, StatusCode, Testable};
 use std::collections::HashMap;
 
 pub(crate) mod terminal;
 
+pub type RunResults<'a> = Vec<(&'a String, &'a &'a Testable, Vec<CheckResult>)>;
+
+pub fn worst_status(results: &RunResults) -> StatusCode {
+    results
+        .iter()
+        .map(|(_sectionname, _testable, checkresults)| {
+            checkresults
+                .iter()
+                .map(|r| r.status.code)
+                .max()
+                .unwrap_or(StatusCode::Pass)
+        })
+        .max()
+        .unwrap_or(StatusCode::Pass)
+}
+
+pub type OrganisedResults<'a> = HashMap<&'a Testable, HashMap<String, Vec<CheckResult>>>;
+
+/// Organize the results by testable and section
+pub fn organize(results: RunResults) -> OrganisedResults {
+    let mut organised_results: OrganisedResults = HashMap::new();
+    for (sectionname, testable, checkresults) in results {
+        // let filename = testable.filename.clone();
+        let section = organised_results.entry(testable).or_default();
+        let results = section.entry(sectionname.clone()).or_default();
+        results.extend(checkresults);
+    }
+    organised_results
+}
+
+pub fn summary_results(organised_results: OrganisedResults) -> HashMap<StatusCode, i32> {
+    let mut summary = HashMap::new();
+    for (_testable, sectionresults) in organised_results.iter() {
+        for (_sectionname, results) in sectionresults.iter() {
+            for result in results.iter() {
+                let entry = summary.entry(result.status.code).or_insert(0);
+                *entry += 1;
+            }
+        }
+    }
+    summary
+}
+
 pub trait Reporter {
-    fn report(
-        &self,
-        organised_results: &HashMap<&Testable, HashMap<String, Vec<CheckResult>>>,
-        args: &Args,
-        registry: &Registry,
-    );
+    fn report(&self, organised_results: &OrganisedResults, args: &Args, registry: &Registry);
 }