Resolve conflicts region by region c5f3bde466d1

//! The conflict resolver (hub spec §6.10): a conflicted text file of a

//! bookmark, region by region. For each region the user keeps one side,

//! every side in order, none, or text of their own; the file is put back

//! together around the unconflicted lines and committed through the

//! web-edit path, which makes it a `resolution` change depending on every

//! change that contributed to the conflict.

use super::edit::{after_web_commit, signer_for};

use super::settings::{csrf, require};

use super::{lookup_role, Error, Page, RepoShell, Shell};

use crate::auth::{Access, Viewer};

use crate::repos::edits;

use crate::repos::view::{self, FileBody};

use crate::Shared;

use askama::Template;

use axum::extract::{Form, Path, State};

use axum::response::{IntoResponse, Redirect, Response};

use oxy_core::repo::FileEdit;

use std::collections::HashMap;

/// A piece of a file rendered with `oxy` conflict markers (spec §9.5).

#[derive(Clone, Debug, PartialEq, Eq)]

pub enum Piece {

    /// Lines outside any conflict, kept as they are.

    Plain(String),

    Region(Region),

}

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct Region {

    /// 1-based, as the markers number it.

    pub n: usize,

    pub sides: Vec<Side>,

}

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct Side {

    /// "change 3f2a…", or "deleted by change …".

    pub label: String,

    /// The side's lines, each ending in `\n`.

    pub text: String,

    /// A deletion side: `text` is what was deleted, shown for context;

    /// keeping this side keeps the deletion, so it contributes nothing.

    pub deletion: bool,

}

impl Side {

    /// What keeping this side puts in the file.

    pub fn kept(&self) -> &str {

        if self.deletion {

            ""

        } else {

            &self.text

        }

    }

}

impl Region {

    /// Every side in order: what keeping all of them puts in the file.

    pub fn all(&self) -> String {

        self.sides.iter().map(Side::kept).collect()

    }

}

/// Split a marked rendering into plain text and regions. `None` when the

/// markers are malformed (the page then offers the plain editor).

pub fn parse(marked: &str) -> Option<Vec<Piece>> {

    let mut out = Vec::new();

    let mut plain = String::new();

    let mut region: Option<Region> = None;

    let mut lines = marked.split_inclusive('\n').peekable();

    while let Some(line) = lines.next() {

        let bare = line.trim_end_matches('\n');

        if let Some(rest) = bare.strip_prefix("<<<<<<< oxy conflict ") {

            if region.is_some() {

                return None;

            }

            if !plain.is_empty() {

                out.push(Piece::Plain(std::mem::take(&mut plain)));

            }

            let (n, label) = header(rest)?;

            let mut side = Side { label, text: String::new(), deletion: false };

            if lines.peek().map(|l| l.trim_end_matches('\n')) == Some("-------") {

                lines.next();

                side.deletion = true;

            }

            region = Some(Region { n, sides: vec![side] });

        } else if let Some(rest) = bare.strip_prefix("======= oxy conflict ") {

            let r = region.as_mut()?;

            let (n, label) = header(rest)?;

            if n != r.n {

                return None;

            }

            r.sides.push(Side { label, text: String::new(), deletion: false });

        } else if bare.starts_with(">>>>>>> oxy conflict ") {

            out.push(Piece::Region(region.take()?));

        } else {

            match region.as_mut() {

                Some(r) => r.sides.last_mut()?.text.push_str(line),

                None => plain.push_str(line),

            }

        }

    }

    if region.is_some() {

        return None;

    }

    if !plain.is_empty() {

        out.push(Piece::Plain(plain));

    }

    Some(out)

}

/// `N of T, side I of K: LABEL` → (N, LABEL).

fn header(rest: &str) -> Option<(usize, String)> {

    let (n, tail) = rest.split_once(" of ")?;

    let label = tail.split_once(": ").map(|(_, l)| l.to_string()).unwrap_or_default();

    Some((n.trim().parse().ok()?, label))

}

/// A user's choice for one region.

#[derive(Clone, Debug, PartialEq, Eq)]

pub enum Choice {

    Side(usize),

    All,

    None,

    Text(String),

}

/// The file with each region replaced by what was chosen for it; every

/// region needs a choice.

