Resolve a proposal's conflicts on the web: the hub brings the target into the source bookmark, as oxy merge would, and opens the resolver; the proposal follows the resolution (closes #337) 217814c239f0

- **A proposal's conflicts are resolved on the web (#337).** A proposal whose landing would conflict has RESOLVE ON THE WEB for those who may push to its source: the hub brings the target into the source bookmark, as `oxy merge TARGET` would there (signed as the user's delegate, or unsigned where no trust policy asks for more), and opens the resolver on the first conflicted file. The resolution is committed to the source, so the proposal follows it and lands. A proposal from a fork is resolved in the fork.

        .route("/{owner}/{name}/proposal/{number}/resolve", post(proposals::resolve_on_web))

    /// May bring the target into the source and resolve on the web (#337).

    can_resolve: bool,

    let can_resolve = role >= Role::Write && p.is_open() && p.source_kind == "bookmark";

        can_resolve,

/// `POST …/proposal/{n}/resolve` (#337): bring a conflicted proposal's

/// target into its source bookmark on the hub, as `oxy merge TARGET` on the

/// source would, so the conflict is on the source; then open the resolver

/// on its first conflicted file. The proposal follows its source, so the

/// resolution committed there clears it. For those who may push to the

/// source, and a source in this repository.

pub async fn resolve_on_web(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, number)): Path<(String, String, i64)>,

    Form(f): Form<LandForm>,

) -> Result<Response, Error> {

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

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

    csrf(&viewer, &f.csrf, &shell)?;

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

    let p = pdb::get(&app.db, row.id, number)

        .await

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

        .filter(|p| p.is_open())

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    if p.source_kind != "bookmark" {

        let msg = "Its source is not a bookmark of this repository: resolve it there, then push.".to_string();

        return Ok(back(&owner, &name, number, "conversation", None, Some(msg)));

    }

    let (source, target) = (p.source_bookmark.clone(), p.target.clone());

    let (s, t) = (source.clone(), target.clone());

    let union = app

        .repos

        .read(&repo, move |r, _| {

            let view = r.view()?;

            let (Some(ours), Some(theirs)) = (view.bookmarks.get(&s).copied(), view.bookmarks.get(&t).copied()) else { return Ok(None) };

            let mut all = r.store().get_state(&ours)?.heads;

            all.extend(r.store().get_state(&theirs)?.heads);

            all.sort();

            all.dedup();

            let state = r.load_state(&all)?;

            Ok(Some(state.maximal(&all)))

        })

        .await

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

    let Some(union) = union else {

        return Ok(back(&owner, &name, number, "conversation", None, Some(format!("{source} or {target} is not a bookmark any more."))));

    };

    if let Err(why) = super::refs::set_bookmark(&app, &repo, me.account.id, &source, union.clone()).await {

        return Ok(back(&owner, &name, number, "conversation", None, Some(format!("Could not bring {target} into {source}: {why}"))));

    }

    let detail = format!("{target} into {source} for proposal #{number}");

    accounts::audit(&app.db, Some(&me.account), "proposal.merged_target", &format!("{owner}/{name}"), &detail).await.ok();

    let s = source.clone();

    let first = app

        .repos

        .read(&repo, move |r, cache| Ok(view::conflicts(r, cache)?.into_iter().find(|c| c.bookmark == s).map(|c| c.path)))

        .await

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

    Ok(match first {

        Some(path) => Redirect::to(&format!("/{owner}/{name}/resolve/{source}/{path}")).into_response(),

        None => {

            back(&owner, &name, number, "conversation", Some(format!("Brought {target} into {source}: nothing left to resolve.")), None)

        }

    })

}

    let made = set_bookmark(&app, &repo, me.account.id, &bookmark, heads.clone()).await;

}

/// Move (or make) `bookmark` at `heads` from the web: as the user's

/// delegate when they have one, otherwise unsigned, which a repository

/// without a trust policy takes, as a push without one. `Err` says why not.

