debian_analyzer/
relations.rs

1//! Functions for working with package relations.
2use debian_control::lossless::relations::{Entry, Relation, Relations};
3use debian_control::relations::VersionConstraint;
4use debversion::Version;
5
6/// Check if one dependency is implied by another.
7///
8/// Is dep implied by outer?
9pub fn is_dep_implied(dep: &Relation, outer: &Relation) -> bool {
10    if dep.name() != outer.name() {
11        return false;
12    }
13
14    let (v1, v2) = match (dep.version(), outer.version()) {
15        (Some(v1), Some(v2)) => (v1, v2),
16        (None, _) => return true,
17        (_, None) => return false,
18    };
19
20    match (v1, v2) {
21        ((VersionConstraint::GreaterThanEqual, v1), (VersionConstraint::GreaterThan, v2)) => {
22            v2 > v1
23        }
24        (
25            (VersionConstraint::GreaterThanEqual, v1),
26            (VersionConstraint::GreaterThanEqual, v2) | (VersionConstraint::Equal, v2),
27        ) => v2 >= v1,
28        (
29            (VersionConstraint::GreaterThanEqual, _v1),
30            (VersionConstraint::LessThanEqual, _v2) | (VersionConstraint::LessThan, _v2),
31        ) => false,
32        ((VersionConstraint::Equal, v1), (VersionConstraint::Equal, v2)) => v2 == v1,
33        ((VersionConstraint::Equal, _), (_, _)) => false,
34        ((VersionConstraint::LessThan, v1), (VersionConstraint::LessThan, v2)) => v2 <= v1,
35        (
36            (VersionConstraint::LessThan, v1),
37            (VersionConstraint::LessThanEqual, v2) | (VersionConstraint::Equal, v2),
38        ) => v2 < v1,
39        (
40            (VersionConstraint::LessThan, _v1),
41            (VersionConstraint::GreaterThanEqual, _v2) | (VersionConstraint::GreaterThan, _v2),
42        ) => false,
43        (
44            (VersionConstraint::LessThanEqual, v1),
45            (VersionConstraint::LessThanEqual, v2)
46            | (VersionConstraint::Equal, v2)
47            | (VersionConstraint::LessThan, v2),
48        ) => v2 <= v1,
49        (
50            (VersionConstraint::LessThanEqual, _v1),
51            (VersionConstraint::GreaterThanEqual, _v2) | (VersionConstraint::GreaterThan, _v2),
52        ) => false,
53        ((VersionConstraint::GreaterThan, v1), (VersionConstraint::GreaterThan, v2)) => v2 >= v1,
54        (
55            (VersionConstraint::GreaterThan, v1),
56            (VersionConstraint::GreaterThanEqual, v2) | (VersionConstraint::Equal, v2),
57        ) => v2 > v1,
58        (
59            (VersionConstraint::GreaterThan, _v1),
60            (VersionConstraint::LessThanEqual, _v2) | (VersionConstraint::LessThan, _v2),
61        ) => false,
62    }
63}
64
65/// Check if one relation implies another.
66///
67/// # Arguments
68/// * `inner` - Inner relation (e.g. "bzr (>= 1.3)")
69/// * `outer` - Outer relation (e.g. "bzr (>= 1.3) | libc6")
70pub fn is_relation_implied(inner: &Entry, outer: &Entry) -> bool {
71    if inner == outer {
72        return true;
73    }
74
75    // "bzr >= 1.3" implied by "bzr >= 1.3 | libc6"
76    for inner_dep in inner.relations() {
77        if outer
78            .relations()
79            .any(|outer_dep| is_dep_implied(&inner_dep, &outer_dep))
80        {
81            return true;
82        }
83    }
84
85    false
86}
87
88/// Ensure that a relation exists.
89///
90/// This is done by either verifying that there is an existing
91/// relation that satisfies the specified relation, or
92/// by upgrading an existing relation.
93pub fn ensure_relation(rels: &mut Relations, newrel: Entry) {
94    let mut obsolete = vec![];
95    for (i, relation) in rels.entries().enumerate() {
96        if is_relation_implied(&newrel, &relation) {
97            // The new relation is already implied by an existing one.
98            return;
99        }
100        if is_relation_implied(&relation, &newrel) {
101            obsolete.push(i);
102        }
103    }
104
105    if let Some(pos) = obsolete.pop() {
106        rels.replace(pos, newrel);
107    } else {
108        rels.push(newrel);
109    }
110
111    for i in obsolete.into_iter().rev() {
112        rels.remove_entry(i);
113    }
114}
115
116/// Update a relation string to ensure a particular version is required.
117///
118/// # Arguments
119/// * `relations` - Package relation
120/// * `package` - Package name
121/// * `minimum_version` - Minimum version
122///
123/// # Returns
124/// True if the relation was changed
125///
126/// # Examples
127/// ```rust
128/// use debian_control::lossless::relations::Relations;
129/// use debian_analyzer::relations::ensure_minimum_version;
130/// let mut rels: Relations = "".parse().unwrap();
131/// ensure_minimum_version(&mut rels, "foo", &"1.0".parse().unwrap());
132/// assert_eq!("foo (>= 1.0)", rels.to_string());
133/// ensure_minimum_version(&mut rels, "foo", &"2.0".parse().unwrap());
134/// assert_eq!("foo (>= 2.0)", rels.to_string());
135///
136/// let mut rels: Relations = "foo (= 1.0)".parse().unwrap();
137/// ensure_minimum_version(&mut rels, "foo", &"2.0".parse().unwrap());
138/// assert_eq!("foo (>= 2.0)", rels.to_string());
139/// ```
140pub fn ensure_minimum_version(
141    relations: &mut Relations,
142    package: &str,
143    minimum_version: &Version,
144) -> bool {
145    let is_obsolete = |entry: &Entry| -> bool {
146        for r in entry.relations() {
147            if r.name() != package {
148                continue;
149            }
150            if let Some((vc, v)) = r.version().as_ref() {
151                if *vc == VersionConstraint::GreaterThan && v < minimum_version {
152                    return true;
153                }
154                if *vc == VersionConstraint::GreaterThanEqual && v <= minimum_version {
155                    return true;
156                }
157            }
158        }
159        false
160    };
161
162    let mut found = false;
163    let mut changed = false;
164    let mut obsolete_relations = vec![];
165    let mut relevant_relations = vec![];
166    for (i, entry) in relations.entries().enumerate() {
167        let names = entry
168            .relations()
169            .map(|r| r.name().to_string())
170            .collect::<Vec<_>>();
171        if names.len() > 1 && names.contains(&package.to_string()) && is_obsolete(&entry) {
172            obsolete_relations.push(i);
173        }
174        if names != [package] {
175            continue;
176        }
177        found = true;
178        if entry
179            .relations()
180            .next()
181            .and_then(|r| r.version())
182            .map(|(_vc, v)| &v < minimum_version)
183            .unwrap_or(false)
184        {
185            relevant_relations.push(i);
186        }
187    }
188    if !found {
189        changed = true;
190        relations.push(
191            Relation::new(
192                package,
193                Some((VersionConstraint::GreaterThanEqual, minimum_version.clone())),
194            )
195            .into(),
196        );
197    } else {
198        for i in relevant_relations.into_iter().rev() {
199            relations.replace(
200                i,
201                Relation::new(
202                    package,
203                    Some((VersionConstraint::GreaterThanEqual, minimum_version.clone())),
204                )
205                .into(),
206            );
207            changed = true;
208        }
209    }
210    for i in obsolete_relations.into_iter().rev() {
211        relations.remove_entry(i);
212    }
213    changed
214}
215
216/// Update a relation string to depend on a specific version.
217///
218/// # Arguments
219/// * `relation` - Package relations
220/// * `package` - Package name
221/// * `version` - Exact version to depend on
222/// * `position` - Optional position in the list to insert any new entries
223///
224/// # Examples
225/// ```rust
226/// use debian_control::lossless::relations::Relations;
227/// use debian_analyzer::relations::ensure_exact_version;
228/// let mut rels: Relations = "".parse().unwrap();
229/// ensure_exact_version(&mut rels, "foo", &"1.0".parse().unwrap(), None);
230/// assert_eq!("foo (= 1.0)", rels.to_string());
231///
232/// let mut rels: Relations = "foo (= 1.0)".parse().unwrap();
233/// ensure_exact_version(&mut rels, "foo", &"2.0".parse().unwrap(), None);
234/// assert_eq!("foo (= 2.0)", rels.to_string());
235/// ```
236pub fn ensure_exact_version(
237    relations: &mut Relations,
238    package: &str,
239    version: &Version,
240    position: Option<usize>,
241) -> bool {
242    let mut changed = false;
243    let mut found = vec![];
244
245    for (i, entry) in relations.entries().enumerate() {
246        let names = entry
247            .relations()
248            .map(|r| r.name().to_string())
249            .collect::<Vec<_>>();
250        if names != [package] {
251            continue;
252        }
253        let relation = entry.relations().next().unwrap();
254        if relation.version().map_or(true, |(vc, v)| {
255            vc != VersionConstraint::Equal || &v != version
256        }) {
257            found.push(i);
258        }
259    }
260    if found.is_empty() {
261        changed = true;
262        let relation = Relation::new(package, Some((VersionConstraint::Equal, version.clone())));
263        if let Some(position) = position {
264            relations.insert(position, relation.into());
265        } else {
266            relations.push(relation.into());
267        }
268    } else {
269        for i in found.into_iter().rev() {
270            relations.replace(
271                i,
272                Relation::new(package, Some((VersionConstraint::Equal, version.clone()))).into(),
273            );
274            changed = true;
275        }
276    }
277    changed
278}
279
280/// Ensure that a relation exists for a particular package.
281///
282/// # Arguments
283/// * `relations` - Relations to update
284/// * `package` - Package name
285///
286/// # Examples
287/// ```rust
288/// use debian_control::lossless::relations::Relations;
289/// use debian_analyzer::relations::ensure_some_version;
290///
291/// let mut rels: Relations = "".parse().unwrap();
292/// ensure_some_version(&mut rels, "foo");
293/// assert_eq!("foo", rels.to_string());
294///
295/// let mut rels: Relations = "foo".parse().unwrap();
296/// ensure_some_version(&mut rels, "foo");
297/// assert_eq!("foo", rels.to_string());
298///
299/// let mut rels: Relations = "foo (>= 1), bar".parse().unwrap();
300/// ensure_some_version(&mut rels, "foo");
301/// assert_eq!("foo (>= 1), bar", rels.to_string());
302/// ```
303pub fn ensure_some_version(relations: &mut Relations, package: &str) -> bool {
304    for entry in relations.entries() {
305        let names = entry
306            .relations()
307            .map(|r| r.name().to_string())
308            .collect::<Vec<_>>();
309        if names == [package] {
310            return false;
311        }
312    }
313    relations.push(Relation::simple(package).into());
314    true
315}
316
317#[cfg(test)]
318mod tests {
319    use super::*;
320    use debian_control::lossless::relations::{Relation, Relations};
321
322    mod is_dep_implied {
323        use super::*;
324        fn parse(s: &str) -> Relation {
325            let rs: Relations = s.parse().unwrap();
326            let mut entries = rs.entries();
327            let entry = entries.next().unwrap();
328            assert_eq!(entries.next(), None);
329            let mut relations = entry.relations();
330            let relation = relations.next().unwrap();
331            assert_eq!(relations.next(), None);
332            relation
333        }
334
335        fn is_dep_implied(inner: &str, outer: &str) -> bool {
336            super::is_dep_implied(&parse(inner), &parse(outer))
337        }
338
339        #[test]
340        fn test_no_version() {
341            assert!(is_dep_implied("bzr", "bzr"));
342            assert!(is_dep_implied("bzr", "bzr (>= 3)"));
343            assert!(is_dep_implied("bzr", "bzr (<< 3)"));
344        }
345
346        #[test]
347        fn test_wrong_package() {
348            assert!(!is_dep_implied("bzr", "foo (<< 3)"));
349        }
350
351        #[test]
352        fn test_version() {
353            assert!(!is_dep_implied("bzr (>= 3)", "bzr (<< 3)"));
354            assert!(is_dep_implied("bzr (>= 3)", "bzr (= 3)"));
355            assert!(!is_dep_implied("bzr (= 3)", "bzr (>= 3)"));
356            assert!(!is_dep_implied("bzr (>= 3)", "bzr (>> 3)"));
357            assert!(!is_dep_implied("bzr (= 3)", "bzr (= 4)"));
358            assert!(!is_dep_implied("bzr (>= 3)", "bzr (>= 2)"));
359            assert!(is_dep_implied("bzr (>= 3)", "bzr (>= 3)"));
360            assert!(is_dep_implied("bzr", "bzr (<< 3)"));
361            assert!(is_dep_implied("bzr (<< 3)", "bzr (<< 3)"));
362            assert!(is_dep_implied("bzr (<= 3)", "bzr (<< 3)"));
363            assert!(!is_dep_implied("bzr (>= 2)", "bzr (<< 3)"));
364            assert!(!is_dep_implied("bzr (<< 2)", "bzr (<< 3)"));
365            assert!(!is_dep_implied("bzr (<= 2)", "bzr (<< 3)"));
366            assert!(is_dep_implied("bzr (<= 5)", "bzr (<< 3)"));
367            assert!(is_dep_implied("bzr (<= 5)", "bzr (= 3)"));
368            assert!(!is_dep_implied("bzr (<= 5)", "bzr (>= 3)"));
369            assert!(is_dep_implied("bzr (>> 5)", "bzr (>> 6)"));
370            assert!(is_dep_implied("bzr (>> 5)", "bzr (>> 5)"));
371            assert!(!is_dep_implied("bzr (>> 5)", "bzr (>> 4)"));
372            assert!(is_dep_implied("bzr (>> 5)", "bzr (= 6)"));
373            assert!(!is_dep_implied("bzr (>> 5)", "bzr (= 5)"));
374            assert!(is_dep_implied("bzr:any (>> 5)", "bzr:any (= 6)"));
375        }
376    }
377
378    mod is_relation_implied {
379        use debian_control::lossless::relations::Relations;
380
381        fn parse(s: &str) -> super::Entry {
382            let r: Relations = s.parse().unwrap();
383            let mut entries = r.entries();
384            let entry = entries.next().unwrap();
385            assert_eq!(entries.next(), None);
386            entry
387        }
388
389        fn is_relation_implied(inner: &str, outer: &str) -> bool {
390            super::is_relation_implied(&parse(inner), &parse(outer))
391        }
392
393        #[test]
394        fn test_unrelated() {
395            assert!(!is_relation_implied("bzr", "bar"));
396            assert!(!is_relation_implied("bzr (= 3)", "bar"));
397            assert!(!is_relation_implied("bzr (= 3) | foo", "bar"));
398        }
399
400        #[test]
401        fn test_too_old() {
402            assert!(!is_relation_implied("bzr (= 3)", "bzr"));
403            assert!(!is_relation_implied("bzr (= 3)", "bzr (= 2)"));
404            assert!(!is_relation_implied("bzr (= 3)", "bzr (>= 2)"));
405        }
406
407        #[test]
408        fn test_ors() {
409            assert!(!is_relation_implied("bzr (= 3)", "bzr | foo"));
410            assert!(is_relation_implied("bzr", "bzr | foo"));
411            assert!(is_relation_implied("bzr | foo", "bzr | foo"));
412        }
413
414        #[test]
415        fn test_implied() {
416            assert!(is_relation_implied("bzr (= 3)", "bzr (= 3)"));
417            assert!(is_relation_implied("bzr (>= 3)", "bzr (>= 4)"));
418            assert!(is_relation_implied("bzr (>= 4)", "bzr (>= 4)"));
419            assert!(is_relation_implied("bzr", "bzr"));
420            assert!(is_relation_implied("bzr | foo", "bzr"));
421            assert!(!is_relation_implied("bzr (= 3)", "bzr (>= 3)"));
422            assert!(is_relation_implied(
423                "python3:any | dh-sequence-python3",
424                "python3:any"
425            ));
426            assert!(is_relation_implied(
427                "python3:any | python3-dev:any | dh-sequence-python3",
428                "python3:any | python3-dev:any"
429            ));
430        }
431    }
432
433    #[test]
434    fn test_ensure_relation() {
435        let mut rels: Relations = "".parse().unwrap();
436        let rel = Relation::simple("foo");
437        ensure_relation(&mut rels, rel.into());
438        assert_eq!("foo", rels.to_string());
439    }
440
441    #[test]
442    fn test_ensure_relation_upgrade() {
443        let mut rels = "foo".parse().unwrap();
444        let newrel: Entry = Relation::new(
445            "foo",
446            Some((VersionConstraint::Equal, "1.0".parse().unwrap())),
447        )
448        .into();
449        ensure_relation(&mut rels, newrel);
450        assert_eq!("foo (= 1.0)", rels.to_string());
451    }
452
453    #[test]
454    fn test_ensure_relation_new() {
455        let mut rels = "bar (= 1.0)".parse().unwrap();
456        let newrel: Entry = Relation::new(
457            "foo",
458            Some((VersionConstraint::Equal, "2.0".parse().unwrap())),
459        )
460        .into();
461        ensure_relation(&mut rels, newrel);
462        assert_eq!("bar (= 1.0), foo (= 2.0)", rels.to_string());
463    }
464
465    #[test]
466    fn test_drops_obsolete() {
467        let mut rels = "bar (= 1.0), foo (>= 2.0), foo (>= 1.0)".parse().unwrap();
468        let newrel: Entry = Relation::new(
469            "foo",
470            Some((VersionConstraint::GreaterThanEqual, "3.0".parse().unwrap())),
471        )
472        .into();
473        ensure_relation(&mut rels, newrel);
474        assert_eq!("bar (= 1.0), foo (>= 3.0)", rels.to_string());
475    }
476
477    #[test]
478    fn test_ensure_relation_with_error() {
479        let mut rels = Relations::parse_relaxed("@cdbs@, debhelper (>= 9)", false).0;
480        let newrel: Entry = Relation::new("foo", None).into();
481
482        ensure_relation(&mut rels, newrel);
483        assert_eq!("@cdbs@, debhelper (>= 9), foo", rels.to_string());
484    }
485
486    #[test]
487    fn test_ensure_minimum_version() {
488        let mut rels = "".parse().unwrap();
489        ensure_minimum_version(&mut rels, "foo", &"1.0".parse().unwrap());
490        assert_eq!("foo (>= 1.0)", rels.to_string());
491    }
492
493    #[test]
494    fn test_ensure_minimum_version_upgrade() {
495        let mut rels = "foo (>= 1.0)".parse().unwrap();
496        ensure_minimum_version(&mut rels, "foo", &"2.0".parse().unwrap());
497        assert_eq!("foo (>= 2.0)", rels.to_string());
498    }
499
500    #[test]
501    fn test_ensure_minimum_version_upgrade_with_or() {
502        let mut rels = "foo (>= 1.0) | bar".parse().unwrap();
503        ensure_minimum_version(&mut rels, "foo", &"2.0".parse().unwrap());
504        assert_eq!("foo (>= 2.0)", rels.to_string());
505    }
506
507    #[test]
508    fn test_ensure_exact_version() {
509        let mut rels = "".parse().unwrap();
510        ensure_exact_version(&mut rels, "foo", &"1.0".parse().unwrap(), None);
511        assert_eq!("foo (= 1.0)", rels.to_string());
512    }
513
514    #[test]
515    fn test_ensure_exact_version_upgrade() {
516        let mut rels = "foo (= 1.0)".parse().unwrap();
517        ensure_exact_version(&mut rels, "foo", &"2.0".parse().unwrap(), None);
518        assert_eq!("foo (= 2.0)", rels.to_string());
519    }
520
521    #[test]
522    fn test_ensure_exact_version_upgrade_with_position() {
523        let mut rels = "foo (= 1.0)".parse().unwrap();
524        ensure_exact_version(&mut rels, "foo", &"2.0".parse().unwrap(), Some(0));
525        assert_eq!("foo (= 2.0)", rels.to_string());
526    }
527}
debian_analyzer/relations.rs

debian_analyzer/
relations.rs