pub fn assemble(pieces: &[Piece], choices: &HashMap<usize, Choice>) -> Result<String, String> {

    let mut out = String::new();

    for p in pieces {

        match p {

            Piece::Plain(t) => out.push_str(t),

            Piece::Region(r) => match choices.get(&r.n) {

                Some(Choice::Side(i)) => {

                    out.push_str(r.sides.get(i.wrapping_sub(1)).ok_or_else(|| format!("conflict {} has no side {i}", r.n))?.kept())

                }

                Some(Choice::All) => out.push_str(&r.all()),

                Some(Choice::None) => {}

                Some(Choice::Text(t)) => {

                    let t = t.replace("\r\n", "\n");

                    out.push_str(&t);

                    if !t.is_empty() && !t.ends_with('\n') {

                        out.push('\n');

                    }

                }

                None => return Err(format!("choose how to resolve conflict {}", r.n)),

            },

        }

    }

    Ok(out)

}

#[derive(Template)]

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

pub struct ResolvePage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    path: String,

    state: String,

    pieces: Vec<Piece>,

    delegation: Option<String>,

    error: Option<String>,

    message: String,

}

/// The bookmark's state, and the file rendered there when it is a

/// conflicted text file.

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

    let limit = app.config.limits.render_limit.0;

    let (b, p) = (bookmark.to_string(), path.to_string());

    let (state, file) = app

        .repos

        .read(repo, move |r, cache| {

            let state = r.view()?.bookmarks.get(&b).map(|s| s.to_hex());

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

            Ok((state, view::file(r, cache, target, &p, limit)?))

        })

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

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

    match file.body {

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

        FileBody::Text(_) => Err(Error::bad(shell.clone(), "That file has no conflicts on this bookmark.")),

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

    }

}

#[allow(clippy::too_many_arguments)]

async fn page(

    app: &Shared,

    viewer: &Viewer,

    owner: &str,

    name: &str,

    bookmark: &str,

    path: &str,

    error: Option<String>,

    message: Option<String>,

) -> Result<Page<ResolvePage>, 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, text) = load(app, &shell, &repo, bookmark, path).await?;

    let Some(pieces) = parse(&text) else {

        return Err(Error::bad(shell, "The conflict markers could not be read; resolve the file in the plain editor."));

    };

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

    Ok(Page(ResolvePage {

        shell,

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

        bookmark: bookmark.to_string(),

        path: path.to_string(),

        state,

        pieces,

        delegation,

        error,

        message: message.unwrap_or_else(|| format!("Resolve the conflicts in {path}")),

    }))

}

pub async fn form(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, bookmark, path)): Path<(String, String, String, String)>,

) -> Result<Response, Error> {

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

    let shell = Shell::new(&app, "", &viewer);

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

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

    if parse(&text).is_none() {

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

    }

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

}

pub async fn save(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, bookmark, path)): Path<(String, String, String, String)>,

    Form(f): Form<HashMap<String, String>>,

) -> Result<Response, Error> {

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

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

    csrf(&viewer, f.get("_csrf").map(String::as_str).unwrap_or(""), &shell)?;

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

    let message = f.get("message").map(|m| m.trim().to_string()).unwrap_or_default();

    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 { page(&app, &viewer, &owner, &name, &bookmark, &path, Some(msg), Some(message)).await.map(IntoResponse::into_response) }

    };

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

    if f.get("state") != Some(&state) {

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

    }

    let Some(pieces) = parse(&text) else { return again("The conflict markers could not be read.".into()).await };

    let mut choices = HashMap::new();

    for p in &pieces {

        if let Piece::Region(r) = p {

            let choice = match f.get(&format!("r{}", r.n)).map(String::as_str) {

                Some("all") => Choice::All,

                Some("none") => Choice::None,

                Some("text") => Choice::Text(f.get(&format!("t{}", r.n)).cloned().unwrap_or_default()),

                Some(s) => match s.strip_prefix("side").and_then(|i| i.parse().ok()) {

                    Some(i) => Choice::Side(i),

                    None => continue,

                },

                None => continue,

            };

            choices.insert(r.n, choice);

        }

    }

    let content = match assemble(&pieces, &choices) {

        Ok(c) => c,

        Err(msg) => return again(msg).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,

    };

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

    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;

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

}

#[cfg(test)]

mod tests {

