bookmark switch --carry takes uncommitted work along 61e3bce7ea5b

    /// Switch to `name` taking uncommitted work along (spec §10.1), as `git

    /// switch` does: every path the working copy changes must be the same

    /// in `name`'s state as in the working copy's base, so carrying the

    /// files over applies exactly the same edits there. Otherwise nothing

    /// happens and the error names the paths that differ. Returns the

    /// checkout report and the carried paths.

    pub fn bookmark_switch_carry(&mut self, name: &str) -> Result<(CheckoutReport, Vec<String>)> {

        let view = self.view()?;

        let Some(st) = view.bookmarks.get(name) else {

            return fail(format!("no bookmark {name}"));

        };

        let heads = self.store.get_state(st)?.heads;

        let snap = self.snapshot(&format!("oxy bookmark switch {name} --carry"))?;

        // Every path the work touches: changed ones, and base files it

        // removed or renamed away (a rename reports only its new path).

        let mut touched: BTreeSet<String> = snap.statuses.iter().map(|s| s.path.clone()).collect();

        for (p, f) in &snap.base_snapshot.files {

            if f.kind != NodeKind::Dir

                && f.kind != NodeKind::Subrepo

                && fs::symlink_metadata(self.root.join(p)).is_err()

            {

                touched.insert(p.clone());

            }

        }

        let target = self.load_state(&heads)?.materialize();

        let same = |p: &String| {

            let a = snap.base_snapshot.files.get(p);

            let b = target.files.get(p);

            match (a, b) {

                (None, None) => true,

                (Some(a), Some(b)) => {

                    a.kind == b.kind && a.mode == b.mode && a.content == b.content

                }

                _ => false,

            }

        };

        let differ: Vec<&String> = touched.iter().filter(|p| !same(p)).collect();

        if !differ.is_empty() {

            let list: Vec<&str> = differ.iter().take(10).map(|p| p.as_str()).collect();

            return fail(format!(

                "{name} has other versions of {} you changed ({}{}); commit first, or switch with --discard",

                if differ.len() == 1 { "a file" } else { "files" },

                list.join(", "),

                if differ.len() > 10 { ", …" } else { "" }

            ));

        }

        // The work as it is on disk: content and mode, or absent.

        let mut carried: Vec<(String, Carried)> = Vec::new();

        for p in &touched {

            let full = self.root.join(p);

            let item = match fs::symlink_metadata(&full) {

                Ok(m) if m.file_type().is_symlink() => {

                    Carried::Symlink(fs::read_link(&full)?.to_string_lossy().as_bytes().to_vec())

                }

                Ok(m) if m.is_file() => Carried::File(is_executable(&m), fs::read(&full)?),

                Ok(_) => continue,

                Err(_) => Carried::Absent,

            };

            carried.push((p.clone(), item));

        }

        let report = self.checkout(&heads, true, &format!("oxy bookmark switch {name} --carry"))?;

        for (p, item) in &carried {

            match item {

                Carried::Symlink(target) => self.write_symlink(p, target)?,

                Carried::File(exec, bytes) => self.write_file(p, bytes, *exec)?,

                Carried::Absent => {

                    let _ = fs::remove_file(self.root.join(p));

                }

            }

        }

        fs::create_dir_all(self.workspace_bookmark_path().parent().unwrap())?;

        write_atomic(&self.workspace_bookmark_path(), name.as_bytes())?;

        self.config.bookmark = name.to_string();

        self.drop_manifest();

        self.snapshot(&format!("oxy bookmark switch {name} --carry"))?;

        Ok((report, carried.into_iter().map(|(p, _)| p).collect()))

    }

}

/// A path's state on disk, taken along by `bookmark switch --carry`.

enum Carried {

    Symlink(Vec<u8>),

    /// Executable bit and content.

    File(bool, Vec<u8>),

