Auto merge of #529 - Zeegomo:check-crates-version, r=pietroalbini

Check crates version

Checks if a crate has been updated before report creation

Author: bors

src/report/html.rs

@@ -84,6 +84,8 @@ struct CrateResultHTML {
     name: String,
     url: String,
     res: Comparison,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    status: Option<String>,
     runs: [Option<BuildTestResultHTML>; 2],
 }
 
@@ -130,6 +132,7 @@ fn write_report<W: ReportWriter>(
         CrateResultHTML {
             name: result.name.clone(),
             url: result.url.clone(),
+            status: result.status.map(|status| status.to_string()),
             res: result.res,
             runs,
         }

src/report/markdown.rs

@@ -64,6 +64,10 @@ fn write_crate(
     ];
 
     let prefix = if is_child { "  * " } else { "* " };
+    let status_warning = krate
+        .status
+        .map(|status| format!(" ({})", status.to_string()))
+        .unwrap_or_default();
 
     if let ReportConfig::Complete(toolchain) = comparison.report_config() {
         let (conj, run) = match toolchain {
@@ -73,9 +77,10 @@ fn write_crate(
 
         writeln!(
             &mut rendered,
-            "{}[{}]({}) {} {} **{}** [start]({}/log.txt) | [end]({}/log.txt)",
+            "{}[{}{}]({}) {} {} **{}** [start]({}/log.txt) | [end]({}/log.txt)",
             prefix,
             krate.name,
+            status_warning,
             krate.url,
             comparison.to_string(),
             conj,
@@ -86,9 +91,10 @@ fn write_crate(
     } else {
         writeln!(
             &mut rendered,
-            "{}[{}]({}) {} [start]({}/log.txt) | [end]({}/log.txt)",
+            "{}[{}{}]({}) {} [start]({}/log.txt) | [end]({}/log.txt)",
             prefix,
             krate.name,
+            status_warning,
             krate.url,
             comparison.to_string(),
             runs[1],

src/report/mod.rs

@@ -1,11 +1,13 @@
 use crate::config::Config;
 use crate::crates::Crate;
+use crate::dirs::WORK_DIR;
 use crate::experiments::Experiment;
 use crate::prelude::*;
 use crate::report::analyzer::{analyze_report, ReportConfig, ToolchainSelect};
 use crate::results::{EncodedLog, EncodingType, FailureReason, ReadResults, TestResult};
 use crate::toolchain::Toolchain;
 use crate::utils;
+use crates_index::Index;
 use mime::{self, Mime};
 use percent_encoding::{utf8_percent_encode, AsciiSet};
 use std::borrow::Cow;
@@ -53,10 +55,19 @@ pub struct CrateResult {
     name: String,
     url: String,
     krate: Crate,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    status: Option<CrateVersionStatus>,
     pub res: Comparison,
     runs: [Option<BuildTestResult>; 2],
 }
 
+string_enum!(enum CrateVersionStatus {
+    Yanked => "yanked",
+    Outdated => "outdated",
+    UpToDate => "",
+    MissingFromIndex => "missing from the index",
+});
+
 string_enum!(pub enum Comparison {
     Regressed => "regressed",
     Fixed => "fixed",
@@ -172,13 +183,42 @@ fn crate_to_path_fragment(
     path
 }
 
+fn get_crate_version_status(index: &Index, krate: &Crate) -> Fallible<Option<CrateVersionStatus>> {
+    if let Crate::Registry(krate) = krate {
+        let index_krate = index
+            .crate_(&krate.name)
+            .ok_or_else(|| err_msg(format!("no crate found in index {:?}", &krate)))?;
+
+        let outdated = index_krate.latest_version().version() != krate.version;
+
+        for version in index_krate.versions().iter().rev() {
+            // Check if the tested version is yanked
+            if version.version() == krate.version {
+                if version.is_yanked() {
+                    return Ok(Some(CrateVersionStatus::Yanked));
+                } else if outdated {
+                    return Ok(Some(CrateVersionStatus::Outdated));
+                } else {
+                    return Ok(Some(CrateVersionStatus::UpToDate));
+                }
+            }
+        }
+
+        bail!("version not found");
+    } else {
+        // we do not check versions for other crates
+        Ok(None)
+    }
+}
+
 pub fn generate_report<DB: ReadResults>(
     db: &DB,
     config: &Config,
     ex: &Experiment,
     crates: &[Crate],
 ) -> Fallible<RawTestResults> {
     let mut crates = crates.to_vec();
+    let index = Index::new(WORK_DIR.join("crates.io-index"));
     //crate ids are unique so unstable sort is equivalent to stable sort but is generally faster
     crates.sort_unstable_by(|a, b| a.id().cmp(&b.id()));
     let res = crates
@@ -212,6 +252,8 @@ pub fn generate_report<DB: ReadResults>(
             Ok(CrateResult {
                 name: crate_to_name(&krate)?,
                 url: crate_to_url(&krate)?,
+                status: get_crate_version_status(&index, &krate)
+                    .unwrap_or(Some(CrateVersionStatus::MissingFromIndex)),
                 krate: krate.clone(),
                 res: comp,
                 runs: [crate1, crate2],
@@ -584,9 +626,11 @@ mod tests {
     use super::*;
     use crate::config::{Config, CrateConfig};
     use crate::crates::{Crate, GitHubRepo, RegistryCrate};
+    use crate::dirs::WORK_DIR;
     use crate::experiments::{CapLints, Experiment, Mode, Status};
     use crate::results::{BrokenReason, DummyDB, FailureReason, TestResult};
     use crate::toolchain::{MAIN_TOOLCHAIN, TEST_TOOLCHAIN};
+    use crates_index::Index;
 
     #[test]
     fn test_crate_to_path_fragment() {
@@ -652,6 +696,39 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_crate_version_status() {
+        let reg = Crate::Registry(RegistryCrate {
+            name: "lazy_static".into(),
+            version: "0.1.0".into(),
+        });
+
+        let yanked = Crate::Registry(RegistryCrate {
+            name: "structopt".into(),
+            version: "0.3.6".into(),
+        });
+
+        let repo = GitHubRepo {
+            org: "brson".into(),
+            name: "hello-rs".into(),
+            sha: None,
+        };
+        let gh = Crate::GitHub(repo.clone());
+
+        let index = Index::new(WORK_DIR.join("crates.io-index"));
+        index.retrieve_or_update().unwrap();
+
+        assert_eq!(
+            get_crate_version_status(&index, &reg).unwrap().unwrap(),
+            CrateVersionStatus::Outdated
+        );
+        assert_eq!(
+            get_crate_version_status(&index, &yanked).unwrap().unwrap(),
+            CrateVersionStatus::Yanked
+        );
+        assert!(get_crate_version_status(&index, &gh).unwrap().is_none());
+    }
+
     #[test]
     fn test_crate_to_url() {
         let reg = Crate::Registry(RegistryCrate {

templates/macros.html

@@ -22,7 +22,9 @@
 
 {% macro crate_div(crate) %}
     <div class="crate">
-        <a href="{{ crate.url|safe }}" target="_blank" rel="noopener">{{ crate.name }}</a>
+        <a href="{{ crate.url|safe }}" target="_blank" rel="noopener">
+            {{ crate.name }} {% if crate.status %} ({{ crate.status }}) {% endif %}
+        </a>
         {% for run in crate.runs %}
             <span class="run">
                 {% if run %}