A proposal whose only conflicts are union adjacent insertions lands with their resolution (closes andymccall/oxygen#145) dd0788b756f2

- **Changelog entries no longer block a landing (oxygen#145).** Two proposals that each add a line at the same place in a file marked `merge=union` in `.oxyattributes` (`CHANGELOG.md merge=union`) used to leave the second unlandable where conflicts are refused. When a proposal's only conflicts are such adjacent insertions, landing it now adds the resolution, both sides kept, the earlier change's first, authored by whoever lands it and signed by the hub as their delegate. Any other conflict blocks as before.

version = "0.4.0"

version = "0.4.0"

version = "0.7.0"

version = "0.7.0"

version = "0.7.0"

/// Land onto `bookmark` the state with `heads`, its conflicts settled by

/// `edits` (oxygen#145: union files' adjacent insertions, both sides kept):

/// a resolution change on `heads`, authored by the user and signed by the

/// hub key as their delegate, and the bookmark moved to it in one update.

/// The new heads.

pub async fn land_resolved(

    repos: &Repos,

    repo: &RepoName,

    bookmark: String,

    heads: Vec<ChangeHash>,

    edits: Vec<FileEdit>,

    message: String,

    signer: Signer,

) -> Result<Vec<ChangeHash>> {

    repos

        .write(repo, move |r: &Repo, _| {

            let change = r.build_change(&heads, &edits, &message, signer.author.hash())?;

            let hash = change.hash();

            let sig = signer.hub_secret.sign(Domain::Change, &signer.hub_key, &hash);

            let mut state = r.load_state(&heads)?;

            state.add(change.clone()).map_err(|e| fail(e.to_string()))?;

            let mut candidates = heads.clone();

            candidates.push(hash);

            let new_heads = state.maximal(&candidates);

            let update = r.host_ref_update(&bookmark, &new_heads, Some((&signer.hub_key, &signer.hub_secret)))?;

            let report = r.apply_hosted(Some((change, vec![sig])), &[signer.hub_identity.clone(), signer.author.clone()], update)?;

            if let Some(refused) = report.results.iter().find(|x| !x.ok) {

                return Err(fail(format!("the repository refused the landing: {}", refused.reason)));

            }

            Ok(new_heads)

        })

        .await

}

    /// When every conflict is an adjacent insertion in a `merge=union`

    /// file (oxygen#145): each such file's text with both sides kept, which

    /// landing commits as the resolution.

    pub union: Option<Vec<(String, Vec<u8>)>>,

                union: if p.conflicted { oxy_core::repo::Repo::union_resolution(&p.loaded.state, &p.loaded.snapshot) } else { None },

    if loaded.conflicted && loaded.union.is_none() && !requirements.allow_conflicts {

    // Only adjacent insertions in union files in the way (oxygen#145): the

    // landing carries their resolution, both sides kept.

    let union = loaded.union.clone().filter(|_| loaded.conflicted);

    let mut heads = heads;

    let result = match (signer, union) {

        (Ok(signer), Some(files)) => {

            let names: Vec<&str> = files.iter().map(|(p, _)| p.as_str()).collect();

            let message = format!("Keep both sides in {} (merge=union), landing #{number}", names.join(", "));

            let edits = files.into_iter().map(|(path, text)| oxy_core::repo::FileEdit { path, content: Some(text) }).collect();

            crate::repos::edits::land_resolved(&app.repos, repo, target.clone(), heads.clone(), edits, message, signer).await.map(|h| {

                heads = h;

                pl::state_ref(&heads).to_hex()

            })

        }

        (Err(why), Some(_)) => {

            return Err(refused(format!(

                "Cannot land: its changelog-style conflicts are settled by a resolution the hub signs for you, and it cannot: {why}"

            )))

        }

        (signer, None) => match signer {

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

                .await

                .map(|_| pl::state_ref(&heads).to_hex()),

            Err(why) => {

                let (target, heads) = (target.clone(), heads.clone());

                app.repos

        },

    crate::flow::on_push(app, row, &p.target, &state, &heads, &me.username).await;

        crate::web::issues::close_from_arrived(app, row, loaded.target_heads.clone(), heads.clone(), Some(body)).await;

    let heads = heads.clone();

    // A union file (oxygen#145): two proposals each add a changelog line

    // after the same one. Conflicts are refused here again, but these are

    // only adjacent insertions in a `merge=union` file, so the second

    // lands with a resolution keeping both, the earlier first.

    db::proposals::set_requirements(

        &app.db,

        row.id,

        db::proposals::Requirements { required_approvals: 0, require_owners: false, allow_conflicts: false },

    )

    .await

    .unwrap();

    for (path, text) in [(".oxyattributes", "CHANGELOG.md merge=union\n"), ("CHANGELOG.md", "# Changelog\n## Unreleased\n## 1.0\n")] {

        let r = send(

            app,

            "POST",

            "/andy/demo/edit/main",

            Some(&andy),

            Some(&format!("_csrf={csrf}&path={}&content={}&message=add&mode=commit", enc(path), enc(text))),

        )

        .await;

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

    }

    for (b, line) in [("log-a", "- first\n"), ("log-b", "- second\n")] {

        let text = format!("# Changelog\n## Unreleased\n{line}## 1.0\n");

        let r = send(

            app,

            "POST",

            "/andy/demo/edit/main",

            Some(&andy),

            Some(&format!(

                "_csrf={csrf}&path=CHANGELOG.md&original=CHANGELOG.md&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 [9, 10] {

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

        assert!(!page.body.contains("landing would carry conflicts"), "#{n}: {}", page.body);

        let r =

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

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

    }

    assert_eq!(

        send(app, "GET", "/andy/demo/raw/main/CHANGELOG.md", None, None).await.body,

        "# Changelog\n## Unreleased\n- first\n- second\n## 1.0\n"

    );

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

    assert!(send(app, "GET", "/andy/demo/changes/main", Some(&andy), None).await.body.contains("Keep both sides in CHANGELOG.md"));

Landing requirements per repository (settings): N approvals, approvals from code owners (`.oxyowners` in the target state, GitHub `CODEOWNERS` syntax), required checks green on the projected state, no conflicts (or conflicts allowed, matching the policy rule's `allow_conflicts`; conflicts that are all adjacent insertions in `merge=union` files, oxygen#145, do not count: landing adds their resolution, both sides kept, earlier change first, authored by the person landing and signed by the hub as their delegate), and no outstanding "request changes". A repository under an organisation of two or more members starts with one approval required (someone other than the author can give it; nobody may approve their own proposal), any other with none; an admin changes either in Settings. When none is required and nobody has approved, the proposal page says so beside Land, and Land asks for confirmation.