Marker-like text no longer blocks a conflict resolution 3652104ae7d3

/// Whether `content` still holds a conflict marker oxy wrote for this file

/// (oxygen#126): a marker-like line of the materialized conflicted file

/// that is not one of its unconflicted lines (`plain`). Text that merely

/// looks like a marker, as oxy's own documentation or a test fixture has,

/// is in the unconflicted lines, so it is not taken for one.

pub fn has_own_conflict_markers(content: &[u8], materialized: &[u8], plain: &[&[u8]]) -> bool {

    let line = |l: &[u8]| -> Vec<u8> {

        let l = l.strip_suffix(b"\n").unwrap_or(l);

        l.strip_suffix(b"\r").unwrap_or(l).to_vec()

    };

    let marker = |l: &[u8]| {

        l.starts_with(b"<<<<<<< oxy conflict")

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

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

    };

    let unconflicted: HashSet<Vec<u8>> = plain.iter().map(|l| line(l)).collect();

    let own: HashSet<Vec<u8>> = split_lines(materialized)

        .into_iter()

        .map(line)

        .filter(|l| marker(l) && !unconflicted.contains(l))

        .collect();

    !own.is_empty()

        && split_lines(content)

            .into_iter()

            .any(|l| own.contains(&line(l)))

}

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

                    let plain: Vec<&[u8]> =

                        regions.plain.iter().map(|(_, l)| l.as_slice()).collect();

                    if has_own_conflict_markers(&e.content, bytes, &plain) {

/// oxygen#126: a file whose text includes an example of oxy's markers (as

/// the spec's §9.5 does) can still have its conflict resolved; a real

/// marker left behind is still caught.

fn marker_like_text_does_not_block_a_resolution() {

    hermetic();

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

    let root = dir.path();

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

    let example = "```\n<<<<<<< oxy conflict 1 of 2, side 1: change k7m2p9 \"Add retry loop\"\n... lines ...\n======= oxy conflict 1 of 2, side 2: change q3x8w1 \"Refactor client\"\n>>>>>>> oxy conflict 1 of 2 end\n```\n";

    write(

        root,

        "doc.md",

        format!("intro\n{example}b\nend\n").as_bytes(),

    );

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

    write(

        root,

        "doc.md",

        format!("intro\n{example}B\nend\n").as_bytes(),

    );

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

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

    write(

        root,

        "doc.md",

        format!("intro\n{example}X\nend\n").as_bytes(),

    );

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

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

        .unwrap();

    let marked = fs::read_to_string(root.join("doc.md")).unwrap();

    assert!(marked.contains("oxy conflict 1 of 1"), "{marked}");

    // A real marker left: still caught.

    write(root, "doc.md", marked.replace("B\n", "BB\n").as_bytes());

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

    assert_eq!(

        statuses(&s),

        vec![("doc.md".into(), ChangeStatus::ConflictEdited)]

    );

    // Resolved, the example kept: a resolution.

    write(

        root,

        "doc.md",

        format!("intro\n{example}X\nend\n").as_bytes(),

    );

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

    assert_eq!(

        statuses(&s),

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

    );

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

    assert_eq!(

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

        ChangeKind::Resolution

    );

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

}

#[test]