fix(updating): never recreate deleted paths on update

Previously, paths that matched a pattern in `skip_if_exists` and that
were deleted in the generated project were recreated during each update.

These deletions are contained in the diff between old vanilla generated
project and the (pre-update) current one. They are not executed though
since the paths are excluded from the diff application.

Similarly, if a file that was deleted intentionally in a generated
project was changed in the template, an update would have regenerated
it (but not if it did not have any changes). I'm not completely sure how
this manifested, but it probably involved a suppressed merge conflict.

This commit ensures that update behavior is always consistent -
never regenerate deleted paths during `update` - by acquiring a list of
deleted paths and excluding them in the copy operations that are
relevant for acquiring the update diff.

Author: lkubb

Diff for: copier/main.py

@@ -933,6 +933,16 @@ def _apply_update(self) -> None:  # noqa: C901
             self._execute_tasks(
                 self.template.migration_tasks("before", self.subproject.template)  # type: ignore[arg-type]
             )
+            with local.cwd(old_copy):
+                self._git_initialize_repo()
+                git("remote", "add", "real_dst", "file://" + str(subproject_top))
+                git("fetch", "--depth=1", "real_dst", "HEAD")
+                # Save a list of files that were intentionally removed in the generated
+                # project to avoid recreating them during the update.
+                diff_removed = git(
+                    "diff-tree", "-r", "--diff-filter=D", "--name-only", "HEAD...FETCH_HEAD",
+                ).splitlines()
+                temp_exclude = list(set(self.exclude).union(diff_removed))
             # Create a copy of the real destination after applying migrations
             # but before performing any further update for extracting the diff
             # between the temporary destination of the old template and the
@@ -954,6 +964,8 @@ def _apply_update(self) -> None:  # noqa: C901
             # Do a normal update in final destination
             with replace(
                 self,
+                # Don't regenerate intentionally deleted paths
+                exclude=temp_exclude,
                 # Files can change due to the historical diff, and those
                 # changes are not detected in this process, so it's better to
                 # say nothing than lie.
@@ -970,6 +982,7 @@ def _apply_update(self) -> None:  # noqa: C901
                 defaults=True,
                 quiet=True,
                 src_path=self.subproject.template.url,  # type: ignore[union-attr]
+                exclude=temp_exclude,
             ) as new_worker:
                 new_worker.run_copy()
             with local.cwd(new_copy):
@@ -978,7 +991,6 @@ def _apply_update(self) -> None:  # noqa: C901
             # real destination with some special handling of newly added files
             # in both the poject and the template.
             with local.cwd(old_copy):
-                self._git_initialize_repo()
                 git("remote", "add", "dst_copy", "file://" + str(dst_copy))
                 git("fetch", "--depth=1", "dst_copy", "HEAD:dst_copy")
                 git("remote", "add", "new_copy", "file://" + str(new_copy))

Diff for: tests/test_updatediff.py

@@ -554,6 +554,80 @@ def test_skip_update(tmp_path_factory: pytest.TempPathFactory) -> None:
     assert not (dst / "skip_me.rej").exists()
 
 
+def test_skip_update_deleted(tmp_path_factory: pytest.TempPathFactory) -> None:
+    """
+    Ensure that ``skip_if_exists`` does not interfere with
+    deleted paths during updates (i.e. they stay deleted).
+    Issue #1718
+    """
+    src, dst = map(tmp_path_factory.mktemp, ("src", "dst"))
+    with local.cwd(src):
+        build_file_tree(
+            {
+                "copier.yaml": "_skip_if_exists: [skip_me]",
+                "{{ _copier_conf.answers_file }}.jinja": "{{ _copier_answers|to_yaml }}",
+                "skip_me": "1",
+                "another_file": "foobar",
+            }
+        )
+        git("init")
+        git("add", ".")
+        git("commit", "-m1")
+        git("tag", "1.0.0")
+    run_copy(str(src), dst, defaults=True, overwrite=True)
+    skip_me = dst / "skip_me"
+    answers_file = dst / ".copier-answers.yml"
+    answers = yaml.safe_load(answers_file.read_text())
+    assert skip_me.read_text() == "1"
+    assert answers["_commit"] == "1.0.0"
+    skip_me.unlink()
+    with local.cwd(dst):
+        git("init")
+        git("add", ".")
+        git("commit", "-m1")
+    run_update(dst, skip_answered=True, overwrite=True)
+    assert not (dst / "skip_me").exists()
+
+
+def test_update_deleted_path(tmp_path_factory: pytest.TempPathFactory) -> None:
+    """
+    Ensure that deleted paths are not regenerated during updates,
+    even if the template has changes in that path.
+    Issue #1721
+    """
+    src, dst = map(tmp_path_factory.mktemp, ("src", "dst"))
+    with local.cwd(src):
+        build_file_tree(
+            {
+                "copier.yaml": "_skip_if_exists: [skip_me]",
+                "{{ _copier_conf.answers_file }}.jinja": "{{ _copier_answers|to_yaml }}",
+                "updated_file": "foo",
+                "another_file": "foobar",
+            }
+        )
+        git("init")
+        git("add", ".")
+        git("commit", "-m1")
+        git("tag", "1.0.0")
+    run_copy(str(src), dst, defaults=True, overwrite=True)
+    updated_file = dst / "updated_file"
+    answers_file = dst / ".copier-answers.yml"
+    answers = yaml.safe_load(answers_file.read_text())
+    assert updated_file.read_text() == "foo"
+    assert answers["_commit"] == "1.0.0"
+    updated_file.unlink()
+    with local.cwd(dst):
+        git("init")
+        git("add", ".")
+        git("commit", "-m1")
+    with local.cwd(src):
+        build_file_tree({"updated_file": "bar"})
+        git("commit", "-am2")
+        git("tag", "2.0.0")
+    run_update(dst, skip_answered=True, overwrite=True)
+    assert not (dst / "updated_file").exists()
+
+
 @pytest.mark.parametrize(
     "answers_file", [None, ".copier-answers.yml", ".custom.copier-answers.yaml"]
 )