Versioning

Author: eduairet

development_tools/Cargo.toml

@@ -8,4 +8,5 @@ chrono = "0.4.38"
 env_logger = "0.11.4"
 log = "0.4.22"
 log4rs = "1.3.0"
+semver = "1.0.23"
 syslog = "6.1.1"

development_tools/src/versioning.rs

@@ -1,4 +1,41 @@
-/// TODO implement
-pub fn parse_and_increment_version(version: &str) -> String {
-    version.to_string()
+use semver::{Error, Version, VersionReq};
+
+/// Find the maximum version that satisfies the given version requirement string.
+///
+/// # Arguments
+///
+/// * `version_req_str` - A string slice that holds the version requirement.
+/// * `iterable` - An iterator over a collection of strings that can be parsed into versions.
+///
+/// # Returns
+///
+/// * `Ok(Some(Version))` - The maximum version that satisfies the version requirement.
+/// * `Ok(None)` - If no version satisfies the version requirement.
+/// * `Err(Error)` - If the version requirement string is invalid.
+///
+/// # Example
+///
+/// ```
+/// use development_tools::find_max_matching_version;
+/// use semver::Version;
+///
+/// assert_eq!(
+///    find_max_matching_version("<= 1.0.0", vec!["0.9.0", "1.0.0", "1.0.1"]).unwrap(),
+///    Some(Version::parse("1.0.0").unwrap())
+/// );
+/// ```
+pub fn find_max_matching_version<'a, I>(
+    version_req_str: &str,
+    iterable: I,
+) -> Result<Option<Version>, Error>
+where
+    I: IntoIterator<Item = &'a str>,
+{
+    let v_req = VersionReq::parse(version_req_str)?;
+
+    Ok(iterable
+        .into_iter()
+        .filter_map(|s| Version::parse(s).ok())
+        .filter(|s| v_req.matches(s))
+        .max())
 }

development_tools/tests/tests_versioning.rs

@@ -1,2 +1,113 @@
+use development_tools::find_max_matching_version;
+use semver::{BuildMetadata, Prerelease, Version, VersionReq};
+use std::process::Command;
+
 #[cfg(test)]
-mod tests_versioning {}
+mod tests_versioning {
+
+    use super::*;
+
+    #[test]
+    fn test_parse_and_increment_version() {
+        let mut parsed_version = Version::parse("0.2.6").unwrap();
+
+        assert_eq!(
+            parsed_version,
+            Version {
+                major: 0,
+                minor: 2,
+                patch: 6,
+                pre: Prerelease::EMPTY,
+                build: BuildMetadata::EMPTY,
+            }
+        );
+
+        parsed_version.patch += 1;
+        assert_eq!(parsed_version.to_string(), "0.2.7");
+        println!("New patch release: v{}", parsed_version);
+
+        parsed_version.minor += 1;
+        parsed_version.patch = 0;
+        assert_eq!(parsed_version.to_string(), "0.3.0");
+        println!("New minor release: v{}", parsed_version);
+
+        parsed_version.major += 1;
+        parsed_version.minor = 0;
+        assert_eq!(parsed_version.to_string(), "1.0.0");
+        println!("New major release: v{}", parsed_version);
+    }
+
+    #[test]
+    fn test_parse_complex_version() {
+        let version_str = "1.0.49-125+g72ee7853";
+        let parsed_version = Version::parse(version_str).unwrap();
+        let pre = Prerelease::new("125").unwrap();
+        let build = BuildMetadata::new("g72ee7853").unwrap();
+
+        assert_eq!(
+            parsed_version,
+            Version {
+                major: 1,
+                minor: 0,
+                patch: 49,
+                pre,
+                build
+            }
+        );
+
+        assert_eq!(
+            parsed_version.build,
+            BuildMetadata::new("g72ee7853").unwrap()
+        );
+
+        let serialized_version = parsed_version.to_string();
+        assert_eq!(&serialized_version, version_str);
+    }
+
+    #[test]
+    fn test_version_is_prerelease() {
+        let version_1 = Version::parse("1.0.0-alpha").unwrap();
+        let version_2 = Version::parse("1.0.0").unwrap();
+
+        assert!(!version_1.pre.is_empty());
+        assert!(version_2.pre.is_empty());
+    }
+
+    #[test]
+    fn test_find_max_matching_version() {
+        assert_eq!(
+            find_max_matching_version("<= 1.0.0", vec!["0.9.0", "1.0.0", "1.0.1"]).unwrap(),
+            Some(Version::parse("1.0.0").unwrap())
+        );
+
+        assert_eq!(
+            find_max_matching_version(
+                ">1.2.3-alpha.3",
+                vec![
+                    "1.2.3-alpha.3",
+                    "1.2.3-alpha.4",
+                    "1.2.3-alpha.10",
+                    "1.2.3-beta.4",
+                    "3.4.5-alpha.9",
+                ]
+            )
+            .unwrap(),
+            Some(Version::parse("1.2.3-beta.4").unwrap())
+        );
+    }
+
+    #[test]
+    fn test_check_external_command_version_for_compatibility() {
+        let version_constraint = ">=1.50.0";
+        let version_test = VersionReq::parse(version_constraint).unwrap();
+        let output = Command::new("rustc").arg("--version").output().unwrap();
+
+        assert_eq!(output.status.success(), true);
+
+        let version_str = String::from_utf8(output.stdout).unwrap();
+        let version = version_str.split_whitespace().nth(1).unwrap();
+        let parsed_version = Version::parse(version).unwrap();
+
+        assert!(version_test.matches(&parsed_version));
+    }
+}

src/main.rs

@@ -283,7 +283,7 @@ fn main() {
     log::debug!("[foo] debug");
     foo::run();
     // Versioning
-    let version = "1.2.3";
-    let result = parse_and_increment_version(version);
-    println!("Version: {}", result);
+    let max_version =
+        find_max_matching_version("<= 1.0.0", vec!["0.9.0", "1.0.0", "1.0.1"]).unwrap();
+    println!("Max version: {:?}", max_version);
 }