    Absent,

/// `bookmark switch --carry` (spec §10.1): uncommitted work goes along

/// when the target has the same versions of the files it touches, and is

/// refused, untouched, when it has others.

#[test]

fn switching_bookmarks_carries_uncommitted_work() {

    hermetic();

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

    let root = dir.path();

    let mut repo = Repo::init(root).unwrap().with_home(root.join("home"));

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

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

    write(root, "gone.txt", b"gone\n");

    repo.commit("base", &[]).unwrap();

    repo.bookmark_create("feature", None).unwrap();

    // Started on main, belongs on feature: edit, add, remove.

    write(root, "a.txt", b"a\nmore\n");

    write(root, "new.txt", b"new\n");

    fs::remove_file(root.join("gone.txt")).unwrap();

    let (_, carried) = repo.bookmark_switch_carry("feature").unwrap();

    assert_eq!(carried, vec!["a.txt", "gone.txt", "new.txt"]);

    assert_eq!(repo.config.bookmark, "feature");

    assert_eq!(fs::read(root.join("a.txt")).unwrap(), b"a\nmore\n");

    assert_eq!(fs::read(root.join("new.txt")).unwrap(), b"new\n");

    assert!(!root.join("gone.txt").exists());

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

    assert_eq!(

        statuses(&snap),

        vec![

            ("a.txt".to_string(), ChangeStatus::Modified),

            ("gone.txt".to_string(), ChangeStatus::Removed),

            ("new.txt".to_string(), ChangeStatus::Added)

        ]

    );

    repo.commit("the work", &[]).unwrap();

    assert!(repo.resolve_heads("main").unwrap().len() == 1);

    // main moves b.txt on; work on feature touching b.txt cannot follow.

    repo.bookmark_switch("main", false).unwrap();

    write(root, "b.txt", b"b on main\n");

    repo.commit("b on main", &[]).unwrap();

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

    write(root, "b.txt", b"b edited\n");

    let err = repo.bookmark_switch_carry("main").unwrap_err().to_string();

    assert!(err.contains("b.txt") && err.contains("--discard"), "{err}");

    assert_eq!(repo.config.bookmark, "feature", "nothing happened");

    assert_eq!(fs::read(root.join("b.txt")).unwrap(), b"b edited\n");

}

A repository holds any number of bookmarks. Each workspace has a **current bookmark** (`oxy bookmark switch NAME`, recorded per workspace) that its working copy sits on and that `commit`, `log`, `push`, and `pull` act on by default. Switching refuses uncommitted work unless told what to do with it: `--discard` drops it, and `--carry` takes it along when every path it touches is the same in NAME's state as in the working copy's base (so the same edits apply there), refusing and naming the paths otherwise. `oxy bookmark create feat && oxy bookmark switch feat --carry` moves work started on one bookmark onto a new one. `oxy bookmark create NAME [CHANGE..]` names a new state (default: the current working copy's base heads), `set NAME CHANGE..` moves one, `delete NAME` removes it (its changes stay until unreachable, §21), `list` shows all with their heads and the remote-tracking difference, and `oxy merge NAME` unions the named bookmark's heads into the current one, which is the whole of merging in this model: no merge change, conflicts reified (§9). `oxy checkout NAME` materializes a bookmark without switching to it. Bookmark names are resolved before change prefixes wherever a change is expected.

    /// Make NAME this workspace's bookmark and check it out. Uncommitted work stops it; --carry takes the work along, --discard drops it

        /// Take uncommitted changes along; refused when NAME has other

        /// versions of the files they touch

        #[arg(long, conflicts_with = "discard")]

        carry: bool,

            BookmarkCmd::Switch {

                name,

                discard,

                carry,

            } => workspace::bookmark_switch(&name, discard, carry),

pub fn bookmark_switch(name: &str, discard: bool, carry: bool) -> Result<i32> {

    let (r, carried) = if carry {

        repo.bookmark_switch_carry(name)?

    } else {

        (repo.bookmark_switch(name, discard)?, vec![])

    };

        "{} to {}: {} written, {} removed{}",

        r.removed,

        if carried.is_empty() {

            String::new()

        } else {

            format!("; carried {}", plural(carried.len(), "changed path"))

        }