Name moved subrepo pins in status and commit; changelog on the WASM tier (closes #162) 232aabb5452d

//! oxygen#162: a subrepo pin moved by work inside the subrepo is a change

//! the parent's next commit records; `oxy status` and `oxy commit` say so,

//! and say when a subrepo holds uncommitted edits of its own.

use std::path::Path;

use std::process::Command;

fn oxy(dir: &Path, home: &Path, args: &[&str]) -> (i32, String) {

    let out = Command::new(env!("CARGO_BIN_EXE_oxy"))

        .arg("--plain")

        .args(args)

        .current_dir(dir)

        .env("OXY_HOME", home)

        .env("NO_COLOR", "1")

        .output()

        .unwrap();

    let text = format!(

        "{}{}",

        String::from_utf8_lossy(&out.stdout),

        String::from_utf8_lossy(&out.stderr)

    );

    (out.status.code().unwrap_or(-1), text)

}

fn ok(dir: &Path, home: &Path, args: &[&str]) -> String {

    let (code, out) = oxy(dir, home, args);

    assert_eq!(code, 0, "oxy {args:?}: {out}");

    out

}

#[test]

fn moved_pins_and_edits_inside_subrepos_are_named() {

    let tmp = tempfile::tempdir().unwrap();

    let t = tmp.path();

    let home = t.join("home");

    std::fs::create_dir_all(&home).unwrap();

    ok(

        t,

        &home,

        &[

            "identity",

            "create",

            "--name",

            "Ada",

            "--email",

            "[email protected]",

        ],

    );

    // The subrepo's own repository, with one change.

    let lib = t.join("lib");

    ok(t, &home, &["init", lib.to_str().unwrap()]);

    std::fs::write(lib.join("lib.txt"), "one\n").unwrap();

    ok(&lib, &home, &["commit", "-m", "lib one"]);

    // The parent pins it.

    let app = t.join("app");

    ok(t, &home, &["init", app.to_str().unwrap()]);

    std::fs::write(app.join("app.txt"), "app\n").unwrap();

    ok(

        &app,

        &home,

        &["submodule", "add", lib.to_str().unwrap(), "deps/lib"],

    );

    ok(&app, &home, &["commit", "-m", "app with lib"]);

    let quiet = ok(&app, &home, &["status"]);

    assert!(!quiet.contains("Subrepo pins"), "{quiet}");

    // Edits inside the subrepo, not committed there: named, not a pin move.

    let inner = app.join("deps/lib");

    std::fs::write(inner.join("lib.txt"), "two\n").unwrap();

    let st = ok(&app, &home, &["status"]);

    assert!(

        st.contains("Subrepo pins") && st.contains("uncommitted edits inside it"),

        "{st}"

    );

    assert!(!st.contains("pin moved"), "{st}");

    // Committed inside: the pin has moved, and a bare commit says it records it.

    ok(&inner, &home, &["commit", "-m", "lib two"]);

    let st = ok(&app, &home, &["status"]);

    assert!(st.contains("deps/lib") && st.contains("pin moved"), "{st}");

    std::fs::write(app.join("app.txt"), "app 2\n").unwrap();

    let by_path = ok(&app, &home, &["commit", "-m", "app only", "app.txt"]);

    assert!(

        !by_path.contains("recorded subrepo"),

        "a commit by path leaves the pin out: {by_path}"

    );

    let bare = ok(&app, &home, &["commit", "-m", "everything"]);

    assert!(

        bare.contains("recorded subrepo deps/lib's pin moving") && bare.contains("a pin bump"),

        "{bare}"

    );

    let after = ok(&app, &home, &["status"]);

    assert!(!after.contains("Subrepo pins"), "recorded: {after}");

}

// Cheap checks on the WASM tier (oxygenflow#96): OxygenFlow's checks module,

// copied from oxygenflow/.flow/checks.wasm (built there from

// crates/flow-checks; copy it again when it changes). No image and no KVM,

// so any runner with the WASM tier takes it: a phone, plex, windows-1.

sandbox "wasm" {

    runtime "wasm"

    memory-limit "64MiB"

}

// 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"

}

