Identical conflict sides settle by themselves, keeping one, in any file (closes #146) c0d4075cadc0

- **Identical sides settle by themselves (#146).** Two bookmarks that each resolved the same conflict to the same text conflicted again when merged, both sides the identical lines. A conflict whose sides are byte-identical now settles as `merge=union` adjacent insertions do (#145), in any file and keeping one side: a checkout writes it once ("kept one of its identical sides") and the next commit records the resolution, and a host landing a proposal settles it too.

            report.kept_both = self.settle_conflicts(command)?;

    /// Of those, the ones whose sides were identical, settled by keeping

    /// one (oxygen#146).

    pub identical: Vec<usize>,

    let plans: Vec<Option<crate::state::Settle>> = sides

        .iter()

        .map(|s| {

            s.as_ref().map(|w| crate::state::Settle {

                sides: w.clone(),

                kept: w.clone(),

                identical: false,

            })

        })

        .collect();

    settle_text(text, &plans, reverse)

}

/// `text` (a working-copy file) with the marker block of each conflict

/// that `plans` (from [`State::settle_plans`]) settle replaced by its

/// kept text, the sides in order (`reverse`d on request); the conflicts

/// settled, and those left and why. A block whose text between the

/// markers is not its sides' keeps its markers.

pub(crate) fn settle_text(

    text: &[u8],

    plans: &[Option<crate::state::Settle>],

    reverse: bool,

) -> (Vec<u8>, Vec<usize>, Vec<(usize, &'static str)>) {

        let wanted = match plans.get(n.wrapping_sub(1)) {

            _ if total != plans.len() => {

            let mut a: Vec<Vec<u8>> = w.sides.iter().map(|s| with_newline(s)).collect();

                Ok(&w.kept)

                identical: Vec::new(),

    /// Settle what a checkout may settle by itself in each conflicted text

    /// file ([`State::settle_plans`]): conflicts whose sides are identical,

    /// keeping one (oxygen#146), and in files whose `.oxyattributes` say

    /// `merge=union`, adjacent insertions, keeping both sides earliest

    /// change first (oxygen#145). The next commit records the resolution.

    /// The files it settled something in.

    pub(crate) fn settle_conflicts(&self, command: &str) -> Result<Vec<KeptBoth>> {

        let mut out = Vec::new();

        for (p, f) in &snap.base_snapshot.files {

            if !matches!(&f.content, FileContent::Text { materialized, .. } if materialized.is_conflicted())

            {

                continue;

            }

            let plans = snap

                .base

                .settle_plans(&f.node, snap.attributes.lookup(p).union);

            if plans.iter().all(Option::is_none) {

                continue;

            }

            let disk = self.root().join(p);

            let Ok(text) = fs::read(&disk) else { continue };

            let (bytes, settled, left) = settle_text(&text, &plans, false);

            if settled.is_empty() {

                continue;

            }

            fs::write(&disk, bytes)?;

            let identical = settled

                .iter()

                .copied()

                .filter(|n| plans[n - 1].as_ref().is_some_and(|w| w.identical))

                .collect();

            out.push(KeptBoth {

                path: p.clone(),

                settled,

                identical,

                left,

            });

        Ok(out)

    /// Every conflict of `snap`, `state`'s materialization, settled as a

    /// checkout settles them ([`State::settle_plans`]): the new text of

    /// each conflicted file, when each is a text file whose every conflict

    /// has identical sides (one kept, oxygen#146) or, in a file its

    /// `.oxyattributes` mark `merge=union`, is an adjacent insertion (both

    /// kept, oxygen#145); `None` when any conflict needs a person, or there

    /// is none. A host lands a proposal with these as a resolution, as a

    /// checkout settles them in a working copy.

            let plans = state.settle_plans(&f.node, attrs.lookup(p).union);

            let (text, _, left) = settle_text(bytes, &plans, false);

            if !left.is_empty() || plans.iter().any(Option::is_none) {

                identical: vec![],

/// oxygen#146: two bookmarks that resolved the same conflict to the same

/// text agree. Merged, their resolutions are a conflict whose sides are

/// identical: a checkout keeps one, in any file, and a host settles it so

/// too; the next commit records it.

#[test]

fn identical_resolutions_on_two_bookmarks_settle_by_themselves() {

    hermetic();

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

    let root = dir.path();

    let repo = Repo::init(root).unwrap();

    write(root, "f.txt", b"a\nx\nb\n");

    let base = repo.commit("base", &[]).unwrap();

    write(root, "f.txt", b"a\nX1\nb\n");

    let c1 = repo.commit("X1", &[]).unwrap();

    repo.checkout(&[base], false, "checkout").unwrap();

    write(root, "f.txt", b"a\nX2\nb\n");

    let c2 = repo.commit("X2", &[]).unwrap();

    // Each bookmark merges both and resolves the conflict the same way.

    repo.checkout(&[c1, c2], false, "checkout").unwrap();

    assert!(has_conflict_markers(&fs::read(root.join("f.txt")).unwrap()));

    write(root, "f.txt", b"a\nX\nb\n");

    let r1 = repo.commit("resolve on one", &[]).unwrap();

    repo.checkout(&[c1, c2], false, "checkout").unwrap();

    write(root, "f.txt", b"a\nX\nb\n");

    let r2 = repo.commit("resolve on two", &[]).unwrap();

    assert_ne!(r1, r2);

    let st = repo.load_state(&[r1, r2]).unwrap();

    assert!(

        st.materialize().is_conflicted(),

        "two resolutions, one place"

    );

    assert_eq!(

        Repo::union_resolution(&st, &st.materialize()),

        Some(vec![("f.txt".into(), b"a\nX\nb\n".to_vec())]),

        "a host settles it"

    );

    let r = repo.checkout(&[r1, r2], false, "checkout").unwrap();

    assert!(r.conflicted);

    assert_eq!(r.kept_both.len(), 1, "{:?}", r.kept_both);

    assert_eq!(

        (r.kept_both[0].path.as_str(), &r.kept_both[0].identical),

        ("f.txt", &vec![1])

    );

    assert_eq!(fs::read_to_string(root.join("f.txt")).unwrap(), "a\nX\nb\n");

    let s = repo.snapshot("status").unwrap();

    assert_eq!(statuses(&s), vec![("f.txt".into(), ChangeStatus::Resolved)]);

    let merged = repo.commit("merge", &[]).unwrap();

    let st = repo.load_state(&[merged]).unwrap();

    assert!(!st.materialize().is_conflicted());

}

/// How one conflict settles without a person ([`State::settle_plans`]).

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

pub struct Settle {

    /// Its sides' text, as its markers show them.

    pub sides: Vec<Vec<u8>>,

    /// The text that takes the markers' place, side by side, in order.

    pub kept: Vec<Vec<u8>>,

    /// Its sides are identical, and one is kept.

    pub identical: bool,

}

                }

                _ => out.push(None),

            }

        }

        out

    }

    /// How each conflict of a text node settles without a person, in

    /// marker order (spec §9.5); `None` for one that needs a person. A

    /// conflict whose sides are identical keeps one of them, in any file

    /// (oxygen#146): two bookmarks that resolved the same conflict the same

    /// way agree. With `union` (the file is `merge=union`, oxygen#145), an

    /// adjacent insertion keeps every side, earliest change first.

    pub fn settle_plans(&self, node: &NodeId, union: bool) -> Vec<Option<Settle>> {

        let Some(g) = self.graph(node) else {

            return Vec::new();

        };

        let m = self.materialize_ordered(g);

        let text = |s: &[AtomKey]| -> Vec<u8> {

            s.iter()

                .flat_map(|a| g.content(a).unwrap_or_default().to_vec())

                .collect()

        };

        let mut out = Vec::new();

        for (i, seg) in m.segments.iter().enumerate() {

            match seg {

                crate::graph::Segment::Lines(_) => {}

                crate::graph::Segment::Conflict(sides) => {

                    let texts: Vec<Vec<u8>> = sides.iter().map(|s| text(s)).collect();

                    out.push(if texts.len() > 1 && texts.iter().all(|t| *t == texts[0]) {

                        Some(Settle {

                            kept: vec![texts[0].clone()],

                            sides: texts,

                            identical: true,

                        })

                    } else if union && g.adjacent_insertion(&m, i, self) {

                        Some(Settle {

                            kept: texts.clone(),

                            sides: texts,

                            identical: false,

                        })

                    } else {

                        None

                    });

An **adjacent insertion** is an order conflict whose sides only add lines between two lines that were next to each other: no line between them was deleted by a change that not every side builds on (two changes that each replaced the same line conflict the same way, and are not one). Keeping every side settles it without losing or repeating a line, though either order can be wrong for code, so it is never done silently: `oxy resolve --both [PATH]..` replaces the markers of each adjacent insertion in the working copy with its sides, earliest first (`--reverse`: latest first), and leaves the markers of any other conflict, or of one whose lines between the markers were edited. `oxy status` says which conflicts qualify. A file whose `.oxyattributes` say `merge=union` (§19; changelogs, lists where order does not matter) needs no command: a checkout settles its adjacent insertions the same way at once, and the next commit records the resolution. The state is still conflicted until then; nothing about what a conflict is changes. A conflict whose sides are **identical**, byte for byte, settles the same way in any file, with one side kept: two bookmarks that resolved the same conflict to the same text, then merged, agree (oxygen#146; Git merges identical changes cleanly too). A host landing a proposal settles both kinds, and only them, as a checkout does.

        let how = if k.identical.len() == k.settled.len() {

            "kept one of its identical sides"

        } else if k.identical.is_empty() {

            "kept both sides (merge=union)"

        } else {

            "kept one of identical sides and both of others (merge=union)"

        };

            "  {} settled {}: {how}; the next commit records it",