submodule: name .oxymodules entries that were never added 7993d465675b

    /// `.oxymodules` entries with no subrepo behind them: never added, so

    /// there is no pin to clone or check out (oxygen#72).

    pub fn unpinned_modules(&self) -> Result<Vec<(String, Module)>> {

        let pinned: Vec<String> = self.subrepos()?.into_iter().map(|s| s.path).collect();

        Ok(self

            .modules_on_disk()

            .entries

            .into_iter()

            .filter(|(path, _)| !pinned.contains(path))

            .collect())

    }

#[test]

fn a_module_entry_that_was_never_added_is_reported_as_unpinned() {

    // oxygen#72: a .oxymodules section with no subrepo behind it.

    hermetic();

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

    let root = dir.path();

    let _lib_origin = Repo::init(&root.join("lib-origin")).unwrap();

    let lib_url = root.join("lib-origin").to_string_lossy().to_string();

    let lib = Repo::clone(&lib_url, &root.join("lib"))

        .unwrap()

        .with_home(root.join("home"));

    write(&root.join("lib"), "lib.txt", b"v1\n");

    lib.commit("lib v1", &[]).unwrap();

    assert!(lib.push("origin", false).unwrap()[0].ok);

    let app_dir = root.join("app");

    let app = Repo::init(&app_dir).unwrap().with_home(root.join("home"));

    write(

        &app_dir,

        ".oxymodules",

        format!("[libs/lib]\nurl = {lib_url}\n").as_bytes(),

    );

    let unpinned = app.unpinned_modules().unwrap();

    assert_eq!(unpinned.len(), 1);

    assert_eq!(unpinned[0].0, "libs/lib");

    assert_eq!(unpinned[0].1.url, lib_url);

    assert!(app.submodule_update(true, &[]).unwrap().is_empty());

    app.submodule_add(&lib_url, "libs/lib", None).unwrap();

    assert!(app.unpinned_modules().unwrap().is_empty(), "added now");

}

repository keeps its pin until you run `update --init`. A `.oxymodules`

section written by hand has no pin until `oxy submodule add` clones it;

`status` and `update` name such entries, and `update` exits non-zero. Git

submodules survive `oxy git import` as Git pins and go back out as gitlinks

on export.

    let unpinned: Vec<_> = repo

        .unpinned_modules()?

        .into_iter()

        .filter(|(p, _)| paths.is_empty() || paths.iter().any(|q| q.trim_end_matches('/') == p))

        .collect();

    if results.is_empty() && unpinned.is_empty() {

        println!("{}", ui::dim("No subrepos."));

    }

    let code = print_subrepo_results(results);

    print_unpinned(&unpinned);

    Ok(if unpinned.is_empty() { code } else { 1 })

/// `.oxymodules` entries never added: nothing to clone, so say how to add

/// them (oxygen#72).

fn print_unpinned(unpinned: &[(String, oxy_core::subrepo::Module)]) {

    for (path, m) in unpinned {

        let url = if m.url.is_empty() { "<url>" } else { &m.url };

        println!(

            "{} {}",

            ui::warn(format!(

                "{} in .oxymodules but never added, so no pin",

                ui::glyph("⚠", "!")

            )),

            ui::path(path)

        );

        println!(

            "  {}",

            ui::dim(format!("add it with: oxy submodule add {url} {path}"))

        );

    }

}

    let unpinned = repo.unpinned_modules()?;

        let pinned = subs.iter().map(|s| {

            json::obj([

                ("path", json::s(&s.path)),

                ("pin", pin_json(&s.pin)),

                ("actual", json::opt(s.actual.as_ref(), pin_json)),

                ("at_pin", json::b(s.actual.as_ref() == Some(&s.pin))),

                ("dirty", json::b(s.dirty)),

                ("committed", json::b(s.committed)),

                ("url", json::opt(s.url.as_deref(), json::s)),

            ])

        });

        // Listed in .oxymodules but never added: no pin at all.

        let unpinned_json = unpinned.iter().map(|(path, m)| {

            json::obj([

                ("path", json::s(path)),

                ("pin", "null".to_string()),

                ("actual", "null".to_string()),

                ("at_pin", json::b(false)),

                ("dirty", json::b(false)),

                ("committed", json::b(false)),

                ("url", json::s(&m.url)),

            ])

        });

        println!("{}", json::arr(pinned.chain(unpinned_json)));

    if subs.is_empty() && unpinned.is_empty() {

    print_unpinned(&unpinned);