display tree and results in report for selected comparisons

Author: zeegomo

assets/report.css

@@ -149,6 +149,12 @@ div.category div.header.header-background {
     background: #292929;
 }
 
+
+div.category div.subheader.header {
+    margin: 10px;
+    top: 2em;
+}
+
 div.category div.crate {
     display: flex;
     padding: 0.8em;

src/report/analyzer.rs

@@ -0,0 +1,95 @@
+use super::{Comparison, CrateResult, RawTestResults};
+use crate::crates::Crate;
+use crate::results::{
+    FailureReason,
+    TestResult::{self, BuildFail},
+};
+use std::collections::BTreeSet;
+use std::collections::HashMap;
+
+#[derive(PartialEq)]
+pub enum ReportConfig {
+    Simple,
+    Complete { toolchain: usize },
+}
+
+#[derive(Clone)]
+pub enum ReportCrates {
+    Plain(Vec<CrateResult>),
+    Complete {
+        tree: HashMap<Crate, Vec<CrateResult>>,
+        results: HashMap<TestResult, Vec<CrateResult>>,
+    },
+}
+
+pub struct TestResults {
+    pub categories: HashMap<Comparison, ReportCrates>,
+    pub info: HashMap<Comparison, u32>,
+}
+
+fn analyze_detailed(toolchain: usize, crates: Vec<CrateResult>) -> ReportCrates {
+    let mut tree = HashMap::new();
+    let mut results = HashMap::new();
+
+    let mut root = Vec::new();
+    for krate in crates {
+        if let BuildFail(FailureReason::DependsOn(ref deps)) =
+            (&krate.runs[toolchain]).as_ref().unwrap().res
+        {
+            for dep in deps {
+                tree.entry(dep.clone())
+                    .or_insert_with(Vec::new)
+                    .push(krate.clone())
+            }
+        } else {
+            root.push(krate);
+        }
+    }
+
+    for krate in root {
+        // record results only for root crates
+        if let BuildFail(FailureReason::CompilerError(codes)) =
+            krate.runs[toolchain].clone().unwrap().res
+        {
+            for code in codes {
+                results
+                    .entry(BuildFail(FailureReason::CompilerError(btreeset![code])))
+                    .or_insert_with(Vec::new)
+                    .push(krate.clone())
+            }
+        } else {
+            results
+                .entry(krate.runs[toolchain].as_ref().unwrap().res.clone())
+                .or_insert_with(Vec::new)
+                .push(krate)
+        }
+    }
+
+    ReportCrates::Complete { tree, results }
+}
+
+pub fn analyze_report(test: RawTestResults) -> TestResults {
+    let mut comparison = HashMap::new();
+    for krate in test.crates {
+        comparison
+            .entry(krate.res)
+            .or_insert_with(Vec::new)
+            .push(krate);
+    }
+
+    let info = comparison
+        .iter()
+        .map(|(&key, vec)| (key, vec.len() as u32))
+        .collect::<HashMap<_, _>>();
+
+    let mut categories = HashMap::new();
+    for (cat, crates) in comparison {
+        if let ReportConfig::Complete { toolchain } = cat.report_config() {
+            categories.insert(cat, analyze_detailed(toolchain, crates));
+        } else {
+            categories.insert(cat, ReportCrates::Plain(crates));
+        }
+    }
+
+    TestResults { categories, info }
+}

src/report/html.rs

@@ -2,9 +2,10 @@ use crate::assets;
 use crate::experiments::Experiment;
 use crate::prelude::*;
 use crate::report::{
-    archives::Archive, Color, Comparison, ReportWriter, ResultColor, ResultName, TestResults,
+    analyzer::ReportCrates, archives::Archive, Color, Comparison, CrateResult, ReportWriter,
+    ResultColor, ResultName, TestResults,
 };
-use crate::results::EncodingType;
+use crate::results::{EncodingType, FailureReason, TestResult};
 use std::collections::HashMap;
 
 #[derive(Serialize)]
@@ -21,6 +22,19 @@ enum CurrentPage {
     Downloads,
 }
 
+#[derive(Serialize)]
+enum ReportCratesHTML {
+    Plain(Vec<CrateResultHTML>),
+    Tree {
+        count: u32,
+        tree: HashMap<String, Vec<CrateResultHTML>>,
+    },
+    RootResults {
+        count: u32,
+        results: HashMap<String, Vec<CrateResultHTML>>,
+    },
+}
+
 impl CurrentPage {
     fn navbar(&self) -> Vec<NavbarItem> {
         vec![
@@ -47,7 +61,8 @@ impl CurrentPage {
 struct ResultsContext<'a> {
     ex: &'a Experiment,
     nav: Vec<NavbarItem>,
-    categories: HashMap<Comparison, Vec<CrateResultHTML>>,
+    categories: Vec<(Comparison, ReportCratesHTML)>,
+    info: HashMap<Comparison, u32>,
     full: bool,
     crates_count: usize,
 
@@ -93,43 +108,103 @@ fn write_report<W: ReportWriter>(
     let mut result_colors = Vec::new();
     let mut result_names = Vec::new();
 
-    let mut categories = HashMap::new();
-    for result in &res.crates {
-        // Skip some categories if this is not the full report
-        if !full && !result.res.show_in_summary() {
-            continue;
-        }
-
-        // Add the colors and names used in this run
-        comparison_colors
-            .entry(result.res)
-            .or_insert_with(|| result.res.color());
-
+    let mut to_html_crate_result = |result: CrateResult| {
         let mut runs = [None, None];
 
         for (pos, run) in result.runs.iter().enumerate() {
             if let Some(ref run) = run {
-                let idx = test_results_to_int.entry(&run.res).or_insert_with(|| {
-                    result_colors.push(run.res.color());
-                    result_names.push(run.res.name());
-                    result_names.len() - 1
-                });
+                let idx = test_results_to_int
+                    .entry(run.res.clone())
+                    .or_insert_with(|| {
+                        result_colors.push(run.res.color());
+                        result_names.push(run.res.name());
+                        result_names.len() - 1
+                    });
                 runs[pos] = Some(BuildTestResultHTML {
                     res: *idx as usize,
                     log: run.log.clone(),
                 });
             }
         }
 
-        let category = categories.entry(result.res).or_insert_with(Vec::new);
-        let result = CrateResultHTML {
+        CrateResultHTML {
             name: result.name.clone(),
             url: result.url.clone(),
             res: result.res,
             runs,
-        };
-        category.push(result);
-    }
+        }
+    };
+
+    let categories = res
+        .categories
+        .iter()
+        .filter(|(category, _)| full || category.show_in_summary())
+        .map(|(&category, crates)| (category, crates.to_owned()))
+        .flat_map(|(category, crates)| {
+            comparison_colors.insert(category, category.color());
+
+            match crates {
+                ReportCrates::Plain(crates) => vec![(
+                    category,
+                    ReportCratesHTML::Plain(
+                        crates
+                            .into_iter()
+                            .map(|result| to_html_crate_result(result))
+                            .collect::<Vec<_>>(),
+                    ),
+                )]
+                .into_iter(),
+                ReportCrates::Complete { tree, results } => {
+                    let tree = tree
+                        .into_iter()
+                        .map(|(root, deps)| {
+                            (
+                                root.to_string(),
+                                deps.into_iter()
+                                    .map(|result| to_html_crate_result(result))
+                                    .collect::<Vec<_>>(),
+                            )
+                        })
+                        .collect::<HashMap<_, _>>();
+                    let results = results
+                        .into_iter()
+                        .map(|(res, krates)| {
+                            (
+                                if let TestResult::BuildFail(FailureReason::CompilerError(_)) = res
+                                {
+                                    res.to_string()
+                                } else {
+                                    res.name()
+                                },
+                                krates
+                                    .into_iter()
+                                    .map(|result| to_html_crate_result(result))
+                                    .collect::<Vec<_>>(),
+                            )
+                        })
+                        .collect::<HashMap<_, _>>();
+
+                    vec![
+                        (
+                            category,
+                            ReportCratesHTML::Tree {
+                                count: tree.keys().len() as u32,
+                                tree,
+                            },
+                        ),
+                        (
+                            category,
+                            ReportCratesHTML::RootResults {
+                                count: results.keys().len() as u32,
+                                results,
+                            },
+                        ),
+                    ]
+                    .into_iter()
+                }
+            }
+        })
+        .collect();
 
     let context = ResultsContext {
         ex,
@@ -140,6 +215,7 @@ fn write_report<W: ReportWriter>(
         }
         .navbar(),
         categories,
+        info: res.info.clone(),
         full,
         crates_count,
         comparison_colors,