oxy resolve PATH settles a replace conflict with the working copy's content (closes #140) 157d02e95586

- **A binary file's or subrepo pin's conflict can be settled from the command line (#140).** Two changes that replaced the same binary file, or moved the same subrepo pin, leave a replace conflict with no markers to edit, and every commit was refused until it was settled, which only a hosted edit could do. `oxy resolve PATH…` now settles it with what the working copy holds at the path (the file, or the subrepo's pin): the next commit is a resolution replacing every version with it. A path with no replace conflict is refused, and a choice is forgotten once committed.

- **The object store works where hard links are refused (#141).** Android forbids apps hard links in their own storage, so the OxygenHub app's phone runner could clone nothing (`Permission denied`). Where a link is refused, objects are renamed into place with `renameat2(RENAME_NOREPLACE)`: as atomic, and still never over a name that is taken.

/// Whether `base` has two or more live versions of the opaque file or

/// subrepo pin at `path` (a replace conflict, spec §9.3).

fn has_replace_conflict(base: &Snapshot, path: &str) -> bool {

    matches!(base.files.get(path).map(|f| &f.content), Some(FileContent::Opaque { blobs }) if blobs.len() > 1)

}

    }

    fn resolutions_path(&self) -> PathBuf {

        self.oxy

            .join("workspaces")

            .join(self.workspace.to_hex())

            .join("resolve")

    }

    /// The paths whose replace conflicts the user chose to settle with what

    /// the working copy holds there (`oxy resolve PATH`, spec §9.3).

    pub fn resolutions(&self) -> Result<BTreeSet<String>> {

        match fs::read_to_string(self.resolutions_path()) {

            Ok(text) => Ok(text

                .lines()

                .filter(|l| !l.is_empty())

                .map(String::from)

                .collect()),

            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(BTreeSet::new()),

            Err(e) => Err(e.into()),

        }

    }

    /// Settle the replace conflicts at `paths` (a file's or a subrepo pin's,

    /// spec §9.3) with what the working copy holds there: the next snapshot

    /// replaces every live candidate with it. Refused for a path whose base

    /// has no replace conflict.

    pub fn choose_resolutions(&self, base: &Snapshot, paths: &[String]) -> Result<()> {

        for p in paths {

            if !has_replace_conflict(base, p) {

                return Err(RepoError::Msg(format!(

                    "{p} has no replace conflict to settle (a text file's conflict is settled by editing out its markers)"

                )));

            }

        }

        let mut all = self.resolutions()?;

        all.extend(paths.iter().cloned());

        let text: String = all.iter().map(|p| format!("{p}\n")).collect();

        crate::durable::write_atomic(&self.resolutions_path(), text.as_bytes())?;

        Ok(())

    }

    /// The chosen resolutions `base` still needs; the rest are forgotten.

    fn resolutions_for(&self, base: &Snapshot) -> Result<HashSet<String>> {

        let all = self.resolutions()?;

        if all.is_empty() {

            return Ok(HashSet::new());

        }

        let live: HashSet<String> = all

            .iter()

            .filter(|p| has_replace_conflict(base, p))

            .cloned()

            .collect();

        if live.is_empty() {

            match fs::remove_file(self.resolutions_path()) {

                Ok(()) => {}

                Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}

                Err(e) => return Err(e.into()),

            }

        }

        Ok(live)

        // Replace conflicts the user settled with `oxy resolve PATH`

        // (oxygen#140): those still in the base; a choice the base no longer

        // needs (once committed) is forgotten.

        let resolve = self.resolutions_for(&base_snapshot)?;

            if !resolve.is_empty() {

                self.build_from_entries_resolving(

                    &base,

                    &base_snapshot,

                    reuse,

                    &fs_entries,

                    &resolve,

                )?

            } else if partial && self.config.sparse_paths.is_empty() {

/// oxygen#140: a replace conflict is settled from the working copy, as

/// `oxy resolve PATH` does: the path's content on disk becomes the

/// resolution, and the commit that records it is a Resolution.

fn a_replace_conflict_is_settled_from_the_working_copy() {

    hermetic();

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

    let root = dir.path();

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

    let blob = |n: u8| {

        let mut v = vec![0u8; 64];

        v[1] = n;

        v

    };

    write(root, "img.bin", &blob(1));

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

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

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

    write(root, "img.bin", &blob(2));

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

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

    write(root, "img.bin", &blob(3));

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

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

    repo.merge("other").unwrap();

    // Without a choice, nothing the working copy holds settles it, and

    // other work cannot be committed past it.

    write(root, "img.bin", &blob(9));

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

    assert!(

        repo.commit("edit a", &[]).is_err(),

        "refused while conflicted"

    );

    let snap = repo.snapshot("oxy resolve").unwrap();

    assert!(

        repo.choose_resolutions(&snap.base_snapshot, &["a.txt".to_string()])

            .is_err(),

        "a.txt has no replace conflict"

    );

    repo.choose_resolutions(&snap.base_snapshot, &["img.bin".to_string()])

        .unwrap();

    let snap = repo.snapshot("oxy resolve").unwrap();

    assert!(snap

        .statuses

        .iter()

        .any(|s| s.path == "img.bin" && s.status == ChangeStatus::Resolved));

    let c = repo.commit("settle img", &[]).unwrap();

    assert_eq!(

        repo.store().get_change(&c).unwrap().kind,

        ChangeKind::Resolution

    );

    let after = repo

        .load_state(&repo.bookmark_heads().unwrap())

        .unwrap()

        .materialize();

    assert!(!after.is_conflicted());

    assert_eq!(

        after.files["img.bin"].content,

        FileContent::Opaque {

            blobs: vec![Repo::blob_ref(&blob(9))]

        }

    );

    assert!(

        matches!(&after.files["a.txt"].content, FileContent::Text { bytes, .. } if bytes == b"a\nmore\n")

    );

    // Settled: the choice is forgotten, and the working copy is clean.

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

    assert!(snap.statuses.is_empty(), "{:?}", snap.statuses);

    assert!(repo.resolutions().unwrap().is_empty());

}

/// oxygen#140: the same for a subrepo pin moved two ways at once.

#[test]

fn a_pin_conflict_is_settled_from_the_working_copy() {

    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 mut 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();

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

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

        .unwrap()

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

    fn pin(app: &Repo, nested: &Repo, text: &[u8], message: &str) {

        write(nested.root(), "lib.txt", text);

        nested.commit(message, &[]).unwrap();

        app.commit(&format!("pin {message}"), &[]).unwrap();

    }

    app.bookmark_create("other", None).unwrap();

    pin(&app, &nested, b"v2\n", "v2");

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

    pin(&app, &nested, b"v3\n", "v3");

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

    app.merge("other").unwrap();

    let merged = app

        .load_state(&app.bookmark_heads().unwrap())

        .unwrap()

        .materialize();

    assert!(

        matches!(&merged.files["libs/lib"].content, FileContent::Opaque { blobs } if blobs.len() == 2),

        "a pin conflict"

    );

    // The nested repository moves on once more; that pin is the choice.

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

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

    let snap = app.snapshot("oxy resolve").unwrap();

    app.choose_resolutions(&snap.base_snapshot, &["libs/lib".to_string()])

        .unwrap();

    let c = app.commit("settle the pin", &[]).unwrap();

    assert_eq!(

        app.store().get_change(&c).unwrap().kind,

        ChangeKind::Resolution

    );

    let after = app

        .load_state(&app.bookmark_heads().unwrap())

        .unwrap()

        .materialize();

    assert!(!after.is_conflicted());

    assert!(app.snapshot("status").unwrap().statuses.is_empty());

}

#[test]

A binary file or a subrepo pin changed two ways has no markers to edit:

the checkout writes one version, and you say which content wins by

naming it. Put the bytes you want at the path (or move the subrepo to the

pin you want), then:

```

oxy resolve assets/logo.png deps/lib   # these paths' content settles them

```

Which blobs are live: a replace record is superseded by a later replacement of its blob, a record whose `old` is its `new` and whose change depends on its change (§8.1 makes every replacement depend on the change that made its `old` current). Replacements that do not know each other both stay live, and a file reverted to an earlier blob keeps it. A replace conflict is **resolved** by a `kind = resolution` change with one `Replace` from each live blob to the chosen one, depending on every change that made a candidate live, so each is superseded and one blob remains. A working-copy snapshot never settles a replace conflict on its own (a checkout writes one candidate at the path); a tool that knows the user's choice, such as a forge's resolver or `oxy resolve PATH` (which takes the working copy's content at the path), builds the resolution. A replacement recorded without that dependency (before Draft 0.8i) supersedes every record with its `new` that does not come after it, the rule until then.

oxy split CHANGE [PATH]..           oxy abandon CHANGE | -r REVSET [--yes]   oxy resolve [PATH]..

    /// Report which conflicts of the working copy's base are resolved by the current files;

    /// with paths, settle their replace conflicts (binary files, subrepo pins) with what the

    /// working copy holds there

        /// Opaque files or subrepos whose replace conflict to settle with their current content

        paths: Vec<String>,

        Cmd::Resolve { paths, json } => workspace::resolve(&paths, json),

pub fn resolve(paths: &[String], as_json: bool) -> Result<i32> {

    let mut snap = repo.snapshot("oxy resolve")?;

    if !paths.is_empty() {

        // A replace conflict has no markers to edit out: the user says which

        // content wins (oxygen#140, spec §9.3), and the snapshot builds it.

        let paths: Vec<String> = paths

            .iter()

            .map(|p| p.trim_start_matches("./").trim_end_matches('/').to_string())

            .collect();

        repo.choose_resolutions(&snap.base_snapshot, &paths)?;

        snap = repo.snapshot("oxy resolve")?;

    }