chore: version cmp cheatcodes clean up (foundry-rs#9914)

Author: DaniPopes

crates/cheatcodes/assets/cheatcodes.json

@@ -1677,21 +1677,27 @@ interface Vm {
         string calldata error
     ) external pure;
 
-    /// Returns true if the current Foundry version is at least the given version.
-    /// Version string can be in the format `major.minor.patch`.
+    /// Returns true if the current Foundry version is greater than or equal to the given version.
+    /// The given version string must be in the format `major.minor.patch`.
+    ///
+    /// This is equivalent to `foundryVersionCmp(version) >= 0`.
     #[cheatcode(group = Testing, safety = Safe)]
     function foundryVersionAtLeast(string calldata version) external view returns (bool);
 
     /// Compares the current Foundry version with the given version string.
-    /// Version string can be in the format `major.minor.patch`.
+    /// The given version string must be in the format `major.minor.patch`.
+    ///
     /// Returns:
-    /// -1 if current version is less than the given version
-    /// 0 if current version equals the given version
-    /// 1 if current version is greater than the given version
+    /// -1 if current Foundry version is less than the given version
+    /// 0 if current Foundry version equals the given version
+    /// 1 if current Foundry version is greater than the given version
+    ///
+    /// This result can then be used with a comparison operator against `0`.
+    /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:
+    /// `if (foundryVersionCmp("1.0.0") >= 0) { ... }`
     #[cheatcode(group = Testing, safety = Safe)]
     function foundryVersionCmp(string calldata version) external view returns (int256);
 
-
     // ======== OS and Filesystem ========
 
     // -------- Metadata --------

crates/cheatcodes/spec/src/vm.rs

@@ -7,45 +7,35 @@ use std::cmp::Ordering;
 impl Cheatcode for foundryVersionCmpCall {
     fn apply(&self, _state: &mut Cheatcodes) -> Result {
         let Self { version } = self;
-
-        if version.contains("+") || version.contains("-") {
-            return Err(fmt_err!("Version must be in only major.minor.patch format"));
-        }
-
-        let parsed_version = Version::parse(version)
-            .map_err(|e| fmt_err!("Invalid semver format '{}': {}", version, e))?;
-        let current_semver = Version::parse(SEMVER_VERSION)
-            .map_err(|_| fmt_err!("Invalid current version format"))?;
-
-        let current_version =
-            Version::new(current_semver.major, current_semver.minor, current_semver.patch);
-        // Note: returns -1 if current < provided, 0 if equal, 1 if current > provided.
-        let cmp_result = match current_version.cmp(&parsed_version) {
-            Ordering::Less => -1i32,
-            Ordering::Equal => 0i32,
-            Ordering::Greater => 1i32,
-        };
-        Ok(cmp_result.abi_encode())
+        foundry_version_cmp(version).map(|cmp| (cmp as i8).abi_encode())
     }
 }
 
 impl Cheatcode for foundryVersionAtLeastCall {
     fn apply(&self, _state: &mut Cheatcodes) -> Result {
         let Self { version } = self;
+        foundry_version_cmp(version).map(|cmp| cmp.is_ge().abi_encode())
+    }
+}
 
-        if version.contains("+") || version.contains("-") {
-            return Err(fmt_err!("Version must be in only major.minor.patch format"));
-        }
-
-        let parsed_version =
-            Version::parse(version).map_err(|_| fmt_err!("Invalid version format"))?;
-        let current_semver = Version::parse(SEMVER_VERSION)
-            .map_err(|_| fmt_err!("Invalid current version format"))?;
+fn foundry_version_cmp(version: &str) -> Result<Ordering> {
+    version_cmp(SEMVER_VERSION.split('-').next().unwrap(), version)
+}
 
-        let current_version =
-            Version::new(current_semver.major, current_semver.minor, current_semver.patch);
+fn version_cmp(version_a: &str, version_b: &str) -> Result<Ordering> {
+    let version_a = parse_version(version_a)?;
+    let version_b = parse_version(version_b)?;
+    Ok(version_a.cmp(&version_b))
+}
 
-        let at_least = current_version.cmp(&parsed_version) != Ordering::Less;
-        Ok(at_least.abi_encode())
+fn parse_version(version: &str) -> Result<Version> {
+    let version =
+        Version::parse(version).map_err(|e| fmt_err!("invalid version `{version}`: {e}"))?;
+    if !version.pre.is_empty() {
+        return Err(fmt_err!("invalid version `{version}`: pre-release versions are not supported"));
+    }
+    if !version.build.is_empty() {
+        return Err(fmt_err!("invalid version `{version}`: build metadata is not supported"));
     }
+    Ok(version)
 }