- **Changed: the changelog is checked on the WASM tier.** A `changelog` job in the pipeline runs OxygenFlow's checks module on any runner with the WASM tier, failing when the changelog's sections are out of shape or Cargo.toml's version has none.

- **Changed: moved subrepo pins are named (#162).** A pin moved by work inside a subrepo is a pin bump the parent's next commit records, and it used to go in unsaid. `oxy status` now lists it under *Subrepo pins* (old → new), and a subrepo's own uncommitted edits, which the parent does not record; a bare `oxy commit` that records a moved pin says so and how to leave it out (`oxy commit PATHS`).

        print_pin_moves(&pin_moves(&repo, None));

    print_pin_moves(&pin_moves(&repo, None));

    // Pins this commit records as moved, said after it (oxygen#162): a pin

    // moved by work inside a subrepo is a pin bump, easy to make unasked.

    let moves = match &selection {

        oxy_core::repo::Selection::All => pin_moves(&repo, None),

        oxy_core::repo::Selection::Paths(p) => pin_moves(&repo, Some(p)),

        oxy_core::repo::Selection::Hunks(_) => Vec::new(),

    };

    for m in &moves {

        let line = match (&m.to, m.dirty) {

            (Some(to), _) => format!(

                "recorded subrepo {}'s pin moving {} {} {}: a pin bump. Meant only your own files? `oxy commit PATHS` leaves pins out",

                m.path,

                m.from,

                ui::glyph("→", "->"),

                to

            ),

            (None, true) => format!(

                "subrepo {} has uncommitted edits of its own: the pin names its last committed state; the edits stay in it",

                m.path

            ),

            (None, false) => continue,

        };

        println!("  {} {}", ui::caution(), ui::warn(line));

    }

}

/// A subrepo whose pin the next commit would move (`to`), or which has

/// uncommitted edits of its own (oxygen#162).

struct PinMove {

    path: String,

    from: String,

    to: Option<String>,

    dirty: bool,

}

/// The subrepos (among `paths`, when given) whose checkout is not at the

/// pin the base records, or holds uncommitted edits. Only a checkout with

/// subrepos (an `.oxymodules`) pays for the look.

fn pin_moves(repo: &oxy_core::repo::Repo, paths: Option<&[String]>) -> Vec<PinMove> {

    if !repo.root().join(".oxymodules").exists() {

        return Vec::new();

    }

    let Ok(subs) = repo.subrepos() else {

        return Vec::new();

    };

    let chosen = |p: &str| {

        paths.is_none_or(|ps| {

            ps.iter().any(|x| {

                let x = x.trim_end_matches('/');

                p == x || p.starts_with(&format!("{x}/")) || x.is_empty() || x == "."

            })

        })

    };

    subs.into_iter()

        .filter(|s| s.committed && chosen(&s.path))

        .filter_map(|s| {

            let to = s

                .actual

                .as_ref()

                .filter(|a| !a.same_state(&s.pin))

                .map(|a| a.summary());

            (to.is_some() || s.dirty).then(|| PinMove {

                from: s.pin.summary(),

                to,

                dirty: s.dirty,

                path: s.path,

            })

        })

        .collect()

}

/// `oxy status`'s word on subrepos: a moved pin is a change the next commit

/// records; edits inside a subrepo are not.

fn print_pin_moves(moves: &[PinMove]) {

    if moves.is_empty() {

        return;

    }

    println!("{}", ui::section("Subrepo pins"));

    for m in moves {

        if let Some(to) = &m.to {

            println!(

                "  {} {}  {} {} {}  {}",

                ui::warn(ui::glyph("↕", "<>")),

                ui::path(&m.path),

                ui::dim(&m.from),

                ui::dim(ui::glyph("→", "->")),

                to,

                ui::dim("pin moved: a bare `oxy commit` records it")

            );

        }

        if m.dirty {

            println!(

                "  {} {}  {}",

                ui::warn(ui::glyph("✎", "~")),

                ui::path(&m.path),

                ui::dim("uncommitted edits inside it: commit them there; the parent records only its pin")

            );

        }

    }