Remove or move every copy of a node at one place e8e6e0cac26a

- **Removing a file removes every copy of it (#88).** When two lines of history each put a file back in the same place, it has two placements there and shows as one file. Removing or moving it retired only one, so the other stayed behind, and once its directory went it was an orphan: a conflict in the state. It is the one difference the Git import of VS Code had in its first 31 000 commits. Both now go together, in a commit and in a Git import.

        let placement = self.base_snapshot.tree.entries[old].placement;

            old: op_ref(placement),

        for k in self.same_place(&expected.node, placement) {

            self.tree_ops.push(TreeOp::RemoveNode {

                node: expected.node,

                placement: op_ref(k),

            });

        }

    /// The node's other live placements at the same place as `k`, the one

    /// the tree shows: two lines of history that put a node back where it

    /// was each leave a placement, and the tree shows them as one file. A

    /// change that removes or moves it retires them together, or the copy

    /// left behind outlives its directory (oxygen#88).

    fn same_place(&self, node: &NodeId, k: (ChangeHash, u32)) -> Vec<(ChangeHash, u32)> {

        let tree = self.base.tree();

        let Some(shown) = tree.placement(&k) else {

            return Vec::new();

        };

        tree.live_placements(node)

            .into_iter()

            .filter(|(o, p)| *o != k && p.parent == shown.parent && p.name == shown.name)

            .map(|(o, _)| o)

            .collect()

    }

        let placement = entry.placement;

            placement: op_ref(placement),

        for k in self.same_place(&expected.node, placement) {

            self.tree_ops.push(TreeOp::RemoveNode {

                node: expected.node,

                placement: op_ref(k),

            });

        }

/// oxygen#88 (vscode 9ab2056393c8): two lines of history that each move a

/// file back where it was leave two placements at one place, which the

/// tree shows as one file. Removing it, and then its directory, retires

/// both, so no copy is left under a directory that is gone.

#[test]

fn git_import_removes_every_copy_of_a_file_at_one_place() {

    hermetic();

    if std::process::Command::new("git")

        .arg("--version")

        .output()

        .is_err()

    {

        eprintln!("git not installed; skipping");

        return;

    }

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

    let root = dir.path();

    let g = root.join("src.git");

    fs::create_dir_all(&g).unwrap();

    let git = |args: &[&str]| {

        let out = std::process::Command::new("git")

            .arg("-C")

            .arg(&g)

            .args([

                "-c",

                "user.name=Grace",

                "-c",

                "[email protected]",

                "-c",

                "commit.gpgsign=false",

            ])

            .args(args)

            .output()

            .unwrap();

        assert!(

            out.status.success(),

            "git {args:?}: {}",

            String::from_utf8_lossy(&out.stderr)

        );

    };

    git(&["init", "-q", "-b", "main"]);

    write(&g, "d/list.txt", b"one\ntwo\nthree\nfour\n");

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

    git(&["add", "."]);

    git(&["commit", "-qm", "base"]);

    fs::create_dir_all(g.join("d/sub")).unwrap();

    git(&["mv", "d/list.txt", "d/sub/list.txt"]);

    git(&["commit", "-qm", "into sub"]);

    git(&["checkout", "-qb", "side"]);

    git(&["mv", "d/sub/list.txt", "d/list.txt"]);

    git(&["commit", "-qm", "back, on side"]);

    git(&["checkout", "-q", "main"]);

    git(&["mv", "d/sub/list.txt", "d/list.txt"]);

    git(&["commit", "-qm", "back, on main"]);

    git(&["merge", "-q", "--no-edit", "side"]);

    git(&["rm", "-rq", "d"]);

    git(&["commit", "-qm", "d goes"]);

    let repo = Repo::init(&root.join("o")).unwrap();

    repo.import_git(&g, "main").unwrap();

    let v = repo.verify_git_import(&g, "main").unwrap();

    assert!(v.mismatches.is_empty(), "{:?}", v.mismatches);

    let st = repo

        .load_state_history(&repo.bookmark_heads().unwrap())

        .unwrap();

    let view = st.tree().view();

    assert!(view.conflicts.is_empty(), "{:?}", view.conflicts);

    assert_eq!(view.entries.keys().collect::<Vec<_>>(), vec!["keep.txt"]);

}