Resolve name conflicts by keeping a candidate fd958fbc06fb

{% extends "base.html" %}

{% import "repo_tabs.html" as m %}

{% block title %}Resolve {{ path }} · {{ repo.owner }}/{{ repo.name }}{% endblock %}

{% block bodyattrs %} data-repo="{{ repo.url }}"{% endblock %}

{% block tabs %}{% call m::tabs(repo, "conflicts") %}{% endblock %}

{% block mainclass %} class="wide"{% endblock %}

{% block content %}

<div class="head"><h1>Resolve <code>{{ path }}</code> <small>on <span class="lbl lbl-bm">{{ bookmark }}</span></small></h1>

<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></div>

{% if let Some(e) = error %}<p class="error">{{ e }}</p>{% endif %}

{% if let Some(d) = delegation %}<p class="error">{{ d }}</p>{% endif %}

<form method="post" action="{{ repo.url }}/resolve/{{ bookmark }}/{{ path }}">

<input type="hidden" name="_csrf" value="{{ shell.csrf }}">

<input type="hidden" name="state" value="{{ state }}">

{% for c in candidates %}

<section class="file-diff" id="candidate-{{ loop.index }}">

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

  {% if let Some(p) = c.preview %}<pre class="marked">{{ p }}</pre>{% else %}<p class="small mute">binary, {{ c.content.len() }} bytes</p>{% endif %}

</section>

{% endfor %}

<label for="message">Message</label><input type="text" id="message" name="message" value="{{ message }}">

<button type="submit">COMMIT RESOLUTION</button>

</form>

{% endblock %}

        TreeConflict::Name { name, nodes, parent } => {

            let path = if parent.is_root() { name.clone() } else { format!("{}/{name}", path_of(parent)) };

            (path, format!("name: {} entries want this name", nodes.len()))

        }

/// One of the entries a name conflict shows at `NAME.oxy-conflict-N`.

#[derive(Clone, Debug)]

pub struct Candidate {

    pub path: String,

    pub content: Vec<u8>,

    /// The start of a text candidate, for the page.

    pub preview: Option<String>,

}

/// The candidates of a name conflict at `path` in a loaded state: the

/// files the tree shows as `path.oxy-conflict-N`. `None` when `path` has no

/// name conflict; an error for one between directories or links.

fn name_candidates(r: &oxy_core::repo::Repo, snapshot: &oxy_core::state::Snapshot, path: &str) -> Result<Option<Vec<Candidate>>, String> {

    use oxy_core::objects::NodeKind;

    use oxy_core::state::FileContent;

    use oxy_core::tree::TreeConflict;

    let by_node = snapshot.tree.by_node();

    for c in &snapshot.tree.conflicts {

        let TreeConflict::Name { parent, name, nodes } = c else { continue };

        let full = if parent.is_root() {

            name.clone()

        } else {

            match by_node.get(parent) {

                Some(e) => format!("{}/{name}", e.path),

                None => continue,

            }

        };

        if full != path {

            continue;

        }

        let mut out = Vec::new();

        for n in nodes {

            let Some(e) = by_node.get(n) else { continue };

            let f = snapshot.files.get(&e.path).ok_or("a candidate is missing")?;

            if f.kind != NodeKind::File {

                return Err("This conflict is between directories or links; resolve it from a client.".into());

            }

            let content = match &f.content {

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

                FileContent::Opaque { blobs } => match blobs.first() {

                    Some(b) => r.read_blob(b).map_err(|e| e.to_string())?,

                    None => vec![],

                },

                FileContent::Dir => continue,

            };

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

            out.push(Candidate { path: e.path.clone(), content, preview });

        }

        out.sort_by(|a, b| a.path.cmp(&b.path));

        return Ok(Some(out));

    }

    Ok(None)

}

/// What resolving `path` on a bookmark means.

enum Target {

    /// A conflicted text file, rendered with markers.

    Lines(String),

    /// A name conflict: keep one candidate at `path`.

    Name(Vec<Candidate>),

}

#[derive(Template)]

#[template(path = "resolve_name.html")]

pub struct NamePage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    path: String,

    state: String,

    candidates: Vec<Candidate>,

    delegation: Option<String>,

    error: Option<String>,

    message: String,

}

/// The bookmark's state and what resolving `path` there means.

async fn load(app: &Shared, shell: &Shell, repo: &crate::repos::RepoName, bookmark: &str, path: &str) -> Result<(String, Target), Error> {

    let found = app

            let Some(st) = r.view()?.bookmarks.get(&b).copied() else { return Ok(None) };

            let heads = r.store().get_state(&st)?.heads;

            let loaded = cache.load(r, &heads)?;

            let names = name_candidates(r, &loaded.snapshot, &p);

            let file = if names.as_ref().is_ok_and(|n| n.is_some()) {

                None

            } else {

                let target = view::resolve(r, cache, &b)?;

                Some(view::file(r, cache, target, &p, limit))

            };

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

    let Some((state, names, file)) = found else { return Err(Error::bad(shell.clone(), "Conflicts are resolved on a bookmark.")) };

    match names {

        Ok(Some(c)) => return Ok((state, Target::Name(c))),

        Err(msg) => return Err(Error::bad(shell.clone(), &msg)),

        Ok(None) => {}

    }

    let file = match file {

        Some(Ok(f)) => f,

        Some(Err(e)) => return Err(Error::from_repo(shell.clone(), e)),

        None => return Err(Error::bad(shell.clone(), "Nothing to resolve there.")),

    };

        FileBody::Text(t) if file.conflicted => Ok((state, Target::Lines(t))),

        _ => Err(Error::bad(shell.clone(), "Only text files within the render limit, and name conflicts, are resolved in the browser.")),

    let (state, target) = load(app, &shell, &repo, bookmark, path).await?;

    let text = match target {

        Target::Lines(t) => t,

        Target::Name(_) => return Err(Error::bad(shell, "That is a name conflict.")),

    };

    let shell = Shell::new(&app, &format!("/{owner}/{name}/resolve/{bookmark}/{path}"), &viewer);

    match load(&app, &shell, &repo, &bookmark, &path).await?.1 {

        // Malformed markers: the plain editor still resolves the file.

        Target::Lines(text) if parse(&text).is_none() => {

            Ok(Redirect::to(&format!("/{owner}/{name}/edit/{bookmark}/{path}")).into_response())

        }

        Target::Lines(_) => Ok(page(&app, &viewer, &owner, &name, &bookmark, &path, None, None).await?.into_response()),

        Target::Name(_) => Ok(name_page(&app, &viewer, &owner, &name, &bookmark, &path, None, None).await?.into_response()),

#[allow(clippy::too_many_arguments)]

async fn name_page(

    app: &Shared,

    viewer: &Viewer,

    owner: &str,

    name: &str,

    bookmark: &str,

    path: &str,

    error: Option<String>,

    message: Option<String>,

) -> Result<Page<NamePage>, Error> {

    let shell = Shell::new(app, &format!("/{owner}/{name}/resolve/{bookmark}/{path}"), viewer);

    let me = require(viewer, &shell)?;

    let (repo, row, role) = lookup_role(app, &shell, viewer, owner, name, Access::Write).await?;

    let (state, target) = load(app, &shell, &repo, bookmark, path).await?;

    let Target::Name(candidates) = target else { return Err(Error::bad(shell, "That is not a name conflict.")) };

    let delegation = signer_for(app, me.account.id).await.err();

    Ok(Page(NamePage {

        shell,

        repo: RepoShell::new(app, &row, "conflicts").with_role(role),

        bookmark: bookmark.to_string(),

        path: path.to_string(),

        state,

        candidates,

        delegation,

        error,

        message: message.unwrap_or_else(|| format!("Resolve the name conflict at {path}")),

    }))

}

    let (state, target) = load(&app, &shell, &repo, &bookmark, &path).await?;

    let stale = f.get("state") != Some(&state);

    let text = match target {

        Target::Lines(t) => t,

        Target::Name(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 candidates 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 candidate 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,

            };

            // The kept candidate's content at the name, every candidate

            // gone: the snapshot pairs the kept one with the name as a

            // move, so it keeps its identity.

            let mut edit: Vec<FileEdit> = candidates.iter().map(|c| FileEdit { path: c.path.clone(), content: None }).collect();

            edit.push(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());

        }

    };

    if stale {

    // A name conflict: two proposals add different files called new.txt.

    for (b, text) in [("first-new", "first\n"), ("second-new", "second\n")] {

        let r = send(

            app,

            "POST",

            "/andy/demo/edit/main",

            Some(&andy),

            Some(&format!("_csrf={csrf}&path=new.txt&content={}&message={b}&mode=propose&new_bookmark={b}", enc(text))),

        )

        .await;

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

    }

    for n in [5, 6] {

        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("choose which to keep") && conflicts.contains("/andy/demo/resolve/main/new.txt"), "{conflicts}");

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

    assert!(page.body.contains("new.txt.oxy-conflict-1") && page.body.contains("new.txt.oxy-conflict-2"), "{}", page.body);

    let state = {

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

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

    };

    // Which suffix holds "second" depends on node order; keep that one.

    let second = if page.body.find("second").unwrap() < page.body.find("first").unwrap() { 0 } else { 1 };

    let r = send(

        app,

        "POST",

        "/andy/demo/resolve/main/new.txt",

        Some(&andy),

        Some(&format!("_csrf={csrf}&state={state}&keep={second}&message={}", enc("Keep the second new.txt"))),

    )

    .await;

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

    // The kept file moved to the name, keeping its identity.

    let hash = r.location.unwrap().rsplit('/').next().unwrap().to_string();

    let detail = send(app, "GET", &format!("/api/v1/repos/andy/demo/changes/{hash}"), Some(&andy), None).await.body;

    assert!(detail.contains("\"kind\":\"renamed\""), "{detail}");

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

    assert_eq!(send(app, "GET", "/andy/demo/file/main/new.txt?plain=1", None, None).await.body, "second\n");

    let tree = send(app, "GET", "/andy/demo/tree/main", None, None).await.body;

    assert!(!tree.contains("oxy-conflict"), "the candidates are gone");

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. Conflicts between directories or links, and replace conflicts of binary files, are resolved from a client. The change page tags resolution changes. Otherwise the page gives the two-line client recipe.

  {% if c.kind.starts_with("name:") && 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 %}