prompt: compare a subrepo by its pin, not its directory's time 80677b7a3513

                    // A subrepo: its pin is compared on its own (`subrepo_moved`),

                    // its directory's time says nothing (oxygen#75).

                    Ok(md) if md.is_dir() => {

                        path.join(OXY_DIR).exists() || path.join(".git").exists()

                    }

    /// The manifest's entries that are subrepos (nested repositories it

    /// tracks): a directory, compared by its pin, not its stat.

    /// Known from the walk's nested repositories, and from `.oxymodules`:

    /// a commit's manifest does not list the nested repositories.

    fn subrepo_entries<'m>(&self, manifest: &'m Manifest) -> Vec<(&'m String, &'m ManifestEntry)> {

        let modules = self.modules_on_disk();

        let mut out: Vec<(&'m String, &'m ManifestEntry)> = manifest

            .nested

            .iter()

            .map(String::as_str)

            .chain(modules.entries.keys().map(String::as_str))

            .filter_map(|n| manifest.entries.get_key_value(n))

            .collect();

        out.sort_by(|a, b| a.0.cmp(b.0));

        out.dedup_by(|a, b| a.0 == b.0);

        out

    }

    /// Whether a subrepo is at another pin than the manifest recorded: its

    /// pin now (the nested repository's base, or Git's `HEAD`), encoded as

    /// a snapshot records it, against the recorded hash. Absent, it keeps

    /// its recorded pin, as a snapshot does; unreadable, it counts as moved.

    fn subrepo_moved(&self, rel: &str, me: &ManifestEntry) -> bool {

        let dir = self.root.join(rel);

        if !(dir.join(OXY_DIR).exists() || dir.join(".git").exists()) {

            return false;

        }

        let modules = self.modules_on_disk();

        let hint = modules.entries.get(rel).and_then(|m| m.bookmark.clone());

        match super::subrepos::read_pin(&dir, hint.as_deref()) {

            // A commit's manifest names the pin by its blob (its hash is of

            // no bytes); a snapshot's by the bytes' hash.

            Ok(pin) => match me.blob {

                Some(b) => Repo::blob_ref(&pin.encode()) != b,

                None => *blake3::hash(&pin.encode()).as_bytes() != me.hash,

            },

            Err(_) => true,

        }

    }

        // Subrepos are directories, compared by their pins below.

        let subrepos = self.subrepo_entries(manifest);

        let is_subrepo = |rel: &str| subrepos.iter().any(|(r, _)| r.as_str() == rel);

        let tracked: Vec<(&String, &ManifestEntry)> = manifest

            .entries

            .iter()

            .filter(|(rel, _)| !is_subrepo(rel))

            .collect();

        let rels: Vec<&String> = tracked.iter().map(|(r, _)| *r).collect();

        let entries: Vec<&ManifestEntry> = tracked.iter().map(|(_, me)| *me).collect();

            .any(|((rel, me), n)| differs_from(me, rel, n.as_ref().unwrap()))

            || subrepos.iter().any(|(rel, me)| self.subrepo_moved(rel, me));

            // Subrepos are not listed as files: compared by their pins.

            let subrepos = self.subrepo_entries(manifest);

            if subrepos.iter().any(|(rel, me)| self.subrepo_moved(rel, me)) {

                return Ok(true);

            }

            let skipped: Vec<_> = skipped

                .into_iter()

                .filter(|(rel, _)| !subrepos.iter().any(|(r, _)| r == rel))

                .collect();

/// oxygen#75: the prompt's quick check agrees with status in a repository

/// with a subrepo: clean after a commit, dirty when the subrepo moves to

/// another state, clean again once that pin is committed. (It compared the

/// subrepo's directory as if it were a file, so it was always dirty.)

#[test]

fn the_quick_dirty_check_compares_a_subrepo_by_its_pin() {

    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, "main.txt", b"app\n");

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

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

    // Out of the racy window, so the stat-only path decides.

    std::thread::sleep(std::time::Duration::from_millis(2100));

    let reopen = || Repo::open(&app_dir).unwrap();

    assert_eq!(

        reopen().quick_dirty().unwrap(),

        Some(false),

        "clean, as status says"

    );

    let nested = Repo::open(&app_dir.join("libs/lib")).unwrap();

    write(&app_dir.join("libs/lib"), "lib.txt", b"v2\n");

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

    assert_eq!(

        reopen().quick_dirty().unwrap(),

        Some(true),

        "the subrepo moved"

    );

    reopen().commit("pin lib v2", &[]).unwrap();

    std::thread::sleep(std::time::Duration::from_millis(2100));

    assert_eq!(

        reopen().quick_dirty().unwrap(),

        Some(false),

        "the new pin is committed"

    );

}