cargo-rail 0.28.1

Cargo-native Rust workspace engine for affected CI, Rust source-surface analysis, compiler reuse, dependency coherence, exact-SHA releases, and split/sync
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

//! Internal change interpretation shared by release attribution and planning.

use std::path::Path;

use crate::error::RailResult;
use crate::workspace::WorkspaceContext;
use rustc_hash::FxHashSet;

pub(crate) mod semantic;

/// Return workspace crates with changed inputs that require release-intent coverage.
pub(crate) fn changed_code_crate_names(ctx: &WorkspaceContext, base: Option<&str>) -> RailResult<FxHashSet<String>> {
    let mut crates = FxHashSet::default();
    for repository_path in ctx.source_paths_since(base)? {
        let Some(workspace_path) = ctx.to_workspace_path(&repository_path) else {
            continue;
        };
        if !is_release_coverage_input(&workspace_path) {
            continue;
        }
        if let Some(owner) = ctx.graph().file_to_crate(&workspace_path) {
            crates.insert(owner);
        }
    }
    Ok(crates)
}

pub(crate) fn is_release_coverage_input(path: &Path) -> bool {
    let path = path.to_string_lossy();

    if path.ends_with("build.rs")
        || path == "Cargo.lock"
        || path == "rust-toolchain"
        || path.ends_with("Cargo.toml")
        || path.ends_with(".cargo/config")
        || path.ends_with(".cargo/config.toml")
    {
        return true;
    }

    if path.starts_with(".github/") {
        return false;
    }

    if path.ends_with(".rs") {
        return !is_test_bench_or_example(&path);
    }

    path.ends_with(".toml")
}

fn is_test_bench_or_example(path: &str) -> bool {
    path.starts_with("tests/")
        || path.contains("/tests/")
        || path.starts_with("benches/")
        || path.contains("/benches/")
        || path.starts_with("examples/")
        || path.contains("/examples/")
}

#[cfg(test)]
mod tests {
    use std::path::Path;

    use super::is_release_coverage_input;

    #[test]
    fn release_coverage_preserves_rust_and_cargo_boundaries() {
        let cases = [
            ("crates/demo/src/lib.rs", true),
            ("crates/demo/build.rs", true),
            ("Cargo.toml", true),
            ("crates/demo/Cargo.toml", true),
            ("Cargo.lock", true),
            ("rust-toolchain", true),
            ("rust-toolchain.toml", true),
            (".cargo/config", true),
            (".cargo/config.toml", true),
            ("crates/demo/tooling.toml", true),
            ("crates/demo/tests/api.rs", false),
            ("crates/demo/benches/throughput.rs", false),
            ("crates/demo/examples/client.rs", false),
            (".github/workflows/check.rs", false),
            (".github/workflows/check.toml", false),
            ("scripts/generate.py", false),
            ("scripts/check.sh", false),
            ("docs/design.md", false),
            (".editorconfig", false),
            ("crates/demo/assets/input.bin", false),
        ];

        for (path, expected) in cases {
            assert_eq!(
                is_release_coverage_input(Path::new(path)),
                expected,
                "release coverage mismatch for {path}"
            );
        }
    }
}