cloudiful-redactor 0.2.9

Structured text redaction with reversible sessions for secrets, domains, URLs, and related sensitive values.
Documentation 
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

use crate::types::Finding;

pub(crate) fn select_non_overlapping(mut findings: Vec<Finding>) -> (Vec<Finding>, usize) {
    findings.sort_by(|left, right| {
        left.start
            .cmp(&right.start)
            .then_with(|| right.score().cmp(&left.score()))
            .then_with(|| (right.end - right.start).cmp(&(left.end - left.start)))
    });

    let mut selected = Vec::new();
    let mut dropped = 0;

    for finding in findings {
        if let Some(previous) = selected.last_mut() {
            if overlaps(previous, &finding) {
                if prefer_right(previous, &finding) {
                    *previous = finding;
                } else {
                    dropped += 1;
                }
                continue;
            }
        }

        selected.push(finding);
    }

    selected.sort_by_key(|item| item.start);
    (selected, dropped)
}

fn overlaps(left: &Finding, right: &Finding) -> bool {
    left.start < right.end && right.start < left.end
}

fn prefer_right(left: &Finding, right: &Finding) -> bool {
    let left_contains_right = left.start <= right.start && left.end >= right.end;
    let right_contains_left = right.start <= left.start && right.end >= left.end;

    if left_contains_right || right_contains_left {
        let left_priority = left.kind.containment_priority();
        let right_priority = right.kind.containment_priority();
        if left_priority != right_priority {
            return right_priority > left_priority;
        }
    }

    right.score() > left.score()
        || (right.score() == left.score() && (right.end - right.start) > (left.end - left.start))
}