feat(split): support extracting renamed files

This is a 1st pass; still TODO:
- confirm rename w/ changed contents can split
- confirm rename w/ other files can split

Author: claytonrcarter

git-branchless-lib/src/git/diff.rs

@@ -16,6 +16,15 @@ pub struct Diff<'repo> {
 }
 
 impl Diff<'_> {
+    /// Enable rename and copy detection for this diff.
+    ///
+    /// Must be called before iterating deltas if you want renames to be
+    /// reported as a single `Renamed` delta rather than separate add/delete
+    /// deltas.
+    pub fn find_similar(&mut self) -> eyre::Result<()> {
+        self.inner.find_similar(None).map_err(|e| eyre::eyre!(e))
+    }
+
     /// Summarize this diff into a single line "short" format.
     pub fn short_stats(&self) -> eyre::Result<String> {
         let stats = self.inner.stats()?;
@@ -48,11 +57,15 @@ pub fn summarize_diff_for_temporary_commit(diff: &Diff) -> eyre::Result<String>
         // returns an Err, so catch and ignore it
         let _ = diff.inner.foreach(
             &mut |delta: git2::DiffDelta, _| {
-                let relevant_path = delta
-                    .old_file()
-                    .path()
-                    .or(delta.new_file().path())
-                    .unwrap_or_else(|| unreachable!("diff should have contained at least 1 file"));
+                // For deletions show the old (removed) path; for everything
+                // else (including renames) prefer the new path so that e.g.
+                // a rename "foo.txt → bar.txt" is labelled as "bar.txt".
+                let relevant_path = if delta.status() == git2::Delta::Deleted {
+                    delta.old_file().path().or_else(|| delta.new_file().path())
+                } else {
+                    delta.new_file().path().or_else(|| delta.old_file().path())
+                }
+                .unwrap_or_else(|| unreachable!("diff should have contained at least 1 file"));
                 filename = Some(format!("{}", relevant_path.display()));
                 false
             },
@@ -67,7 +80,9 @@ pub fn summarize_diff_for_temporary_commit(diff: &Diff) -> eyre::Result<String>
     };
 
     let ins_del = match (stats.insertions(), stats.deletions()) {
-        (0, 0) => unreachable!("empty diff"),
+        // A diff with no insertions or deletions still has a file change,
+        // e.g. a pure rename or a file-mode change.
+        (0, 0) => "0".to_string(),
         (i, 0) => format!("+{i}"),
         (0, d) => format!("-{d}"),
         (i, d) => format!("+{i}/-{d}"),

git-branchless/src/commands/split.rs

@@ -28,8 +28,8 @@ use lib::{
     },
     git::{
         CherryPickFastOptions, FileMode, GitRunInfo, MaybeZeroOid, NonZeroOid, Repo,
-        ResolvedReferenceInfo, hydrate_tree, make_empty_tree, process_diff_for_record,
-        summarize_diff_for_temporary_commit,
+        ResolvedReferenceInfo, get_changed_paths_between_trees, hydrate_tree, make_empty_tree,
+        process_diff_for_record, summarize_diff_for_temporary_commit,
     },
     try_exit_code,
     util::{ExitCode, EyreExitOr},
@@ -298,6 +298,41 @@ pub fn split(
         }
     };
 
+    // Pre-compute a map of exact renames in the target commit: new_path -> old_path.
+    // A rename is detected when a path is absent from parent_tree but present in
+    // target_tree, and another path with the SAME blob OID is absent from target_tree
+    // but present in parent_tree (same content = exact rename, no content change).
+    //
+    // This map is used when extracting a renamed file to correctly restore the
+    // original path in the remainder tree, preventing cherry-pick conflicts.
+    let rename_map: HashMap<PathBuf, PathBuf> = {
+        let changed_paths =
+            get_changed_paths_between_trees(&repo, Some(&parent_tree), Some(&target_tree))?;
+        let mut deleted_by_oid: HashMap<NonZeroOid, PathBuf> = HashMap::new();
+        let mut added_entries: Vec<(PathBuf, NonZeroOid)> = Vec::new();
+        for path in changed_paths {
+            let parent_oid = parent_tree.get_oid_for_path(&path)?;
+            let target_oid = target_tree.get_oid_for_path(&path)?;
+            match (parent_oid, target_oid) {
+                (Some(MaybeZeroOid::NonZero(p_oid)), None | Some(MaybeZeroOid::Zero)) => {
+                    deleted_by_oid.insert(p_oid, path);
+                }
+                (None | Some(MaybeZeroOid::Zero), Some(MaybeZeroOid::NonZero(t_oid))) => {
+                    added_entries.push((path, t_oid));
+                }
+                _ => {}
+            }
+        }
+        added_entries
+            .into_iter()
+            .filter_map(|(new_path, blob_oid)| {
+                deleted_by_oid
+                    .get(&blob_oid)
+                    .map(|old_path| (new_path, old_path.clone()))
+            })
+            .collect()
+    };
+
     for (spec, path) in resolved_specs.iter() {
         let path = path.as_path();
 
@@ -326,21 +361,50 @@ pub fn split(
 
                 let target_entry = target_tree.get_path(path)?;
                 let temp_tree_oid = match (parent_entry, target_entry, &split_mode) {
-                    // added or modified & InsertBefore => add to extracted commit
-                    (None, Some(commit_entry), SplitMode::InsertBefore)
-                    | (Some(_), Some(commit_entry), SplitMode::InsertBefore) => {
+                    // modified & InsertBefore => add to extracted commit (no rename handling needed)
+                    (Some(_), Some(commit_entry), SplitMode::InsertBefore) => {
                         remainder_tree.add_or_replace(&repo, path, &commit_entry)?
                     }
 
+                    // added & InsertBefore => add to extracted commit; for renames, also remove
+                    // the original path (which is present in the parent-based remainder tree)
+                    (None, Some(commit_entry), SplitMode::InsertBefore) => {
+                        let oid = remainder_tree.add_or_replace(&repo, path, &commit_entry)?;
+                        if let Some(old_path) = rename_map.get(path) {
+                            let interim = repo
+                                .find_tree(oid)?
+                                .expect("hydrated tree should always be findable");
+                            interim.remove(&repo, old_path)?
+                        } else {
+                            oid
+                        }
+                    }
+
                     // removed & InsertBefore => remove from remainder commit
                     (Some(_), None, SplitMode::InsertBefore) => {
                         remainder_tree.remove(&repo, path)?
                     }
 
-                    // added => remove from remainder commit
+                    // added => remove from remainder commit; for renames, also restore the
+                    // original path from the parent tree so the remainder accurately reflects
+                    // only the non-extracted changes
                     (None, Some(_), SplitMode::InsertAfter)
                     | (None, Some(_), SplitMode::DetachAfter)
-                    | (None, Some(_), SplitMode::Discard) => remainder_tree.remove(&repo, path)?,
+                    | (None, Some(_), SplitMode::Discard) => {
+                        let oid = remainder_tree.remove(&repo, path)?;
+                        if let Some(old_path) = rename_map.get(path) {
+                            if let Some(old_entry) = parent_tree.get_path(old_path)? {
+                                let interim = repo
+                                    .find_tree(oid)?
+                                    .expect("hydrated tree should always be findable");
+                                interim.add_or_replace(&repo, old_path, &old_entry)?
+                            } else {
+                                oid
+                            }
+                        } else {
+                            oid
+                        }
+                    }
 
                     // deleted or modified => replace w/ parent content in split commit
                     (Some(parent_entry), _, _) => {
@@ -489,12 +553,16 @@ pub fn split(
         } else {
             (&remainder_tree, &target_tree)
         };
-        let diff = repo.get_diff_between_trees(
+        let mut diff = repo.get_diff_between_trees(
             effects,
             Some(old_tree),
             new_tree,
             0, // we don't care about the context here
         )?;
+        // Enable rename detection so that a pure rename shows as one file
+        // changed with 0 insertions/deletions rather than two separate
+        // add/delete entries.
+        diff.find_similar()?;
 
         summarize_diff_for_temporary_commit(&diff)?
     };

git-branchless/tests/test_split.rs

@@ -238,6 +238,73 @@ fn test_split_deleted_file() -> eyre::Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_split_renamed_file() -> eyre::Result<()> {
+    let git = make_git()?;
+    git.init_repo()?;
+    git.detach_head()?;
+
+    git.commit_file("test1", 1)?;
+
+    git.run(&["mv", "test1.txt", "test1-renamed.txt"])?;
+    git.write_file_txt("test2", "new contents")?;
+    git.run(&["add", "."])?;
+    git.run(&["commit", "-m", "first commit"])?;
+
+    {
+        let (stdout, _stderr) = git.branchless("smartlog", &[])?;
+        insta::assert_snapshot!(stdout, @r###"
+            O f777ecc (master) create initial.txt
+            |
+            o 62fc20d create test1.txt
+            |
+            @ d5713a5 first commit
+        "###);
+    }
+
+    {
+        let (stdout, _stderr) = git.run(&["show", "--pretty=format:", "--stat", "HEAD"])?;
+        insta::assert_snapshot!(&stdout, @"
+            test1.txt => test1-renamed.txt | 0
+            test2.txt                      | 1 +
+            2 files changed, 1 insertion(+)
+        ");
+    }
+
+    {
+        let (stdout, _stderr) = git.branchless("split", &["HEAD", "test1-renamed.txt"])?;
+        insta::assert_snapshot!(&stdout, @r###"
+            branchless: running command: <git-executable> checkout 495b4c09b4cc1755847ba0fd42c903f9c7eecc00 --
+            Nothing to restack.
+            O f777ecc (master) create initial.txt
+            |
+            o 62fc20d create test1.txt
+            |
+            @ 495b4c0 first commit
+            |
+            o ca4a140 temp(split): test1-renamed.txt (0)
+        "###);
+    }
+
+    {
+        git.branchless("next", &[])?;
+
+        let (stdout, _stderr) = git.run(&["show", "--pretty=format:", "--stat", "HEAD~"])?;
+        insta::assert_snapshot!(&stdout, @"
+            test2.txt | 1 +
+            1 file changed, 1 insertion(+)
+        ");
+
+        let (stdout, _stderr) = git.run(&["show", "--pretty=format:", "--stat", "HEAD"])?;
+        insta::assert_snapshot!(&stdout, @"
+            test1.txt => test1-renamed.txt | 0
+            1 file changed, 0 insertions(+), 0 deletions(-)
+        ");
+    }
+
+    Ok(())
+}
+
 #[test]
 fn test_split_multiple_files() -> eyre::Result<()> {
     let git = make_git()?;