oxy resolve --both keeps both sides of an adjacent insertion (closes #121) 9bd98cfb4f7e

- **Two changes adding lines at the same place are settled with one command (#121).** Like Git, oxy leaves a conflict when two changes each add lines after the same line, since either order can be wrong for code; settling it meant editing out the markers by hand. `oxy resolve --both [PATH]…` now keeps every side of each such *adjacent insertion*, the earlier change's first (`--reverse` for the other order), and `oxy status` says which conflicts qualify. It leaves the markers where the sides changed the same lines (keeping both would keep two versions of them) or where the lines between the markers were edited. Conflict markers now list their sides earliest change first, not in hash order.

    /// Whether the conflict at `m.segments[i]` is an adjacent insertion

    /// (oxygen#121): its sides only add lines between two lines that were

    /// next to each other, so keeping every side repeats nothing. It is not

    /// when a line there was deleted by a change only some sides build on:

    /// two changes that each replaced the same line conflict the same way,

    /// and keeping both would keep two versions of it. A line deleted in

    /// history every side shares does not count.

    pub fn adjacent_insertion(&self, m: &Materialized, i: usize, deps: &dyn DepOracle) -> bool {

        let Some(Segment::Conflict(sides)) = m.segments.get(i) else {

            return false;

        };

        let before = match i.checked_sub(1).map(|j| &m.segments[j]) {

            None => Vertex::Start,

            Some(Segment::Lines(a)) => match a.last() {

                Some(k) => Vertex::Atom(*k),

                None => return false,

            },

            Some(_) => return false,

        };

        let on_side: HashSet<AtomKey> = sides.iter().flatten().copied().collect();

        let side_changes: Vec<BTreeSet<ChangeHash>> = sides

            .iter()

            .map(|s| s.iter().map(|a| a.0).collect())

            .collect();

        let shared = |d: &ChangeHash| {

            side_changes

                .iter()

                .all(|s| s.iter().any(|c| deps.depends_on(c, d)))

        };

        // From the line before, through the sides' lines and deleted ones,

        // up to the next live line.

        let mut seen: HashSet<AtomKey> = HashSet::default();

        let mut todo = vec![before];

        while let Some(v) = todo.pop() {

            for &w in self.succ.get(&v).map(Edges::as_slice).unwrap_or(&[]) {

                let Vertex::Atom(k) = w else { continue };

                if !seen.insert(k) {

                    continue;

                }

                if !on_side.contains(&k) {

                    if self.is_live(&k) {

                        continue;

                    }

                    if self.deleters(&k).any(|d| !shared(d)) {

                        return false;

                    }

                }

                todo.push(w);

            }

        }

        true

    }

    render_change, render_hunks, similarity, ChangeStatus, DiffHunk, FileDiff, Hunk, KeptBoth,

    PathStatus, Selection, SnapshotResult,

/// What `oxy resolve --both` did to one file (oxygen#121).

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

pub struct KeptBoth {

    pub path: String,

    /// The conflicts settled by keeping every side, by number.

    pub settled: Vec<usize>,

    /// The conflicts that keep their markers, by number, and why.

    pub left: Vec<(usize, &'static str)>,

}

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

/// `sides` (from [`State::both_sides`]) says keeping both settles replaced

/// by its sides' lines; the conflicts settled, and those left and why.

pub(crate) fn keep_both_text(

    text: &[u8],

    sides: &[Option<Vec<Vec<u8>>>],

    reverse: bool,

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

    // A side as the markers hold it: the renderer ends each with a newline.

    let with_newline = |s: &[u8]| {

        let mut s = s.to_vec();

        if !s.is_empty() && !s.ends_with(b"\n") {

            s.push(b'\n');

        }

        s

    };

    let lines: Vec<&[u8]> = text.split_inclusive(|&b| b == b'\n').collect();

    let (mut out, mut settled, mut left) = (Vec::new(), Vec::new(), Vec::new());

    let mut i = 0;

    while i < lines.len() {

        let Some((n, total)) = conflict_header(lines[i]) else {

            out.extend_from_slice(lines[i]);

            i += 1;

            continue;

        };

        let end = format!(">>>>>>> oxy conflict {n} of {total} end");

        let next_side = format!("======= oxy conflict {n} of {total}, side ");

        let Some(stop) =

            (i + 1..lines.len()).find(|&j| lines[j].trim_ascii_end() == end.as_bytes())

        else {

            left.push((n, "its end marker is missing; edit it by hand"));

            out.extend_from_slice(lines[i]);

            i += 1;

            continue;

        };

        let mut found: Vec<Vec<u8>> = vec![Vec::new()];

        for line in &lines[i + 1..stop] {

            if line.starts_with(next_side.as_bytes()) {

                found.push(Vec::new());

            } else {

                found.last_mut().unwrap().extend_from_slice(line);

            }

        }

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

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

                Err("the markers are not the file's conflicts now; see `oxy status`")

            }

            Some(Some(w)) => Ok(w),

            _ => Err("both sides changed these lines; edit the markers"),

        };

        let keep = wanted.and_then(|w| {

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

            let mut b = found.clone();

            a.sort();

            b.sort();

            if a == b {

                Ok(w)

            } else {

                Err("the lines between its markers were edited; finish it by hand")

            }

        });

        match keep {

            Ok(w) => {

                let order: Vec<&Vec<u8>> = if reverse {

                    w.iter().rev().collect()

                } else {

                    w.iter().collect()

                };

                for s in order {

                    out.extend_from_slice(&with_newline(s));

                }

                settled.push(n);

            }

            Err(why) => {

                left.push((n, why));

                for line in &lines[i..=stop] {

                    out.extend_from_slice(line);

                }

            }

        }

        i = stop + 1;

    }

    (out, settled, left)

}

/// `(n, total)` from a conflict's opening marker (spec §9.5).

fn conflict_header(line: &[u8]) -> Option<(usize, usize)> {

    let rest = line.strip_prefix(b"<<<<<<< oxy conflict ")?;

    let rest = std::str::from_utf8(rest).ok()?;

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

    let total = rest.split(|c: char| !c.is_ascii_digit()).next()?;

    Some((n.parse().ok()?, total.parse().ok()?))

}

                    "{p} has no replace conflict to settle (a text file's conflict is settled by editing out its markers, or `oxy resolve --both {p}`)"

    }

    /// Settle the adjacent-insertion conflicts of the text files at `paths`

    /// (oxygen#121) by keeping every side, earliest change first (latest

    /// first with `reverse`): each one's markers in the working copy give

    /// way to its sides' lines, and the next snapshot records the result.

    /// A conflict whose sides changed the same lines, or whose text between

    /// the markers was edited, keeps its markers. With no paths, every

    /// conflicted text file.

    pub fn keep_both(

        &self,

        snap: &SnapshotResult,

        paths: &[String],

        reverse: bool,

    ) -> Result<Vec<KeptBoth>> {

        let paths: Vec<String> = if paths.is_empty() {

            snap.base_snapshot

                .files

                .iter()

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

                .map(|(p, _)| p.clone())

                .collect()

        } else {

            paths.to_vec()

        };

        let mut out = Vec::new();

        for p in paths {

            let conflicted = match snap.base_snapshot.files.get(&p).map(|f| (f, &f.content)) {

                Some((f, FileContent::Text { materialized, .. }))

                    if materialized.is_conflicted() =>

                {

                    f

                }

                Some((_, FileContent::Opaque { blobs })) if blobs.len() > 1 => {

                    return Err(RepoError::Msg(format!(

                        "{p} has a replace conflict: keep one version with `oxy resolve {p}`"

                    )))

                }

                _ => {

                    return Err(RepoError::Msg(format!(

                        "{p} has no text conflict to settle"

                    )))

                }

            };

            let sides = snap.base.both_sides(&conflicted.node);

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

            let text = fs::read(&disk)?;

            let (bytes, settled, left) = keep_both_text(&text, &sides, reverse);

            if !settled.is_empty() {

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

            }

            out.push(KeptBoth {

                path: p,

                settled,

                left,

            });

        }

        Ok(out)

/// oxygen#121: two changes each adding a line after the same line conflict;

/// the markers list the earlier change first, and `oxy resolve --both`

/// keeps both lines in that order (or the other with `--reverse`).

fn adjacent_insertions_are_settled_by_keeping_both() {

    hermetic();

    for reverse in [false, true] {

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

        let root = dir.path();

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

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

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

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

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

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

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

        repo.commit("second", &[]).unwrap();

        repo.checkout(&repo.bookmark_heads().unwrap(), false, "checkout main")

            .unwrap();

        let marked = fs::read_to_string(root.join("f.txt")).unwrap();

        let (f, s) = (

            marked.find("first\n").unwrap(),

            marked.find("second\n").unwrap(),

        );

        assert!(f < s, "the earlier change's side comes first: {marked}");

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

        let node = snap.base_snapshot.files["f.txt"].node;

        assert_eq!(snap.base.both_sides(&node).iter().flatten().count(), 1);

        let kept = repo.keep_both(&snap, &[], reverse).unwrap();

        assert_eq!(

            kept,

            vec![KeptBoth {

                path: "f.txt".into(),

                settled: vec![1],

                left: vec![]

            }]

        );

        let want: &[u8] = if reverse {

            b"a\nsecond\nfirst\nb\n"

        } else {

            b"a\nfirst\nsecond\nb\n"

        };

        assert_eq!(fs::read(root.join("f.txt")).unwrap(), want);

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

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

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

        assert_eq!(

            repo.store().get_change(&h).unwrap().kind,

            ChangeKind::Resolution

        );

        assert!(!repo.load_state(&[h]).unwrap().materialize().is_conflicted());

    }

}

/// oxygen#121: two changes that each replaced the same line are not an

/// adjacent insertion: keeping both would keep two versions of the line,

/// so `--both` leaves the markers, as it does for markers already edited.

#[test]

fn keeping_both_refuses_replaced_or_edited_lines() {

    hermetic();

    let (dir, repo, _, _, _) = conflicted_repo();

    let root = dir.path();

    repo.checkout(&repo.bookmark_heads().unwrap(), false, "checkout main")

        .unwrap();

    let marked = fs::read(root.join("f.txt")).unwrap();

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

    let node = snap.base_snapshot.files["f.txt"].node;

    assert_eq!(snap.base.both_sides(&node), vec![None]);

    let kept = repo.keep_both(&snap, &["f.txt".into()], false).unwrap();

    assert!(kept[0].settled.is_empty());

    assert_eq!(kept[0].left[0].0, 1);

    assert!(kept[0].left[0].1.contains("both sides changed"), "{kept:?}");

    assert_eq!(fs::read(root.join("f.txt")).unwrap(), marked);

    // An adjacent insertion whose lines were edited between the markers.

    let sides = vec![Some(vec![b"x\n".to_vec(), b"y\n".to_vec()])];

    let text = b"a\n<<<<<<< oxy conflict 1 of 1, side 1 of 2: change k \"x\"\nx!\n======= oxy conflict 1 of 1, side 2 of 2: change q \"y\"\ny\n>>>>>>> oxy conflict 1 of 1 end\nb\n";

    let (out, settled, left) = super::snapshot::keep_both_text(text, &sides, false);

    assert_eq!(out, text.to_vec());

    assert!(settled.is_empty());

    assert!(left[0].1.contains("edited"), "{left:?}");

    // Unedited, in either order on disk: kept in the graph's order.

    let text = b"a\n<<<<<<< oxy conflict 1 of 1, side 1 of 2: change q \"y\"\ny\n======= oxy conflict 1 of 1, side 2 of 2: change k \"x\"\nx\n>>>>>>> oxy conflict 1 of 1 end\nb\n";

    let (out, settled, _) = super::snapshot::keep_both_text(text, &sides, false);

    assert_eq!(out, b"a\nx\ny\nb\n".to_vec());

    assert_eq!(settled, vec![1]);

}

#[test]

    /// A file graph materialized with each conflict's sides earliest change

    /// first (oxygen#121), by the clock of the oldest change on a side, so

    /// markers read in the order the work was done and `oxy resolve --both`

    /// keeps that order.

    fn materialize_ordered(&self, g: &FileGraph) -> Materialized {

        let mut m = g.materialize(self);

        let when = |h: &ChangeHash| match self.changes.get(h) {

            Some(c) => (false, c.hlc, *h),

            None => (true, Default::default(), *h),

        };

        for seg in &mut m.segments {

            if let crate::graph::Segment::Conflict(sides) = seg {

                sides.sort_by_cached_key(|s| s.iter().map(|a| when(&a.0)).min());

            }

        }

        m

    }

    /// For each conflict of a text node, in marker order (spec §9.5): the

    /// text of its sides, earliest change first, when it is an adjacent

    /// insertion that keeping both sides settles (oxygen#121); `None` for

    /// the others.

    pub fn both_sides(&self, node: &NodeId) -> Vec<Option<Vec<Vec<u8>>>> {

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

            return Vec::new();

        };

        let m = self.materialize_ordered(g);

        let mut out = Vec::new();

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

            match seg {

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

                crate::graph::Segment::Conflict(sides) if g.adjacent_insertion(&m, i, self) => {

                    out.push(Some(

                        sides

                            .iter()

                            .map(|s| {

                                s.iter()

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

                                    .collect()

                            })

                            .collect(),

                    ));

                }

                _ => out.push(None),

            }

        }

        out

    }

        let m = self.materialize_ordered(g);

