merge=union: a checkout keeps both sides of a union file's adjacent insertions (refs #145) 4afe288b7946

# oxygen#145: two changes adding changelog entries keep both.

CHANGELOG.md merge=union

- **Changelogs stop conflicting (#145).** A file marked `merge=union` in `.oxyattributes` (`CHANGELOG.md merge=union`) has its adjacent insertions settled by the checkout itself: both sides kept, the earlier change's first, as `oxy resolve --both` does, and the next commit records the resolution. Only adjacent insertions: where two changes changed the same lines, the markers stay. Oxygen's own changelog is marked so.

//! (or `-binary`), `eol=lf`, `eol=crlf`, `nocompress`, `lockable`, or

//! `merge=union`. A

    /// `merge=union` (oxygen#145): two changes adding lines at the same

    /// place keep both, without asking (`oxy resolve --both`, spec §9.5).

    pub union: bool,

                    ("merge", Some("union")) => a.union = true,

                    ("merge", Some(_)) | ("-merge", None) => a.union = false,

                lockable: false,

                union: false

        let u = Attributes::from_files([(".oxyattributes", &b"CHANGELOG.md merge=union\n"[..])]);

        assert!(u.lookup("CHANGELOG.md").union);

        assert!(u.lookup("docs/CHANGELOG.md").union);

        assert!(!u.lookup("README.md").union);

    /// Union files whose adjacent insertions were settled by keeping both

    /// sides (oxygen#145).

    pub kept_both: Vec<KeptBoth>,

        if report.conflicted && !self.bare {

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

        }

    /// Settle the adjacent insertions of each conflicted text file whose

    /// `.oxyattributes` say `merge=union` (oxygen#145) by keeping both

    /// sides, earliest change first, as [`Repo::keep_both`] does: a

    /// checkout calls it, and the next commit records the resolution. The

    /// files it settled something in.

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

        let snap = self.snapshot(command)?;

        let paths: Vec<String> = snap

            .base_snapshot

            .files

            .iter()

            .filter(|(p, f)| {

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

                    && snap.attributes.lookup(p).union

            })

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

            .collect();

        if paths.is_empty() {

            return Ok(Vec::new());

        }

        let kept = self.keep_both(&snap, &paths, false)?;

        Ok(kept.into_iter().filter(|k| !k.settled.is_empty()).collect())

    }

/// oxygen#145: a file marked `merge=union` has its adjacent insertions

/// settled by the checkout itself, both kept, earliest first; the next

/// commit records the resolution. Other files keep their markers.

#[test]

fn union_files_keep_both_sides_on_checkout() {

    hermetic();

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

    let root = dir.path();

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

    write(root, ".oxyattributes", b"CHANGELOG.md merge=union\n");

    write(

        root,

        "CHANGELOG.md",

        b"# Changelog\n## Unreleased\n## 1.0\n",

    );

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

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

    write(

        root,

        "CHANGELOG.md",

        b"# Changelog\n## Unreleased\n- one\n## 1.0\n",

    );

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

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

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

    write(

        root,

        "CHANGELOG.md",

        b"# Changelog\n## Unreleased\n- two\n## 1.0\n",

    );

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

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

    let r = repo

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

        .unwrap();

    assert!(r.conflicted);

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

    assert_eq!(r.kept_both[0].path, "CHANGELOG.md");

    assert_eq!(

        fs::read_to_string(root.join("CHANGELOG.md")).unwrap(),

        "# Changelog\n## Unreleased\n- one\n- two\n## 1.0\n"

    );

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

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

    assert_eq!(

        statuses(&s),

        vec![("CHANGELOG.md".into(), ChangeStatus::Resolved)]

    );

}

            kept_both: vec![],

For files where the order never matters, such as a changelog, say so once

in `.oxyattributes` and checkouts keep both sides without asking:

```

CHANGELOG.md merge=union

```

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.

| `.oxyattributes` | Per-path attributes: `binary` (force opaque), `text` (text unless NUL bytes), `eol=lf|crlf` (store LF; check out as given), `nocompress` (chunks packed raw), `lockable` (read-only until `oxy lock`), `merge=union` (adjacent insertions settled by keeping both sides, §9.5), `filter=<name>`. Gitattributes syntax: a pattern without `/` matches basenames below the file's directory, one with `/` is anchored to it; later rules and deeper files override. The attributes in force for a change are those in the files being committed. |

| Configuration, attributes, hooks (§19, §20) | Implemented (`.oxyattributes`: binary, text, eol, nocompress, lockable, merge=union) |

    print_kept_both(&r);

/// Union files (`merge=union`, oxygen#145) a checkout settled itself.

fn print_kept_both(r: &oxy_core::repo::CheckoutReport) {

    for k in &r.kept_both {

        println!(

            "  {} kept both sides in {} (merge=union); the next commit records it",

            ui::note(),

            ui::path(&k.path)

        );

    }

}

    print_kept_both(&r);