refactor!: pluralize NoVersion incompatibilities (#62)

* refactor!: pluralize NoVersion incompatibility

* refactor!: pluralize report.collapse_noversion()

* docs: document incompatibility::Kind

Author: aleksator

examples/branching_error_reporting.rs

@@ -56,7 +56,7 @@ fn main() {
     match resolve(&dependency_provider, "root", (1, 0, 0)) {
         Ok(sol) => println!("{:?}", sol),
         Err(PubGrubError::NoSolution(mut derivation_tree)) => {
-            derivation_tree.collapse_noversion();
+            derivation_tree.collapse_no_versions();
             eprintln!("{}", DefaultStringReporter::report(&derivation_tree));
             std::process::exit(1);
         }

examples/doc_interface_error.rs

@@ -73,7 +73,7 @@ fn main() {
     match resolve(&dependency_provider, "root", (1, 0, 0)) {
         Ok(sol) => println!("{:?}", sol),
         Err(PubGrubError::NoSolution(mut derivation_tree)) => {
-            derivation_tree.collapse_noversion();
+            derivation_tree.collapse_no_versions();
             eprintln!("{}", DefaultStringReporter::report(&derivation_tree));
         }
         Err(err) => panic!("{:?}", err),

examples/doc_interface_semantic.rs

@@ -64,7 +64,7 @@ fn main() {
     match resolve(&dependency_provider, "root", (1, 0, 0)) {
         Ok(sol) => println!("{:?}", sol),
         Err(PubGrubError::NoSolution(mut derivation_tree)) => {
-            derivation_tree.collapse_noversion();
+            derivation_tree.collapse_no_versions();
             eprintln!("{}", DefaultStringReporter::report(&derivation_tree));
         }
         Err(err) => panic!("{:?}", err),

examples/linear_error_reporting.rs

@@ -38,7 +38,7 @@ fn main() {
     match resolve(&dependency_provider, "root", (1, 0, 0)) {
         Ok(sol) => println!("{:?}", sol),
         Err(PubGrubError::NoSolution(mut derivation_tree)) => {
-            derivation_tree.collapse_noversion();
+            derivation_tree.collapse_no_versions();
             eprintln!("{}", DefaultStringReporter::report(&derivation_tree));
             std::process::exit(1);
         }

src/internal/incompatibility.rs

@@ -39,10 +39,15 @@ pub struct Incompatibility<P: Package, V: Version> {
 
 #[derive(Debug, Clone)]
 enum Kind<P: Package, V: Version> {
+    /// Initial incompatibility aiming at picking the root package for the first decision.
     NotRoot(P, V),
-    NoVersion(P, Range<V>),
+    /// No versions from range satisfy given constraints.
+    NoVersions(P, Range<V>),
+    /// Dependencies of the package are unavailable for versions in that range.
     UnavailableDependencies(P, Range<V>),
+    /// Incompatibility coming from the dependencies of a given package.
     FromDependencyOf(P, Range<V>, P, Range<V>),
+    /// Derived from two causes. Stores cause ids.
     DerivedFrom(usize, usize),
 }
 
@@ -83,7 +88,7 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
 
     /// Create an incompatibility to remember
     /// that a given range does not contain any version.
-    pub fn no_version(id: usize, package: P, term: Term<V>) -> Self {
+    pub fn no_versions(id: usize, package: P, term: Term<V>) -> Self {
         let range = match &term {
             Term::Positive(r) => r.clone(),
             Term::Negative(_) => panic!("No version should have a positive term"),
@@ -93,7 +98,7 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
         Self {
             id,
             package_terms,
-            kind: Kind::NoVersion(package, range),
+            kind: Kind::NoVersions(package, range),
         }
     }
 
@@ -301,8 +306,8 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
             Kind::NotRoot(package, version) => {
                 DerivationTree::External(External::NotRoot(package.clone(), version.clone()))
             }
-            Kind::NoVersion(package, range) => {
-                DerivationTree::External(External::NoVersion(package.clone(), range.clone()))
+            Kind::NoVersions(package, range) => {
+                DerivationTree::External(External::NoVersions(package.clone(), range.clone()))
             }
             Kind::UnavailableDependencies(package, range) => DerivationTree::External(
                 External::UnavailableDependencies(package.clone(), range.clone()),

src/lib.rs

@@ -172,16 +172,16 @@
 //! match resolve(&dependency_provider, root_package, root_version) {
 //!     Ok(solution) => println!("{:?}", solution),
 //!     Err(PubGrubError::NoSolution(mut derivation_tree)) => {
-//!         derivation_tree.collapse_noversion();
+//!         derivation_tree.collapse_no_versions();
 //!         eprintln!("{}", DefaultStringReporter::report(&derivation_tree));
 //!     }
 //!     Err(err) => panic!("{:?}", err),
 //! };
 //! ```
 //! Notice that we also used
-//! [collapse_noversion()](crate::report::DerivationTree::collapse_noversion) above.
+//! [collapse_no_versions()](crate::report::DerivationTree::collapse_no_versions) above.
 //! This method simplifies the derivation tree to get rid of the
-//! [NoVersion](crate::report::External::NoVersion)
+//! [NoVersions](crate::report::External::NoVersions)
 //! external incompatibilities in the derivation tree.
 //! So instead of seeing things like this in the report:
 //! ```txt

src/report.rs

@@ -35,11 +35,10 @@ pub enum DerivationTree<P: Package, V: Version> {
 /// they have their own reason.
 #[derive(Debug, Clone)]
 pub enum External<P: Package, V: Version> {
-    /// Initial incompatibility aiming at picking the root package
-    /// for the first decision.
+    /// Initial incompatibility aiming at picking the root package for the first decision.
     NotRoot(P, V),
-    /// No version exist in that range.
-    NoVersion(P, Range<V>),
+    /// No versions from range satisfy given constraints.
+    NoVersions(P, Range<V>),
     /// Dependencies of the package are unavailable for versions in that range.
     UnavailableDependencies(P, Range<V>),
     /// Incompatibility coming from the dependencies of a given package.
@@ -64,52 +63,52 @@ pub struct Derived<P: Package, V: Version> {
 }
 
 impl<P: Package, V: Version> DerivationTree<P, V> {
-    /// Merge the [NoVersion](External::NoVersion) external incompatibilities
+    /// Merge the [NoVersions](External::NoVersions) external incompatibilities
     /// with the other one they are matched with
     /// in a derived incompatibility.
     /// This cleans up quite nicely the generated report.
     /// You might want to do this if you know that the
     /// [DependencyProvider](crate::solver::DependencyProvider)
     /// was not run in some kind of offline mode that may not
     /// have access to all versions existing.
-    pub fn collapse_noversion(&mut self) {
+    pub fn collapse_no_versions(&mut self) {
         match self {
             DerivationTree::External(_) => {}
             DerivationTree::Derived(derived) => {
                 match (&mut *derived.cause1, &mut *derived.cause2) {
-                    (DerivationTree::External(External::NoVersion(p, r)), ref mut cause2) => {
-                        cause2.collapse_noversion();
+                    (DerivationTree::External(External::NoVersions(p, r)), ref mut cause2) => {
+                        cause2.collapse_no_versions();
                         *self = cause2
                             .clone()
-                            .merge_noversion(p.to_owned(), r.to_owned())
+                            .merge_no_versions(p.to_owned(), r.to_owned())
                             .unwrap_or_else(|| self.to_owned());
                     }
-                    (ref mut cause1, DerivationTree::External(External::NoVersion(p, r))) => {
-                        cause1.collapse_noversion();
+                    (ref mut cause1, DerivationTree::External(External::NoVersions(p, r))) => {
+                        cause1.collapse_no_versions();
                         *self = cause1
                             .clone()
-                            .merge_noversion(p.to_owned(), r.to_owned())
+                            .merge_no_versions(p.to_owned(), r.to_owned())
                             .unwrap_or_else(|| self.to_owned());
                     }
                     _ => {
-                        derived.cause1.collapse_noversion();
-                        derived.cause2.collapse_noversion();
+                        derived.cause1.collapse_no_versions();
+                        derived.cause2.collapse_no_versions();
                     }
                 }
             }
         }
     }
 
-    fn merge_noversion(self, package: P, range: Range<V>) -> Option<Self> {
+    fn merge_no_versions(self, package: P, range: Range<V>) -> Option<Self> {
         match self {
             // TODO: take care of the Derived case.
             // Once done, we can remove the Option.
             DerivationTree::Derived(_) => Some(self),
             DerivationTree::External(External::NotRoot(_, _)) => {
-                panic!("How did we end up with a NoVersion merged with a NotRoot?")
+                panic!("How did we end up with a NoVersions merged with a NotRoot?")
             }
-            DerivationTree::External(External::NoVersion(_, r)) => Some(DerivationTree::External(
-                External::NoVersion(package, range.union(&r)),
+            DerivationTree::External(External::NoVersions(_, r)) => Some(DerivationTree::External(
+                External::NoVersions(package, range.union(&r)),
             )),
             DerivationTree::External(External::UnavailableDependencies(_, r)) => {
                 Some(DerivationTree::External(External::UnavailableDependencies(
@@ -144,7 +143,7 @@ impl<P: Package, V: Version> fmt::Display for External<P, V> {
             Self::NotRoot(package, version) => {
                 write!(f, "we are solving dependencies of {} {}", package, version)
             }
-            Self::NoVersion(package, range) => {
+            Self::NoVersions(package, range) => {
                 if range == &Range::any() {
                     write!(f, "there is no available version for {}", package)
                 } else {

src/solver.rs

@@ -119,7 +119,7 @@ pub fn resolve<P: Package, V: Version>(
         let v = match PartialSolution::<P, V>::pick_version(&available_versions[..], &term) {
             None => {
                 state.add_incompatibility(|id| {
-                    Incompatibility::no_version(id, p.clone(), term.clone())
+                    Incompatibility::no_versions(id, p.clone(), term.clone())
                 });
                 continue;
             }