cargo-allow 0.1.3

Source-tree exception ledger and policy scanner for Rust repositories.
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use super::*;
use allow_core::{Lifecycle, Selector, Span, StructuralIdentity};

pub(super) fn row_status(rows: &[ListRow], id: &str) -> MatchStatus {
    rows.iter()
        .find(|row| row.id == id)
        .map(|row| row.status)
        .unwrap_or_else(|| std::panic::panic_any(format!("missing row {id}")))
}

pub(super) fn list_row(id: &str, kind: FindingKind, owner: &str, classification: &str) -> ListRow {
    ListRow {
        id: id.to_string(),
        status: if classification == "baseline_debt" {
            MatchStatus::BaselineDebt
        } else {
            MatchStatus::Matched
        },
        matches: 1,
        kind,
        family: None,
        owner: owner.to_string(),
        classification: classification.to_string(),
        scope: "src/lib.rs".to_string(),
        source_package: None,
        evidence_count: 0,
        broken_evidence_references: 0,
        weak_evidence_references: 0,
        selector_precision: 0,
        broad_scope: false,
        review_after: "-".to_string(),
        expires: "-".to_string(),
        reason: "reason".to_string(),
    }
}

pub(super) fn test_entry(id: &str, kind: FindingKind) -> AllowEntry {
    AllowEntry {
        id: id.to_string(),
        kind,
        family: None,
        path: Some(PathBuf::from("tracked.file")),
        glob: None,
        owner: "owner".to_string(),
        classification: "classification".to_string(),
        reason: "reason".to_string(),
        evidence: Vec::new(),
        links: Vec::new(),
        occurrence_limit: None,
        lifecycle: Lifecycle::empty(),
        selector: Selector {
            ast_kind: Some("tracked_file".to_string()),
            ..Selector::default()
        },
        last_seen: None,
    }
}

pub(super) fn test_finding(
    kind: FindingKind,
    family: Option<&str>,
    path: &str,
    ast_kind: &str,
) -> Finding {
    Finding {
        kind,
        family: family.map(str::to_string),
        path: PathBuf::from(path),
        span: Some(Span { line: 1, column: 1 }),
        identity: StructuralIdentity::new("file", ast_kind),
        message: "test finding".to_string(),
    }
}

pub(super) fn test_outcome(
    status: MatchStatus,
    allow_id: Option<&str>,
    finding_index: Option<usize>,
    message: &str,
) -> MatchOutcome {
    MatchOutcome {
        status,
        allow_id: allow_id.map(str::to_string),
        finding_index,
        message: message.to_string(),
        score: 100,
    }
}