library: return required update for each crate

src/check_release.rs

@@ -10,7 +10,7 @@ use trustfall_rustdoc::{VersionedCrate, VersionedIndexedCrate, VersionedRustdocA
 
 use crate::{
     query::{ActualSemverUpdate, RequiredSemverUpdate, SemverQuery},
-    GlobalConfig, ReleaseType,
+    CrateReport, GlobalConfig, ReleaseType,
 };
 
 type QueryResultItem = BTreeMap<Arc<str>, FieldValue>;
@@ -84,7 +84,7 @@ pub(super) fn run_check_release(
     current_crate: VersionedCrate,
     baseline_crate: VersionedCrate,
     release_type: Option<ReleaseType>,
-) -> anyhow::Result<bool> {
+) -> anyhow::Result<CrateReport> {
     let current_version = current_crate.crate_version();
     let baseline_version = baseline_crate.crate_version();
 
@@ -315,7 +315,7 @@ pub(super) fn run_check_release(
                     let message = config
                         .handlebars()
                         .render_template(template, &pretty_result)
-                        .with_context(|| "Error instantiating semver query template.")
+                        .context("Error instantiating semver query template.")
                         .expect("could not materialize template");
                     colored_ln(config.stdout(), |w| colored!(w, "  {}", message,))
                         .expect("print failed");
@@ -349,9 +349,9 @@ pub(super) fn run_check_release(
         }
 
         let required_bump = if required_versions.contains(&RequiredSemverUpdate::Major) {
-            "major"
+            RequiredSemverUpdate::Major
         } else if required_versions.contains(&RequiredSemverUpdate::Minor) {
-            "minor"
+            RequiredSemverUpdate::Minor
         } else {
             unreachable!("{:?}", required_versions)
         };
@@ -362,7 +362,7 @@ pub(super) fn run_check_release(
                 format_args!(
                     "[{:>8.3}s] semver requires new {} version: {} major and {} minor checks failed",
                     total_duration.as_secs_f32(),
-                    required_bump,
+                    required_bump.as_str(),
                     required_versions.iter().filter(|x| *x == &RequiredSemverUpdate::Major).count(),
                     required_versions.iter().filter(|x| *x == &RequiredSemverUpdate::Minor).count(),
                 ),
@@ -371,7 +371,10 @@ pub(super) fn run_check_release(
             )
             .expect("print failed");
 
-        Ok(false)
+        Ok(CrateReport {
+            required_bump: Some(required_bump.into()),
+            detected_bump: version_change,
+        })
     } else {
         config
             .shell_print(
@@ -387,7 +390,10 @@ pub(super) fn run_check_release(
                 true,
             )
             .expect("print failed");
-        Ok(true)
+        Ok(CrateReport {
+            detected_bump: version_change,
+            required_bump: None,
+        })
     }
 }
 

src/lib.rs

@@ -17,14 +17,13 @@ use directories::ProjectDirs;
 use check_release::run_check_release;
 use trustfall_rustdoc::{load_rustdoc, VersionedCrate};
 
-use itertools::Itertools;
 use rustdoc_cmd::RustdocCommand;
 use semver::Version;
-use std::collections::HashSet;
+use std::collections::{BTreeMap, HashSet};
 use std::path::{Path, PathBuf};
 
 pub use config::GlobalConfig;
-pub use query::{RequiredSemverUpdate, SemverQuery};
+pub use query::{ActualSemverUpdate, RequiredSemverUpdate, SemverQuery};
 
 /// Test a release for semver violations.
 #[non_exhaustive]
@@ -320,7 +319,12 @@ impl Check {
         let current_loader = self.get_rustdoc_generator(&mut config, &self.current.source)?;
         let baseline_loader = self.get_rustdoc_generator(&mut config, &self.baseline.source)?;
 
-        let all_outcomes: Vec<anyhow::Result<bool>> = match &self.current.source {
+        // Create a report for each crate.
+        // We want to run all the checks, even if one returns `Err`.
+        let all_outcomes: Vec<anyhow::Result<(String, Option<CrateReport>)>> = match &self
+            .current
+            .source
+        {
             RustdocSource::Rustdoc(_)
             | RustdocSource::Revision(_, _)
             | RustdocSource::VersionFromRegistry(_) => {
@@ -337,26 +341,26 @@ impl Check {
                     ScopeMode::AllowList(lst) => lst.clone(),
                 };
                 names
-                    .iter()
+                    .into_iter()
                     .map(|name| {
                         let version = None;
                         let (current_crate, baseline_crate) = generate_versioned_crates(
                             &mut config,
                             &rustdoc_cmd,
                             &*current_loader,
                             &*baseline_loader,
-                            name,
+                            &name,
                             version,
                         )?;
 
-                        let success = run_check_release(
+                        let report = run_check_release(
                             &mut config,
-                            name,
+                            &name,
                             current_crate,
                             baseline_crate,
                             self.release_type,
                         )?;
-                        Ok(success)
+                        Ok((name, Some(report)))
                     })
                     .collect()
             }
@@ -383,7 +387,7 @@ impl Check {
                                     format_args!("{crate_name} v{version} (current)"),
                                 )
                             })?;
-                            Ok(true)
+                            Ok((crate_name.clone(), None))
                         } else {
                             let (current_crate, baseline_crate) = generate_versioned_crates(
                                 &mut config,
@@ -394,35 +398,98 @@ impl Check {
                                 Some(version),
                             )?;
 
-                            Ok(run_check_release(
-                                &mut config,
-                                crate_name,
-                                current_crate,
-                                baseline_crate,
-                                self.release_type,
-                            )?)
+                            Ok((
+                                crate_name.clone(),
+                                Some(run_check_release(
+                                    &mut config,
+                                    crate_name,
+                                    current_crate,
+                                    baseline_crate,
+                                    self.release_type,
+                                )?),
+                            ))
                         }
                     })
                     .collect()
             }
         };
-        let success = all_outcomes
-            .into_iter()
-            .fold_ok(true, std::ops::BitAnd::bitand)?;
+        let crate_reports: BTreeMap<String, CrateReport> = {
+            let mut reports = BTreeMap::new();
+            for outcome in all_outcomes {
+                let (name, outcome) = outcome?;
+                if let Some(outcome) = outcome {
+                    reports.insert(name, outcome);
+                }
+            }
+            reports
+        };
 
-        Ok(Report { success })
+        Ok(Report { crate_reports })
     }
 }
 
