carry: work the target already has is no conflict fe9586d93fb1

- **`--carry` takes work the target already has (#100).** Switching bookmarks or checking out with `--carry` refused when uncommitted files were byte-for-byte what the target state holds, as after a proposal of that work landed, leaving only `--discard`. Such work is now already applied: no conflict, nothing to carry, and the rest of the work comes along.

        // Work already the target's: the file on disk is exactly the

        // target's version (or both are absent), so nothing needs carrying

        // and it is no conflict (oxygen#100), as when a proposal's work

        // has landed on the bookmark switched to.

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

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

            match (fs::symlink_metadata(&full), target_state.files.get(p)) {

                (Err(_), None) => true,

                (Ok(m), Some(f)) if m.is_file() && f.kind == NodeKind::File => {

                    if is_executable(&m) != f.mode.exec {

                        return false;

                    }

                    let want = match &f.content {

                        FileContent::Text { bytes, .. } => Some(bytes.clone()),

                        FileContent::Opaque { blobs } if blobs.len() == 1 => {

                            self.read_blob(&blobs[0]).ok()

                        }

                        _ => None,

                    };

                    want.is_some_and(|w| fs::read(&full).is_ok_and(|have| have == w))

                }

                _ => false,

            }

        };

        touched.retain(|p| same(p) || !already(p));

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

    // removed b.txt is already as h1 has it (none), so that is no conflict

    // either (oxygen#100).

}

/// oxygen#100: uncommitted work byte-for-byte what the bookmark switched to

/// already has is no conflict: the switch goes through, nothing is lost,

/// and other carried work still comes along.

#[test]

fn carrying_work_the_target_already_has_is_no_conflict() {

    hermetic();

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

    let root = dir.path();

    let mut repo = Repo::init(root).unwrap();

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

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

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

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

    // On landed, a.txt becomes "two" (as a proposal landing would).

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

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

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

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

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

    // The same edit, uncommitted, on main; and another edit besides.

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

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

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

    assert_eq!(

        carried,

        vec!["b.txt".to_string()],

        "only the work landed lacks is carried"

    );

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

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

    let s = repo.snapshot("oxy status").unwrap();

    let paths: Vec<_> = s.statuses.iter().map(|p| p.path.as_str()).collect();

    assert_eq!(paths, ["b.txt"]);

    // A real difference is still refused.

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

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

    let e = repo

        .bookmark_switch_carry("landed")

        .unwrap_err()

        .to_string();

    assert!(e.contains("a.txt") && e.contains("--discard"), "{e}");