Conflict resolution by editing marked files; working copy stays on its own base after commit; oxy resolve 20247a03a596

//! packs, checkpoints, multiple workspaces, and remotes. Changes are signed individually when `core.sign` is

    /// The file is conflicted in the base state and still contains conflict markers.

    /// The file was conflicted in the base state and the working copy resolves it.

    Resolved,

}

/// Lines that mark a conflict region in a materialized file (spec §9.5).

pub fn has_conflict_markers(content: &[u8]) -> bool {

    split_lines(content).iter().any(|l| {

        l.starts_with(b"<<<<<<< oxy conflict") || l.starts_with(b"======= oxy conflict") || l.starts_with(b">>>>>>> oxy conflict")

    })

    /// Whether the working copy resolves conflicts of its base (spec §9.6).

    pub resolves: bool,

        deps.extend(b.contributors.iter().copied());

        let resolves = b.resolves;

        Ok(SnapshotResult { wc_hash: new_hash, wc, base, base_snapshot, statuses, changed, resolves })

        if let Some(s) = snap.statuses.iter().find(|s| s.status == ChangeStatus::ConflictEdited) {

            return fail(format!("{} still contains conflict markers", s.path));

        if snap.resolves {

            // A resolution depends on every change that contributed to the

            // conflict (spec §8.1); those are already among the working copy's

            // dependencies, so keep every one that is not merely a base head.

            let heads: BTreeSet<ChangeHash> = snap.base.maximal(&snap.wc.deps).into_iter().collect();

            deps.extend(snap.wc.deps.iter().filter(|d| !heads.contains(d) || touches_conflict(&snap)).copied());

        }

            kind: if snap.resolves { ChangeKind::Resolution } else { ChangeKind::Normal },

        // The working copy continues on its own base plus the new change, which

        // is exactly what the files on disk contain; the bookmark may hold

        // other heads (and conflicts) the working copy has not checked out.

        let old_base = snap.base.maximal(&snap.wc.deps);

        let mut all: Vec<ChangeHash> = old_heads.clone();

        all.extend(old_base.iter().copied());

        all.push(hash);

        let mut st = self.load_state(&all)?;

        let mut with_new = old_heads.clone();

        with_new.push(hash);

        let mut wc_base = old_base.clone();

        wc_base.push(hash);

        let wc_base = st.maximal(&wc_base);

        let wc = self.new_working_copy(wc_base, "");

    /// Changes that contributed to conflicts this working copy resolves.

    contributors: BTreeSet<ChangeHash>,

    resolves: bool,

        ChangeBuilder { base, base_snapshot, tree_ops: vec![], edits: vec![], statuses: vec![], dir_nodes, reuse, contributors: BTreeSet::new(), resolves: false }

        if path.contains(".oxy-conflict-") || expected.is_conflicted() {

            self.resolves = true;

        }

                    if bytes == &e.content {

                        return Ok(());

                    }

                    if has_conflict_markers(&e.content) {

                        return Ok(());

                    // Resolution (spec §9.6): diff against the unconflicted lines

                    // with each region as a gap, then retire every region atom.

                    // Whatever the author kept from a region is re-inserted as

                    // new atoms, which leaves the graph totally ordered.

                    let regions = self.base.conflict_regions(&node);

                    let mut edits = text_edits(node, &regions.plain, &e.content);

                    if !regions.region_atoms.is_empty() {

                        edits.insert(0, Edit::Delete { node, atoms: ranges(&regions.region_atoms) });

                    }

                    self.edits.extend(edits);

                    self.contributors.extend(regions.contributors);

                    self.resolves = true;

                    if e.exec != expected.mode.exec {

                        if let Some(old) = mode_atom {

                            self.tree_ops.push(TreeOp::SetMode { node, old, mode: Mode { exec: e.exec, opaque: false } });

                        }

                    }

                    self.statuses.push(PathStatus { path: path.to_string(), status: ChangeStatus::Resolved });

/// Whether a working copy touches a node that is conflicted in its base.

fn touches_conflict(snap: &SnapshotResult) -> bool {

    let conflicted: BTreeSet<NodeId> = snap.base_snapshot.files.values().filter(|f| f.is_conflicted()).map(|f| f.node).collect();

    snap.wc.tree_ops.iter().any(|op| conflicted.contains(&op.node())) || snap.wc.edits.iter().any(|e| conflicted.contains(&e.node()))

}

    /// Make `main` conflicted: two commits on the same base that edit the same line.

    fn conflicted_repo() -> (tempfile::TempDir, Repo, ChangeHash, ChangeHash, ChangeHash) {

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

        let root = dir.path();

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

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

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

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

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

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

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

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

        (dir, repo, h1, h2, h3)

    }

    #[test]

    fn concurrent_edits_conflict_and_can_be_resolved() {

        let (dir, repo, h1, h2, h3) = conflicted_repo();

        let root = dir.path();

        let heads: BTreeSet<_> = repo.bookmark_heads().unwrap().into_iter().collect();

        assert_eq!(heads, [h2, h3].into_iter().collect());

        let st = repo.load_state(&[h2, h3]).unwrap();

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

        // Checking out main writes markers.

        let r = repo.checkout(&repo.bookmark_heads().unwrap(), false, "checkout main").unwrap();

        assert!(r.conflicted);

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

        assert!(marked.starts_with("a\n<<<<<<< oxy conflict 1 of 1"), "{marked}");

        assert!(marked.contains("B\n") && marked.contains("X\n") && marked.ends_with("end\nc\n"), "{marked}");

        assert!(has_conflict_markers(marked.as_bytes()));

        // Untouched markers: clean working copy; commit has nothing to do.

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

        assert!(s.statuses.is_empty());

        assert!(!s.resolves);

        // Partially edited file that still has markers cannot be committed.

        write(root, "f.txt", marked.replace("B\n", "BB\n").as_bytes());

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

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

        assert!(repo.commit("no", &[]).is_err());

        // Resolve by keeping one side and adding a line elsewhere.

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

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

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

        assert!(s.resolves);

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

        let c4 = repo.store().get_change(&h4).unwrap();

        assert_eq!(c4.kind, ChangeKind::Resolution);

        assert!(c4.deps.contains(&h2) && c4.deps.contains(&h3) && c4.deps.contains(&h1), "{:?}", c4.deps);

        assert_eq!(repo.bookmark_heads().unwrap(), vec![h4]);

        let snap = repo.load_state(&[h4]).unwrap().materialize();

        assert!(!snap.is_conflicted());

        assert!(matches!(&snap.files["f.txt"].content, FileContent::Text { bytes, .. } if bytes == b"a\nX\nc\nd\n"));

        assert!(!repo.snapshot("status").unwrap().changed);

        // A peer holding only h2 and h3 and receiving h4 sees the same result,

        // whatever order the changes arrive in.

        let mut st = State::new();

        for h in [h4, h3, h1, h2] {

            st.add_unchecked(repo.store().get_change(&h).unwrap());

        }

        st.validate().unwrap();

        assert!(matches!(&st.materialize().files["f.txt"].content, FileContent::Text { bytes, .. } if bytes == b"a\nX\nc\nd\n"));

    }

    #[test]

    fn resolution_may_keep_both_sides_or_neither() {

        let (dir, repo, _h1, _h2, _h3) = conflicted_repo();

        let root = dir.path();

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

        // Keep both sides in a chosen order.

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

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

        let snap = repo.load_state(&[h]).unwrap().materialize();

        assert!(!snap.is_conflicted());

        assert!(matches!(&snap.files["f.txt"].content, FileContent::Text { bytes, .. } if bytes == b"a\nX\nB\nc\n"));

        // Undo and instead drop the whole region.

        repo.undo().unwrap();

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

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

        let snap = repo.load_state(&[h]).unwrap().materialize();

        assert!(!snap.is_conflicted());

        assert!(matches!(&snap.files["f.txt"].content, FileContent::Text { bytes, .. } if bytes == b"a\nc\n"));

    }

    #[test]

    fn name_conflict_resolved_by_removing_a_candidate() {

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

        let root = dir.path();

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

        write(root, "keep.txt", b"k\n");

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

        write(root, "new.txt", b"one\n");

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

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

        write(root, "new.txt", b"two\n");

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

        let r = repo.checkout(&repo.bookmark_heads().unwrap(), false, "checkout main").unwrap();

        assert!(r.conflicted);

        assert!(root.join("new.txt.oxy-conflict-1").exists() && root.join("new.txt.oxy-conflict-2").exists());

        assert!(!root.join("new.txt").exists());

        // Keep candidate 2 under the real name.

        fs::remove_file(root.join("new.txt.oxy-conflict-1")).unwrap();

        fs::rename(root.join("new.txt.oxy-conflict-2"), root.join("new.txt")).unwrap();

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

        assert_eq!(repo.store().get_change(&h).unwrap().kind, ChangeKind::Resolution);

        // The resolution does not touch keep.txt, so it does not depend on h1;

        // the bookmark keeps both as heads and their union is the state.

        let heads: BTreeSet<_> = repo.bookmark_heads().unwrap().into_iter().collect();

        assert_eq!(heads, [h1, h].into_iter().collect());

        let snap = repo.load_state(&repo.bookmark_heads().unwrap()).unwrap().materialize();

        assert!(!snap.is_conflicted(), "{:?}", snap.tree.conflicts);

        assert_eq!(snap.files.keys().cloned().collect::<Vec<_>>(), ["keep.txt", "new.txt"]);

        assert!(matches!(&snap.files["new.txt"].content, FileContent::Text { bytes, .. } if bytes == b"two\n"));

    }

/// See `State::conflict_regions`.

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

pub struct ConflictRegions {

    pub plain: Vec<(AtomKey, Vec<u8>)>,

    pub region_atoms: Vec<AtomKey>,

    pub contributors: Vec<ChangeHash>,

}

    /// For resolving a conflicted text node (spec §9.6): the live atoms that

    /// are not part of any conflict region in order, every live atom that is

    /// part of a region, and every change that contributed to a region.

    pub fn conflict_regions(&self, node: &NodeId) -> ConflictRegions {

        let mut out = ConflictRegions::default();

        let Some(g) = self.files.get(node) else { return out };

        let m = g.materialize(self);

        let mut contributors = BTreeSet::new();

        for seg in &m.segments {

            match seg {

                crate::graph::Segment::Lines(atoms) => {

                    for a in atoms {

                        out.plain.push((*a, g.content(a).unwrap_or_default().to_vec()));

                    }

                }

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

                    for side in sides {

                        for a in side {

                            out.region_atoms.push(*a);

                            contributors.insert(a.0);

                        }

                    }

                }

                crate::graph::Segment::Zombie { deleted, inserted } => {

                    for a in deleted {

                        contributors.insert(a.0);

                        contributors.extend(g.deleters(a).copied());

                    }

                    for a in inserted {

                        out.region_atoms.push(*a);

                        contributors.insert(a.0);

                    }

                }

            }

        }

        out.contributors = contributors.into_iter().collect();

        out

    }

    /// Report which conflicts of the working copy's base are resolved by the current files

    Resolve,

                    ChangeStatus::Resolved => "R",

                println!("\nConflicts in the base state (edit the marked files, or the .oxy-conflict-N candidates, then commit):");

                        let state = match snap.statuses.iter().find(|s| s.path == *p).map(|s| s.status) {

                            Some(ChangeStatus::Resolved) => "resolved in working copy",

                            Some(ChangeStatus::ConflictEdited) => "markers remain",

                            _ => "unresolved",

                        };

                        println!("  {p}  ({state})");

        Cmd::Resolve => {

            let repo = open()?;

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

            if !snap.base_snapshot.is_conflicted() {

                println!("The working copy's base has no conflicts.");

                return Ok(0);

            }

            let mut remaining = 0;

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

                if !f.is_conflicted() {

                    continue;

                }

                match snap.statuses.iter().find(|s| s.path == *p).map(|s| s.status) {

                    Some(ChangeStatus::Resolved) => println!("resolved   {p}"),

                    Some(ChangeStatus::ConflictEdited) => {

                        remaining += 1;

                        println!("markers    {p}");

                    }

                    _ => {

                        remaining += 1;

                        println!("unresolved {p}");

                    }

                }

            }

            for c in &snap.base_snapshot.tree.conflicts {

                remaining += 1;

                println!("tree       {c:?}");

            }

            if remaining == 0 {

                println!("All conflicts are resolved; `oxy commit` will record the resolution.");

                Ok(0)

            } else {

                Ok(2)

            }

        }