A changelog check on the WASM tier, a job in Flow's pipeline 0aac9efcbeea

// The changelog's shape, and a section for the version Cargo.toml says, so

// a release never finds its notes missing.

job "changelog" {

    sandbox "wasm"

    scope "CHANGELOG.md" "Cargo.toml" ".flow/checks.wasm"

    exec ".flow/checks.wasm" "changelog" "CHANGELOG.md" "Cargo.toml"

}

- **Added: a `changelog` check on the WASM tier.** `.flow/checks.wasm changelog CHANGELOG.md [MANIFEST]` checks the changelog's shape (`## Unreleased` first if at all, then `## X.Y.Z (YYYY-MM-DD)` sections newest first, none empty) and that the version a `Cargo.toml`, `.properties` or `package.json` says has its section, so a release never finds its notes missing. It is a job of OxygenFlow's pipeline, and of OxygenHub's, Oxygen's and the Android app's, any runner with the WASM tier taking it.

//! - `changelog FILE [MANIFEST]`: the changelog's shape: `## Unreleased`

//!   first if at all, then `## X.Y.Z (YYYY-MM-DD)` sections, newest first,

//!   none empty; with a manifest (`Cargo.toml`, `*.properties`,

//!   `package.json`), its version has a section, as a release needs.

const USAGE: &str = "usage: flow-checks layout PATH... | todos DIR... | size DIR | summary | changelog FILE [MANIFEST]";

            "changelog" => match rest {

                [file] => changelog(root, file, None, &mut out),

                [file, manifest] => changelog(root, file, Some(manifest), &mut out),

                _ => Err(USAGE.to_string()),

            },

/// A version as three numbers, or `None`.

fn version(s: &str) -> Option<(u64, u64, u64)> {

    let mut parts = s.split('.').map(|p| p.parse::<u64>().ok());

    let v = (parts.next()??, parts.next()??, parts.next()??);

    parts.next().is_none().then_some(v)

}

/// A `YYYY-MM-DD` date with a real month and day.

fn is_date(s: &str) -> bool {

    let b = s.as_bytes();

    b.len() == 10

        && b[4] == b'-'

        && b[7] == b'-'

        && s[..4].parse::<u32>().is_ok()

        && s[5..7].parse::<u32>().is_ok_and(|m| (1..=12).contains(&m))

        && s[8..].parse::<u32>().is_ok_and(|d| (1..=31).contains(&d))

}

/// The version a manifest declares: `version = "…"` in `Cargo.toml`'s

/// `[package]` or `[workspace.package]`, a `….version=` key of a

/// `.properties` file, or `"version"` in a `package.json`.

fn manifest_version(path: &str, text: &str) -> Option<String> {

    let unquote = |v: &str| v.trim().trim_matches('"').trim_end_matches(',').trim_matches('"').to_string();

    if path.ends_with(".properties") {

        return text.lines().find_map(|l| {

            let (k, v) = l.split_once('=')?;

            (k.trim() == "version" || k.trim().ends_with(".version")).then(|| v.trim().to_string())

        });

    }

    if path.ends_with(".json") {

        return text.lines().find_map(|l| l.trim().strip_prefix("\"version\":").map(unquote));

    }

    let mut section = "";

    for l in text.lines() {

        let l = l.trim();

        if l.starts_with('[') {

            section = l;

        } else if matches!(section, "[package]" | "[workspace.package]") {

            if let Some(v) = l.strip_prefix("version").and_then(|r| r.trim_start().strip_prefix('=')) {

                return Some(unquote(v));

            }

        }

    }

    None

}

/// The changelog's shape, and the manifest's version in it.

