Auto merge of #528 - Zeegomo:md, r=pietroalbini

Add markdown report

Adds markdown report.

Minicrater files for html have changed because json serialization is sorted by key (`ResultName` changes side effect).

Author: bors

src/report/display.rs

@@ -4,6 +4,7 @@ use crate::results::{BrokenReason, FailureReason, TestResult};
 
 pub trait ResultName {
     fn name(&self) -> String;
+    fn long_name(&self) -> String;
 }
 
 impl ResultName for FailureReason {
@@ -17,6 +18,16 @@ impl ResultName for FailureReason {
             FailureReason::DependsOn(_) => "faulty deps".into(),
         }
     }
+
+    fn long_name(&self) -> String {
+        match self {
+            FailureReason::CompilerError(_) | FailureReason::DependsOn(_) => self.to_string(),
+            FailureReason::Unknown
+            | FailureReason::Timeout
+            | FailureReason::OOM
+            | FailureReason::ICE => self.name(),
+        }
+    }
 }
 
 impl ResultName for BrokenReason {
@@ -28,6 +39,10 @@ impl ResultName for BrokenReason {
             BrokenReason::MissingGitRepository => "missing repo".into(),
         }
     }
+
+    fn long_name(&self) -> String {
+        self.name()
+    }
 }
 
 impl ResultName for TestResult {
@@ -42,6 +57,18 @@ impl ResultName for TestResult {
             TestResult::Skipped => "skipped".into(),
         }
     }
+
+    fn long_name(&self) -> String {
+        match self {
+            TestResult::BuildFail(reason) => format!("build {}", reason.long_name()),
+            TestResult::TestFail(reason) => format!("test {}", reason.long_name()),
+            TestResult::BrokenCrate(reason) => reason.long_name(),
+            TestResult::TestSkipped
+            | TestResult::TestPass
+            | TestResult::Error
+            | TestResult::Skipped => self.name(),
+        }
+    }
 }
 
 #[derive(Serialize)]

src/report/html.rs

@@ -5,7 +5,7 @@ use crate::report::{
     analyzer::ReportCrates, archives::Archive, Color, Comparison, CrateResult, ReportWriter,
     ResultColor, ResultName, TestResults,
 };
-use crate::results::{EncodingType, FailureReason, TestResult};
+use crate::results::EncodingType;
 use indexmap::IndexMap;
 
 #[derive(Serialize)]