+/// Report of semver check of one crate.
+#[non_exhaustive]
+#[derive(Debug)]
+pub struct CrateReport {
+    /// Bump between the current version and the baseline one.
+    detected_bump: ActualSemverUpdate,
+    /// Minimum bump required to respect semver.
+    /// For example, if the crate contains breaking changes, this is [`ReleaseType::Major`].
+    /// If no bump is required, this is [`Option::None`].
+    required_bump: Option<ReleaseType>,
+}
+
+impl CrateReport {
+    /// Check if the semver check was successful.
+    /// `true` if required bump <= detected bump.
+    pub fn success(&self) -> bool {
+        match self.required_bump {
+            None => true,
+            Some(required_bump) => {
+                match self.detected_bump {
+                    // If user bumped the major version, any breaking change is accepted.
+                    ActualSemverUpdate::Major => true,
+                    ActualSemverUpdate::Minor => {
+                        matches!(required_bump, ReleaseType::Minor | ReleaseType::Patch)
+                    }
+                    ActualSemverUpdate::Patch | ActualSemverUpdate::NotChanged => {
+                        required_bump == ReleaseType::Patch
+                    }
+                }
+            }
+        }
+    }
+
+    /// Minimum bump required to respect semver.
+    /// It's [`Option::None`] if no bump is required.
+    pub fn required_bump(&self) -> Option<ReleaseType> {
+        self.required_bump
+    }
+
+    /// Bump between the current version and the baseline one.
+    pub fn detected_bump(&self) -> ActualSemverUpdate {
+        self.detected_bump
+    }
+}
+
+/// Report of the whole analysis.
+/// Contains a report for each crate checked.
 #[non_exhaustive]
 #[derive(Debug)]
 pub struct Report {
-    success: bool,
+    /// Collection containing the name and the report of each crate checked.
+    crate_reports: BTreeMap<String, CrateReport>,
 }
 
 impl Report {
+    /// `true` if none of the crates violate semver.
     pub fn success(&self) -> bool {
-        self.success
+        self.crate_reports.values().all(|report| report.success())
+    }
+
+    pub fn crate_reports(&self) -> &BTreeMap<String, CrateReport> {
+        &self.crate_reports
     }
 }
 

