Catch up a stale bookmark: switch, pull and carry 72484195899a

    /// Move `name` to its default remote's state when it is only behind

    /// it: no local change the remote lacks, so nothing is lost

    /// (oxygen#74). Returns how many changes it caught up, if any.

    pub fn catch_up_bookmark(&self, name: &str) -> Result<Option<usize>> {

        let (op_ref, op) = self.head_op()?;

        let remote = self.default_remote();

        let (Some(local), Some(rs)) = (

            op.view.bookmarks.get(name).copied(),

            op.view

                .remotes

                .get(&remote)

                .and_then(|b| b.get(name))

                .copied(),

        ) else {

            return Ok(None);

        };

        if local == rs {

            return Ok(None);

        }

        let heads = self.store.get_state(&local)?.heads;

        let remote_heads = self.store.get_state(&rs)?.heads;

        if !self.negotiate(&remote_heads, &heads)?.is_empty() {

            return Ok(None);

        }

        let behind = self.negotiate(&heads, &remote_heads)?.len();

        if behind == 0 {

            return Ok(None);

        }

        let mut view = op.view.clone();

        view.bookmarks.insert(name.to_string(), rs);

        self.record_op(

            &[op_ref],

            &format!("oxy bookmark switch {name} (catch up with {remote})"),

            view,

        )?;

        Ok(Some(behind))

    }

        // A subrepo whose nested repository is already at the target's pin

        // is no carried work: the target records exactly what is on disk

        // (oxygen#74).

        let at_target_pin = |p: &String| -> bool {

            let Some(f) = target_state.files.get(p) else {

                return false;

            };

            if f.kind != NodeKind::Subrepo {

                return false;

            }

            let FileContent::Opaque { blobs } = &f.content else {

                return false;

            };

            let Some(want) = blobs

                .first()

                .and_then(|b| self.read_blob(b).ok())

                .and_then(|b| Pin::decode(&b).ok())

            else {

                return false;

            };

            let hint = self

                .modules_on_disk()

                .entries

                .get(p)

                .and_then(|m| m.bookmark.clone());

            super::subrepos::read_pin(&self.root.join(p), hint.as_deref())

                .is_ok_and(|have| have == want)

        };

        touched.retain(|p| !at_target_pin(p));

            if base == local_current {

                if clean {

                    self.checkout(&current_heads, false, "oxy pull (checkout)")?;

                    checked_out = true;

                } else {

                    // Uncommitted work comes along when the pulled changes

                    // leave its paths alone, as `git pull` does; otherwise

                    // the working copy stays and the caller says so

                    // (oxygen#74).

                    checked_out = self

                        .checkout_carry(&current_heads, &current, "oxy pull (checkout --carry)")

                        .is_ok();

                }

#[test]

fn carrying_work_over_a_subrepo_already_at_the_target_pin_is_no_conflict() {

    // oxygen#74: a stale state with .oxymodules but no pin, a newer one

    // pinning the subrepo, and the nested repository on disk at that 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();

    // The stale state: registered in .oxymodules, never pinned.

    fs::rename(app_dir.join("libs/lib"), root.join("aside")).unwrap();

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

    let stale = app.bookmark_heads().unwrap();

    fs::rename(root.join("aside"), app_dir.join("libs/lib")).unwrap();

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

    let newer = app.bookmark_heads().unwrap();

    app.checkout(&stale, false, "test").unwrap();

    write(&app_dir, "notes.txt", b"mine\n");

    let (_, carried) = app.checkout_carry(&newer, "main", "test").unwrap();

    assert_eq!(carried, vec!["notes.txt".to_string()]);

    assert!(app_dir.join("notes.txt").exists());

}

#[test]

fn a_bookmark_only_behind_its_remote_catches_up() {

    // oxygen#74: switch takes the remote's state rather than a stale one.

    hermetic();

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

    let root = dir.path();

    let _origin = Repo::init(&root.join("origin")).unwrap();

    let url = root.join("origin").to_string_lossy().to_string();

    let one = Repo::clone(&url, &root.join("one"))

        .unwrap()

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

    write(&root.join("one"), "a.txt", b"a\n");

    one.commit("A", &[]).unwrap();

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

    let two = Repo::clone(&url, &root.join("two"))

        .unwrap()

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

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

    two.commit("B", &[]).unwrap();

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

    assert_eq!(one.catch_up_bookmark("main").unwrap(), None, "not fetched");

    one.fetch("origin").unwrap();

    assert_eq!(one.catch_up_bookmark("main").unwrap(), Some(1));

    assert_eq!(one.bookmarks().unwrap()[0].behind, Some(0));

    // Local work the remote lacks: left alone.

    write(&root.join("one"), "c.txt", b"c\n");

    one.commit("C", &[]).unwrap();

    write(&root.join("two"), "d.txt", b"d\n");

    two.commit("D", &[]).unwrap();

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

    one.fetch("origin").unwrap();

    assert_eq!(one.catch_up_bookmark("main").unwrap(), None);

}

is a union, so this never loses work. A local bookmark that is only behind

its remote (`-3` in `bookmark list`) is caught up when you switch to it.

  conflict is recorded as in section 6. The working copy follows, taking

  uncommitted work along when the pulled changes leave its files alone;

  otherwise it stays and `oxy checkout` updates it.

    // Only behind its remote: take the remote's state, so the switch does

    // not check out a stale one (oxygen#74).

    if let Some(n) = repo.catch_up_bookmark(name)? {

        println!(

            "{} {} with {}: {} it lacked",

            ui::done("Caught up"),

            ui::bookmark(name),

            ui::dim(format!("{}/{name}", repo.default_remote())),

            plural(n, "change")

        );

    }