Resolve a binary file's conflicting versions by keeping one 9e5ef6c23006

/// The versions of a binary file with a replace conflict at `path`, each

/// labelled with the change that wrote it.

fn replace_candidates(

    r: &oxy_core::repo::Repo,

    state: &oxy_core::state::State,

    snapshot: &oxy_core::state::Snapshot,

    path: &str,

) -> Option<Vec<Candidate>> {

    use oxy_core::state::FileContent;

    let f = snapshot.files.get(path)?;

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

    if blobs.len() < 2 || f.kind != oxy_core::objects::NodeKind::File {

        return None;

    }

    let writers = state.live_replaces(&f.node);

    let mut out = Vec::new();

    for (i, b) in blobs.iter().enumerate() {

        let content = r.read_blob(b).ok()?;

        let by = writers.iter().find(|(_, n)| n == b).map(|(h, _)| state.label(h)).unwrap_or_default();

        let preview = std::str::from_utf8(&content).ok().map(|t| t.lines().take(40).collect::<Vec<_>>().join("\n"));

        out.push(Candidate { path: format!("version {} from change {by}", i + 1), content, preview });

    }

    Some(out)

}

    /// A replace conflict of a binary file: keep one of its versions.

    Replace(Vec<Candidate>),

    /// Whether the candidates are versions of one file (a replace

    /// conflict) rather than files wanting one name.

    versions: bool,

            let versions = replace_candidates(r, &loaded.state, &loaded.snapshot, &p);

            Ok(Some((st.to_hex(), names, file, versions)))

    let Some((state, names, file, versions)) = found else {

        return Err(Error::bad(shell.clone(), "Conflicts are resolved on a bookmark."));

    };

    if let Some(v) = versions {

        return Ok((state, Target::Replace(v)));

    }

        Target::Name(_) | Target::Replace(_) => return Err(Error::bad(shell, "That conflict is resolved by keeping a candidate.")),

        Target::Name(_) | Target::Replace(_) => {

            Ok(name_page(&app, &viewer, &owner, &name, &bookmark, &path, None, None).await?.into_response())

        }

    let (candidates, versions) = match target {

        Target::Name(c) => (c, false),

        Target::Replace(c) => (c, true),

        Target::Lines(_) => return Err(Error::bad(shell, "That conflict is resolved region by region.")),

    };

        versions,

        message: message.unwrap_or_else(|| {

            if versions {

                format!("Resolve the conflicting versions of {path}")

            } else {

                format!("Resolve the name conflict at {path}")

            }

        }),

        Target::Name(candidates) | Target::Replace(candidates) if candidates.is_empty() => {

            return again("There are no candidates to keep.".into()).await;

        }

        Target::Replace(candidates) => {

            let again = |msg: String| {

                let (app, viewer, owner, name, bookmark, path, message) =

                    (app.clone(), viewer.clone(), owner.clone(), name.clone(), bookmark.clone(), path.clone(), message.clone());

                async move {

                    name_page(&app, &viewer, &owner, &name, &bookmark, &path, Some(msg), Some(message))

                        .await

                        .map(IntoResponse::into_response)

                }

            };

            if stale {

                return again(format!("{bookmark} has moved since this page was loaded; the versions below are as they are now.")).await;

            }

            let Some(keep) = f.get("keep").and_then(|k| k.parse::<usize>().ok()).and_then(|k| candidates.get(k)) else {

                return again("Choose the version to keep.".into()).await;

            };

            if message.is_empty() {

                return again("Describe the resolution.".into()).await;

            }

            let signer = match signer_for(&app, me.account.id).await {

                Ok(s) => s,

                Err(msg) => return again(msg).await,

            };

            // Writing the kept version at the path settles the conflict.

            let edit = vec![FileEdit { path: path.clone(), content: Some(keep.content.clone()) }];

            let done = match edits::commit(&app.repos, &repo, bookmark.clone(), bookmark.clone(), edit, message.clone(), signer).await {

                Ok(d) => d,

                Err(e) => return again(e.to_string()).await,

            };

            after_web_commit(&app, &me.account, &row, &owner, &name, &done, &message).await;

            return Ok(Redirect::to(&format!("/{owner}/{name}/change/{}", done.change.to_hex())).into_response());

        }

    // A replace conflict: a binary file (a NUL makes it opaque) replaced

    // two ways by proposals that do not know each other.

    let r = send(

        app,

        "POST",

        "/andy/demo/edit/main",

        Some(&andy),

        Some(&format!("_csrf={csrf}&path=img.bin&content=base%00&message=img&mode=commit")),

    )

    .await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    for (b, text) in [("img-a", "alpha%00"), ("img-b", "beta%00")] {

        let r = send(

            app,

            "POST",

            "/andy/demo/edit/main",

            Some(&andy),

            Some(&format!("_csrf={csrf}&path=img.bin&original=img.bin&content={text}&message={b}&mode=propose&new_bookmark={b}")),

        )

        .await;

        assert!(r.location.as_deref().is_some_and(|l| l.contains("/proposal/")), "{}", r.body);

    }

    for n in [7, 8] {

        let page = send(app, "GET", &format!("/andy/demo/proposal/{n}"), Some(&andy), None).await;

        let r =

            send(app, "POST", &format!("/andy/demo/proposal/{n}/land"), Some(&andy), Some(&format!("_csrf={}", csrf_of(&page.body)))).await;

        assert!(r.body.contains("Landed."), "#{n}: {}", r.body);

    }

    let conflicts = send(app, "GET", "/andy/demo/conflicts", Some(&andy), None).await.body;

    assert!(conflicts.contains("replace (2 candidates)") && conflicts.contains("/andy/demo/resolve/main/img.bin"), "{conflicts}");

    let page = send(app, "GET", "/andy/demo/resolve/main/img.bin", Some(&andy), None).await;

    assert!(page.body.contains("has 2 versions") && page.body.contains("version 2 from change"), "{}", page.body);

    let state = {

        let i = page.body.find("name=\"state\" value=\"").unwrap() + "name=\"state\" value=\"".len();

        page.body[i..i + 64].to_string()

    };

    let version = |text: &str| page.body.find(&format!("<pre class=\"marked\">{text}")).expect("a version's preview");

    let beta = if version("beta") < version("alpha") { 0 } else { 1 };

    let r = send(

        app,

        "POST",

        "/andy/demo/resolve/main/img.bin",

        Some(&andy),

        Some(&format!("_csrf={csrf}&state={state}&keep={beta}&message={}", enc("Keep beta"))),

    )

    .await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    assert!(send(app, "GET", "/andy/demo/conflicts", None, None).await.body.contains("No bookmark carries a conflict"));

    assert_eq!(send(app, "GET", "/andy/demo/raw/main/img.bin", None, None).await.body, "beta\u{0}");

    let change = send(app, "GET", r.location.as_deref().unwrap(), Some(&andy), None).await.body;

    assert!(change.contains(">resolution<"), "a resolution change");

