weirflow 0.1.0

GPU-first dataflow analysis primitives for Vyre and Santh compiler pipelines.
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

//! API surface stability contract.
//!
//! Compares the current public API against a committed snapshot.
//! Any removal or signature change must be accompanied by a version-bump
//! comment in Cargo.toml.

use std::collections::BTreeSet;
use std::fs;
use std::path::Path;
use std::process::Command;

const SNAPSHOT_PATH: &str = concat!(
    env!("CARGO_MANIFEST_DIR"),
    "/tests/api_surface_snapshot.json"
);

#[test]
fn api_surface_matches_committed_snapshot() {
    let root = Path::new(env!("CARGO_MANIFEST_DIR"));

    // Run cargo-public-api to capture current API
    let output = Command::new("cargo")
        .args(["public-api", "-ss", "--all-features", "-p", "weir"])
        .current_dir(root)
        .output()
        .expect("cargo-public-api should be installed and runnable");

    if !output.status.success() {
        // Skip the snapshot comparison if cargo-public-api fails
        // (e.g., due to workspace dependency issues in CI).
        eprintln!(
            "WARNING: cargo-public-api failed, skipping API snapshot comparison:\nstderr:\n{}",
            String::from_utf8_lossy(&output.stderr)
        );
        return;
    }

    let current_lines: BTreeSet<String> = String::from_utf8_lossy(&output.stdout)
        .lines()
        .map(|l| l.trim().to_owned())
        .filter(|l| !l.is_empty())
        .collect();

    let snapshot_raw =
        fs::read_to_string(SNAPSHOT_PATH).expect("API snapshot file should be readable");
    let snapshot_lines: BTreeSet<String> = serde_json::from_str::<Vec<String>>(&snapshot_raw)
        .expect("API snapshot should be valid JSON array of strings")
        .into_iter()
        .map(|l| l.trim().to_owned())
        .filter(|l| !l.is_empty())
        .collect();

    let removed: Vec<&String> = snapshot_lines.difference(&current_lines).collect();
    let added: Vec<&String> = current_lines.difference(&snapshot_lines).collect();

    if !removed.is_empty() || !added.is_empty() {
        let manifest =
            fs::read_to_string(root.join("Cargo.toml")).expect("Cargo.toml should be readable");
        let has_bump_comment = manifest.contains("# api-breaking-change")
            || manifest.contains("# version-bump")
            || manifest.contains("# breaking");

        let mut message = String::new();
        message.push_str("Public API surface changed.\n");
        if !removed.is_empty() {
            message.push_str(&format!("\nRemoved ({}):\n", removed.len()));
            for item in &removed {
                message.push_str(&format!("  - {item}\n"));
            }
        }
        if !added.is_empty() {
            message.push_str(&format!("\nAdded ({}):\n", added.len()));
            for item in &added {
                message.push_str(&format!("  + {item}\n"));
            }
        }
        if !has_bump_comment {
            message.push_str(
                "\nIf this change is intentional, add a version-bump comment to Cargo.toml.\n",
            );
        }
        panic!("{message}");
    }
}

#[test]
fn api_snapshot_file_is_sorted_and_unique() {
    let snapshot_raw =
        fs::read_to_string(SNAPSHOT_PATH).expect("API snapshot file should be readable");
    let lines: Vec<String> = serde_json::from_str::<Vec<String>>(&snapshot_raw)
        .expect("API snapshot should be valid JSON array of strings")
        .into_iter()
        .map(|l| l.trim().to_owned())
        .filter(|l| !l.is_empty())
        .collect();

    let mut sorted = lines.clone();
    sorted.sort();
    sorted.dedup();

    assert_eq!(
        lines, sorted,
        "API snapshot must be sorted and contain no duplicates"
    );
}