2011-08-04 12:39:11 +02:00
|
|
|
#ifndef SEQUENCER_H
|
|
|
|
#define SEQUENCER_H
|
|
|
|
|
2018-08-15 19:54:05 +02:00
|
|
|
#include "cache.h"
|
|
|
|
#include "strbuf.h"
|
|
|
|
|
|
|
|
struct commit;
|
|
|
|
|
2018-01-24 13:34:22 +01:00
|
|
|
const char *git_path_commit_editmsg(void);
|
2016-10-14 15:17:12 +02:00
|
|
|
const char *git_path_seq_dir(void);
|
2011-08-04 12:39:11 +02:00
|
|
|
|
2013-02-12 11:17:35 +01:00
|
|
|
#define APPEND_SIGNOFF_DEDUP (1u << 0)
|
|
|
|
|
2012-01-11 19:15:57 +01:00
|
|
|
enum replay_action {
|
|
|
|
REPLAY_REVERT,
|
2017-01-02 16:26:28 +01:00
|
|
|
REPLAY_PICK,
|
|
|
|
REPLAY_INTERACTIVE_REBASE
|
2012-01-11 19:15:57 +01:00
|
|
|
};
|
|
|
|
|
2017-12-13 12:46:21 +01:00
|
|
|
enum commit_msg_cleanup_mode {
|
|
|
|
COMMIT_MSG_CLEANUP_SPACE,
|
|
|
|
COMMIT_MSG_CLEANUP_NONE,
|
|
|
|
COMMIT_MSG_CLEANUP_SCISSORS,
|
|
|
|
COMMIT_MSG_CLEANUP_ALL
|
|
|
|
};
|
|
|
|
|
2012-01-11 19:15:57 +01:00
|
|
|
struct replay_opts {
|
|
|
|
enum replay_action action;
|
|
|
|
|
|
|
|
/* Boolean options */
|
|
|
|
int edit;
|
|
|
|
int record_origin;
|
|
|
|
int no_commit;
|
|
|
|
int signoff;
|
|
|
|
int allow_ff;
|
|
|
|
int allow_rerere_auto;
|
2012-04-11 22:21:53 +02:00
|
|
|
int allow_empty;
|
2012-08-02 12:38:51 +02:00
|
|
|
int allow_empty_message;
|
git-cherry-pick: Add keep-redundant-commits option
The git-cherry-pick --allow-empty command by default only preserves empty
commits that were originally empty, i.e only those commits for which
<commit>^{tree} and <commit>^^{tree} are equal. By default commits which are
non-empty, but were made empty by the inclusion of a prior commit on the current
history are filtered out. This option allows us to override that behavior and
include redundant commits as empty commits in the change history.
Note that this patch changes the default behavior of git cherry-pick slightly.
Prior to this patch all commits in a cherry-pick sequence were applied and git
commit was run. The implication here was that, if a commit was redundant, and
the commit did not trigger the fast forward logic, the git commit operation, and
therefore the git cherry-pick operation would fail, displaying the cherry pick
advice (i.e. run git commit --allow-empty). With this patch however, such
redundant commits are automatically skipped without stopping, unless
--keep-redundant-commits is specified, in which case, they are automatically
applied as empty commits.
Signed-off-by: Neil Horman <nhorman@tuxdriver.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-04-20 16:36:15 +02:00
|
|
|
int keep_redundant_commits;
|
2017-01-02 16:26:53 +01:00
|
|
|
int verbose;
|
2012-01-11 19:15:57 +01:00
|
|
|
|
|
|
|
int mainline;
|
|
|
|
|
2016-10-21 14:24:13 +02:00
|
|
|
char *gpg_sign;
|
2017-12-13 12:46:21 +01:00
|
|
|
enum commit_msg_cleanup_mode default_msg_cleanup;
|
2014-01-24 01:50:58 +01:00
|
|
|
|
2012-01-11 19:15:57 +01:00
|
|
|
/* Merge strategy */
|
2016-10-21 14:24:13 +02:00
|
|
|
char *strategy;
|
|
|
|
char **xopts;
|
2012-01-11 19:15:57 +01:00
|
|
|
size_t xopts_nr, xopts_alloc;
|
|
|
|
|
2018-04-27 22:48:21 +02:00
|
|
|
/* Used by fixup/squash */
|
|
|
|
struct strbuf current_fixups;
|
|
|
|
int current_fixup_count;
|
|
|
|
|
sequencer: learn about the special "fake root commit" handling
When an interactive rebase wants to recreate a root commit, it
- first creates a new, empty root commit,
- checks it out,
- converts the next `pick` command so that it amends the empty root
commit
Introduce support in the sequencer to handle such an empty root commit,
by looking for the file <GIT_DIR>/rebase-merge/squash-onto; if it exists
and contains a commit name, the sequencer will compare the HEAD to said
root commit, and if identical, a new root commit will be created.
While converting scripted code into proper, portable C, we also do away
with the old "amend with an empty commit message, then cherry-pick
without committing, then amend again" dance and replace it with code
that uses the internal API properly to do exactly what we want: create a
new root commit.
To keep the implementation simple, we always spawn `git commit` to create
new root commits.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-05-04 01:01:17 +02:00
|
|
|
/* placeholder commit for -i --root */
|
|
|
|
struct object_id squash_onto;
|
|
|
|
int have_squash_onto;
|
|
|
|
|
2012-01-11 19:15:57 +01:00
|
|
|
/* Only used by REPLAY_NONE */
|
|
|
|
struct rev_info *revs;
|
|
|
|
};
|
2018-04-27 22:48:21 +02:00
|
|
|
#define REPLAY_OPTS_INIT { .action = -1, .current_fixups = STRBUF_INIT }
|
2012-01-11 19:15:57 +01:00
|
|
|
|
2017-12-13 12:46:21 +01:00
|
|
|
/* Call this to setup defaults before parsing command line options */
|
|
|
|
void sequencer_init_config(struct replay_opts *opts);
|
2012-01-11 19:15:57 +01:00
|
|
|
int sequencer_pick_revisions(struct replay_opts *opts);
|
2016-10-21 14:24:55 +02:00
|
|
|
int sequencer_continue(struct replay_opts *opts);
|
|
|
|
int sequencer_rollback(struct replay_opts *opts);
|
|
|
|
int sequencer_remove_state(struct replay_opts *opts);
|
2012-01-11 19:15:57 +01:00
|
|
|
|
2017-12-05 18:52:32 +01:00
|
|
|
#define TODO_LIST_KEEP_EMPTY (1U << 0)
|
|
|
|
#define TODO_LIST_SHORTEN_IDS (1U << 1)
|
2017-12-05 18:52:34 +01:00
|
|
|
#define TODO_LIST_ABBREVIATE_CMDS (1U << 2)
|
2018-04-25 14:29:03 +02:00
|
|
|
#define TODO_LIST_REBASE_MERGES (1U << 3)
|
rebase -i: introduce --rebase-merges=[no-]rebase-cousins
When running `git rebase --rebase-merges` non-interactively with an
ancestor of HEAD as <upstream> (or leaving the todo list unmodified),
we would ideally recreate the exact same commits as before the rebase.
However, if there are commits in the commit range <upstream>.. that do not
have <upstream> as direct ancestor (i.e. if `git log <upstream>..` would
show commits that are omitted by `git log --ancestry-path <upstream>..`),
this is currently not the case: we would turn them into commits that have
<upstream> as direct ancestor.
Let's illustrate that with a diagram:
C
/ \
A - B - E - F
\ /
D
Currently, after running `git rebase -i --rebase-merges B`, the new branch
structure would be (pay particular attention to the commit `D`):
--- C' --
/ \
A - B ------ E' - F'
\ /
D'
This is not really preserving the branch topology from before! The
reason is that the commit `D` does not have `B` as ancestor, and
therefore it gets rebased onto `B`.
This is unintuitive behavior. Even worse, when recreating branch
structure, most use cases would appear to want cousins *not* to be
rebased onto the new base commit. For example, Git for Windows (the
heaviest user of the Git garden shears, which served as the blueprint
for --rebase-merges) frequently merges branches from `next` early, and
these branches certainly do *not* want to be rebased. In the example
above, the desired outcome would look like this:
--- C' --
/ \
A - B ------ E' - F'
\ /
-- D' --
Let's introduce the term "cousins" for such commits ("D" in the
example), and let's not rebase them by default. For hypothetical
use cases where cousins *do* need to be rebased, `git rebase
--rebase=merges=rebase-cousins` needs to be used.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-25 14:29:40 +02:00
|
|
|
/*
|
|
|
|
* When rebasing merges, commits that do have the base commit as ancestor
|
|
|
|
* ("cousins") are *not* rebased onto the new base by default. If those
|
|
|
|
* commits should be rebased onto the new base, this flag needs to be passed.
|
|
|
|
*/
|
|
|
|
#define TODO_LIST_REBASE_COUSINS (1U << 4)
|
2017-12-05 18:52:32 +01:00
|
|
|
int sequencer_make_script(FILE *out, int argc, const char **argv,
|
|
|
|
unsigned flags);
|
2017-07-14 16:44:58 +02:00
|
|
|
|
2017-12-05 18:52:33 +01:00
|
|
|
int sequencer_add_exec_commands(const char *command);
|
2017-12-05 18:52:32 +01:00
|
|
|
int transform_todos(unsigned flags);
|
2017-07-14 16:45:21 +02:00
|
|
|
int check_todo_list(void);
|
2017-07-14 16:45:25 +02:00
|
|
|
int skip_unnecessary_picks(void);
|
2017-07-14 16:45:31 +02:00
|
|
|
int rearrange_squash(void);
|
2017-07-14 16:45:11 +02:00
|
|
|
|
2012-09-14 08:52:03 +02:00
|
|
|
extern const char sign_off_header[];
|
|
|
|
|
2018-08-23 02:50:51 +02:00
|
|
|
/*
|
|
|
|
* Append a signoff to the commit message in "msgbuf". The ignore_footer
|
|
|
|
* parameter specifies the number of bytes at the end of msgbuf that should
|
|
|
|
* not be considered at all. I.e., they are not checked for existing trailers,
|
|
|
|
* and the new signoff will be spliced into the buffer before those bytes.
|
|
|
|
*/
|
|
|
|
void append_signoff(struct strbuf *msgbuf, size_t ignore_footer, unsigned flag);
|
|
|
|
|
2014-10-24 20:34:59 +02:00
|
|
|
void append_conflicts_hint(struct strbuf *msgbuf);
|
2017-11-10 12:09:42 +01:00
|
|
|
int message_is_empty(const struct strbuf *sb,
|
|
|
|
enum commit_msg_cleanup_mode cleanup_mode);
|
|
|
|
int template_untouched(const struct strbuf *sb, const char *template_file,
|
|
|
|
enum commit_msg_cleanup_mode cleanup_mode);
|
2017-11-17 12:34:47 +01:00
|
|
|
int update_head_with_reflog(const struct commit *old_head,
|
|
|
|
const struct object_id *new_head,
|
|
|
|
const char *action, const struct strbuf *msg,
|
|
|
|
struct strbuf *err);
|
2017-11-17 12:34:48 +01:00
|
|
|
void commit_post_rewrite(const struct commit *current_head,
|
|
|
|
const struct object_id *new_head);
|
2012-09-14 08:52:03 +02:00
|
|
|
|
2017-11-24 12:07:54 +01:00
|
|
|
#define SUMMARY_INITIAL_COMMIT (1 << 0)
|
|
|
|
#define SUMMARY_SHOW_AUTHOR_DATE (1 << 1)
|
|
|
|
void print_commit_summary(const char *prefix, const struct object_id *oid,
|
|
|
|
unsigned int flags);
|
2011-08-04 12:39:11 +02:00
|
|
|
#endif
|