For each bookmark whose state has conflicts: the file (or tree entry), the conflict kind, and each side with the change that produced it and its content, rendered with the same marker structure `oxy checkout` writes. For a text file, **resolve region by region** (`/{owner}/{name}/resolve/{bookmark}/{path}`, writers) shows the lines no one disagrees on and each conflict region with its sides and the change that wrote each; per region the user keeps one side, every side in order, none, or their own text (a side that records a deletion keeps the deletion). Regions are linkable (`#region-N`). The file is put back together and committed through the delegate as a web edit (§6.9), which makes it a `kind = resolution` change depending on every contributor; the page carries the bookmark's state and refuses to commit if the bookmark moved meanwhile. Malformed markers fall back to the editor, which also stays available: "edit the marked file" opens the markers in it. A name conflict (several files want one name, shown as `NAME.oxy-conflict-N`) resolves on the same URL by keeping one candidate: it takes the name as a move, keeping its identity, and the other candidates are removed. A replace conflict (a binary file replaced two ways) resolves the same way by keeping one version, each labelled with the change that wrote it; the commit replaces every version with it (Oxygen spec §9.3). Conflicts between directories or links are resolved from a client. Both resolver pages offer **Resolve in VS Code**, a `vscode://oxygen.oxygen-vscode/resolve?url=…&bookmark=…&path=…` link that oxygen-vscode handles: it finds the open checkout of that repository (or offers to clone it), switches to the bookmark after asking, pulls it, and opens the file. The change page tags resolution changes. Otherwise the page gives the two-line client recipe.

  {% if (c.kind.starts_with("name:") || c.kind.starts_with("replace")) && repo.can(crate::auth::Access::Write) %}<p><a class="go small" href="{{ repo.url }}/resolve/{{ c.bookmark }}/{{ c.path }}">choose which to keep</a></p>{% endif %}

{% if versions %}<p class="small mute">Changes that did not know of each other each replaced this file, so it has {{ candidates.len() }} versions. Keep one: the commit is a resolution change on {{ bookmark }} that replaces every version with it.</p>{% else %}<p class="small mute">{{ candidates.len() }} files want this name, so the tree shows them as <code>{{ path }}.oxy-conflict-N</code>. Keep one: it takes the name, keeping its history, and the others are removed. The commit is a resolution change on {{ bookmark }}.</p>{% endif %}</div>

  <header><label><input type="radio" name="keep" value="{{ loop.index0 }}"{% if loop.first %} checked{% endif %}> keep <strong>{{ c.path }}</strong></label>{% if !versions %} <a class="small" href="{{ repo.url }}/file/{{ bookmark }}/{{ c.path }}">view</a>{% endif %}</header>