@@ -170,12 +170,7 @@ fn write_report<W: ReportWriter>(
                         .into_iter()
                         .map(|(res, krates)| {
                             (
-                                if let TestResult::BuildFail(FailureReason::CompilerError(_)) = res
-                                {
-                                    res.to_string()
-                                } else {
-                                    res.name()
-                                },
+                                res.long_name(),
                                 krates
                                     .into_iter()
                                     .map(|result| to_html_crate_result(result))

src/report/markdown.rs

@@ -0,0 +1,219 @@
+use crate::crates::Crate;
+use crate::experiments::Experiment;
+use crate::prelude::*;
+use crate::report::analyzer::{ReportConfig, ReportCrates, ToolchainSelect};
+use crate::report::{
+    crate_to_url, BuildTestResult, Comparison, CrateResult, ReportWriter, ResultName, TestResults,
+};
+use crate::utils::serialize::to_vec;
+use indexmap::{IndexMap, IndexSet};
+use std::fmt::Write;
+
+#[derive(Serialize)]
+enum ReportCratesMD {
+    Plain(Vec<CrateResult>),
+    Complete {
+        // only string keys are allowed in JSON maps
+        #[serde(serialize_with = "to_vec")]
+        res: IndexMap<CrateResult, Vec<CrateResult>>,
+        #[serde(serialize_with = "to_vec")]
+        orphans: IndexMap<Crate, Vec<CrateResult>>,
+    },
+}
+
+#[derive(Serialize)]
+struct ResultsContext<'a> {
+    ex: &'a Experiment,
+    categories: Vec<(Comparison, ReportCratesMD)>,
+    info: IndexMap<Comparison, u32>,
+    full: bool,
+    crates_count: usize,
+}
+
+fn write_crate(
+    mut rendered: &mut String,
+    krate: &CrateResult,
+    comparison: Comparison,
+    is_child: bool,
+) -> Fallible<()> {
+    let get_run_name = |run: &BuildTestResult| {
+        if !is_child {
+            run.res.long_name()
+        } else {
+            run.res.name()
+        }
+    };
+
+    let runs = [
+        krate.runs[0]
+            .as_ref()
+            .map(get_run_name)
+            .unwrap_or_else(|| "unavailable".into()),
+        krate.runs[0]
+            .as_ref()
+            .map(|run| run.log.to_owned())
+            .unwrap_or_else(|| "#".into()),
+        krate.runs[1]
+            .as_ref()
+            .map(get_run_name)
+            .unwrap_or_else(|| "unavailable".into()),
+        krate.runs[1]
+            .as_ref()
+            .map(|run| run.log.to_owned())
+            .unwrap_or_else(|| "#".into()),
+    ];
+
+    let prefix = if is_child { "  * " } else { "* " };
+
+    if let ReportConfig::Complete(toolchain) = comparison.report_config() {
+        let (conj, run) = match toolchain {
+            ToolchainSelect::Start => ("from", 0),
+            ToolchainSelect::End => ("due to", 2),
+        };
+
+        writeln!(
+            &mut rendered,
+            "{}[{}]({}) {} {} **{}** [start]({}/log.txt) | [end]({}/log.txt)",
+            prefix,
+            krate.name,
+            krate.url,
+            comparison.to_string(),
+            conj,
+            runs[run],
+            runs[1],
+            runs[3]
+        )?;
+    } else {
+        writeln!(
+            &mut rendered,
+            "{}[{}]({}) {} [start]({}/log.txt) | [end]({}/log.txt)",
+            prefix,
+            krate.name,
+            krate.url,
+            comparison.to_string(),
+            runs[1],
+            runs[3]
+        )?;
+    };
+
+    Ok(())
+}
+
+fn render_markdown(context: &ResultsContext) -> Fallible<String> {
+    let mut rendered = String::new();
+
+    //add title
+    writeln!(&mut rendered, "# Crater report for {}\n\n", context.ex.name)?;
+
+    for (comparison, results) in context.categories.iter() {
+        writeln!(&mut rendered, "\n### {}", comparison.to_string())?;
+        match results {
+            ReportCratesMD::Plain(crates) => {
+                for krate in crates {
+                    write_crate(&mut rendered, krate, *comparison, false)?;
+                }
+            }
+            ReportCratesMD::Complete { res, orphans } => {
+                for (root, deps) in res {
+                    write_crate(&mut rendered, root, *comparison, false)?;
+                    for krate in deps {
+                        write_crate(&mut rendered, krate, *comparison, true)?;
+                    }
+                }
+
+                for (krate, deps) in orphans {
+                    writeln!(
+                        &mut rendered,
+                        "* [{}]({}) (not covered in crater testing)",
+                        krate,
+                        crate_to_url(&krate)?
+                    )?;
+                    for krate in deps {
+                        write_crate(&mut rendered, krate, *comparison, true)?;
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(rendered)
+}
+
+fn write_report<W: ReportWriter>(
+    ex: &Experiment,
+    crates_count: usize,
+    res: &TestResults,
+    full: bool,
+    to: &str,
+    dest: &W,
+    output_templates: bool,
+) -> Fallible<()> {
+    let categories = res
+        .categories
+        .iter()
+        .filter(|(category, _)| full || category.show_in_summary())
+        .map(|(&category, crates)| (category, crates.to_owned()))
+        .map(|(category, crates)| match crates {
+            ReportCrates::Plain(crates) => (
+                category,
+                ReportCratesMD::Plain(crates.into_iter().collect::<Vec<_>>()),
+            ),
+            ReportCrates::Complete { mut tree, results } => {
+                let res = results
+                    .into_iter()
+                    .flat_map(|(_key, values)| values.into_iter())
+                    .collect::<IndexSet<_>>() // remove duplicates
+                    .into_iter()
+                    .map(|krate| {
+                        // done here to avoid cloning krate
+                        let deps = tree.remove(&krate.krate).unwrap_or_default();
+                        (krate, deps)
+                    })
+                    .collect::<IndexMap<_, _>>();
+
+                (category, ReportCratesMD::Complete { res, orphans: tree })
+            }
+        })
+        .collect();
+
+    let context = ResultsContext {
+        ex,
+        categories,
+        info: res.info.clone(),
+        full,
+        crates_count,
+    };
+
+    let markdown = render_markdown(&context)?;
+    info!("generating {}", to);
+    dest.write_string(to, markdown.into(), &mime::TEXT_PLAIN)?;
+
+    if output_templates {
+        dest.write_string(
+            [to, ".context.json"].concat(),
+            serde_json::to_string(&context)?.into(),
+            &mime::TEXT_PLAIN,
+        )?;
+    }
+
+    Ok(())
+}
+
+pub fn write_markdown_report<W: ReportWriter>(
+    ex: &Experiment,
+    crates_count: usize,
+    res: &TestResults,
+    dest: &W,
+    output_templates: bool,
+) -> Fallible<()> {
+    write_report(
+        ex,
+        crates_count,
+        res,
+        false,
+        "markdown.md",
+        dest,
+        output_templates,
+    )?;
+    Ok(())
+}

src/report/mod.rs

@@ -23,6 +23,7 @@ mod analyzer;
 mod archives;
 mod display;
 mod html;
+mod markdown;
 mod s3;
 
 pub use self::display::{Color, ResultColor, ResultName};
@@ -46,8 +47,8 @@ pub struct RawTestResults {
     pub crates: Vec<CrateResult>,
 }
 
-#[cfg_attr(test, derive(Debug, PartialEq))]
-#[derive(Serialize, Deserialize, Clone)]
+#[cfg_attr(test, derive(Debug))]
+#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
 pub struct CrateResult {
     name: String,
     url: String,
@@ -107,8 +108,8 @@ impl Comparison {
     }
 }
 
-#[cfg_attr(test, derive(Debug, PartialEq))]
-#[derive(Serialize, Deserialize, Clone)]
+#[cfg_attr(test, derive(Debug))]
+#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
 struct BuildTestResult {
     res: TestResult,
     log: String,
@@ -309,6 +310,8 @@ pub fn gen<DB: ReadResults, W: ReportWriter + Display>(
         dest,
         output_templates,
     )?;
+    info!("writing markdown files");
+    markdown::write_markdown_report(ex, crates.len(), &res, dest, output_templates)?;
     info!("writing logs");
     write_logs(db, ex, crates, dest, config)?;
 

src/utils/mod.rs

@@ -10,6 +10,7 @@ pub(crate) mod http;
 #[macro_use]
 mod macros;
 pub(crate) mod path;
+pub(crate) mod serialize;
 pub mod size;
 pub(crate) mod string;
 

src/utils/serialize.rs

@@ -0,0 +1,17 @@
+use serde::ser::{Serialize, SerializeSeq, Serializer};
+use std::iter::IntoIterator;
+
+pub fn to_vec<S, T>(data: T, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: IntoIterator,
+    T::Item: Serialize,
+    T::IntoIter: std::iter::ExactSizeIterator,
+{
+    let data = IntoIterator::into_iter(data);
+    let mut seq = serializer.serialize_seq(Some(data.len()))?;
+    for element in data {
+        seq.serialize_element(&element)?;
+    }
+    seq.end()
+}

templates/report/downloads.html

@@ -43,6 +43,10 @@
                 <a href="retry-regressed-list.txt">Regressed crates as list</a>
                 <span><a href="retry-regressed-list.txt">Download</a></span>
             </div>
+            <div class="crate">
+                <a href="markdown.md">Markdown report</a>
+                <span><a href="markdown.md">Download</a></span>
+            </div>
         </div>
     </div>
 {% endblock %}

tests/minicrater/blacklist/markdown.md.context.expected.json

@@ -0,0 +1,10 @@
+{
+  "categories": [],
+  "crates_count": 3,
+  "full": false,
+  "info": {
+    "skipped": 1,
+    "test-pass": 1,
+    "test-skipped": 1
+  }
+}

tests/minicrater/clippy/full.html.context.expected.json

@@ -37,7 +37,7 @@
         "RootResults": {
           "count": 1,
           "results": {
-            "build-fail:compiler-error(clippy::print_with_newline)": [
+            "build compiler-error(clippy::print_with_newline)": [
               {
                 "name": "clippy-warn (local)",
                 "res": "regressed",