Skip to main content

publet_algorithms/
version.rs

1//! Whether a tool's version meets a requirement.
2//!
3//! Tools print versions in many shapes -- `0.15`, `1.98.1`, `22.22.1` --
4//! so versions here are any number of dot-separated integers rather than
5//! strict semantic versions. For release arithmetic on strict
6//! `MAJOR.MINOR.PATCH` versions, use the [`semver`](https://crates.io/crates/semver)
7//! crate, as pubrel does.
8
9/// Whether `version` satisfies `requires`.
10///
11/// `requires` takes one of four forms:
12///
13/// - `^X.Y`, compatible, as Cargo reads a caret requirement: not below
14///   `X.Y`, and the same up to its first non-zero part. `^1.2` admits
15///   `1.9.0` but not `2.0.0`; `^0.1` admits `0.1.9` but not `0.2.0`;
16///   `^0.0.3` admits only `0.0.3`;
17/// - `X.Y+`, a minimum: any version not below it, compared numerically
18///   part by part;
19/// - a prefix at a dot boundary: `0.15` admits `0.15` and `0.15.2`, not
20///   `0.150`;
21/// - empty, which anything satisfies.
22///
23/// A version or requirement with a part that is not a number satisfies
24/// none of the numeric forms.
25///
26/// # Example
27///
28/// ```
29/// use publet_algorithms::version::satisfies;
30///
31/// // Compatible, as Cargo reads it.
32/// assert!(satisfies("1.98.1", "^1.80"));
33/// assert!(!satisfies("2.0.0", "^1.80"));
34/// assert!(satisfies("0.1.9", "^0.1"));
35/// assert!(!satisfies("0.2.0", "^0.1"));
36///
37/// // A minimum, and a prefix.
38/// assert!(satisfies("22.22.1", "22+"));
39/// assert!(satisfies("0.15.2", "0.15"));
40/// assert!(!satisfies("0.150", "0.15"));
41/// ```
42#[must_use]
43pub fn satisfies(version: &str, requires: &str) -> bool {
44    let parts =
45        |v: &str| -> Option<Vec<u64>> { v.split('.').map(|p| p.parse::<u64>().ok()).collect() };
46    if let Some(base) = requires.strip_prefix('^') {
47        let (Some(have), Some(need)) = (parts(version), parts(base)) else {
48            return false;
49        };
50        // Cargo: the parts up to and including the first non-zero one must
51        // match exactly; with none non-zero, every part given must.
52        let fixed = need
53            .iter()
54            .position(|&p| p != 0)
55            .map_or(need.len(), |i| i + 1);
56        let same = need
57            .iter()
58            .take(fixed)
59            .enumerate()
60            .all(|(i, part)| have.get(i).copied().unwrap_or(0) == *part);
61        return same && have >= need;
62    }
63    if let Some(minimum) = requires.strip_suffix('+') {
64        return match (parts(version), parts(minimum)) {
65            (Some(have), Some(need)) => have >= need,
66            _ => false,
67        };
68    }
69    requires.is_empty()
70        || version == requires
71        || version
72            .strip_prefix(requires)
73            .is_some_and(|rest| rest.starts_with('.'))
74}
75
76#[cfg(test)]
77mod tests {
78    use super::*;
79
80    // covers: version::satisfies
81    #[test]
82    fn a_requirement_is_a_version_prefix_at_a_dot_boundary() {
83        assert!(satisfies("0.15", "0.15"));
84        assert!(satisfies("0.15.2", "0.15"));
85        assert!(satisfies("0.15.2", ""));
86        assert!(!satisfies("0.150", "0.15"));
87        assert!(!satisfies("0.16.0", "0.15"));
88    }
89
90    // covers: version::satisfies
91    #[test]
92    fn a_minimum_compares_part_by_part() {
93        assert!(satisfies("1.98.1", "1.80+"));
94        assert!(satisfies("22.22.1", "22+"));
95        assert!(!satisfies("1.79.0", "1.80+"));
96        assert!(!satisfies("abc", "1+"));
97    }
98
99    // covers: version::satisfies
100    #[test]
101    fn a_caret_is_compatible_as_cargo_reads_it() {
102        // From 1.0: the major part is fixed.
103        assert!(satisfies("2.4.0", "^2.1"));
104        assert!(!satisfies("3.0.0", "^2.1"));
105        assert!(!satisfies("2.0.9", "^2.1"));
106        // Below 1.0: the minor part is fixed.
107        assert!(satisfies("0.1.0", "^0.1"));
108        assert!(satisfies("0.1.9", "^0.1"));
109        assert!(!satisfies("0.3.2", "^0.1"));
110        assert!(!satisfies("1.0.0", "^0.1"));
111        assert!(!satisfies("0.0.9", "^0.1"));
112        // Below 0.1: every part is fixed.
113        assert!(satisfies("0.0.3", "^0.0.3"));
114        assert!(!satisfies("0.0.4", "^0.0.3"));
115        // All zero: the parts given are fixed.
116        assert!(satisfies("0.0.7", "^0.0"));
117        assert!(!satisfies("0.1.0", "^0.0"));
118        assert!(!satisfies("x.1", "^0.1"));
119    }
120}