Two changes that each add lines at the same place (two new imports, two

changelog entries) conflict too, since oxy will not guess their order.

`oxy status` says when a conflict is one of these; keep both sides, the

earlier change's first, with one command:

```

oxy resolve --both CHANGELOG.md   # --reverse for the later change's first

```

The short identifiers are ChangeId prefixes. A conflict's sides are written earliest first, by the clock (§6.4) of the oldest change on each side, then by ChangeHash. Delete/insert conflicts render the deleted context as a `-------` section. Tree conflicts are materialized by writing each candidate with a suffix `.oxy-conflict-<n>` and are listed by `oxy status`. Replace conflicts materialize as `<name>.oxy-conflict-<n>` files.

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.

oxy split CHANGE [PATH]..           oxy abandon CHANGE | -r REVSET [--yes]   oxy resolve [--both [--reverse]] [PATH]..

        /// Opaque files or subrepos whose replace conflict to settle with their current content;

        /// with --both, the text files whose conflicts to settle (all of them when none)

        /// Settle each adjacent insertion (two changes adding lines at the same place) by keeping

        /// every side, earliest change first; refused where the sides changed the same lines

        #[arg(long)]

        both: bool,

        /// With --both, the latest change first

        #[arg(long, requires = "both")]

        reverse: bool,

        Cmd::Resolve {

            paths,

            both,

            reverse,

            json,

        } => workspace::resolve(&paths, both, reverse, json),

            let resolved = matches!(

                snap.statuses

                    .iter()

                    .find(|s| s.path == *p)

                    .map(|s| s.status),

                Some(ChangeStatus::Resolved)

            );

            let both = if resolved {

                0

            } else {

                snap.base.both_sides(&f.node).iter().flatten().count()

            };

            if both > 0 {

                println!(

                    "     {}",

                    ui::dim(format!(

                        "{} adjacent {}: `oxy resolve --both {p}` keeps both sides, earliest first",

                        both,

                        if both == 1 { "insertion" } else { "insertions" }

                    ))

                );

            }

pub fn resolve(paths: &[String], both: bool, reverse: bool, as_json: bool) -> Result<i32> {

    let paths: Vec<String> = paths

        .iter()

        .map(|p| p.trim_start_matches("./").trim_end_matches('/').to_string())

        .collect();

    if both {

        // Adjacent insertions (oxygen#121): every side kept, in order.

        let kept = repo.keep_both(&snap, &paths, reverse)?;

        if !as_json {

            for k in &kept {

                if !k.settled.is_empty() {

                    let n: Vec<String> = k.settled.iter().map(|n| n.to_string()).collect();

                    println!("kept both  {}: conflict {}", k.path, n.join(", "));

                }

                for (n, why) in &k.left {

                    println!("markers    {}: conflict {n}: {why}", k.path);

                }

            }

        }

        snap = repo.snapshot("oxy resolve")?;

    } else if !paths.is_empty() {