A subrepo at its pinned state is unmodified on any bookmark (closes #147) b5e98094eb8f

- **A subrepo at its pinned state is unmodified on any bookmark (#147).** A subrepo whose heads were exactly its pin's but which sat on another bookmark than the pin named counted as modified, so `oxy bookmark switch` refused ("the working copy has changes"). Only the state counts now: the same repository at the same heads, or the same Git commit; the recorded pin stands.

                .is_ok_and(|have| have.same_state(&want))

        // A subrepo at the state its recorded pin names is unmodified,

        // whatever bookmark it sits on (#147): the recorded pin stands.

        let subrepo_entry = |rel: &str, pin: crate::subrepo::Pin| -> FsEntry {

            if let Some((NodeKind::Subrepo, Some(b))) = tracked.get(rel) {

                let recorded = self

                    .read_blob(b)

                    .ok()

                    .and_then(|x| crate::subrepo::Pin::decode(&x).ok());

                if recorded.is_some_and(|r| r.same_state(&pin)) {

                    return FsEntry {

                        blob: Some(*b),

                        ..FsEntry::new(NodeKind::Subrepo, false, vec![])

                    };

                }

            }

            FsEntry::new(NodeKind::Subrepo, false, pin.encode())

        };

            let entry = subrepo_entry(&rel, pin);

            out.insert(rel, entry);

                    out.insert(rel.clone(), subrepo_entry(rel, pin));

        let same = pin.same_state(&actual);

/// oxygen#147: a subrepo at its pinned state is unmodified whatever

/// bookmark it sits on, so the parent's status is clean and a bookmark

/// switch goes ahead; a new state in it is still a change.

#[test]

fn a_subrepo_at_its_pinned_state_on_another_bookmark_is_unmodified() {

    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_origin = Repo::init(&root.join("app-origin")).unwrap();

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

    let mut app = Repo::clone(&root.join("app-origin").to_string_lossy(), &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();

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

    // The nested repository moves to another bookmark at the same heads.

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

        .unwrap()

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

    let heads = nested.bookmark_heads().unwrap();

    nested.bookmark_create("feature", Some(&heads)).unwrap();

    nested.bookmark_switch("feature", false).unwrap();

    let snap = app.snapshot("status").unwrap();

    assert!(

        !snap.changed,

        "only the bookmark differs: {:?}",

        snap.statuses

    );

    app.bookmark_create("other", Some(&[a1])).unwrap();

    app.bookmark_switch("other", false).unwrap();

    // A new state in it is a change, as before.

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

        .unwrap()

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

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

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

    let snap = app.snapshot("status").unwrap();

    assert_eq!(

        snap.statuses

            .iter()

            .map(|s| (s.path.as_str(), s.status))

            .collect::<Vec<_>>(),

        vec![("libs/lib", ChangeStatus::Modified)]

    );

}

    /// Whether two pins name the same state: the same repository at the

    /// same heads, in any order, or the same Git commit. The bookmark or

    /// branch each names does not count (#147): a subrepo at its pinned

    /// state is at it whatever bookmark it sits on.

    pub fn same_state(&self, other: &Pin) -> bool {

        match (self, other) {

            (

                Pin::Oxy {

                    repo: r1,

                    heads: h1,

                    ..

                },

                Pin::Oxy {

                    repo: r2,

                    heads: h2,

                    ..

                },

            ) => {

                let (mut a, mut b) = (h1.clone(), h2.clone());

                a.sort();

                a.dedup();

                b.sort();

                b.dedup();

                r1 == r2 && a == b

            }

            (Pin::Git { sha: a, .. }, Pin::Git { sha: b, .. }) => a == b,

            _ => false,

        }

    }