feat(repo): Add AmendFastOptions::FromCommit

Existing `AmendFastOptions` only support amending from the working copy
or index, but we can't use either of these for implementing something
like `RebaseCommand::FixUp` because needs to use the entries from an
existing commit.

Author: claytonrcarter

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

@@ -419,7 +419,7 @@ pub enum CherryPickFastError {
 
 /// Options for `Repo::amend_fast`
 #[derive(Debug)]
-pub enum AmendFastOptions {
+pub enum AmendFastOptions<'repo> {
     /// Amend a set of paths from the current state of the working copy.
     FromWorkingCopy {
         /// The status entries for the files to amend.
@@ -430,14 +430,20 @@ pub enum AmendFastOptions {
         /// The paths to amend.
         paths: Vec<PathBuf>,
     },
+    /// Amend a set of paths from a different commit.
+    FromCommit {
+        /// The commit whose contents will be ammended.
+        commit: Commit<'repo>,
+    },
 }
 
-impl AmendFastOptions {
+impl<'repo> AmendFastOptions<'repo> {
     /// Returns whether there are any paths to be amended.
     pub fn is_empty(&self) -> bool {
         match &self {
             AmendFastOptions::FromIndex { paths } => paths.is_empty(),
             AmendFastOptions::FromWorkingCopy { status_entries } => status_entries.is_empty(),
+            AmendFastOptions::FromCommit { commit } => commit.is_empty(),
         }
     }
 }
@@ -1378,6 +1384,11 @@ impl Repo {
                         result.extend(entry.paths().iter().cloned());
                     }
                 }
+                AmendFastOptions::FromCommit { commit } => {
+                    if let Some(paths) = self.get_paths_touched_by_commit(commit)? {
+                        result.extend(paths.iter().cloned());
+                    }
+                }
             };
             result.into_iter().collect_vec()
         };
@@ -1431,6 +1442,27 @@ impl Repo {
                     })
                     .collect::<HashMap<_, _>>()
             }
+            AmendFastOptions::FromCommit { commit } => self
+                .get_paths_touched_by_commit(commit)?
+                .unwrap_or_default()
+                .iter()
+                .map(|path| {
+                    // FIXME This is just a stab in the dark bsed on the other
+                    // arms. I really have no idea what this is meant for or
+                    // supposed to be doing.
+                    match commit
+                        .get_tree()
+                        .expect("Could not get tree for commit")
+                        .get_path(path)
+                        .expect("Could not get tree entry for commit")
+                    {
+                        Some(entry) => {
+                            (path.clone(), Some((entry.get_oid(), entry.get_filemode())))
+                        }
+                        None => (path.clone(), None),
+                    }
+                })
+                .collect::<HashMap<_, _>>(),
         };
 
         // Merge the new path entries into the existing set of parent tree.
@@ -2411,6 +2443,127 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_amend_fast_from_commit() -> eyre::Result<()> {
+        let git = make_git()?;
+        git.init_repo()?;
+
+        git.run(&["checkout", "master"])?;
+        let initial_oid = git.commit_file_with_contents("initial", 2, "initial contents")?;
+        let second_oid = git.commit_file_with_contents("second", 3, "second contents")?;
+
+        let repo = git.get_repo()?;
+        let initial_commit = repo.find_commit_or_fail(initial_oid)?;
+        let second_commit = repo.find_commit_or_fail(second_oid)?;
+
+        let tree = initial_commit.get_tree()?;
+        insta::assert_debug_snapshot!(tree, @r###"
+        Tree {
+            inner: Tree {
+                id: 01deb7745d411223bbf6b9cb1abaeed451bb25a0,
+            },
+        }
+        "###);
+        insta::assert_debug_snapshot!(tree.inner.iter().map(|entry| (entry.name().unwrap().to_string(), entry.id().to_string())).collect_vec(), @r###"
+        [
+            (
+                "initial.txt",
+                "5c41c3d7e736911dbbd53d62c10292b9bc78f838",
+            ),
+        ]
+        "###);
+
+        let tree = repo.amend_fast(
+            &initial_commit,
+            &AmendFastOptions::FromCommit {
+                commit: second_commit,
+            },
+        )?;
+
+        insta::assert_debug_snapshot!(tree, @r###"
+        Tree {
+            inner: Tree {
+                id: cca737a0875ca64ba04a67a2aff58dfeb97ff275,
+            },
+        }
+        "###);
+        insta::assert_debug_snapshot!(tree.inner.iter().map(|entry| (entry.name().unwrap().to_string(), entry.id().to_string())).collect_vec(), @r###"
+        [
+            (
+                "initial.txt",
+                "5c41c3d7e736911dbbd53d62c10292b9bc78f838",
+            ),
+            (
+                "second.txt",
+                "034b69666691fbb00fdc6f0e8ae8596d9a8d26ab",
+            ),
+        ]
+        "###);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_amend_fast_from_distant_commit() -> eyre::Result<()> {
+        let git = make_git()?;
+        git.init_repo()?;
+
+        git.run(&["checkout", "master"])?;
+        let initial_oid = git.commit_file_with_contents("initial", 2, "initial contents")?;
+        let _second_oid = git.commit_file_with_contents("second", 3, "second contents")?;
+        let third_oid = git.commit_file_with_contents("third", 4, "third contents")?;
+
+        let repo = git.get_repo()?;
+        let initial_commit = repo.find_commit_or_fail(initial_oid)?;
+        let third_commit = repo.find_commit_or_fail(third_oid)?;
+
+        let tree = initial_commit.get_tree()?;
+        insta::assert_debug_snapshot!(tree, @r###"
+        Tree {
+            inner: Tree {
+                id: 01deb7745d411223bbf6b9cb1abaeed451bb25a0,
+            },
+        }
+        "###);
+        insta::assert_debug_snapshot!(tree.inner.iter().map(|entry| (entry.name().unwrap().to_string(), entry.id().to_string())).collect_vec(), @r###"
+        [
+            (
+                "initial.txt",
+                "5c41c3d7e736911dbbd53d62c10292b9bc78f838",
+            ),
+        ]
+        "###);
+
+        let tree = repo.amend_fast(
+            &initial_commit,
+            &AmendFastOptions::FromCommit {
+                commit: third_commit,
+            },
+        )?;
+
+        insta::assert_debug_snapshot!(tree, @r###"
+        Tree {
+            inner: Tree {
+                id: 76ac27e1486c6db934f6e10dc5f1c30f480f979a,
+            },
+        }
+        "###);
+        insta::assert_debug_snapshot!(tree.inner.iter().map(|entry| (entry.name().unwrap().to_string(), entry.id().to_string())).collect_vec(), @r###"
+        [
+            (
+                "initial.txt",
+                "5c41c3d7e736911dbbd53d62c10292b9bc78f838",
+            ),
+            (
+                "third.txt",
+                "175b41591c574329a8546b09c968345d0cddb4ed",
+            ),
+        ]
+        "###);
+
+        Ok(())
+    }
+
     #[test]
     fn test_branch_debug() -> eyre::Result<()> {
         let git = make_git()?;

git-branchless/src/commands/amend.rs

@@ -180,6 +180,9 @@ pub fn amend(
                 uncommitted_changes,
             )?;
         }
+        AmendFastOptions::FromCommit { .. } => {
+            unreachable!("BUG: AmendFastOptions::FromCommit should not have been constructed.")
+        }
     }
     Ok(ExitCode(0))
 }