1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
pub mod comp_op;
pub mod version;
pub mod version_part;
#[cfg(test)]
mod test;
use comp_op::CompOp;
use version::Version;
/// Version compare structure.
pub struct VersionCompare { }
/// Version compare implementation.
impl VersionCompare {
/// Compare two version number strings to each other.
/// This compares version `a` to version `b`, and returns whether version `a` is greater, less
/// or equal to version `b`.
///
/// The two given version numbers must be valid, or an error will be returned.
///
/// One of the following ok results may be returned:
/// - CompOp::Eq
/// - CompOp::Lt
/// - CompOp::Gt
///
/// # Examples
///
/// ```
/// use version_compare::VersionCompare;
/// use version_compare::comp_op::CompOp;
///
/// // Compare version numbers
/// assert_eq!(VersionCompare::compare("1.2.3", "1.2.3"), Ok(CompOp::Eq));
/// assert_eq!(VersionCompare::compare("1.2.3", "1.2.4"), Ok(CompOp::Lt));
/// assert_eq!(VersionCompare::compare("1", "0.1"), Ok(CompOp::Gt));
/// ```
pub fn compare(a: &str, b: &str) -> Result<CompOp, ()> {
// Create version instances
let a_ver = Version::from(a);
let b_ver = Version::from(b);
// Both version numbers must have been parsed
if a_ver.is_none() || b_ver.is_none() {
return Err(());
}
// Compare and return the result
Ok(a_ver.unwrap().compare(&b_ver.unwrap()))
}
/// Compare two version number strings to each other and check whether the given comparison
/// `operator` is valid.
///
/// The two given version numbers must be valid, or an error will be returned.
///
/// # Examples
///
/// ```
/// use version_compare::VersionCompare;
/// use version_compare::comp_op::CompOp;
///
/// // Compare version numbers
/// assert!(VersionCompare::compare_to("1.2.3", "1.2.3", &CompOp::Eq).unwrap());
/// assert!(VersionCompare::compare_to("1.2.3", "1.2.3", &CompOp::Le).unwrap());
/// assert!(VersionCompare::compare_to("1.2.3", "1.2.4", &CompOp::Lt).unwrap());
/// assert!(VersionCompare::compare_to("1", "0.1", &CompOp::Gt).unwrap());
/// assert!(VersionCompare::compare_to("1", "0.1", &CompOp::Ge).unwrap());
/// ```
pub fn compare_to(a: &str, b: &str, operator: &CompOp) -> Result<bool, ()> {
// Create version instances
let a_ver = Version::from(a);
let b_ver = Version::from(b);
// Both version numbers must have been parsed
if a_ver.is_none() || b_ver.is_none() {
return Err(());
}
// Compare and return the result
Ok(a_ver.unwrap().compare_to(&b_ver.unwrap(), &operator))
}
}
#[cfg(test)]
mod tests {
use comp_op::CompOp;
use test::test_version_set::TEST_VERSION_SETS;
use super::VersionCompare;
#[test]
fn compare() {
// Compare each version in the version set
for entry in TEST_VERSION_SETS {
assert_eq!(
VersionCompare::compare(&entry.0, &entry.1),
Ok(entry.2.clone())
);
}
}
#[test]
fn compare_to() {
// Compare each version in the version set
for entry in TEST_VERSION_SETS {
// Test
assert!(VersionCompare::compare_to(&entry.0, &entry.1, &entry.2).unwrap());
// Make sure the inverse operator is not correct
assert_eq!(VersionCompare::compare_to(&entry.0, &entry.1, &entry.2.invert()).unwrap(), false);
}
// Assert an exceptional case, compare to not equal
assert!(VersionCompare::compare_to("1.2.3", "1.2", &CompOp::Ne).unwrap());
}
}