SYNOPSIS
--------
[verse]
-(EXPERIMENTAL!) 'git replay' ([--contained] --onto <newbase> | --advance <branch>) <revision-range>...
+(EXPERIMENTAL!) 'git replay' ([--contained] --onto <newbase> | --advance <branch>) [--ref-action[=<mode>]] <revision-range>...
DESCRIPTION
-----------
Takes ranges of commits and replays them onto a new location. Leaves
-the working tree and the index untouched, and updates no references.
-The output of this command is meant to be used as input to
-`git update-ref --stdin`, which would update the relevant branches
+the working tree and the index untouched. By default, updates the
+relevant references using an atomic transaction (all refs update or
+none). Use `--ref-action=print` to avoid automatic ref updates and
+instead get update commands that can be piped to `git update-ref --stdin`
(see the OUTPUT section below).
THIS COMMAND IS EXPERIMENTAL. THE BEHAVIOR MAY CHANGE.
Starting point at which to create the new commits. May be any
valid commit, and not just an existing branch name.
+
-When `--onto` is specified, the update-ref command(s) in the output will
-update the branch(es) in the revision range to point at the new
-commits, similar to the way how `git rebase --update-refs` updates
-multiple branches in the affected range.
+When `--onto` is specified, the branch(es) in the revision range will be
+updated to point at the new commits, similar to the way `git rebase --update-refs`
+updates multiple branches in the affected range.
--advance <branch>::
Starting point at which to create the new commits; must be a
branch name.
+
-When `--advance` is specified, the update-ref command(s) in the output
-will update the branch passed as an argument to `--advance` to point at
-the new commits (in other words, this mimics a cherry-pick operation).
+The history is replayed on top of the <branch> and <branch> is updated to
+point at the tip of the resulting history. This is different from `--onto`,
+which uses the target only as a starting point without updating it.
+
+--ref-action[=<mode>]::
+ Control how references are updated. The mode can be:
++
+--
+ * `update` (default): Update refs directly using an atomic transaction.
+ All refs are updated or none are (all-or-nothing behavior).
+ * `print`: Output update-ref commands for pipeline use. This is the
+ traditional behavior where output can be piped to `git update-ref --stdin`.
+--
<revision-range>::
Range of commits to replay. More than one <revision-range> can
OUTPUT
------
-When there are no conflicts, the output of this command is usable as
-input to `git update-ref --stdin`. It is of the form:
+By default, or with `--ref-action=update`, this command produces no output on
+success, as refs are updated directly using an atomic transaction.
+
+When using `--ref-action=print`, the output is usable as input to
+`git update-ref --stdin`. It is of the form:
update refs/heads/branch1 ${NEW_branch1_HASH} ${OLD_branch1_HASH}
update refs/heads/branch2 ${NEW_branch2_HASH} ${OLD_branch2_HASH}
------------
$ git replay --onto target origin/main..mybranch
+------------
+
+The refs are updated atomically and no output is produced on success.
+
+To see what would be updated without actually updating:
+
+------------
+$ git replay --ref-action=print --onto target origin/main..mybranch
update refs/heads/mybranch ${NEW_mybranch_HASH} ${OLD_mybranch_HASH}
------------
------------
$ git replay --advance target origin/main..mybranch
-update refs/heads/target ${NEW_target_HASH} ${OLD_target_HASH}
------------
Note that the first two examples replay the exact same commits and on
top of the exact same new base, they only differ in that the first
-provides instructions to make mybranch point at the new commits and
-the second provides instructions to make target point at them.
+updates mybranch to point at the new commits and the second updates
+target to point at them.
What if you have a stack of branches, one depending upon another, and
you'd really like to rebase the whole set?
------------
$ git replay --contained --onto origin/main origin/main..tipbranch
-update refs/heads/branch1 ${NEW_branch1_HASH} ${OLD_branch1_HASH}
-update refs/heads/branch2 ${NEW_branch2_HASH} ${OLD_branch2_HASH}
-update refs/heads/tipbranch ${NEW_tipbranch_HASH} ${OLD_tipbranch_HASH}
------------
+All three branches (`branch1`, `branch2`, and `tipbranch`) are updated
+atomically.
+
When calling `git replay`, one does not need to specify a range of
commits to replay using the syntax `A..B`; any range expression will
do:
------------
$ git replay --onto origin/main ^base branch1 branch2 branch3
-update refs/heads/branch1 ${NEW_branch1_HASH} ${OLD_branch1_HASH}
-update refs/heads/branch2 ${NEW_branch2_HASH} ${OLD_branch2_HASH}
-update refs/heads/branch3 ${NEW_branch3_HASH} ${OLD_branch3_HASH}
------------
This will simultaneously rebase `branch1`, `branch2`, and `branch3`,
#include <oidset.h>
#include <tree.h>
+enum ref_action_mode {
+ REF_ACTION_UPDATE,
+ REF_ACTION_PRINT,
+};
+
static const char *short_commit_name(struct repository *repo,
struct commit *commit)
{
return create_commit(repo, result->tree, pickme, replayed_base);
}
+static enum ref_action_mode parse_ref_action_mode(const char *ref_action, const char *source)
+{
+ if (!ref_action || !strcmp(ref_action, "update"))
+ return REF_ACTION_UPDATE;
+ if (!strcmp(ref_action, "print"))
+ return REF_ACTION_PRINT;
+ die(_("invalid %s value: '%s'"), source, ref_action);
+}
+
+static int handle_ref_update(enum ref_action_mode mode,
+ struct ref_transaction *transaction,
+ const char *refname,
+ const struct object_id *new_oid,
+ const struct object_id *old_oid,
+ const char *reflog_msg,
+ struct strbuf *err)
+{
+ switch (mode) {
+ case REF_ACTION_PRINT:
+ printf("update %s %s %s\n",
+ refname,
+ oid_to_hex(new_oid),
+ oid_to_hex(old_oid));
+ return 0;
+ case REF_ACTION_UPDATE:
+ return ref_transaction_update(transaction, refname, new_oid, old_oid,
+ NULL, NULL, 0, reflog_msg, err);
+ default:
+ BUG("unknown ref_action_mode %d", mode);
+ }
+}
+
int cmd_replay(int argc,
const char **argv,
const char *prefix,
struct commit *onto = NULL;
const char *onto_name = NULL;
int contained = 0;
+ const char *ref_action = NULL;
+ enum ref_action_mode ref_mode = REF_ACTION_UPDATE;
struct rev_info revs;
struct commit *last_commit = NULL;
struct merge_result result;
struct strset *update_refs = NULL;
kh_oid_map_t *replayed_commits;
+ struct ref_transaction *transaction = NULL;
+ struct strbuf transaction_err = STRBUF_INIT;
+ struct strbuf reflog_msg = STRBUF_INIT;
int ret = 0;
- const char * const replay_usage[] = {
+ const char *const replay_usage[] = {
N_("(EXPERIMENTAL!) git replay "
"([--contained] --onto <newbase> | --advance <branch>) "
- "<revision-range>..."),
+ "[--ref-action[=<mode>]] <revision-range>..."),
NULL
};
struct option replay_options[] = {
N_("replay onto given commit")),
OPT_BOOL(0, "contained", &contained,
N_("advance all branches contained in revision-range")),
+ OPT_STRING(0, "ref-action", &ref_action,
+ N_("mode"),
+ N_("control ref update behavior (update|print)")),
OPT_END()
};
die_for_incompatible_opt2(!!advance_name_opt, "--advance",
contained, "--contained");
+ /* Parse ref action mode */
+ if (ref_action)
+ ref_mode = parse_ref_action_mode(ref_action, "--ref-action");
+
advance_name = xstrdup_or_null(advance_name_opt);
repo_init_revisions(repo, &revs, prefix);
determine_replay_mode(repo, &revs.cmdline, onto_name, &advance_name,
&onto, &update_refs);
+ /* Build reflog message */
+ if (advance_name_opt)
+ strbuf_addf(&reflog_msg, "replay --advance %s", advance_name_opt);
+ else
+ strbuf_addf(&reflog_msg, "replay --onto %s",
+ oid_to_hex(&onto->object.oid));
+
+ /* Initialize ref transaction if using update mode */
+ if (ref_mode == REF_ACTION_UPDATE) {
+ transaction = ref_store_transaction_begin(get_main_ref_store(repo),
+ 0, &transaction_err);
+ if (!transaction) {
+ ret = error(_("failed to begin ref transaction: %s"),
+ transaction_err.buf);
+ goto cleanup;
+ }
+ }
+
if (!onto) /* FIXME: Should handle replaying down to root commit */
die("Replaying down to root commit is not supported yet!");
if (decoration->type == DECORATION_REF_LOCAL &&
(contained || strset_contains(update_refs,
decoration->name))) {
- printf("update %s %s %s\n",
- decoration->name,
- oid_to_hex(&last_commit->object.oid),
- oid_to_hex(&commit->object.oid));
+ if (handle_ref_update(ref_mode, transaction,
+ decoration->name,
+ &last_commit->object.oid,
+ &commit->object.oid,
+ reflog_msg.buf,
+ &transaction_err) < 0) {
+ ret = error(_("failed to update ref '%s': %s"),
+ decoration->name, transaction_err.buf);
+ goto cleanup;
+ }
}
decoration = decoration->next;
}
/* In --advance mode, advance the target ref */
if (result.clean == 1 && advance_name) {
- printf("update %s %s %s\n",
- advance_name,
- oid_to_hex(&last_commit->object.oid),
- oid_to_hex(&onto->object.oid));
+ if (handle_ref_update(ref_mode, transaction, advance_name,
+ &last_commit->object.oid,
+ &onto->object.oid,
+ reflog_msg.buf,
+ &transaction_err) < 0) {
+ ret = error(_("failed to update ref '%s': %s"),
+ advance_name, transaction_err.buf);
+ goto cleanup;
+ }
+ }
+
+ /* Commit the ref transaction if we have one */
+ if (transaction && result.clean == 1) {
+ if (ref_transaction_commit(transaction, &transaction_err)) {
+ ret = error(_("failed to commit ref transaction: %s"),
+ transaction_err.buf);
+ goto cleanup;
+ }
}
merge_finalize(&merge_opt, &result);
ret = result.clean;
cleanup:
+ if (transaction)
+ ref_transaction_free(transaction);
+ strbuf_release(&transaction_err);
+ strbuf_release(&reflog_msg);
release_revisions(&revs);
free(advance_name);
'
test_expect_success 'using replay to rebase two branches, one on top of other' '
- git replay --onto main topic1..topic2 >result &&
+ git replay --ref-action=print --onto main topic1..topic2 >result &&
test_line_count = 1 result &&
'
test_expect_success 'using replay on bare repo to rebase two branches, one on top of other' '
- git -C bare replay --onto main topic1..topic2 >result-bare &&
+ git -C bare replay --ref-action=print --onto main topic1..topic2 >result-bare &&
test_cmp expect result-bare
'
# 2nd field of result is refs/heads/main vs. refs/heads/topic2
# 4th field of result is hash for main instead of hash for topic2
- git replay --advance main topic1..topic2 >result &&
+ git replay --ref-action=print --advance main topic1..topic2 >result &&
test_line_count = 1 result &&
'
test_expect_success 'using replay on bare repo to perform basic cherry-pick' '
- git -C bare replay --advance main topic1..topic2 >result-bare &&
+ git -C bare replay --ref-action=print --advance main topic1..topic2 >result-bare &&
test_cmp expect result-bare
'
'
test_expect_success 'using replay to also rebase a contained branch' '
- git replay --contained --onto main main..topic3 >result &&
+ git replay --ref-action=print --contained --onto main main..topic3 >result &&
test_line_count = 2 result &&
cut -f 3 -d " " result >new-branch-tips &&
'
test_expect_success 'using replay on bare repo to also rebase a contained branch' '
- git -C bare replay --contained --onto main main..topic3 >result-bare &&
+ git -C bare replay --ref-action=print --contained --onto main main..topic3 >result-bare &&
test_cmp expect result-bare
'
test_expect_success 'using replay to rebase multiple divergent branches' '
- git replay --onto main ^topic1 topic2 topic4 >result &&
+ git replay --ref-action=print --onto main ^topic1 topic2 topic4 >result &&
test_line_count = 2 result &&
cut -f 3 -d " " result >new-branch-tips &&
'
test_expect_success 'using replay on bare repo to rebase multiple divergent branches, including contained ones' '
- git -C bare replay --contained --onto main ^main topic2 topic3 topic4 >result &&
+ git -C bare replay --ref-action=print --contained --onto main ^main topic2 topic3 topic4 >result &&
test_line_count = 4 result &&
cut -f 3 -d " " result >new-branch-tips &&
--onto rename-onto rename-onto..rename-from
'
+test_expect_success 'default atomic behavior updates refs directly' '
+ # Use a separate branch to avoid contaminating topic2 for later tests
+ git branch test-atomic topic2 &&
+ test_when_finished "git branch -D test-atomic" &&
+
+ # Test default atomic behavior (no output, refs updated)
+ git replay --onto main topic1..test-atomic >output &&
+ test_must_be_empty output &&
+
+ # Verify ref was updated
+ git log --format=%s test-atomic >actual &&
+ test_write_lines E D M L B A >expect &&
+ test_cmp expect actual &&
+
+ # Verify reflog message includes SHA of onto commit
+ git reflog test-atomic -1 --format=%gs >reflog-msg &&
+ ONTO_SHA=$(git rev-parse main) &&
+ echo "replay --onto $ONTO_SHA" >expect-reflog &&
+ test_cmp expect-reflog reflog-msg
+'
+
+test_expect_success 'atomic behavior in bare repository' '
+ # Store original state for cleanup
+ START=$(git -C bare rev-parse topic2) &&
+ test_when_finished "git -C bare update-ref refs/heads/topic2 $START" &&
+
+ # Test atomic updates work in bare repo
+ git -C bare replay --onto main topic1..topic2 >output &&
+ test_must_be_empty output &&
+
+ # Verify ref was updated in bare repo
+ git -C bare log --format=%s topic2 >actual &&
+ test_write_lines E D M L B A >expect &&
+ test_cmp expect actual
+'
+
+test_expect_success 'reflog message for --advance mode' '
+ # Store original state
+ START=$(git rev-parse main) &&
+ test_when_finished "git update-ref refs/heads/main $START" &&
+
+ # Test --advance mode reflog message
+ git replay --advance main topic1..topic2 >output &&
+ test_must_be_empty output &&
+
+ # Verify reflog message includes --advance and branch name
+ git reflog main -1 --format=%gs >reflog-msg &&
+ echo "replay --advance main" >expect-reflog &&
+ test_cmp expect-reflog reflog-msg
+'
+
test_done
projects / thirdparty / git.git / commitdiff