fn changelog(root: &Path, file: &str, manifest: Option<&String>, out: &mut impl Write) -> Done {

    let text = fs::read_to_string(root.join(file)).map_err(|e| format!("{file}: {e}"))?;

    let mut sections: Vec<(usize, String, usize)> = Vec::new(); // (line, heading, entries)

    for (i, line) in text.lines().enumerate() {

        if let Some(h) = line.strip_prefix("## ") {

            sections.push((i + 1, h.trim().to_string(), 0));

        } else if let Some(last) = sections.last_mut() {

            if line.trim_start().starts_with("- ") || line.trim_start().starts_with("* ") {

                last.2 += 1;

            }

        }

    }

    let mut problems = Vec::new();

    let mut last: Option<(u64, u64, u64)> = None;

    let mut released = Vec::new();

    for (k, (line, h, n)) in sections.iter().enumerate() {

        if h == "Unreleased" {

            if k != 0 {

                problems.push(format!("{file}:{line}: ## Unreleased comes first"));

            }

            continue;

        }

        let (v, rest) = h.split_once(' ').unwrap_or((h.as_str(), ""));

        let date = rest.trim().strip_prefix('(').and_then(|r| r.strip_suffix(')'));

        match (version(v), date) {

            (Some(ver), Some(d)) if is_date(d) => {

                if last.is_some_and(|l| ver >= l) {

                    problems.push(format!("{file}:{line}: {v} is not older than the section above it"));

                }

                last = Some(ver);

                released.push(v.to_string());

                if *n == 0 {

                    problems.push(format!("{file}:{line}: ## {h} has no entries"));

                }

            }

            _ => problems.push(format!("{file}:{line}: \"## {h}\" is not \"## X.Y.Z (YYYY-MM-DD)\" or \"## Unreleased\"")),

        }

    }

    let mut said = format!("changelog: {} released section{}", released.len(), if released.len() == 1 { "" } else { "s" });

    if let Some(m) = manifest {

        let mtext = fs::read_to_string(root.join(m)).map_err(|e| format!("{m}: {e}"))?;

        match manifest_version(m, &mtext) {

            Some(v) if released.contains(&v) => said.push_str(&format!(", {m} at {v} has its section")),

            Some(v) => problems.push(format!(

                "{m} says version {v}, but {file} has no \"## {v} (YYYY-MM-DD)\" section: a release of it would have no notes"

            )),

            None => problems.push(format!("{m}: no version found")),

        }

    }

    if problems.is_empty() {

        return emit(out, &said);

    }

    Err(problems.join("\n"))

}

    }

    #[test]

    fn changelog_shape_and_the_manifest_version() {

        let good = "# Changelog\n\nIntro.\n\n## Unreleased\n\n## 0.2.0 (2026-11-03)\n\n- **New.**\n\n## 0.1.9 (2026-10-01)\n\n- Old.\n";

        let dir = tree(&[

            ("CHANGELOG.md", good),

            ("Cargo.toml", "[workspace]\nmembers = []\n\n[workspace.package]\nversion = \"0.2.0\"\n"),

            ("gradle.properties", "android.useAndroidX=true\noxygenhub.version=0.1.9\n"),

            ("package.json", "{\n  \"name\": \"x\",\n  \"version\": \"0.3.0\",\n}\n"),

        ]);

        let r = |m: Option<&str>| run(|o| changelog(dir.path(), "CHANGELOG.md", m.map(String::from).as_ref(), o));

        let (done, out) = r(None);

        assert_eq!((done, out.trim()), (Ok(()), "changelog: 2 released sections"));

        assert!(r(Some("Cargo.toml")).1.contains("Cargo.toml at 0.2.0 has its section"));

        assert!(r(Some("gradle.properties")).0.is_ok(), "an older release's section counts");

        let e = r(Some("package.json")).0.unwrap_err();

        assert!(e.contains("version 0.3.0") && e.contains("no \"## 0.3.0 (YYYY-MM-DD)\""), "{e}");

        let bad = "## 0.1.0 (2026-10-01)\n\n- a\n\n## Unreleased\n\n## 0.2.0 (2026-13-01)\n\n- b\n\n## 0.0.9 (2026-09-01)\n\n## v1\n";

        let dir = tree(&[("CHANGELOG.md", bad)]);

        let e = run(|o| changelog(dir.path(), "CHANGELOG.md", None, o)).0.unwrap_err();

        assert!(e.contains(":5: ## Unreleased comes first"), "{e}");

        assert!(e.contains(":7: \"## 0.2.0 (2026-13-01)\" is not"), "a month 13: {e}");

        assert!(e.contains(":11: ## 0.0.9 (2026-09-01) has no entries"), "{e}");

        assert!(e.contains(":13: \"## v1\""), "{e}");

        let order = "## 0.1.0 (2026-10-01)\n\n- a\n\n## 0.2.0 (2026-11-01)\n\n- b\n";

        let dir = tree(&[("CHANGELOG.md", order)]);

        let e = run(|o| changelog(dir.path(), "CHANGELOG.md", None, o)).0.unwrap_err();

        assert!(e.contains("0.2.0 is not older than the section above it"), "{e}");