sequencer: extract revert message formatting into shared function

The logic for formatting revert commit messages (handling "Revert" and
"Reapply" cases, appending "This reverts commit <ref>.", and handling
merge-parent references) currently lives inline in do_pick_commit().
The upcoming replay --revert mode needs to reuse this logic.

Extract all of this into a new sequencer_format_revert_message()
function. The function takes a repository, the subject line, commit,
parent, a use_commit_reference flag, and the output strbuf. It handles
both regular reverts ("Revert "<subject>"") and revert-of-revert cases
("Reapply "<subject>""), and uses refer_to_commit() internally to
format the commit reference.

Update refer_to_commit() to take a struct repository parameter instead
of relying on the_repository, and a bool instead of reading from
replay_opts directly. This makes it usable from the new shared function
without pulling in sequencer-specific state.

Signed-off-by: Siddharth Asthana <siddharthasthana31@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/sequencer.c b/sequencer.c
index 1f492f8460e23765f0dd04a25d89f0966b24b115..403c32e00da0e526de295ac204a29abb8045f677 100644 (file)
--- a/sequencer.c
+++ b/sequencer.c
@@ -2198,15 +2198,16 @@ static int should_edit(struct replay_opts *opts) {
        return opts->edit;
 }
 
-static void refer_to_commit(struct replay_opts *opts,
-                           struct strbuf *msgbuf, struct commit *commit)
+static void refer_to_commit(struct repository *r, struct strbuf *msgbuf,
+                           const struct commit *commit,
+                           bool use_commit_reference)
 {
-       if (opts->commit_use_reference) {
+       if (use_commit_reference) {
                struct pretty_print_context ctx = {
                        .abbrev = DEFAULT_ABBREV,
                        .date_mode.type = DATE_SHORT,
                };
-               repo_format_commit_message(the_repository, commit,
+               repo_format_commit_message(r, commit,
                                           "%h (%s, %ad)", msgbuf, &ctx);
        } else {
                strbuf_addstr(msgbuf, oid_to_hex(&commit->object.oid));
@@ -2356,38 +2357,14 @@ static int do_pick_commit(struct repository *r,
         */
 
        if (command == TODO_REVERT) {
-               const char *orig_subject;
-
                base = commit;
                base_label = msg.label;
                next = parent;
                next_label = msg.parent_label;
-               if (opts->commit_use_reference) {
-                       strbuf_commented_addf(&ctx->message, comment_line_str,
-                               "*** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
-               } else if (skip_prefix(msg.subject, "Revert \"", &orig_subject) &&
-                          /*
-                           * We don't touch pre-existing repeated reverts, because
-                           * theoretically these can be nested arbitrarily deeply,
-                           * thus requiring excessive complexity to deal with.
-                           */
-                          !starts_with(orig_subject, "Revert \"")) {
-                       strbuf_addstr(&ctx->message, "Reapply \"");
-                       strbuf_addstr(&ctx->message, orig_subject);
-                       strbuf_addstr(&ctx->message, "\n");
-               } else {
-                       strbuf_addstr(&ctx->message, "Revert \"");
-                       strbuf_addstr(&ctx->message, msg.subject);
-                       strbuf_addstr(&ctx->message, "\"\n");
-               }
-               strbuf_addstr(&ctx->message, "\nThis reverts commit ");
-               refer_to_commit(opts, &ctx->message, commit);
-
-               if (commit->parents && commit->parents->next) {
-                       strbuf_addstr(&ctx->message, ", reversing\nchanges made to ");
-                       refer_to_commit(opts, &ctx->message, parent);
-               }
-               strbuf_addstr(&ctx->message, ".\n");
+               sequencer_format_revert_message(r, msg.subject, commit,
+                                               parent,
+                                               opts->commit_use_reference,
+                                               &ctx->message);
        } else {
                const char *p;
 
@@ -5572,6 +5549,43 @@ out:
        return res;
 }
 
+void sequencer_format_revert_message(struct repository *r,
+                                    const char *subject,
+                                    const struct commit *commit,
+                                    const struct commit *parent,
+                                    bool use_commit_reference,
+                                    struct strbuf *message)
+{
+       const char *orig_subject;
+
+       if (use_commit_reference) {
+               strbuf_commented_addf(message, comment_line_str,
+                                     "*** SAY WHY WE ARE REVERTING ON THE TITLE LINE ***");
+       } else if (skip_prefix(subject, "Revert \"", &orig_subject) &&
+                  /*
+                   * We don't touch pre-existing repeated reverts, because
+                   * theoretically these can be nested arbitrarily deeply,
+                   * thus requiring excessive complexity to deal with.
+                   */
+                  !starts_with(orig_subject, "Revert \"")) {
+               strbuf_addstr(message, "Reapply \"");
+               strbuf_addstr(message, orig_subject);
+               strbuf_addstr(message, "\n");
+       } else {
+               strbuf_addstr(message, "Revert \"");
+               strbuf_addstr(message, subject);
+               strbuf_addstr(message, "\"\n");
+       }
+       strbuf_addstr(message, "\nThis reverts commit ");
+       refer_to_commit(r, message, commit, use_commit_reference);
+
+       if (commit->parents && commit->parents->next) {
+               strbuf_addstr(message, ", reversing\nchanges made to ");
+               refer_to_commit(r, message, parent, use_commit_reference);
+       }
+       strbuf_addstr(message, ".\n");
+}
+
 void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag)
 {
        unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;

diff --git a/sequencer.h b/sequencer.h
index 719684c8a9fb2e5ab10464e3edf1726097fe33c8..56cd50233aa310bf1716cc10a78c8e2db6115e33 100644 (file)
--- a/sequencer.h
+++ b/sequencer.h
@@ -271,4 +271,17 @@ int sequencer_determine_whence(struct repository *r, enum commit_whence *whence)
  */
 int sequencer_get_update_refs_state(const char *wt_dir, struct string_list *refs);
 
+/*
+ * Format a revert commit message with appropriate 'Revert "<subject>"' or
+ * 'Reapply "<subject>"' prefix and 'This reverts commit <ref>.' body.
+ * When use_commit_reference is set, <ref> is an abbreviated hash with
+ * subject and date; otherwise the full hex hash is used.
+ */
+void sequencer_format_revert_message(struct repository *r,
+                                    const char *subject,
+                                    const struct commit *commit,
+                                    const struct commit *parent,
+                                    bool use_commit_reference,
+                                    struct strbuf *message);
+
 #endif /* SEQUENCER_H */