Merges move clean working copies; checkouts say what blocks them 1c2bd9abdd4f

    /// switch` does: see [`Repo::checkout_carry`]. Returns the checkout

    /// report and the carried paths.

        let out =

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

        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.snapshot(&format!("oxy bookmark switch {name} --carry"))?;

        Ok(out)

    }

    /// Check out `heads` taking uncommitted work along: every path the

    /// working copy changes must be the same in the target 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 (`target` names the state in it). Returns the

    /// checkout report and the carried paths.

    pub fn checkout_carry(

        &self,

        heads: &[ChangeHash],

        target: &str,

        command: &str,

    ) -> Result<(CheckoutReport, Vec<String>)> {

        let snap = self.snapshot(command)?;

        let target_state = self.load_state(heads)?.materialize();

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

                "{target} has other versions of {} you changed ({}{}); commit first, or drop the changes with --discard",

        let report = self.checkout(heads, true, command)?;

        self.snapshot(command)?;

    /// §10.1). A working copy without changes follows.

        // A working copy without changes follows the merge, whichever state

        // it sat on: nothing of the user's can be lost.

        if clean {

            let list: Vec<String> = snap

                .statuses

                .iter()

                .take(8)

                .map(|s| format!("{} {}", status_word(s.status), s.path))

                .collect();

            return fail(format!(

                "the working copy has changes ({}{}); commit them, take them along with --carry, or drop them with --discard",

                list.join(", "),

                if snap.statuses.len() > 8 { ", …" } else { "" }

            ));

    }

}

/// How a refusal names a path's change: "removed" is a file of the working

/// copy's base that is missing on disk.

fn status_word(s: ChangeStatus) -> &'static str {

    match s {

        ChangeStatus::Added => "added",

        ChangeStatus::Modified => "modified",

        ChangeStatus::Removed => "removed",

        ChangeStatus::Renamed => "renamed",

        ChangeStatus::ModeChanged => "mode changed",

        ChangeStatus::ConflictEdited => "conflict edited",

        ChangeStatus::Resolved => "resolved",

/// Merging and checking out (feedback 3): a working copy without changes

/// follows a merge whichever state it sat on; a refused checkout names

/// what is in the way; `checkout --carry` takes the work along.

#[test]

fn merges_move_clean_working_copies_and_checkouts_say_what_blocks_them() {

    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");

    let h1 = repo.commit("a", &[]).unwrap();

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

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

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

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

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

    repo.commit("c on feature", &[]).unwrap();

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

    // The working copy sits on an older state than main's heads.

    repo.checkout(&[h1], false, "checkout").unwrap();

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

    let m = repo.merge("feature").unwrap();

    assert!(m.checked_out, "a clean working copy follows the merge");

    for f in ["a.txt", "b.txt", "c.txt"] {

        assert!(root.join(f).exists(), "{f}");

    }

    // A refusal says which paths are in the way and what to do.

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

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

    let err = repo

        .checkout(&[h1], false, "checkout")

        .unwrap_err()

        .to_string();

    assert!(

        err.contains("modified a.txt") && err.contains("removed b.txt") && err.contains("--carry"),

        "{err}"

    );

    // --carry takes them along: h1 has a.txt as the base has it, and no b.txt

    // is carried as absent (h1 has none either, so that is refused).

    let err = repo

        .checkout_carry(&[h1], "the first change", "checkout")

        .unwrap_err()

        .to_string();

    assert!(

        err.contains("b.txt") && err.contains("the first change"),

        "{err}"

    );

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

    let (_, carried) = repo

        .checkout_carry(&[h1], "the first change", "checkout")

        .unwrap();

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

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

    assert!(!root.join("b.txt").exists(), "h1 has no b.txt");

}

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); a working copy without changes follows the merge, whichever state it sat on. `oxy checkout NAME` materializes a bookmark without switching to it; with uncommitted work it refuses, naming each changed path and how it changed (a *removed* path is in the working copy's base but not on disk), unless `--discard` or `--carry` (as for switching) says what to do with the work. Bookmark names are resolved before change prefixes wherever a change is expected.

oxy checkout [CHANGE].. [--discard|--carry] oxy undo                     oxy op log

        /// Take uncommitted changes along; refused when the target has

        /// other versions of the files they touch

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

        carry: bool,

        Cmd::Checkout {

            changes,

            discard,

            carry,

        } => workspace::checkout(&changes, discard, carry),

pub fn checkout(changes: &[String], discard: bool, carry: bool) -> Result<i32> {

    let command = format!("oxy checkout {spec}");

    let (r, carried) = if carry {

        repo.checkout_carry(&heads, &spec, &command)?

    } else {

        (repo.checkout(&heads, discard, &command)?, vec![])

    };

        "{} on {}: {} written, {} removed{}",

        r.removed,

        if carried.is_empty() {

            String::new()

        } else {

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

        }