src/query.rs

@@ -21,8 +21,17 @@ impl RequiredSemverUpdate {
     }
 }
 
+impl From<RequiredSemverUpdate> for ReleaseType {
+    fn from(value: RequiredSemverUpdate) -> Self {
+        match value {
+            RequiredSemverUpdate::Major => Self::Major,
+            RequiredSemverUpdate::Minor => Self::Minor,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum ActualSemverUpdate {
+pub enum ActualSemverUpdate {
     Major,
     Minor,
     Patch,

test_crates/trait_missing_with_major_bump/new/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+publish = false
+name = "trait_missing_with_major_bump"
+version = "1.0.0"
+edition = "2021"
+
+[dependencies]

test_crates/trait_missing_with_major_bump/new/src/lib.rs

@@ -0,0 +1,9 @@
+trait AddedPrivateTrait {}
+
+pub trait AddedPubTrait {}
+
+// This trait stops being unsafe. It is not removed and should not be reported.
+pub trait TraitStopsBeingUnsafe {}
+
+// This trait becomes unsafe. It is not removed and should not be reported.
+pub unsafe trait TraitBecomesUnsafe {}

test_crates/trait_missing_with_major_bump/old/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+publish = false
+name = "trait_missing_with_major_bump"
+version = "2.0.0"
+edition = "2021"
+
+[dependencies]

test_crates/trait_missing_with_major_bump/old/src/lib.rs

@@ -0,0 +1,18 @@
+pub trait RemovedTrait {}
+
+pub unsafe trait RemovedUnsafeTrait {}
+
+pub mod my_pub_mod {
+    pub trait PubUseRemovedTrait {}
+}
+
+pub use my_pub_mod::PubUseRemovedTrait;
+
+// This trait stops being unsafe. It is not removed and should not be reported.
+pub unsafe trait TraitStopsBeingUnsafe {}
+
+// This trait becomes unsafe. It is not removed and should not be reported.
+pub trait TraitBecomesUnsafe {}
+
+// This trait is private. Its removal is not breaking and should not be reported.
+trait PrivateTrait {}

test_outputs/trait_missing.output.ron

@@ -42,6 +42,49 @@
             "visibility_limit": String("public"),
         },
     ],
+    "./test_crates/trait_missing_with_major_bump/": [
+        {
+            "name": String("RemovedTrait"),
+            "path": List([
+                String("trait_missing_with_major_bump"),
+                String("RemovedTrait"),
+            ]),
+            "span_begin_line": Uint64(1),
+            "span_filename": String("src/lib.rs"),
+            "visibility_limit": String("public"),
+        },
+        {
+            "name": String("RemovedUnsafeTrait"),
+            "path": List([
+                String("trait_missing_with_major_bump"),
+                String("RemovedUnsafeTrait"),
+            ]),
+            "span_begin_line": Uint64(3),
+            "span_filename": String("src/lib.rs"),
+            "visibility_limit": String("public"),
+        },
+        {
+            "name": String("PubUseRemovedTrait"),
+            "path": List([
+                String("trait_missing_with_major_bump"),
+                String("my_pub_mod"),
+                String("PubUseRemovedTrait"),
+            ]),
+            "span_begin_line": Uint64(6),
+            "span_filename": String("src/lib.rs"),
+            "visibility_limit": String("public"),
+        },
+        {
+            "name": String("PubUseRemovedTrait"),
+            "path": List([
+                String("trait_missing_with_major_bump"),
+                String("PubUseRemovedTrait"),
+            ]),
+            "span_begin_line": Uint64(6),
+            "span_filename": String("src/lib.rs"),
+            "visibility_limit": String("public"),
+        },
+    ],
     "./test_crates/trait_unsafe_added/": [
         {
             "name": String("TraitBecomesPrivateAndUnsafe"),