allow-policy-legacy 0.1.9

Legacy policy adapters for cargo-allow migrations.
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
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use allow_core::{Finding, Lifecycle};

use crate::converter_lifecycle_support::lifecycle_from_legacy_fields;
use crate::types::LegacyNonRustRule;

pub(crate) fn best_rule_index(rules: &[LegacyNonRustRule], finding: &Finding) -> Option<usize> {
    rules
        .iter()
        .enumerate()
        .filter(|(_, rule)| rule.matches(finding))
        .max_by_key(|(_, rule)| rule.specificity())
        .map(|(index, _)| index)
}

pub(crate) fn lifecycle_from_rule(rule: &LegacyNonRustRule) -> Lifecycle {
    lifecycle_from_legacy_fields(
        rule.created.clone(),
        rule.review_after.clone(),
        rule.expires.clone(),
    )
}

pub(crate) fn evidence_from_rule(rule: &LegacyNonRustRule) -> Vec<String> {
    if rule.evidence.is_empty() {
        vec![format!("legacy-policy:{}", rule.id)]
    } else {
        rule.evidence.clone()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use allow_core::{FindingKind, Span, StructuralIdentity};
    use std::path::PathBuf;

    #[test]
    fn best_rule_index_selects_most_specific_matching_rule() {
        let rules = vec![
            legacy_rule("docs", "docs/**", false, Vec::new()),
            legacy_rule(
                "guide",
                "docs\\guide.md",
                true,
                vec!["doc:docs/guide.md".to_string()],
            ),
        ];
        let finding = file_finding(FindingKind::NonRustFile, "docs\\guide.md");

        assert_eq!(best_rule_index(&rules, &finding), Some(1));
    }

    #[test]
    fn best_rule_index_filters_non_file_findings_and_missing_matches() {
        let rules = vec![legacy_rule("docs", "docs/**", false, Vec::new())];

        assert_eq!(
            best_rule_index(&rules, &file_finding(FindingKind::Panic, "docs/guide.md")),
            None
        );
        assert_eq!(
            best_rule_index(
                &rules,
                &file_finding(FindingKind::NonRustFile, "src/lib.rs")
            ),
            None
        );
    }

    #[test]
    fn lifecycle_and_evidence_preserve_explicit_legacy_fields() {
        let rule = legacy_rule(
            "readme",
            "README.md",
            true,
            vec!["doc:README.md".to_string(), "issue:#123".to_string()],
        );

        let lifecycle = lifecycle_from_rule(&rule);

        assert_eq!(lifecycle.created.as_deref(), Some("2026-05-01"));
        assert_eq!(lifecycle.review_after.as_deref(), Some("2026-09-01"));
        assert_eq!(lifecycle.expires.as_deref(), Some("never"));
        assert_eq!(
            evidence_from_rule(&rule),
            vec!["doc:README.md".to_string(), "issue:#123".to_string()]
        );
    }

    #[test]
    fn lifecycle_and_evidence_use_legacy_policy_fallbacks() {
        let mut rule = legacy_rule("docs", "docs/**", false, Vec::new());
        rule.review_after = None;

        let lifecycle = lifecycle_from_rule(&rule);

        assert_eq!(lifecycle.created.as_deref(), Some("2026-05-01"));
        assert_eq!(lifecycle.review_after.as_deref(), Some("2026-05-01"));
        assert_eq!(lifecycle.expires.as_deref(), Some("never"));
        assert_eq!(
            evidence_from_rule(&rule),
            vec!["legacy-policy:docs".to_string()]
        );
    }

    fn legacy_rule(
        id: &str,
        pattern: &str,
        is_path: bool,
        evidence: Vec<String>,
    ) -> LegacyNonRustRule {
        LegacyNonRustRule {
            id: id.to_string(),
            pattern: pattern.to_string(),
            is_path,
            owner: "docs".to_string(),
            classification: "documentation".to_string(),
            reason: "Documentation files are intentionally tracked.".to_string(),
            evidence,
            created: Some("2026-05-01".to_string()),
            review_after: Some("2026-09-01".to_string()),
            expires: Some("never".to_string()),
        }
    }

    fn file_finding(kind: FindingKind, path: &str) -> Finding {
        Finding {
            kind,
            family: Some(kind.as_str().to_string()),
            path: PathBuf::from(path),
            span: Some(Span { line: 7, column: 1 }),
            identity: StructuralIdentity::new("file", "tracked_file"),
            message: format!("tracked file: {path}"),
        }
    }
}