feat(split): add --discard flag

Author: claytonrcarter

git-branchless-opts/src/lib.rs

@@ -661,9 +661,13 @@ pub enum Command {
         files: Vec<String>,
 
         /// Restack any descendents onto the split commit, not the extracted commit.
-        #[clap(action, short = 'd', long = "detach")]
+        #[clap(action, short = 'd', long)]
         detach: bool,
 
+        /// After extracting the changes, don't recommit them.
+        #[clap(action, short = 'D', long = "discard", conflicts_with("detach"))]
+        discard: bool,
+
         /// Options for resolving revset expressions.
         #[clap(flatten)]
         resolve_revset_options: ResolveRevsetOptions,

git-branchless/src/commands/mod.rs

@@ -182,6 +182,7 @@ fn command_main(ctx: CommandContext, opts: Opts) -> EyreExitOr<()> {
 
         Command::Split {
             detach,
+            discard,
             files,
             resolve_revset_options,
             revset,
@@ -192,6 +193,7 @@ fn command_main(ctx: CommandContext, opts: Opts) -> EyreExitOr<()> {
             &resolve_revset_options,
             files,
             detach,
+            discard,
             &move_options,
             &git_run_info,
         )?,

git-branchless/src/commands/split.rs

@@ -42,6 +42,7 @@ pub fn split(
     resolve_revset_options: &ResolveRevsetOptions,
     files_to_extract: Vec<String>,
     detach: bool,
+    discard: bool,
     move_options: &MoveOptions,
     git_run_info: &GitRunInfo,
 ) -> EyreExitOr<()> {
@@ -248,46 +249,57 @@ pub fn split(
         return Ok(Err(ExitCode(1)));
     };
 
-    let extracted_tree = repo.cherry_pick_fast(
-        &commit_to_split,
-        &split_commit,
-        &CherryPickFastOptions {
-            reuse_parent_tree_if_possible: true,
-        },
-    )?;
-    let extracted_commit_oid = repo.create_commit(
-        None,
-        &commit_to_split.get_author(),
-        &commit_to_split.get_committer(),
-        format!("temp(split): {message}").as_str(),
-        &extracted_tree,
-        vec![&split_commit],
-    )?;
-
-    // see git-branchless/src/commands/amend.rs:172
-    // TODO maybe this should happen after we've confirmed the rebase has succeeded
-    mark_commit_reachable(&repo, extracted_commit_oid)
-        .wrap_err("Marking commit as reachable for GC purposes.")?;
     event_log_db.add_events(vec![Event::RewriteEvent {
         timestamp: now.duration_since(UNIX_EPOCH)?.as_secs_f64(),
         event_tx_id,
         old_commit_oid: MaybeZeroOid::NonZero(commit_to_split_oid),
         new_commit_oid: MaybeZeroOid::NonZero(split_commit_oid),
     }])?;
-    event_log_db.add_events(vec![Event::CommitEvent {
-        timestamp: now.duration_since(UNIX_EPOCH)?.as_secs_f64(),
-        event_tx_id,
-        commit_oid: extracted_commit_oid,
-    }])?;
+
+    let extracted_commit_oid = if discard {
+        None
+    } else {
+        let extracted_tree = repo.cherry_pick_fast(
+            &commit_to_split,
+            &split_commit,
+            &CherryPickFastOptions {
+                reuse_parent_tree_if_possible: true,
+            },
+        )?;
+        let extracted_commit_oid = repo.create_commit(
+            None,
+            &commit_to_split.get_author(),
+            &commit_to_split.get_committer(),
+            format!("temp(split): {message}").as_str(),
+            &extracted_tree,
+            vec![&split_commit],
+        )?;
+
+        // see git-branchless/src/commands/amend.rs:172
+        // TODO maybe this should happen after we've confirmed the rebase has succeeded
+        mark_commit_reachable(&repo, extracted_commit_oid)
+            .wrap_err("Marking commit as reachable for GC purposes.")?;
+
+        event_log_db.add_events(vec![Event::CommitEvent {
+            timestamp: now.duration_since(UNIX_EPOCH)?.as_secs_f64(),
+            event_tx_id,
+            commit_oid: extracted_commit_oid,
+        }])?;
+
+        Some(extracted_commit_oid)
+    };
 
     // push the new commits into the dag for the rebase planner
     dag.sync_from_oids(
         effects,
         &repo,
         CommitSet::empty(),
-        vec![split_commit_oid, extracted_commit_oid]
-            .into_iter()
-            .collect(),
+        match extracted_commit_oid {
+            None => CommitSet::from(split_commit_oid),
+            Some(extracted_commit_oid) => vec![split_commit_oid, extracted_commit_oid]
+                .into_iter()
+                .collect(),
+        },
     )?;
 
     let head_info = repo.get_head_info()?;
@@ -297,11 +309,11 @@ pub fn split(
         ResolvedReferenceInfo {
             oid: Some(oid),
             reference_name: Some(_),
-        } if oid == commit_to_split_oid && !detach => (
+        } if oid == commit_to_split_oid && !detach && extracted_commit_oid.is_some() => (
             None,
             vec![(
                 commit_to_split_oid,
-                MaybeZeroOid::NonZero(extracted_commit_oid),
+                MaybeZeroOid::NonZero(extracted_commit_oid.unwrap()),
             )],
         ),
 
@@ -353,10 +365,11 @@ pub fn split(
     let mut builder = RebasePlanBuilder::new(&dag, permissions);
     let children = dag.query_children(CommitSet::from(commit_to_split_oid))?;
     for child in dag.commit_set_to_vec(&children)? {
-        if detach {
-            builder.move_subtree(child, vec![split_commit_oid])?;
-        } else {
-            builder.move_subtree(child, vec![extracted_commit_oid])?;
+        match (detach, extracted_commit_oid) {
+            (_, None) | (true, Some(_)) => builder.move_subtree(child, vec![split_commit_oid])?,
+            (_, Some(extracted_commit_oid)) => {
+                builder.move_subtree(child, vec![extracted_commit_oid])?
+            }
         }
     }
     let rebase_plan = builder.build(effects, &pool, &repo_pool)?;

git-branchless/tests/test_split.rs

@@ -502,6 +502,59 @@ fn test_split_detach() -> eyre::Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_split_discard() -> eyre::Result<()> {
+    let git = make_git()?;
+    git.init_repo()?;
+    git.detach_head()?;
+
+    git.write_file_txt("test1", "contents1")?;
+    git.write_file_txt("test2", "contents2")?;
+    git.write_file_txt("test3", "contents3")?;
+    git.run(&["add", "."])?;
+    git.run(&["commit", "-m", "first commit"])?;
+
+    git.commit_file("test3", 1)?;
+
+    {
+        let (stdout, _stderr) = git.branchless("smartlog", &[])?;
+        insta::assert_snapshot!(stdout, @r###"
+        O f777ecc (master) create initial.txt
+        |
+        o e48cdc5 first commit
+        |
+        @ 3d220e0 create test3.txt
+        "###);
+    }
+
+    {
+        let (stdout, _stderr) = git.branchless("split", &["HEAD~", "test2.txt", "--discard"])?;
+        insta::assert_snapshot!(&stdout, @r###"
+            Attempting rebase in-memory...
+            [1/1] Committed as: f88fbe5 create test3.txt
+            branchless: processing 1 rewritten commit
+            branchless: running command: <git-executable> checkout f88fbe5901493ffe1c669cdb8aa5f056dc0bb605
+            In-memory rebase succeeded.
+            O f777ecc (master) create initial.txt
+            |
+            o 2932db7 first commit
+            |
+            @ f88fbe5 create test3.txt
+        "###);
+    }
+
+    {
+        let (stdout, _stderr) = git.run(&["show", "--pretty=format:", "--stat", "HEAD~"])?;
+        insta::assert_snapshot!(&stdout, @"
+            test1.txt | 1 +
+            test3.txt | 1 +
+            2 files changed, 2 insertions(+)
+        ");
+    }
+
+    Ok(())
+}
+
 #[test]
 fn test_split_undo_works() -> eyre::Result<()> {
     let git = make_git()?;