Upgrade pubgrub version.

Author: Kaholaz

Cargo.toml

@@ -33,7 +33,7 @@ ring = "0.17"
 # PEM -> DER conversion
 x509-parser = "0.15"
 # Pubgrub dependency resolution algorithm
-pubgrub = "0.2"
+pubgrub = "0.3"
 # Basic auth HTTP helper
 http-auth-basic = "0.3"
 # base16 encoding

src/version.rs

@@ -10,8 +10,6 @@ use serde::{
     de::{self, Deserializer},
 };
 
-pub use pubgrub::report as pubgrub_report;
-
 mod lexer;
 mod parser;
 #[cfg(test)]
@@ -101,7 +99,7 @@ impl Version {
     }
 
     /// Parse a Hex compatible version range. i.e. `> 1 and < 2 or == 4.5.2`.
-    fn parse_range(input: &str) -> Result<pubgrub::range::Range<Version>, parser::Error> {
+    fn parse_range(input: &str) -> Result<pubgrub::Range<Version>, parser::Error> {
         let mut parser = Parser::new(input)?;
         let version = parser.range()?;
         if !parser.is_eof() {
@@ -117,6 +115,10 @@ impl Version {
         Ok(version)
     }
 
+    pub fn lowest() -> Self {
+        Self::new(0, 0, 0)
+    }
+
     fn tuple(&self) -> (u32, u32, u32, PreOrder<'_>) {
         (
             self.major,
@@ -131,6 +133,21 @@ impl Version {
     }
 }
 
+pub trait LowestVersion {
+    fn lowest_version(&self) -> Option<Version>;
+}
+impl LowestVersion for pubgrub::Range<Version> {
+    fn lowest_version(&self) -> Option<Version> {
+        self.iter()
+            .flat_map(|(lower, _higher)| match lower {
+                std::ops::Bound::Included(v) => Some(v.clone()),
+                std::ops::Bound::Excluded(_) => None,
+                std::ops::Bound::Unbounded => Some(Version::lowest()),
+            })
+            .min()
+    }
+}
+
 impl<'de> Deserialize<'de> for Version {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -162,104 +179,6 @@ impl std::cmp::Ord for Version {
     }
 }
 
-impl pubgrub::version::Version for Version {
-    fn lowest() -> Self {
-        Self::new(0, 0, 0)
-    }
-
-    fn bump(&self) -> Self {
-        if self.is_pre() {
-            let mut pre = self.pre.clone();
-            let last_component = pre
-                .last_mut()
-                // This `.expect` is safe, as we know there to be at least
-                // one pre-release component.
-                .expect("no pre-release components");
-
-            match last_component {
-                Identifier::Numeric(pre) => *pre += 1,
-                Identifier::AlphaNumeric(pre) => {
-                    let mut segments = split_alphanumeric(pre);
-                    let last_segment = segments.last_mut().unwrap();
-
-                    match last_segment {
-                        AlphaOrNumeric::Numeric(n) => *n += 1,
-                        AlphaOrNumeric::Alpha(alpha) => {
-                            // We should potentially be smarter about this (for instance, pick the next letter in the
-                            // alphabetic sequence), however, this seems like it could be quite a bit more complex.
-                            alpha.push('1')
-                        }
-                    }
-
-                    *pre = segments
-                        .into_iter()
-                        .map(|segment| match segment {
-                            AlphaOrNumeric::Alpha(segment) => segment,
-                            AlphaOrNumeric::Numeric(segment) => segment.to_string(),
-                        })
-                        .collect::<Vec<_>>()
-                        .join("");
-                }
-            }
-
-            Self {
-                major: self.major,
-                minor: self.minor,
-                patch: self.patch,
-                pre,
-                build: None,
-            }
-        } else {
-            self.bump_patch()
-        }
-    }
-}
-
-enum AlphaOrNumeric {
-    Alpha(String),
-    Numeric(u32),
-}
-
-/// Splits the given string into alphabetic and numeric segments.
-fn split_alphanumeric(str: &str) -> Vec<AlphaOrNumeric> {
-    let mut segments = Vec::new();
-    let mut current_segment = String::new();
-    let mut previous_char_was_numeric = None;
-
-    for char in str.chars() {
-        let is_numeric = char.is_ascii_digit();
-        match previous_char_was_numeric {
-            Some(previous_char_was_numeric) if previous_char_was_numeric == is_numeric => {
-                current_segment.push(char)
-            }
-            _ => {
-                if !current_segment.is_empty() {
-                    if current_segment.chars().any(|char| char.is_ascii_digit()) {
-                        segments.push(AlphaOrNumeric::Numeric(current_segment.parse().unwrap()));
-                    } else {
-                        segments.push(AlphaOrNumeric::Alpha(current_segment));
-                    }
-
-                    current_segment = String::new();
-                }
-
-                current_segment.push(char);
-                previous_char_was_numeric = Some(is_numeric);
-            }
-        }
-    }
-
-    if !current_segment.is_empty() {
-        if current_segment.chars().any(|char| char.is_ascii_digit()) {
-            segments.push(AlphaOrNumeric::Numeric(current_segment.parse().unwrap()));
-        } else {
-            segments.push(AlphaOrNumeric::Alpha(current_segment));
-        }
-    }
-
-    segments
-}
-
 impl<'a> TryFrom<&'a str> for Version {
     type Error = parser::Error;
 
@@ -317,18 +236,18 @@ impl Identifier {
 #[derive(Clone, PartialEq, Eq)]
 pub struct Range {
     spec: String,
-    range: pubgrub::range::Range<Version>,
+    range: pubgrub::Range<Version>,
 }
 
 impl Range {
     pub fn new(spec: String) -> Result<Self, parser::Error> {
-        let range = Version::parse_range(spec.as_str())?;
+        let range = Version::parse_range(&spec)?;
         Ok(Self { spec, range })
     }
 }
 
 impl Range {
-    pub fn to_pubgrub(&self) -> &pubgrub::range::Range<Version> {
+    pub fn to_pubgrub(&self) -> &pubgrub::Range<Version> {
         &self.range
     }
 
@@ -337,16 +256,15 @@ impl Range {
     }
 }
 
-impl From<pubgrub::range::Range<Version>> for Range {
-    fn from(range: pubgrub::range::Range<Version>) -> Self {
+impl From<pubgrub::Range<Version>> for Range {
+    fn from(range: pubgrub::Range<Version>) -> Self {
         let spec = range.to_string();
         Self { spec, range }
     }
 }
-
 impl From<Version> for Range {
     fn from(version: Version) -> Self {
-        pubgrub::range::Range::exact(version).into()
+        pubgrub::Range::singleton(version).into()
     }
 }
 

src/version/parser.rs

@@ -8,7 +8,7 @@ use super::lexer::{self, Lexer, Token};
 use crate::version::{Identifier, Version};
 use thiserror::Error;
 
-type PubgrubRange = pubgrub::range::Range<Version>;
+type PubgrubRange = pubgrub::Range<Version>;
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Error)]
 pub enum Error {
@@ -322,11 +322,11 @@ impl<'input> Parser<'input> {
             self.skip_whitespace()?;
             match self.peek() {
                 None => break,
-                Some(Numeric(_)) => range = and(range, PubgrubRange::exact(self.version()?)),
+                Some(Numeric(_)) => range = and(range, PubgrubRange::singleton(self.version()?)),
 
                 Some(Eq) => {
                     self.pop()?;
-                    range = and(range, PubgrubRange::exact(self.version()?));
+                    range = and(range, PubgrubRange::singleton(self.version()?));
                 }
 
                 Some(NotEq) => {

src/version/tests.rs

@@ -2,7 +2,6 @@ use std::cmp::Ordering::{Equal, Greater, Less};
 use std::collections::HashMap;
 
 use parser::Error;
-use pubgrub::version::Version as _;
 
 use super::{
     Identifier::{AlphaNumeric, Numeric},
@@ -208,17 +207,21 @@ fn v_(major: u32, minor: u32, patch: u32, pre: Vec<Identifier>, build: Option<St
     }
 }
 
-type PubgrubRange = pubgrub::range::Range<Version>;
+type PubgrubRange = pubgrub::Range<Version>;
 
-parse_range_test!(leading_space, " 1.2.3", PubgrubRange::exact(v(1, 2, 3)));
-parse_range_test!(trailing_space, "1.2.3 ", PubgrubRange::exact(v(1, 2, 3)));
+parse_range_test!(leading_space, " 1.2.3", PubgrubRange::singleton(v(1, 2, 3)));
+parse_range_test!(
+    trailing_space,
+    "1.2.3 ",
+    PubgrubRange::singleton(v(1, 2, 3))
+);
 
-parse_range_test!(eq_triplet, "== 1.2.3 ", PubgrubRange::exact(v(1, 2, 3)));
+parse_range_test!(eq_triplet, "== 1.2.3 ", PubgrubRange::singleton(v(1, 2, 3)));
 
 parse_range_test!(
     eq_triplet_nospace,
     "==1.2.3 ",
-    PubgrubRange::exact(v(1, 2, 3))
+    PubgrubRange::singleton(v(1, 2, 3))
 );
 
 parse_range_test!(
@@ -227,12 +230,12 @@ parse_range_test!(
     PubgrubRange::strictly_lower_than(v(1, 2, 3)).union(&PubgrubRange::higher_than(v(1, 2, 4)))
 );
 
-parse_range_test!(implicit_eq, "2.2.3", PubgrubRange::exact(v(2, 2, 3)));
+parse_range_test!(implicit_eq, "2.2.3", PubgrubRange::singleton(v(2, 2, 3)));
 
 parse_range_test!(
     range_pre_build,
     "1.2.3-thing+oop",
-    PubgrubRange::exact(v_(
+    PubgrubRange::singleton(v_(
         1,
         2,
         3,
@@ -388,30 +391,6 @@ assert_order!(ord_pre_smaller_than_zero_flip, "1.0.0-rc1", Less, "1.0.0");
 
 assert_order!(ord_pre_rc1_2, "1.0.0-rc1", Less, "1.0.0-rc2");
 
-#[test]
-fn test_pubgrub_bump_patch() {
-    assert_eq!(
-        Version::parse("1.0.0").unwrap().bump(),
-        Version::parse("1.0.1").unwrap()
-    );
-}
-
-#[test]
-fn test_pubgrub_bump_prerelease_ending_with_a_number() {
-    assert_eq!(
-        Version::parse("1.0.0-rc2").unwrap().bump(),
-        Version::parse("1.0.0-rc3").unwrap()
-    );
-}
-
-#[test]
-fn test_pubgrub_bump_prerelease_ending_with_a_letter() {
-    assert_eq!(
-        Version::parse("1.0.0-rc2a").unwrap().bump(),
-        Version::parse("1.0.0-rc2a1").unwrap()
-    );
-}
-
 #[test]
 fn manifest_toml() {
     let manifest = toml::to_string(