pub async fn set_bookmark(

    app: &Shared,

    repo: &crate::repos::RepoName,

    account_id: i64,

    bookmark: &str,

    heads: Vec<oxy_core::hash::ChangeHash>,

) -> Result<(), String> {

    match super::edit::signer_for(app, account_id).await {

        Ok(signer) => crate::repos::edits::move_bookmark(&app.repos, repo, bookmark.to_string(), heads, signer)

            .await

            .map(|_| ())

            .map_err(|e| e.to_string()),

        Err(why) => {

            let target = bookmark.to_string();

            let unsigned = app

                .repos

                .write(repo, move |r, _| {

                    let update = r.host_ref_update(&target, &heads, None)?;

                    let report = r.receive_push_report(Default::default(), vec![update], None, vec![])?;

                    Ok(match report.results.first() {

                        Some(res) if res.ok => Ok(()),

                        Some(res) => Err(res.reason.clone()),

                        None => Err("nothing happened".to_string()),

                    })

                })

                .await

                .map_err(|e| e.to_string())

                .and_then(|r| r);

            unsigned.map_err(|refused| format!("{refused}. {why}"))

        }

    }

/// #337: a proposal whose landing would conflict is resolved on the web:

/// its target is brought into its source bookmark on the hub, the resolver

/// opens on the conflicted file, and once resolved the proposal lands.

#[tokio::test(flavor = "multi_thread")]

async fn a_proposals_conflicts_are_resolved_on_the_web() {

    hermetic();

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

    let mut config = Config::load(dir.path()).unwrap();

    config.registration.setup_code = "test-setup".into();

    config.auth.push_tokens = vec!["site".into()];

    config.registration.mode = "open".into();

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();

    let port = listener.local_addr().unwrap().port();

    config.server.base_url = format!("http://127.0.0.1:{port}");

    let app = oxygenhub::build(config).await.unwrap();

    let router = oxygenhub::router(app.clone());

    tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });

    let base = format!("http://127.0.0.1:{port}");

    let app = &app;

    let r =

        send(app, "POST", "/register", None, Some("username=andy&email=a%40example.com&password=correct-horse-battery&setup=test-setup"))

            .await;

    let andy = r.cookie.unwrap();

    let andy_id = db::accounts::account_by_name(&app.db, "andy").await.unwrap().unwrap().id;

    let repo = RepoName::parse("andy/demo").unwrap();

    app.repos.create(&repo, None).unwrap();

    db::repos::create(&app.db, "andy", "demo", "", hub_api::Visibility::Public).await.unwrap();

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

    let mut client = Repo::init(work.path()).unwrap();

    client.create_identity("Andy McCall", "[email protected]", IdentityScope::Repo).unwrap();

    client.config.set("core.sign", "change").unwrap();

    client.config.set("remote.origin.url", &format!("{base}/andy/demo")).unwrap();

    client.config.set("remote.origin.token", "site").unwrap();

    client.save_config().unwrap();

    write(work.path(), "a.txt", b"one\ntwo\n");

    client.snapshot("t").unwrap();

    client.commit("first", &[]).unwrap();

    assert!(client.push("origin", false).unwrap().iter().all(|r| r.ok));

    client.delegate_add(app.hub_key.identity.clone(), oxy_core::identity::Scope::CHANGES | oxy_core::identity::Scope::REFS, None).unwrap();

    let key = client.config.author_key.unwrap();

    let id = client.identity(&key).unwrap();

    db::accounts::link_identity(&app.db, andy_id, &key.to_hex(), &id.name, &id.email, &id.encode()).await.unwrap();

    let csrf = csrf_of(&send(app, "GET", "/andy/demo/edit/main/a.txt", Some(&andy), None).await.body);

    // Two proposals change the same line; the first lands.

    for (b, text) in [("left", "Left\ntwo\n"), ("right", "Right\ntwo\n")] {

        let r = send(

            app,

            "POST",

            "/andy/demo/edit/main",

            Some(&andy),

            Some(&format!("_csrf={csrf}&path=a.txt&original=a.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);

    }

    let r = send(app, "POST", "/andy/demo/proposal/1/land", Some(&andy), Some(&format!("_csrf={csrf}"))).await;

    assert!(r.location.as_deref().is_some_and(|l| l.contains("notice=Landed.")), "{:?}", r.location);

    // The second would conflict: the page offers to resolve it here.

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

    assert!(page.contains("Landing would carry 1 conflict") && page.contains("RESOLVE ON THE WEB"), "{page}");

    let r = send(app, "POST", "/andy/demo/proposal/2/resolve", Some(&andy), Some(&format!("_csrf={csrf}"))).await;

    assert_eq!(r.location.as_deref(), Some("/andy/demo/resolve/right/a.txt"), "{}", r.body);

    // main is in right now, so right carries the conflict itself.

    let host = app.repos.open(&repo).unwrap();

    let heads = |b: &str| host.store().get_state(&host.view().unwrap().bookmarks[b]).unwrap().heads;

    let right = host.load_state(&heads("right")).unwrap();

    assert!(heads("main").iter().all(|h| right.contains(h)), "main brought into right");

    // Resolved on the resolver, the proposal lands.

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

    let state = {

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

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

    };

    let r = send(

        app,

        "POST",

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

        Some(&andy),

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

    )

    .await;

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

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

    assert!(!page.contains("Landing would carry"), "{page}");

    let r = send(app, "POST", "/andy/demo/proposal/2/land", Some(&andy), Some(&format!("_csrf={csrf}"))).await;

    assert!(r.location.as_deref().is_some_and(|l| l.contains("notice=Landed.")), "{:?}", r.location);

    assert_eq!(send(app, "GET", "/andy/demo/file/main/a.txt?plain=1", None, None).await.body, "Left and right\ntwo\n");

}

{% if conflicted %}<div class="strip bad">Landing would carry {{ conflicts.len()|plural("conflict", "conflicts") }}. Any collaborator can push a resolution change to the source; the proposal follows it. <a href="?tab=files#conflicts">See them</a>{% if can_resolve %}<form class="inline" method="post" action="{{ repo.url }}/proposal/{{ p.number }}/resolve"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"> <button type="submit" class="small" title="Brings {{ p.target }} into {{ p.source_bookmark }} here, as oxy merge would, then opens the resolver on the first conflicted file">RESOLVE ON THE WEB</button></form>{% endif %}</div>{% endif %}