    use super::*;

    const MARKED: &str = "a\n<<<<<<< oxy conflict 1 of 2, side 1 of 2: change 0202\nfrom-2\n======= oxy conflict 1 of 2, side 2 of 2: change 0303\nfrom-3\nmore-3\n>>>>>>> oxy conflict 1 of 2 end\nb\n<<<<<<< oxy conflict 2 of 2, side 1 of 2: deleted by change 0404\n-------\ngone\n======= oxy conflict 2 of 2, side 2 of 2: change 0505\nadded\n>>>>>>> oxy conflict 2 of 2 end\nc\n";

    #[test]

    fn markers_parse_into_regions_and_sides() {

        let p = parse(MARKED).unwrap();

        assert_eq!(p.len(), 5);

        assert_eq!(p[0], Piece::Plain("a\n".into()));

        let Piece::Region(r1) = &p[1] else { panic!() };

        assert_eq!((r1.n, r1.sides.len()), (1, 2));

        assert_eq!((r1.sides[0].label.as_str(), r1.sides[0].text.as_str()), ("change 0202", "from-2\n"));

        assert_eq!(r1.sides[1].text, "from-3\nmore-3\n");

        let Piece::Region(r2) = &p[3] else { panic!() };

        assert!(r2.sides[0].deletion && r2.sides[0].text == "gone\n" && r2.sides[0].kept().is_empty());

        assert_eq!(r2.sides[0].label, "deleted by change 0404");

        assert_eq!(p[4], Piece::Plain("c\n".into()));

        assert!(parse("<<<<<<< oxy conflict 1 of 1, side 1 of 2: change x\nno end\n").is_none());

        assert_eq!(parse("plain\n").unwrap(), vec![Piece::Plain("plain\n".into())]);

    }

    #[test]

    fn choices_assemble_the_file() {

        let p = parse(MARKED).unwrap();

        let pick = |a: Choice, b: Choice| assemble(&p, &HashMap::from([(1, a), (2, b)]));

        assert_eq!(pick(Choice::Side(2), Choice::Side(1)).unwrap(), "a\nfrom-3\nmore-3\nb\nc\n", "the deletion wins: nothing");

        assert_eq!(pick(Choice::All, Choice::Side(2)).unwrap(), "a\nfrom-2\nfrom-3\nmore-3\nb\nadded\nc\n");

        assert_eq!(pick(Choice::None, Choice::Text("mine".into())).unwrap(), "a\nb\nmine\nc\n", "own text ends its line");

        assert!(pick(Choice::Side(3), Choice::None).unwrap_err().contains("no side 3"));

        assert!(assemble(&p, &HashMap::from([(1, Choice::None)])).unwrap_err().contains("conflict 2"));

    }

}

{% 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">Choose what each conflict keeps. The file is put back together around the lines no one disagrees on and committed to {{ bookmark }} as a resolution: it depends on every change that wrote a side, so no side is lost from history. Link to a conflict with its <code>#region-N</code>.</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 p in pieces %}

{% match p %}

{% when crate::web::resolve::Piece::Plain with (text) %}

<pre class="marked context">{{ text }}</pre>

{% when crate::web::resolve::Piece::Region with (r) %}

<section class="file-diff conflict-region" id="region-{{ r.n }}">

  <header><a href="#region-{{ r.n }}"><strong>Conflict {{ r.n }}</strong></a> <span class="small mute">{{ r.sides.len() }} sides</span></header>

  {% for s in r.sides %}

  <div class="side">

    <label><input type="radio" name="r{{ r.n }}" value="side{{ loop.index }}"{% if loop.first %} checked{% endif %}> keep side {{ loop.index }} <span class="small mute">{{ s.label }}</span></label>

    {% if s.deletion %}<p class="small mute">Keeping this side keeps the deletion of these lines:</p>{% endif %}

    <pre class="marked{% if s.deletion %} deleted{% endif %}">{{ s.text }}</pre>

  </div>

  {% endfor %}

  <div class="choice">

    <label><input type="radio" name="r{{ r.n }}" value="all"> keep every side, in order</label>

    <label><input type="radio" name="r{{ r.n }}" value="none"> keep none</label>

    <label><input type="radio" name="r{{ r.n }}" value="text"> write it myself:</label>

  </div>

  <textarea name="t{{ r.n }}" rows="{{ r.all().lines().count() + 1 }}" aria-label="Your text for conflict {{ r.n }}">{{ r.all() }}</textarea>

</section>

{% endmatch %}

{% endfor %}

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

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

</form>

{% endblock %}

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

    if f.mode == "propose" {

        match super::proposals::open_proposal(&app, &repo, &row, &me.account, &message, "", &r, &done.bookmark, false).await {

            Ok(p) => return Ok(Redirect::to(&format!("/{owner}/{name}/proposal/{}", p.number)).into_response()),

            Err(msg) => {

                return Ok(Redirect::to(&format!("/{owner}/{name}/tree/{}?notice={}", done.bookmark, super::settings::urlencode(&msg)))

                    .into_response())

            }

        }

    }

    let to = if f.delete.is_some() {

        format!("/{owner}/{name}/tree/{}", done.bookmark)

    } else {

        format!("/{owner}/{name}/file/{}/{}", done.bookmark, path)

    };

    Ok(Redirect::to(&to).into_response())

}

