From 6bdf0f2e4d0ba9edb57e62473609ca6257dbbaf8 Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Tue, 19 Dec 2023 13:50:59 -0500 Subject: [PATCH 01/16] Add new `VersionBumpType` and refactor `Version.bump()` to determine the bumping logic. --- crates/rattler_conda_types/src/lib.rs | 3 +- .../rattler_conda_types/src/version/bump.rs | 13 ++ crates/rattler_conda_types/src/version/mod.rs | 154 ++++++++++++++++-- 3 files changed, 159 insertions(+), 11 deletions(-) create mode 100644 crates/rattler_conda_types/src/version/bump.rs diff --git a/crates/rattler_conda_types/src/lib.rs b/crates/rattler_conda_types/src/lib.rs index 11d1b8506..698cc1cfb 100644 --- a/crates/rattler_conda_types/src/lib.rs +++ b/crates/rattler_conda_types/src/lib.rs @@ -43,7 +43,8 @@ pub use repo_data::{ pub use repo_data_record::RepoDataRecord; pub use run_export::RunExportKind; pub use version::{ - Component, ParseVersionError, ParseVersionErrorKind, StrictVersion, Version, VersionWithSource, + Component, ParseVersionError, ParseVersionErrorKind, StrictVersion, Version, VersionBumpType, + VersionWithSource, }; pub use version_spec::VersionSpec; diff --git a/crates/rattler_conda_types/src/version/bump.rs b/crates/rattler_conda_types/src/version/bump.rs new file mode 100644 index 000000000..a8436b752 --- /dev/null +++ b/crates/rattler_conda_types/src/version/bump.rs @@ -0,0 +1,13 @@ +/// VersionBumpType is used to specify the type of bump to perform on a version. +// #[derive(Default)] +pub enum VersionBumpType { + /// Bump the major version number. + Major, + /// Bump the minor version number. + Minor, + /// Bump the patch version number. + Patch, + /// Bump the last version number. + // #[default] + Last, +} diff --git a/crates/rattler_conda_types/src/version/mod.rs b/crates/rattler_conda_types/src/version/mod.rs index 518c0b879..3d8396272 100644 --- a/crates/rattler_conda_types/src/version/mod.rs +++ b/crates/rattler_conda_types/src/version/mod.rs @@ -22,6 +22,9 @@ pub(crate) mod parse; mod segment; mod with_source; +pub(crate) mod bump; +pub use bump::VersionBumpType; + use flags::Flags; use segment::Segment; @@ -227,8 +230,8 @@ impl Version { }) } - /// Returns a new version where the last numerical segment of this version has been bumped. - pub fn bump(&self) -> Self { + /// Returns a new version after bumping it according to the specified bump type. + pub fn bump(&self, bump_type: VersionBumpType) -> Self { let mut components = ComponentVec::new(); let mut segments = SegmentVec::new(); let mut flags = Flags::default(); @@ -239,6 +242,31 @@ impl Version { flags = flags.with_has_epoch(true); } + // Sanity check whether the version has enough segments for this bump type. + let segment_count = self.segment_count(); + match bump_type { + VersionBumpType::Major => { + if segment_count < 1 { + panic!("cannot bump the major segment of a version with less than 1 segment"); + } + } + VersionBumpType::Minor => { + if segment_count < 2 { + panic!("cannot bump the minor segment of a version with less than 2 segments"); + } + } + VersionBumpType::Patch => { + if segment_count < 3 { + panic!("cannot bump the last segment of a version with less than 3 segment"); + } + } + VersionBumpType::Last => { + if segment_count == 0 { + panic!("cannot bump the last segment of a version with no segments"); + } + } + } + // Copy over all the segments and bump the last segment. let segment_count = self.segment_count(); for (idx, segment_iter) in self.segments().enumerate() { @@ -247,9 +275,16 @@ impl Version { let mut segment_components = segment_iter.components().cloned().collect::(); - // If this is the last segment of the version bump the last number. Each segment must at - // least start with a number so this should always work. - if idx == (segment_count - 1) { + // Determine whether this is the segment that needs to be bumped. + let is_segment_to_bump = match bump_type { + VersionBumpType::Major => idx == 0, + VersionBumpType::Minor => idx == 1, + VersionBumpType::Patch => idx == 2, + VersionBumpType::Last => idx == (segment_count - 1), + }; + + // Bump the segment if we need to. Each segment must at least start with a number so this should always work. + if is_segment_to_bump { let last_numeral_component = segment_components .iter_mut() .filter_map(Component::as_number_mut) @@ -998,7 +1033,7 @@ mod test { use rand::seq::SliceRandom; - use crate::version::StrictVersion; + use crate::version::{StrictVersion, VersionBumpType}; use super::Version; @@ -1202,17 +1237,23 @@ mod test { } #[test] - fn bump() { + fn bump_last() { assert_eq!( - Version::from_str("1.1").unwrap().bump(), + Version::from_str("1.1") + .unwrap() + .bump(VersionBumpType::Last), Version::from_str("1.2").unwrap() ); assert_eq!( - Version::from_str("1.1l").unwrap().bump(), + Version::from_str("1.1l") + .unwrap() + .bump(VersionBumpType::Last), Version::from_str("1.2l").unwrap() ); assert_eq!( - Version::from_str("5!1.alpha+3.4").unwrap().bump(), + Version::from_str("5!1.alpha+3.4") + .unwrap() + .bump(VersionBumpType::Last), Version::from_str("5!1.1alpha+3.4").unwrap() ); } @@ -1347,4 +1388,97 @@ mod test { Version::from_str("3!4.5a.6b").unwrap() ); } + + #[test] + fn bump_dev() { + let version = Version::from_str("5!1.alpha+3.4").unwrap(); + + println!("****************"); + println!("components: {:?}", version.components); + println!("flags: {:?}", version.flags); + println!("segments: {:#?}", version.segments); + println!("****************"); + } + + #[test] + fn bump_major() { + assert_eq!( + Version::from_str("1.1") + .unwrap() + .bump(VersionBumpType::Major), + Version::from_str("2.1").unwrap() + ); + assert_eq!( + Version::from_str("2.1l") + .unwrap() + .bump(VersionBumpType::Major), + Version::from_str("3.1l").unwrap() + ); + assert_eq!( + Version::from_str("5!1.alpha+3.4") + .unwrap() + .bump(VersionBumpType::Major), + Version::from_str("5!2.alpha+3.4").unwrap() + ); + } + + #[test] + fn bump_minor() { + assert_eq!( + Version::from_str("1.1") + .unwrap() + .bump(VersionBumpType::Minor), + Version::from_str("1.2").unwrap() + ); + assert_eq!( + Version::from_str("2.1l") + .unwrap() + .bump(VersionBumpType::Minor), + Version::from_str("2.2l").unwrap() + ); + assert_eq!( + Version::from_str("5!1.alpha+3.4") + .unwrap() + .bump(VersionBumpType::Minor), + Version::from_str("5!1.1alpha+3.4").unwrap() + ); + } + + #[test] + #[should_panic( + expected = "cannot bump the minor segment of a version with less than 2 segments" + )] + fn bump_minor_fail() { + Version::from_str("1").unwrap().bump(VersionBumpType::Minor); + } + + #[test] + fn bump_patch() { + assert_eq!( + Version::from_str("1.1.9") + .unwrap() + .bump(VersionBumpType::Patch), + Version::from_str("1.1.10").unwrap() + ); + assert_eq!( + Version::from_str("2.1l.5alpha") + .unwrap() + .bump(VersionBumpType::Patch), + Version::from_str("2.1l.6alpha").unwrap() + ); + assert_eq!( + Version::from_str("5!1.8.alpha+3.4") + .unwrap() + .bump(VersionBumpType::Patch), + Version::from_str("5!1.8.1alpha+3.4").unwrap() + ); + } + + #[test] + #[should_panic(expected = "cannot bump the last segment of a version with less than 3 segment")] + fn bump_patch_fail() { + Version::from_str("1.3") + .unwrap() + .bump(VersionBumpType::Patch); + } } From 67483250cff0f5568bf295563d202cec2a832ffa Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Tue, 19 Dec 2023 13:52:00 -0500 Subject: [PATCH 02/16] remove left over default for bump type --- crates/rattler_conda_types/src/version/bump.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/crates/rattler_conda_types/src/version/bump.rs b/crates/rattler_conda_types/src/version/bump.rs index a8436b752..44d108ad9 100644 --- a/crates/rattler_conda_types/src/version/bump.rs +++ b/crates/rattler_conda_types/src/version/bump.rs @@ -1,5 +1,4 @@ /// VersionBumpType is used to specify the type of bump to perform on a version. -// #[derive(Default)] pub enum VersionBumpType { /// Bump the major version number. Major, @@ -8,6 +7,5 @@ pub enum VersionBumpType { /// Bump the patch version number. Patch, /// Bump the last version number. - // #[default] Last, } From 4d37df46ab6ec67a13799179132cc3346959aab9 Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Tue, 19 Dec 2023 15:48:34 -0500 Subject: [PATCH 03/16] Return an error instead of panic --- crates/rattler_conda_types/src/lib.rs | 4 +- .../rattler_conda_types/src/version/bump.rs | 15 +++ crates/rattler_conda_types/src/version/mod.rs | 101 +++++++++++------- 3 files changed, 80 insertions(+), 40 deletions(-) diff --git a/crates/rattler_conda_types/src/lib.rs b/crates/rattler_conda_types/src/lib.rs index 698cc1cfb..eedff4a41 100644 --- a/crates/rattler_conda_types/src/lib.rs +++ b/crates/rattler_conda_types/src/lib.rs @@ -43,8 +43,8 @@ pub use repo_data::{ pub use repo_data_record::RepoDataRecord; pub use run_export::RunExportKind; pub use version::{ - Component, ParseVersionError, ParseVersionErrorKind, StrictVersion, Version, VersionBumpType, - VersionWithSource, + Component, ParseVersionError, ParseVersionErrorKind, StrictVersion, Version, VersionBumpError, + VersionBumpType, VersionWithSource, }; pub use version_spec::VersionSpec; diff --git a/crates/rattler_conda_types/src/version/bump.rs b/crates/rattler_conda_types/src/version/bump.rs index 44d108ad9..61d264a8c 100644 --- a/crates/rattler_conda_types/src/version/bump.rs +++ b/crates/rattler_conda_types/src/version/bump.rs @@ -1,3 +1,5 @@ +use std::fmt; + /// VersionBumpType is used to specify the type of bump to perform on a version. pub enum VersionBumpType { /// Bump the major version number. @@ -9,3 +11,16 @@ pub enum VersionBumpType { /// Bump the last version number. Last, } + +/// VersionBumpError is used to specify the type of error that occurred when bumping a version. +#[derive(Debug, Clone)] +pub struct VersionBumpError { + /// The reason for the error. + pub reason: String, +} + +impl fmt::Display for VersionBumpError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "Error bumping the version: {}", self.reason) + } +} diff --git a/crates/rattler_conda_types/src/version/mod.rs b/crates/rattler_conda_types/src/version/mod.rs index 3d8396272..5c82d0542 100644 --- a/crates/rattler_conda_types/src/version/mod.rs +++ b/crates/rattler_conda_types/src/version/mod.rs @@ -23,7 +23,7 @@ mod segment; mod with_source; pub(crate) mod bump; -pub use bump::VersionBumpType; +pub use bump::{VersionBumpError, VersionBumpType}; use flags::Flags; use segment::Segment; @@ -231,7 +231,7 @@ impl Version { } /// Returns a new version after bumping it according to the specified bump type. - pub fn bump(&self, bump_type: VersionBumpType) -> Self { + pub fn bump(&self, bump_type: VersionBumpType) -> Result { let mut components = ComponentVec::new(); let mut segments = SegmentVec::new(); let mut flags = Flags::default(); @@ -247,22 +247,38 @@ impl Version { match bump_type { VersionBumpType::Major => { if segment_count < 1 { - panic!("cannot bump the major segment of a version with less than 1 segment"); + return Err(VersionBumpError { + reason: String::from( + "cannot bump the major segment of a version with less than 1 segment", + ), + }); } } VersionBumpType::Minor => { if segment_count < 2 { - panic!("cannot bump the minor segment of a version with less than 2 segments"); + return Err(VersionBumpError { + reason: String::from( + "cannot bump the major segment of a version with less than 2 segment", + ), + }); } } VersionBumpType::Patch => { if segment_count < 3 { - panic!("cannot bump the last segment of a version with less than 3 segment"); + return Err(VersionBumpError { + reason: String::from( + "cannot bump the major segment of a version with less than 3 segment", + ), + }); } } VersionBumpType::Last => { if segment_count == 0 { - panic!("cannot bump the last segment of a version with no segments"); + return Err(VersionBumpError { + reason: String::from( + "cannot bump the last segment of a version with no segments", + ), + }); } } } @@ -325,11 +341,11 @@ impl Version { .expect("this should never fail because no new segments are added") } - Self { + Ok(Self { components, segments, flags, - } + }) } /// Returns the segments that belong the local part of the version. @@ -1241,19 +1257,22 @@ mod test { assert_eq!( Version::from_str("1.1") .unwrap() - .bump(VersionBumpType::Last), + .bump(VersionBumpType::Last) + .unwrap(), Version::from_str("1.2").unwrap() ); assert_eq!( Version::from_str("1.1l") .unwrap() - .bump(VersionBumpType::Last), + .bump(VersionBumpType::Last) + .unwrap(), Version::from_str("1.2l").unwrap() ); assert_eq!( Version::from_str("5!1.alpha+3.4") .unwrap() - .bump(VersionBumpType::Last), + .bump(VersionBumpType::Last) + .unwrap(), Version::from_str("5!1.1alpha+3.4").unwrap() ); } @@ -1389,35 +1408,27 @@ mod test { ); } - #[test] - fn bump_dev() { - let version = Version::from_str("5!1.alpha+3.4").unwrap(); - - println!("****************"); - println!("components: {:?}", version.components); - println!("flags: {:?}", version.flags); - println!("segments: {:#?}", version.segments); - println!("****************"); - } - #[test] fn bump_major() { assert_eq!( Version::from_str("1.1") .unwrap() - .bump(VersionBumpType::Major), + .bump(VersionBumpType::Major) + .unwrap(), Version::from_str("2.1").unwrap() ); assert_eq!( Version::from_str("2.1l") .unwrap() - .bump(VersionBumpType::Major), + .bump(VersionBumpType::Major) + .unwrap(), Version::from_str("3.1l").unwrap() ); assert_eq!( Version::from_str("5!1.alpha+3.4") .unwrap() - .bump(VersionBumpType::Major), + .bump(VersionBumpType::Major) + .unwrap(), Version::from_str("5!2.alpha+3.4").unwrap() ); } @@ -1427,29 +1438,36 @@ mod test { assert_eq!( Version::from_str("1.1") .unwrap() - .bump(VersionBumpType::Minor), + .bump(VersionBumpType::Minor) + .unwrap(), Version::from_str("1.2").unwrap() ); assert_eq!( Version::from_str("2.1l") .unwrap() - .bump(VersionBumpType::Minor), + .bump(VersionBumpType::Minor) + .unwrap(), Version::from_str("2.2l").unwrap() ); assert_eq!( Version::from_str("5!1.alpha+3.4") .unwrap() - .bump(VersionBumpType::Minor), + .bump(VersionBumpType::Minor) + .unwrap(), Version::from_str("5!1.1alpha+3.4").unwrap() ); } #[test] - #[should_panic( - expected = "cannot bump the minor segment of a version with less than 2 segments" - )] fn bump_minor_fail() { - Version::from_str("1").unwrap().bump(VersionBumpType::Minor); + let err = Version::from_str("1") + .unwrap() + .bump(VersionBumpType::Minor) + .unwrap_err(); + + assert!(err + .reason + .contains("cannot bump the major segment of a version with less than 2 segment")) } #[test] @@ -1457,28 +1475,35 @@ mod test { assert_eq!( Version::from_str("1.1.9") .unwrap() - .bump(VersionBumpType::Patch), + .bump(VersionBumpType::Patch) + .unwrap(), Version::from_str("1.1.10").unwrap() ); assert_eq!( Version::from_str("2.1l.5alpha") .unwrap() - .bump(VersionBumpType::Patch), + .bump(VersionBumpType::Patch) + .unwrap(), Version::from_str("2.1l.6alpha").unwrap() ); assert_eq!( Version::from_str("5!1.8.alpha+3.4") .unwrap() - .bump(VersionBumpType::Patch), + .bump(VersionBumpType::Patch) + .unwrap(), Version::from_str("5!1.8.1alpha+3.4").unwrap() ); } #[test] - #[should_panic(expected = "cannot bump the last segment of a version with less than 3 segment")] fn bump_patch_fail() { - Version::from_str("1.3") + let err = Version::from_str("1.3") .unwrap() - .bump(VersionBumpType::Patch); + .bump(VersionBumpType::Patch) + .unwrap_err(); + + assert!(err + .reason + .contains("cannot bump the major segment of a version with less than 3 segment")) } } From 93036bcf2b122c91769b128683d203726bf66b3c Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Tue, 19 Dec 2023 16:25:33 -0500 Subject: [PATCH 04/16] use thiserror for VersionBumpError --- .../rattler_conda_types/src/version/bump.rs | 26 ++++++++------ crates/rattler_conda_types/src/version/mod.rs | 34 ++++--------------- 2 files changed, 22 insertions(+), 38 deletions(-) diff --git a/crates/rattler_conda_types/src/version/bump.rs b/crates/rattler_conda_types/src/version/bump.rs index 61d264a8c..14d3078e3 100644 --- a/crates/rattler_conda_types/src/version/bump.rs +++ b/crates/rattler_conda_types/src/version/bump.rs @@ -1,4 +1,4 @@ -use std::fmt; +use thiserror::Error; /// VersionBumpType is used to specify the type of bump to perform on a version. pub enum VersionBumpType { @@ -13,14 +13,18 @@ pub enum VersionBumpType { } /// VersionBumpError is used to specify the type of error that occurred when bumping a version. -#[derive(Debug, Clone)] -pub struct VersionBumpError { - /// The reason for the error. - pub reason: String, -} - -impl fmt::Display for VersionBumpError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "Error bumping the version: {}", self.reason) - } +#[derive(Error, Debug, PartialEq)] +pub enum VersionBumpError { + /// Cannot bump the major segment of a version with less than 1 segment. + #[error("cannot bump the major segment of a version with less than 1 segment")] + NoMajorSegment, + /// Cannot bump the minor segment of a version with less than 2 segments. + #[error("cannot bump the minor segment of a version with less than 2 segments")] + NoMinorSegment, + /// Cannot bump the patch segment of a version with less than 3 segments. + #[error("cannot bump the patch segment of a version with less than 3 segments")] + NoPatchSegment, + /// Cannot bump the last segment of a version with no segments. + #[error("cannot bump the last segment of a version with no segments")] + NoLastSegment, } diff --git a/crates/rattler_conda_types/src/version/mod.rs b/crates/rattler_conda_types/src/version/mod.rs index 5c82d0542..d64d0c067 100644 --- a/crates/rattler_conda_types/src/version/mod.rs +++ b/crates/rattler_conda_types/src/version/mod.rs @@ -247,38 +247,22 @@ impl Version { match bump_type { VersionBumpType::Major => { if segment_count < 1 { - return Err(VersionBumpError { - reason: String::from( - "cannot bump the major segment of a version with less than 1 segment", - ), - }); + return Err(VersionBumpError::NoMajorSegment); } } VersionBumpType::Minor => { if segment_count < 2 { - return Err(VersionBumpError { - reason: String::from( - "cannot bump the major segment of a version with less than 2 segment", - ), - }); + return Err(VersionBumpError::NoMinorSegment); } } VersionBumpType::Patch => { if segment_count < 3 { - return Err(VersionBumpError { - reason: String::from( - "cannot bump the major segment of a version with less than 3 segment", - ), - }); + return Err(VersionBumpError::NoPatchSegment); } } VersionBumpType::Last => { if segment_count == 0 { - return Err(VersionBumpError { - reason: String::from( - "cannot bump the last segment of a version with no segments", - ), - }); + return Err(VersionBumpError::NoLastSegment); } } } @@ -1049,7 +1033,7 @@ mod test { use rand::seq::SliceRandom; - use crate::version::{StrictVersion, VersionBumpType}; + use crate::version::{StrictVersion, VersionBumpError, VersionBumpType}; use super::Version; @@ -1465,9 +1449,7 @@ mod test { .bump(VersionBumpType::Minor) .unwrap_err(); - assert!(err - .reason - .contains("cannot bump the major segment of a version with less than 2 segment")) + assert_eq!(err, VersionBumpError::NoMinorSegment); } #[test] @@ -1502,8 +1484,6 @@ mod test { .bump(VersionBumpType::Patch) .unwrap_err(); - assert!(err - .reason - .contains("cannot bump the major segment of a version with less than 3 segment")) + assert_eq!(err, VersionBumpError::NoPatchSegment); } } From 2228f1c905aa1e808bcb48eb5e104e7dfbe87f7f Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Tue, 19 Dec 2023 16:38:21 -0500 Subject: [PATCH 05/16] wip attempt for the python binding --- crates/rattler_conda_types/src/version/bump.rs | 1 + py-rattler/src/version/mod.rs | 12 ++++++------ 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/crates/rattler_conda_types/src/version/bump.rs b/crates/rattler_conda_types/src/version/bump.rs index 14d3078e3..939162365 100644 --- a/crates/rattler_conda_types/src/version/bump.rs +++ b/crates/rattler_conda_types/src/version/bump.rs @@ -1,6 +1,7 @@ use thiserror::Error; /// VersionBumpType is used to specify the type of bump to perform on a version. +#[derive(Clone)] pub enum VersionBumpType { /// Bump the major version number. Major, diff --git a/py-rattler/src/version/mod.rs b/py-rattler/src/version/mod.rs index 922e876ad..ccd67926c 100644 --- a/py-rattler/src/version/mod.rs +++ b/py-rattler/src/version/mod.rs @@ -2,8 +2,8 @@ mod component; use crate::PyRattlerError; use component::PyComponent; -use pyo3::{basic::CompareOp, pyclass, pymethods}; -use rattler_conda_types::Version; +use pyo3::{basic::CompareOp, pyclass, pymethods, PyResult}; +use rattler_conda_types::{Version, VersionBumpType}; use std::{ collections::hash_map::DefaultHasher, hash::{Hash, Hasher}, @@ -133,10 +133,10 @@ impl PyVersion { } /// Returns a new version where the last numerical segment of this version has been bumped. - pub fn bump(&self) -> Self { - Self { - inner: self.inner.bump(), - } + pub fn bump(&self, bump_type: VersionBumpType) -> PyResult { + Ok(Self { + inner: self.inner.bump(bump_type).unwrap(), + }) } /// Compute the hash of the version. From f4ea4c621c1de7c137226a1d6f173ce1e3f94f0e Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Wed, 20 Dec 2023 09:54:00 -0500 Subject: [PATCH 06/16] Python binding wrap up --- .../rattler_conda_types/src/version/parse.rs | 4 +- crates/rattler_lock/src/conda.rs | 2 +- .../src/authentication_storage/storage.rs | 4 +- crates/rattler_solve/src/resolvo/mod.rs | 4 +- py-rattler/rattler/exceptions.py | 5 ++ py-rattler/rattler/version/version.py | 56 +++++++++++++++++-- py-rattler/src/error.rs | 6 +- py-rattler/src/lib.rs | 4 +- py-rattler/src/version/mod.rs | 35 ++++++++++-- py-rattler/tests/unit/test_version.py | 16 ++++++ 10 files changed, 120 insertions(+), 16 deletions(-) diff --git a/crates/rattler_conda_types/src/version/parse.rs b/crates/rattler_conda_types/src/version/parse.rs index 8f0bbe6f9..8a90e8b04 100644 --- a/crates/rattler_conda_types/src/version/parse.rs +++ b/crates/rattler_conda_types/src/version/parse.rs @@ -208,7 +208,9 @@ fn trailing_dash_underscore_parser( dash_or_underscore: Option, ) -> IResult<&str, (Option, Option), ParseVersionErrorKind> { // Parse a - or _. Return early if it cannot be found. - let (rest, Some(separator)) = opt(one_of::<_,_,(&str, ErrorKind)>("-_"))(input).map_err(|e| e.map(|(_, kind)| ParseVersionErrorKind::Nom(kind)))? else { + let (rest, Some(separator)) = opt(one_of::<_, _, (&str, ErrorKind)>("-_"))(input) + .map_err(|e| e.map(|(_, kind)| ParseVersionErrorKind::Nom(kind)))? + else { return Ok((input, (None, dash_or_underscore))); }; diff --git a/crates/rattler_lock/src/conda.rs b/crates/rattler_lock/src/conda.rs index 494c9fd8a..4482835be 100644 --- a/crates/rattler_lock/src/conda.rs +++ b/crates/rattler_lock/src/conda.rs @@ -93,7 +93,7 @@ impl TryFrom for RepoDataRecord { .. } = value; let LockedDependencyKind::Conda(value) = specific else { - return Err(ConversionError::NotACondaRecord) + return Err(ConversionError::NotACondaRecord); }; let version = version.parse()?; diff --git a/crates/rattler_networking/src/authentication_storage/storage.rs b/crates/rattler_networking/src/authentication_storage/storage.rs index 94c31d955..063c59ecf 100644 --- a/crates/rattler_networking/src/authentication_storage/storage.rs +++ b/crates/rattler_networking/src/authentication_storage/storage.rs @@ -110,7 +110,7 @@ impl AuthenticationStorage { ) -> Result<(Url, Option), reqwest::Error> { let url = url.into_url()?; let Some(host) = url.host_str() else { - return Ok((url, None)) + return Ok((url, None)); }; match self.get(host) { @@ -121,7 +121,7 @@ impl AuthenticationStorage { // Check for credentials under e.g. `*.prefix.dev` let Some(mut domain) = url.domain() else { - return Ok((url, None)) + return Ok((url, None)); }; loop { diff --git a/crates/rattler_solve/src/resolvo/mod.rs b/crates/rattler_solve/src/resolvo/mod.rs index c0e138542..9424ad336 100644 --- a/crates/rattler_solve/src/resolvo/mod.rs +++ b/crates/rattler_solve/src/resolvo/mod.rs @@ -357,7 +357,9 @@ impl<'a> DependencyProvider> for CondaDependencyProvider<'a> } fn get_dependencies(&self, solvable: SolvableId) -> Dependencies { - let SolverPackageRecord::Record(rec) = self.pool.resolve_solvable(solvable).inner() else { return Dependencies::default() }; + let SolverPackageRecord::Record(rec) = self.pool.resolve_solvable(solvable).inner() else { + return Dependencies::default(); + }; let mut parse_match_spec_cache = self.parse_match_spec_cache.borrow_mut(); let mut dependencies = Dependencies::default(); diff --git a/py-rattler/rattler/exceptions.py b/py-rattler/rattler/exceptions.py index d645d1e3f..5ec6791e9 100644 --- a/py-rattler/rattler/exceptions.py +++ b/py-rattler/rattler/exceptions.py @@ -16,6 +16,7 @@ FetchRepoDataError, SolverError, ConvertSubdirError, + VersionBumpError, ) except ImportError: # They are only redefined for documentation purposes @@ -69,6 +70,9 @@ class SolverError(Exception): # type: ignore[no-redef] class ConvertSubdirError(Exception): # type: ignore[no-redef] """An error that can occur when parsing a platform from a string.""" + class VersionBumpError(Exception): # type: ignore[no-redef] + """An error that can occur when bumping a version.""" + __all__ = [ "ActivationError", @@ -87,4 +91,5 @@ class ConvertSubdirError(Exception): # type: ignore[no-redef] "SolverError", "TransactionError", "ConvertSubdirError", + "VersionBumpError", ] diff --git a/py-rattler/rattler/version/version.py b/py-rattler/rattler/version/version.py index 744db382b..0ce9c2ae8 100644 --- a/py-rattler/rattler/version/version.py +++ b/py-rattler/rattler/version/version.py @@ -49,21 +49,69 @@ def epoch(self) -> Optional[str]: """ return self._version.epoch() - def bump(self) -> Version: + def bump_major(self) -> Version: """ - Returns a new version where the last numerical segment of this version has + Returns a new version where the major segment of this version has been bumped. Examples -------- ```python >>> v = Version('1.0') - >>> v.bump() + >>> v.bump_major() + Version("2.0") + >>> + ``` + """ + return Version._from_py_version(self._version.bump_major()) + + def bump_minor(self) -> Version: + """ + Returns a new version where the minor segment of this version has + been bumped. + + Examples + -------- + ```python + >>> v = Version('1.0') + >>> v.bump_minor() + Version("1.1") + >>> + ``` + """ + return Version._from_py_version(self._version.bump_minor()) + + def bump_patch(self) -> Version: + """ + Returns a new version where the patch segment of this version has + been bumped. + + Examples + -------- + ```python + >>> v = Version('1.0.5') + >>> v.bump_patch() + Version("1.0.6") + >>> + ``` + """ + return Version._from_py_version(self._version.bump_patch()) + + def bump_last(self) -> Version: + """ + Returns a new version where the last segment of this version has + been bumped. + + Examples + -------- + ```python + >>> v = Version('1.0') + >>> v.bump_last() Version("1.1") >>> ``` """ - return Version._from_py_version(self._version.bump()) + return Version._from_py_version(self._version.bump_last()) @property def has_local(self) -> bool: diff --git a/py-rattler/src/error.rs b/py-rattler/src/error.rs index 463905527..2f376b3b7 100644 --- a/py-rattler/src/error.rs +++ b/py-rattler/src/error.rs @@ -5,7 +5,7 @@ use pyo3::{create_exception, PyErr}; use rattler::install::TransactionError; use rattler_conda_types::{ ConvertSubdirError, InvalidPackageNameError, ParseArchError, ParseChannelError, - ParseMatchSpecError, ParsePlatformError, ParseVersionError, + ParseMatchSpecError, ParsePlatformError, ParseVersionError, VersionBumpError, }; use rattler_repodata_gateway::fetch::FetchRepoDataError; use rattler_shell::activation::ActivationError; @@ -48,6 +48,8 @@ pub enum PyRattlerError { LinkError(String), #[error(transparent)] ConverSubdirError(#[from] ConvertSubdirError), + #[error(transparent)] + VersionBumpError(#[from] VersionBumpError), } impl From for PyErr { @@ -85,6 +87,7 @@ impl From for PyErr { PyRattlerError::ConverSubdirError(err) => { ConvertSubdirException::new_err(err.to_string()) } + PyRattlerError::VersionBumpError(err) => VersionBumpException::new_err(err.to_string()), } } } @@ -105,3 +108,4 @@ create_exception!(exceptions, SolverException, PyException); create_exception!(exceptions, TransactionException, PyException); create_exception!(exceptions, LinkException, PyException); create_exception!(exceptions, ConvertSubdirException, PyException); +create_exception!(exceptions, VersionBumpException, PyException); diff --git a/py-rattler/src/lib.rs b/py-rattler/src/lib.rs index bddd5c878..83d77dc74 100644 --- a/py-rattler/src/lib.rs +++ b/py-rattler/src/lib.rs @@ -23,7 +23,7 @@ use error::{ FetchRepoDataException, InvalidChannelException, InvalidMatchSpecException, InvalidPackageNameException, InvalidUrlException, InvalidVersionException, IoException, LinkException, ParseArchException, ParsePlatformException, PyRattlerError, SolverException, - TransactionException, + TransactionException, VersionBumpException, }; use generic_virtual_package::PyGenericVirtualPackage; use match_spec::PyMatchSpec; @@ -143,5 +143,7 @@ fn rattler(py: Python, m: &PyModule) -> PyResult<()> { py.get_type::(), ) .unwrap(); + m.add("VersionBumpError", py.get_type::()) + .unwrap(); Ok(()) } diff --git a/py-rattler/src/version/mod.rs b/py-rattler/src/version/mod.rs index ccd67926c..0fb479d80 100644 --- a/py-rattler/src/version/mod.rs +++ b/py-rattler/src/version/mod.rs @@ -132,11 +132,36 @@ impl PyVersion { } } - /// Returns a new version where the last numerical segment of this version has been bumped. - pub fn bump(&self, bump_type: VersionBumpType) -> PyResult { - Ok(Self { - inner: self.inner.bump(bump_type).unwrap(), - }) + /// Returns a new version where the major segment of this version has been bumped. + pub fn bump_major(&self) -> PyResult { + match self.inner.bump(VersionBumpType::Major) { + Ok(v) => Ok(Self { inner: v }), + Err(e) => Err(PyRattlerError::from(e).into()), + } + } + + /// Returns a new version where the minor segment of this version has been bumped. + pub fn bump_minor(&self) -> PyResult { + match self.inner.bump(VersionBumpType::Minor) { + Ok(v) => Ok(Self { inner: v }), + Err(e) => Err(PyRattlerError::from(e).into()), + } + } + + /// Returns a new version where the patch segment of this version has been bumped. + pub fn bump_patch(&self) -> PyResult { + match self.inner.bump(VersionBumpType::Patch) { + Ok(v) => Ok(Self { inner: v }), + Err(e) => Err(PyRattlerError::from(e).into()), + } + } + + /// Returns a new version where the last segment of this version has been bumped. + pub fn bump_last(&self) -> PyResult { + match self.inner.bump(VersionBumpType::Last) { + Ok(v) => Ok(Self { inner: v }), + Err(e) => Err(PyRattlerError::from(e).into()), + } } /// Compute the hash of the version. diff --git a/py-rattler/tests/unit/test_version.py b/py-rattler/tests/unit/test_version.py index 438c66bf7..7b46ef0b4 100644 --- a/py-rattler/tests/unit/test_version.py +++ b/py-rattler/tests/unit/test_version.py @@ -1,5 +1,6 @@ import pytest from rattler import Version +from rattler.exceptions import VersionBumpError def test_version_dash_normalisation() -> None: @@ -17,3 +18,18 @@ def test_version_dash_normalisation() -> None: with pytest.raises(Exception): Version("1-.0dev+3.4-") + + +def test_bump() -> None: + assert Version("0.5.5").bump_major() == Version("1.5.5") + assert Version("0.5.5").bump_minor() == Version("0.6.5") + assert Version("0.5.5").bump_patch() == Version("0.5.6") + assert Version("0.5.5").bump_last() == Version("0.5.6") + + +def test_bump_fail() -> None: + with pytest.raises(VersionBumpError): + Version("1").bump_minor() + + with pytest.raises(VersionBumpError): + Version("1.5").bump_patch() From 9283770893b34b895694b1b28652ffbb618db55f Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Wed, 20 Dec 2023 11:34:58 -0500 Subject: [PATCH 07/16] introduce `VersionBumpType::Segment(i32)` --- .../rattler_conda_types/src/version/bump.rs | 10 ++- crates/rattler_conda_types/src/version/mod.rs | 85 +++++++++++++++++++ 2 files changed, 94 insertions(+), 1 deletion(-) diff --git a/crates/rattler_conda_types/src/version/bump.rs b/crates/rattler_conda_types/src/version/bump.rs index 939162365..4c620bf71 100644 --- a/crates/rattler_conda_types/src/version/bump.rs +++ b/crates/rattler_conda_types/src/version/bump.rs @@ -9,8 +9,10 @@ pub enum VersionBumpType { Minor, /// Bump the patch version number. Patch, - /// Bump the last version number. + /// Bump the last version number. Last, + /// Bump a given segment. If negative, count from the end. + Segment(i32), } /// VersionBumpError is used to specify the type of error that occurred when bumping a version. @@ -28,4 +30,10 @@ pub enum VersionBumpError { /// Cannot bump the last segment of a version with no segments. #[error("cannot bump the last segment of a version with no segments")] NoLastSegment, + /// Invalid segment index. + #[error("cannot bump the segment '{index:?}' of a version if it's not present")] + InvalidSegment { + /// The segment index that was attempted to be bumped. + index: i32, + }, } diff --git a/crates/rattler_conda_types/src/version/mod.rs b/crates/rattler_conda_types/src/version/mod.rs index d64d0c067..405da8b5f 100644 --- a/crates/rattler_conda_types/src/version/mod.rs +++ b/crates/rattler_conda_types/src/version/mod.rs @@ -265,6 +265,19 @@ impl Version { return Err(VersionBumpError::NoLastSegment); } } + VersionBumpType::Segment(index) => { + let uindex; + + if index < 0 { + uindex = segment_count as i32 + index; + } else { + uindex = index; + } + + if uindex < 0 || uindex >= segment_count as i32 { + return Err(VersionBumpError::InvalidSegment { index: index }); + } + } } // Copy over all the segments and bump the last segment. @@ -281,6 +294,13 @@ impl Version { VersionBumpType::Minor => idx == 1, VersionBumpType::Patch => idx == 2, VersionBumpType::Last => idx == (segment_count - 1), + VersionBumpType::Segment(mut index_to_bump) => { + if index_to_bump < 0 { + index_to_bump = segment_count as i32 + index_to_bump; + } + + idx == index_to_bump as usize + } }; // Bump the segment if we need to. Each segment must at least start with a number so this should always work. @@ -1486,4 +1506,69 @@ mod test { assert_eq!(err, VersionBumpError::NoPatchSegment); } + + #[test] + fn bump_segment() { + // Positive index + assert_eq!( + Version::from_str("1.1.9") + .unwrap() + .bump(VersionBumpType::Segment(0)) + .unwrap(), + Version::from_str("2.1.9").unwrap() + ); + assert_eq!( + Version::from_str("1.1.9") + .unwrap() + .bump(VersionBumpType::Segment(1)) + .unwrap(), + Version::from_str("1.2.9").unwrap() + ); + assert_eq!( + Version::from_str("1.1.9") + .unwrap() + .bump(VersionBumpType::Segment(2)) + .unwrap(), + Version::from_str("1.1.10").unwrap() + ); + // Negative index + assert_eq!( + Version::from_str("1.1.9") + .unwrap() + .bump(VersionBumpType::Segment(-1)) + .unwrap(), + Version::from_str("1.1.10").unwrap() + ); + assert_eq!( + Version::from_str("1.1.9") + .unwrap() + .bump(VersionBumpType::Segment(-2)) + .unwrap(), + Version::from_str("1.2.9").unwrap() + ); + assert_eq!( + Version::from_str("1.1.9") + .unwrap() + .bump(VersionBumpType::Segment(-3)) + .unwrap(), + Version::from_str("2.1.9").unwrap() + ); + } + + #[test] + fn bump_segment_fail() { + let err = Version::from_str("1.3") + .unwrap() + .bump(VersionBumpType::Segment(3)) + .unwrap_err(); + + assert_eq!(err, VersionBumpError::InvalidSegment { index: 3 }); + + let err = Version::from_str("1.3") + .unwrap() + .bump(VersionBumpType::Segment(-3)) + .unwrap_err(); + + assert_eq!(err, VersionBumpError::InvalidSegment { index: -3 }); + } } From 4ac1858337f0039d950dcda5408caea378abe917 Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Wed, 20 Dec 2023 11:44:13 -0500 Subject: [PATCH 08/16] python binding for `bump_segment` --- py-rattler/rattler/version/version.py | 16 ++++++++++++++++ py-rattler/src/version/mod.rs | 8 ++++++++ py-rattler/tests/unit/test_version.py | 8 ++++++++ 3 files changed, 32 insertions(+) diff --git a/py-rattler/rattler/version/version.py b/py-rattler/rattler/version/version.py index 0ce9c2ae8..887ca8218 100644 --- a/py-rattler/rattler/version/version.py +++ b/py-rattler/rattler/version/version.py @@ -113,6 +113,22 @@ def bump_last(self) -> Version: """ return Version._from_py_version(self._version.bump_last()) + def bump_segment(self, index: int) -> Version: + """ + Returns a new version where the last segment of this version has + been bumped. + + Examples + -------- + ```python + >>> v = Version('1.0') + >>> v.bump_segment(index=1) + Version("1.1") + >>> + ``` + """ + return Version._from_py_version(self._version.bump_segment(index)) + @property def has_local(self) -> bool: """ diff --git a/py-rattler/src/version/mod.rs b/py-rattler/src/version/mod.rs index 0fb479d80..441547105 100644 --- a/py-rattler/src/version/mod.rs +++ b/py-rattler/src/version/mod.rs @@ -164,6 +164,14 @@ impl PyVersion { } } + /// Returns a new version where the given segment of this version has been bumped. + pub fn bump_segment(&self, index: i32) -> PyResult { + match self.inner.bump(VersionBumpType::Segment(index)) { + Ok(v) => Ok(Self { inner: v }), + Err(e) => Err(PyRattlerError::from(e).into()), + } + } + /// Compute the hash of the version. fn __hash__(&self) -> u64 { let mut hasher = DefaultHasher::new(); diff --git a/py-rattler/tests/unit/test_version.py b/py-rattler/tests/unit/test_version.py index 7b46ef0b4..f2b24744a 100644 --- a/py-rattler/tests/unit/test_version.py +++ b/py-rattler/tests/unit/test_version.py @@ -25,6 +25,8 @@ def test_bump() -> None: assert Version("0.5.5").bump_minor() == Version("0.6.5") assert Version("0.5.5").bump_patch() == Version("0.5.6") assert Version("0.5.5").bump_last() == Version("0.5.6") + assert Version("0.5.5").bump_segment(1) == Version("0.6.5") + assert Version("0.5.5").bump_segment(-1) == Version("0.5.6") def test_bump_fail() -> None: @@ -33,3 +35,9 @@ def test_bump_fail() -> None: with pytest.raises(VersionBumpError): Version("1.5").bump_patch() + + with pytest.raises(VersionBumpError): + Version("1.5").bump_segment(-5) + + with pytest.raises(VersionBumpError): + Version("1.5").bump_segment(5) From 90cd9ce5c58826f3f62ce8ee3c57d3e4d11cedd0 Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Wed, 20 Dec 2023 12:32:14 -0500 Subject: [PATCH 09/16] lint --- crates/rattler_conda_types/src/version/mod.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/crates/rattler_conda_types/src/version/mod.rs b/crates/rattler_conda_types/src/version/mod.rs index 405da8b5f..24ec079d5 100644 --- a/crates/rattler_conda_types/src/version/mod.rs +++ b/crates/rattler_conda_types/src/version/mod.rs @@ -266,16 +266,16 @@ impl Version { } } VersionBumpType::Segment(index) => { - let uindex; + // let uindex; - if index < 0 { - uindex = segment_count as i32 + index; + let uindex = if index < 0 { + segment_count as i32 + index } else { - uindex = index; - } + index + }; if uindex < 0 || uindex >= segment_count as i32 { - return Err(VersionBumpError::InvalidSegment { index: index }); + return Err(VersionBumpError::InvalidSegment { index }); } } } From 951fbc840b880fc6dccbf9d659d9eee5e872f904 Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Wed, 20 Dec 2023 12:42:46 -0500 Subject: [PATCH 10/16] cleaning --- crates/rattler_conda_types/src/version/mod.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/crates/rattler_conda_types/src/version/mod.rs b/crates/rattler_conda_types/src/version/mod.rs index 24ec079d5..864edd02b 100644 --- a/crates/rattler_conda_types/src/version/mod.rs +++ b/crates/rattler_conda_types/src/version/mod.rs @@ -266,8 +266,6 @@ impl Version { } } VersionBumpType::Segment(index) => { - // let uindex; - let uindex = if index < 0 { segment_count as i32 + index } else { From 87bd09b486c1b3b4b2e59b4ebf2a6fb73ca60724 Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Wed, 20 Dec 2023 12:48:59 -0500 Subject: [PATCH 11/16] more cleaning --- crates/rattler_conda_types/src/version/mod.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/crates/rattler_conda_types/src/version/mod.rs b/crates/rattler_conda_types/src/version/mod.rs index 864edd02b..4ac0b7f14 100644 --- a/crates/rattler_conda_types/src/version/mod.rs +++ b/crates/rattler_conda_types/src/version/mod.rs @@ -294,7 +294,7 @@ impl Version { VersionBumpType::Last => idx == (segment_count - 1), VersionBumpType::Segment(mut index_to_bump) => { if index_to_bump < 0 { - index_to_bump = segment_count as i32 + index_to_bump; + index_to_bump += segment_count as i32; } idx == index_to_bump as usize @@ -306,8 +306,7 @@ impl Version { let last_numeral_component = segment_components .iter_mut() .filter_map(Component::as_number_mut) - .rev() - .next() + .next_back() .expect("every segment must at least contain a single numeric component"); *last_numeral_component += 1; } From 3c85dbad9ea76ad762ba40ef2e7dfccd013617bc Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Thu, 21 Dec 2023 08:04:29 -0500 Subject: [PATCH 12/16] Update py-rattler/src/version/mod.rs Co-authored-by: Tarun Pratap Singh <101409098+Wackyator@users.noreply.github.com> --- py-rattler/src/version/mod.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/py-rattler/src/version/mod.rs b/py-rattler/src/version/mod.rs index 441547105..6bb41c79c 100644 --- a/py-rattler/src/version/mod.rs +++ b/py-rattler/src/version/mod.rs @@ -134,7 +134,11 @@ impl PyVersion { /// Returns a new version where the major segment of this version has been bumped. pub fn bump_major(&self) -> PyResult { - match self.inner.bump(VersionBumpType::Major) { + Ok(self + .inner + .bump(VersionBumpType::Major) + .map(Into::into) + .map_err(PyRattlerError::from)?) Ok(v) => Ok(Self { inner: v }), Err(e) => Err(PyRattlerError::from(e).into()), } From d3a63627a23b69e28dec5ffeef5fed939bd7727e Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Thu, 21 Dec 2023 08:11:10 -0500 Subject: [PATCH 13/16] Refactor version bumping methods in PyVersion --- py-rattler/src/version/mod.rs | 39 ++++++++++++++++++----------------- 1 file changed, 20 insertions(+), 19 deletions(-) diff --git a/py-rattler/src/version/mod.rs b/py-rattler/src/version/mod.rs index 6bb41c79c..7c18a7738 100644 --- a/py-rattler/src/version/mod.rs +++ b/py-rattler/src/version/mod.rs @@ -139,41 +139,42 @@ impl PyVersion { .bump(VersionBumpType::Major) .map(Into::into) .map_err(PyRattlerError::from)?) - Ok(v) => Ok(Self { inner: v }), - Err(e) => Err(PyRattlerError::from(e).into()), - } } /// Returns a new version where the minor segment of this version has been bumped. pub fn bump_minor(&self) -> PyResult { - match self.inner.bump(VersionBumpType::Minor) { - Ok(v) => Ok(Self { inner: v }), - Err(e) => Err(PyRattlerError::from(e).into()), - } + Ok(self + .inner + .bump(VersionBumpType::Minor) + .map(Into::into) + .map_err(PyRattlerError::from)?) } /// Returns a new version where the patch segment of this version has been bumped. pub fn bump_patch(&self) -> PyResult { - match self.inner.bump(VersionBumpType::Patch) { - Ok(v) => Ok(Self { inner: v }), - Err(e) => Err(PyRattlerError::from(e).into()), - } + Ok(self + .inner + .bump(VersionBumpType::Patch) + .map(Into::into) + .map_err(PyRattlerError::from)?) } /// Returns a new version where the last segment of this version has been bumped. pub fn bump_last(&self) -> PyResult { - match self.inner.bump(VersionBumpType::Last) { - Ok(v) => Ok(Self { inner: v }), - Err(e) => Err(PyRattlerError::from(e).into()), - } + Ok(self + .inner + .bump(VersionBumpType::Last) + .map(Into::into) + .map_err(PyRattlerError::from)?) } /// Returns a new version where the given segment of this version has been bumped. pub fn bump_segment(&self, index: i32) -> PyResult { - match self.inner.bump(VersionBumpType::Segment(index)) { - Ok(v) => Ok(Self { inner: v }), - Err(e) => Err(PyRattlerError::from(e).into()), - } + Ok(self + .inner + .bump(VersionBumpType::Segment(index)) + .map(Into::into) + .map_err(PyRattlerError::from)?) } /// Compute the hash of the version. From 4d77802a40b8de96841036bda2d33be2d198fd8d Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Thu, 21 Dec 2023 08:12:06 -0500 Subject: [PATCH 14/16] Remove unused test_bump function --- py-rattler/tests/unit/test_version.py | 9 --------- 1 file changed, 9 deletions(-) diff --git a/py-rattler/tests/unit/test_version.py b/py-rattler/tests/unit/test_version.py index f2b24744a..74d4b83ff 100644 --- a/py-rattler/tests/unit/test_version.py +++ b/py-rattler/tests/unit/test_version.py @@ -20,15 +20,6 @@ def test_version_dash_normalisation() -> None: Version("1-.0dev+3.4-") -def test_bump() -> None: - assert Version("0.5.5").bump_major() == Version("1.5.5") - assert Version("0.5.5").bump_minor() == Version("0.6.5") - assert Version("0.5.5").bump_patch() == Version("0.5.6") - assert Version("0.5.5").bump_last() == Version("0.5.6") - assert Version("0.5.5").bump_segment(1) == Version("0.6.5") - assert Version("0.5.5").bump_segment(-1) == Version("0.5.6") - - def test_bump_fail() -> None: with pytest.raises(VersionBumpError): Version("1").bump_minor() From a471b0c225bacdc44b5ae68ca9edf370375f9448 Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Tue, 2 Jan 2024 09:44:53 -0500 Subject: [PATCH 15/16] move tests to doctests --- py-rattler/rattler/version/version.py | 15 +++++++++++++++ py-rattler/tests/unit/test_version.py | 14 -------------- 2 files changed, 15 insertions(+), 14 deletions(-) diff --git a/py-rattler/rattler/version/version.py b/py-rattler/rattler/version/version.py index 887ca8218..8c39f47de 100644 --- a/py-rattler/rattler/version/version.py +++ b/py-rattler/rattler/version/version.py @@ -77,6 +77,10 @@ def bump_minor(self) -> Version: >>> v.bump_minor() Version("1.1") >>> + >>> Version("1").bump_minor() # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + exceptions.VersionBumpException + >>> ``` """ return Version._from_py_version(self._version.bump_minor()) @@ -93,6 +97,10 @@ def bump_patch(self) -> Version: >>> v.bump_patch() Version("1.0.6") >>> + >>> Version("1.5").bump_patch() # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + exceptions.VersionBumpException + >>> ``` """ return Version._from_py_version(self._version.bump_patch()) @@ -125,6 +133,13 @@ def bump_segment(self, index: int) -> Version: >>> v.bump_segment(index=1) Version("1.1") >>> + >>> Version("1.5").bump_segment(-5) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + exceptions.VersionBumpException + >>> Version("1.5").bump_segment(5) # doctest: +IGNORE_EXCEPTION_DETAIL + Traceback (most recent call last): + exceptions.VersionBumpException + >>> ``` """ return Version._from_py_version(self._version.bump_segment(index)) diff --git a/py-rattler/tests/unit/test_version.py b/py-rattler/tests/unit/test_version.py index 74d4b83ff..82edf1e9f 100644 --- a/py-rattler/tests/unit/test_version.py +++ b/py-rattler/tests/unit/test_version.py @@ -18,17 +18,3 @@ def test_version_dash_normalisation() -> None: with pytest.raises(Exception): Version("1-.0dev+3.4-") - - -def test_bump_fail() -> None: - with pytest.raises(VersionBumpError): - Version("1").bump_minor() - - with pytest.raises(VersionBumpError): - Version("1.5").bump_patch() - - with pytest.raises(VersionBumpError): - Version("1.5").bump_segment(-5) - - with pytest.raises(VersionBumpError): - Version("1.5").bump_segment(5) From 5f6e07004563fe92186668046cb76a41dc6b45f4 Mon Sep 17 00:00:00 2001 From: Hadrien Mary Date: Tue, 2 Jan 2024 09:45:41 -0500 Subject: [PATCH 16/16] cleaning --- py-rattler/tests/unit/test_version.py | 1 - 1 file changed, 1 deletion(-) diff --git a/py-rattler/tests/unit/test_version.py b/py-rattler/tests/unit/test_version.py index 82edf1e9f..438c66bf7 100644 --- a/py-rattler/tests/unit/test_version.py +++ b/py-rattler/tests/unit/test_version.py @@ -1,6 +1,5 @@ import pytest from rattler import Version -from rattler.exceptions import VersionBumpError def test_version_dash_normalisation() -> None: