2011-08-04 14:39:11 +04:00
|
|
|
#ifndef SEQUENCER_H
|
|
|
|
#define SEQUENCER_H
|
|
|
|
|
2018-08-15 20:54:05 +03:00
|
|
|
#include "cache.h"
|
|
|
|
#include "strbuf.h"
|
|
|
|
|
|
|
|
struct commit;
|
2018-11-10 08:48:56 +03:00
|
|
|
struct repository;
|
2018-08-15 20:54:05 +03:00
|
|
|
|
2018-01-24 15:34:22 +03:00
|
|
|
const char *git_path_commit_editmsg(void);
|
2016-10-14 16:17:12 +03:00
|
|
|
const char *git_path_seq_dir(void);
|
2018-08-10 19:51:28 +03:00
|
|
|
const char *rebase_path_todo(void);
|
2011-08-04 14:39:11 +04:00
|
|
|
|
2013-02-12 14:17:35 +04:00
|
|
|
#define APPEND_SIGNOFF_DEDUP (1u << 0)
|
|
|
|
|
2012-01-11 22:15:57 +04:00
|
|
|
enum replay_action {
|
|
|
|
REPLAY_REVERT,
|
2017-01-02 18:26:28 +03:00
|
|
|
REPLAY_PICK,
|
|
|
|
REPLAY_INTERACTIVE_REBASE
|
2012-01-11 22:15:57 +04:00
|
|
|
};
|
|
|
|
|
2017-12-13 14:46:21 +03: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 22:15:57 +04: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-12 00:21:53 +04:00
|
|
|
int allow_empty;
|
2012-08-02 14:38:51 +04: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 18:36:15 +04:00
|
|
|
int keep_redundant_commits;
|
2017-01-02 18:26:53 +03:00
|
|
|
int verbose;
|
git-rebase, sequencer: extend --quiet option for the interactive machinery
While 'quiet' and 'interactive' may sound like antonyms, the interactive
machinery actually has logic that implements several
interactive_rebase=implied cases (--exec, --keep-empty, --rebase-merges)
which won't pop up an editor. The rewrite of interactive rebase in C
added a quiet option, though it only turns stats off. Since we want to
make the interactive machinery also take over for git-rebase--merge, it
should fully implement the --quiet option.
git-rebase--interactive was already somewhat quieter than
git-rebase--merge and git-rebase--am, possibly because cherry-pick has
just traditionally been quieter. As such, we only drop a few
informational messages -- "Rebasing (n/m)" and "Successfully rebased..."
Also, for simplicity, remove the differences in how quiet and verbose
options were recorded. Having one be signalled by the presence of a
"verbose" file in the state_dir, while the other was signalled by the
contents of a "quiet" file was just weirdly inconsistent. (This
inconsistency pre-dated the rewrite into C.) Make them consistent by
having them both key off the presence of the file.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-12-11 19:11:36 +03:00
|
|
|
int quiet;
|
2018-12-10 22:04:58 +03:00
|
|
|
int reschedule_failed_exec;
|
2012-01-11 22:15:57 +04:00
|
|
|
|
|
|
|
int mainline;
|
|
|
|
|
2016-10-21 15:24:13 +03:00
|
|
|
char *gpg_sign;
|
2017-12-13 14:46:21 +03:00
|
|
|
enum commit_msg_cleanup_mode default_msg_cleanup;
|
2014-01-24 04:50:58 +04:00
|
|
|
|
2012-01-11 22:15:57 +04:00
|
|
|
/* Merge strategy */
|
2016-10-21 15:24:13 +03:00
|
|
|
char *strategy;
|
|
|
|
char **xopts;
|
2012-01-11 22:15:57 +04:00
|
|
|
size_t xopts_nr, xopts_alloc;
|
|
|
|
|
2018-04-27 23:48:21 +03: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 02:01:17 +03:00
|
|
|
/* placeholder commit for -i --root */
|
|
|
|
struct object_id squash_onto;
|
|
|
|
int have_squash_onto;
|
|
|
|
|
2012-01-11 22:15:57 +04:00
|
|
|
/* Only used by REPLAY_NONE */
|
|
|
|
struct rev_info *revs;
|
|
|
|
};
|
2018-04-27 23:48:21 +03:00
|
|
|
#define REPLAY_OPTS_INIT { .action = -1, .current_fixups = STRBUF_INIT }
|
2012-01-11 22:15:57 +04:00
|
|
|
|
2018-08-10 19:51:28 +03:00
|
|
|
enum missing_commit_check_level {
|
|
|
|
MISSING_COMMIT_CHECK_IGNORE = 0,
|
|
|
|
MISSING_COMMIT_CHECK_WARN,
|
|
|
|
MISSING_COMMIT_CHECK_ERROR
|
|
|
|
};
|
|
|
|
|
|
|
|
int write_message(const void *buf, size_t len, const char *filename,
|
|
|
|
int append_eol);
|
|
|
|
|
2017-12-13 14:46:21 +03:00
|
|
|
/* Call this to setup defaults before parsing command line options */
|
|
|
|
void sequencer_init_config(struct replay_opts *opts);
|
2018-11-10 08:48:56 +03:00
|
|
|
int sequencer_pick_revisions(struct repository *repo,
|
|
|
|
struct replay_opts *opts);
|
|
|
|
int sequencer_continue(struct repository *repo, struct replay_opts *opts);
|
2018-11-10 08:48:57 +03:00
|
|
|
int sequencer_rollback(struct repository *repo, struct replay_opts *opts);
|
2016-10-21 15:24:55 +03:00
|
|
|
int sequencer_remove_state(struct replay_opts *opts);
|
2012-01-11 22:15:57 +04:00
|
|
|
|
2017-12-05 20:52:32 +03:00
|
|
|
#define TODO_LIST_KEEP_EMPTY (1U << 0)
|
|
|
|
#define TODO_LIST_SHORTEN_IDS (1U << 1)
|
2017-12-05 20:52:34 +03:00
|
|
|
#define TODO_LIST_ABBREVIATE_CMDS (1U << 2)
|
2018-04-25 15:29:03 +03: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 15:29:40 +03: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)
|
2018-11-10 08:48:56 +03:00
|
|
|
int sequencer_make_script(struct repository *repo, FILE *out,
|
|
|
|
int argc, const char **argv,
|
2017-12-05 20:52:32 +03:00
|
|
|
unsigned flags);
|
2017-07-14 17:44:58 +03:00
|
|
|
|
2018-11-10 08:48:57 +03:00
|
|
|
int sequencer_add_exec_commands(struct repository *r, const char *command);
|
|
|
|
int transform_todos(struct repository *r, unsigned flags);
|
2018-08-10 19:51:28 +03:00
|
|
|
enum missing_commit_check_level get_missing_commit_check_level(void);
|
2018-11-10 08:48:57 +03:00
|
|
|
int check_todo_list(struct repository *r);
|
|
|
|
int complete_action(struct repository *r, struct replay_opts *opts, unsigned flags,
|
rebase -i: rewrite complete_action() in C
This rewrites complete_action() from shell to C.
A new mode is added to rebase--helper (`--complete-action`), as well as
a new flag (`--autosquash`).
Finally, complete_action() is stripped from git-rebase--interactive.sh.
The original complete_action() would return the code 2 when the todo
list contained no actions. This was a special case for rebase -i and
-p; git-rebase.sh would then apply the autostash, delete the state
directory, and die with the message "Nothing to do". This cleanup is
rewritten in C instead of returning 2. As rebase -i no longer returns
2, the comment describing this behaviour in git-rebase.sh is updated to
reflect this change.
The message "Nothing to do" is now printed with error(), and so becomes
"error: nothing to do". Some tests in t3404 check this value, so they
are updated to fit this change.
The first check might seem useless as we write "noop" to the todo list
if it is empty. Actually, the todo list might contain commented
commands (ie. empty commits). In this case, complete_action() won’t
write "noop", and will abort without starting the editor.
Signed-off-by: Alban Gruin <alban.gruin@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-28 15:10:36 +03:00
|
|
|
const char *shortrevisions, const char *onto_name,
|
|
|
|
const char *onto, const char *orig_head, const char *cmd,
|
|
|
|
unsigned autosquash);
|
2018-11-10 08:48:57 +03:00
|
|
|
int rearrange_squash(struct repository *r);
|
2017-07-14 17:45:11 +03:00
|
|
|
|
2018-08-23 03:50:51 +03: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);
|
|
|
|
|
2018-11-10 08:48:56 +03:00
|
|
|
void append_conflicts_hint(struct index_state *istate, struct strbuf *msgbuf);
|
2017-11-10 14:09:42 +03: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 14:34:47 +03: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);
|
2019-01-12 05:13:23 +03:00
|
|
|
void commit_post_rewrite(struct repository *r,
|
|
|
|
const struct commit *current_head,
|
2017-11-17 14:34:48 +03:00
|
|
|
const struct object_id *new_head);
|
2012-09-14 10:52:03 +04:00
|
|
|
|
2018-08-10 19:51:33 +03:00
|
|
|
int prepare_branch_to_be_rebased(struct replay_opts *opts, const char *commit);
|
|
|
|
|
2017-11-24 14:07:54 +03:00
|
|
|
#define SUMMARY_INITIAL_COMMIT (1 << 0)
|
|
|
|
#define SUMMARY_SHOW_AUTHOR_DATE (1 << 1)
|
2018-11-10 08:48:56 +03:00
|
|
|
void print_commit_summary(struct repository *repo,
|
|
|
|
const char *prefix,
|
|
|
|
const struct object_id *oid,
|
2017-11-24 14:07:54 +03:00
|
|
|
unsigned int flags);
|
2018-10-31 13:15:55 +03:00
|
|
|
|
|
|
|
int read_author_script(const char *path, char **name, char **email, char **date,
|
|
|
|
int allow_missing);
|
2011-08-04 14:39:11 +04:00
|
|
|
#endif
|
2018-08-28 15:10:40 +03:00
|
|
|
|
|
|
|
void parse_strategy_opts(struct replay_opts *opts, char *raw_opts);
|
|
|
|
int write_basic_state(struct replay_opts *opts, const char *head_name,
|
|
|
|
const char *onto, const char *orig_head);
|