/// What a push would have caused, for a change the hub committed for a

/// user: the push log, webhooks, a Flow run, closing keywords, the Git

/// mirror, and the audit log.

pub(super) async fn after_web_commit(

    app: &Shared,

    account: &accounts::Account,

    row: &db::repos::RepoRow,

    owner: &str,

    name: &str,

    done: &edits::Committed,

    message: &str,

) {

    db::repos::record_push(&app.db, row.id, Some((account.id, &account.username)), &[outcome]).await.ok();

    crate::hooks::emit(app, row, "push", &account.username, serde_json::json!({ "updates": [{ "reference": done.bookmark, "old_state": done.old_state, "new_state": done.new_state, "heads": done.heads.len(), "changes": 1 }], "via": "web" })).await;

    crate::flow::on_push(app, row, &done.bookmark, &done.new_state, &done.heads, &account.username).await;

        super::issues::close_from_messages(app, row, &[(done.change.to_hex(), message.to_string())]).await;

        crate::mirror::refresh(app, row).await;

        Some(account),

mod resolve;

        .route("/{owner}/{name}/resolve/{bookmark}/{*path}", get(resolve::form).post(resolve::save))

    assert!(conflicts.contains("resolve region by region") && conflicts.contains("/andy/demo/resolve/main/a.txt"), "{conflicts}");

    // The resolver: region by region, against the state it showed.

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

    assert!(

        page.body.contains("id=\"region-1\"") && page.body.contains("keep side 2") && page.body.contains("keep every side"),

        "{}",

        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 stale = send(

        app,

        "POST",

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

        Some(&andy),

        Some(&format!("_csrf={csrf}&state={}&r1=side2&message=x", "0".repeat(64))),

    )

    .await;

    assert!(stale.body.contains("has moved since this page was loaded"), "{}", stale.body);

    let unchosen =

        send(app, "POST", "/andy/demo/resolve/main/a.txt", Some(&andy), Some(&format!("_csrf={csrf}&state={state}&message=x"))).await;

    assert!(unchosen.body.contains("choose how to resolve conflict 1"), "{}", unchosen.body);

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

        Some(&format!("_csrf={csrf}&state={state}&r1=text&t1={}&message={}", enc("Both"), enc("Resolve a.txt"))),

    let change = r.location.unwrap();

    assert!(change.contains("/andy/demo/change/"), "{change}");

    let shown = send(app, "GET", &change, Some(&andy), None).await.body;

    assert!(shown.to_lowercase().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. The change page tags resolution changes. Otherwise the page gives the two-line client recipe.

  <div class="head"><h1>{{ c.view.title }} <small class="px">{{ c.view.short }}</small>{% if c.view.resolution %} <span class="tag" title="Resolves conflicts; depends on every change that wrote a side">resolution</span>{% endif %}</h1></div>

  {% if c.marked.is_some() && repo.can(crate::auth::Access::Write) %}<p><a class="go small" href="{{ repo.url }}/resolve/{{ c.bookmark }}/{{ c.path }}">resolve region by region</a> <span class="small mute">or <a href="{{ repo.url }}/edit/{{ c.bookmark }}/{{ c.path }}">edit the marked file</a></span></p>{% endif %}