2011-08-04 10:39:11 +00:00
|
|
|
#include "cache.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2014-10-01 10:28:42 +00:00
|
|
|
#include "lockfile.h"
|
2011-08-04 10:39:11 +00:00
|
|
|
#include "sequencer.h"
|
|
|
|
#include "dir.h"
|
2012-01-11 18:15:57 +00:00
|
|
|
#include "object.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "tag.h"
|
|
|
|
#include "run-command.h"
|
|
|
|
#include "exec_cmd.h"
|
|
|
|
#include "utf8.h"
|
|
|
|
#include "cache-tree.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "rerere.h"
|
|
|
|
#include "merge-recursive.h"
|
|
|
|
#include "refs.h"
|
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 14:36:15 +00:00
|
|
|
#include "argv-array.h"
|
2016-10-21 12:25:12 +00:00
|
|
|
#include "quote.h"
|
2016-11-02 17:29:20 +00:00
|
|
|
#include "trailer.h"
|
2017-01-02 15:26:43 +00:00
|
|
|
#include "log-tree.h"
|
2017-01-02 15:26:47 +00:00
|
|
|
#include "wt-status.h"
|
2017-07-14 14:45:31 +00:00
|
|
|
#include "hashmap.h"
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
|
2011-08-04 10:39:11 +00:00
|
|
|
|
2012-09-14 06:52:03 +00:00
|
|
|
const char sign_off_header[] = "Signed-off-by: ";
|
2013-02-12 10:17:32 +00:00
|
|
|
static const char cherry_picked_prefix[] = "(cherry picked from commit ";
|
2012-09-14 06:52:03 +00:00
|
|
|
|
2016-10-14 13:17:12 +00:00
|
|
|
GIT_PATH_FUNC(git_path_seq_dir, "sequencer")
|
|
|
|
|
|
|
|
static GIT_PATH_FUNC(git_path_todo_file, "sequencer/todo")
|
|
|
|
static GIT_PATH_FUNC(git_path_opts_file, "sequencer/opts")
|
|
|
|
static GIT_PATH_FUNC(git_path_head_file, "sequencer/head")
|
2016-12-07 21:51:32 +00:00
|
|
|
static GIT_PATH_FUNC(git_path_abort_safety_file, "sequencer/abort-safety")
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
|
2017-01-02 15:26:28 +00:00
|
|
|
static GIT_PATH_FUNC(rebase_path, "rebase-merge")
|
|
|
|
/*
|
|
|
|
* The file containing rebase commands, comments, and empty lines.
|
|
|
|
* This file is created by "git rebase -i" then edited by the user. As
|
|
|
|
* the lines are processed, they are removed from the front of this
|
|
|
|
* file and written to the tail of 'done'.
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_todo, "rebase-merge/git-rebase-todo")
|
2017-01-02 15:27:00 +00:00
|
|
|
/*
|
|
|
|
* The rebase command lines that have already been processed. A line
|
|
|
|
* is moved here when it is first handled, before any associated user
|
|
|
|
* actions.
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_done, "rebase-merge/done")
|
2017-01-02 15:36:20 +00:00
|
|
|
/*
|
|
|
|
* The file to keep track of how many commands were already processed (e.g.
|
|
|
|
* for the prompt).
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_msgnum, "rebase-merge/msgnum");
|
|
|
|
/*
|
|
|
|
* The file to keep track of how many commands are to be processed in total
|
|
|
|
* (e.g. for the prompt).
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_msgtotal, "rebase-merge/end");
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
/*
|
|
|
|
* The commit message that is planned to be used for any changes that
|
|
|
|
* need to be committed following a user interaction.
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_message, "rebase-merge/message")
|
|
|
|
/*
|
|
|
|
* The file into which is accumulated the suggested commit message for
|
|
|
|
* squash/fixup commands. When the first of a series of squash/fixups
|
|
|
|
* is seen, the file is created and the commit message from the
|
|
|
|
* previous commit and from the first squash/fixup commit are written
|
|
|
|
* to it. The commit message for each subsequent squash/fixup commit
|
|
|
|
* is appended to the file as it is processed.
|
|
|
|
*
|
|
|
|
* The first line of the file is of the form
|
|
|
|
* # This is a combination of $count commits.
|
|
|
|
* where $count is the number of commits whose messages have been
|
|
|
|
* written to the file so far (including the initial "pick" commit).
|
|
|
|
* Each time that a commit message is processed, this line is read and
|
|
|
|
* updated. It is deleted just before the combined commit is made.
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_squash_msg, "rebase-merge/message-squash")
|
|
|
|
/*
|
|
|
|
* If the current series of squash/fixups has not yet included a squash
|
|
|
|
* command, then this file exists and holds the commit message of the
|
|
|
|
* original "pick" commit. (If the series ends without a "squash"
|
|
|
|
* command, then this can be used as the commit message of the combined
|
|
|
|
* commit without opening the editor.)
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_fixup_msg, "rebase-merge/message-fixup")
|
2016-10-21 12:25:04 +00:00
|
|
|
/*
|
|
|
|
* A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
|
|
|
|
* GIT_AUTHOR_DATE that will be used for the commit that is currently
|
|
|
|
* being rebased.
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_author_script, "rebase-merge/author-script")
|
2017-01-02 15:26:43 +00:00
|
|
|
/*
|
|
|
|
* When an "edit" rebase command is being processed, the SHA1 of the
|
|
|
|
* commit to be edited is recorded in this file. When "git rebase
|
|
|
|
* --continue" is executed, if there are any staged changes then they
|
|
|
|
* will be amended to the HEAD commit, but only provided the HEAD
|
|
|
|
* commit is still the commit to be edited. When any other rebase
|
|
|
|
* command is processed, this file is deleted.
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_amend, "rebase-merge/amend")
|
|
|
|
/*
|
|
|
|
* When we stop at a given patch via the "edit" command, this file contains
|
|
|
|
* the abbreviated commit name of the corresponding patch.
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_stopped_sha, "rebase-merge/stopped-sha")
|
2017-01-02 15:28:16 +00:00
|
|
|
/*
|
|
|
|
* For the post-rewrite hook, we make a list of rewritten commits and
|
|
|
|
* their new sha1s. The rewritten-pending list keeps the sha1s of
|
|
|
|
* commits that have been processed, but not committed yet,
|
|
|
|
* e.g. because they are waiting for a 'squash' command.
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_rewritten_list, "rebase-merge/rewritten-list")
|
|
|
|
static GIT_PATH_FUNC(rebase_path_rewritten_pending,
|
|
|
|
"rebase-merge/rewritten-pending")
|
2016-10-21 12:25:12 +00:00
|
|
|
/*
|
|
|
|
* The following files are written by git-rebase just after parsing the
|
|
|
|
* command-line (and are only consumed, not modified, by the sequencer).
|
|
|
|
*/
|
|
|
|
static GIT_PATH_FUNC(rebase_path_gpg_sign_opt, "rebase-merge/gpg_sign_opt")
|
2017-01-02 15:26:53 +00:00
|
|
|
static GIT_PATH_FUNC(rebase_path_orig_head, "rebase-merge/orig-head")
|
|
|
|
static GIT_PATH_FUNC(rebase_path_verbose, "rebase-merge/verbose")
|
2017-01-02 15:27:53 +00:00
|
|
|
static GIT_PATH_FUNC(rebase_path_head_name, "rebase-merge/head-name")
|
|
|
|
static GIT_PATH_FUNC(rebase_path_onto, "rebase-merge/onto")
|
2017-01-02 15:28:27 +00:00
|
|
|
static GIT_PATH_FUNC(rebase_path_autostash, "rebase-merge/autostash")
|
2017-01-02 15:28:30 +00:00
|
|
|
static GIT_PATH_FUNC(rebase_path_strategy, "rebase-merge/strategy")
|
|
|
|
static GIT_PATH_FUNC(rebase_path_strategy_opts, "rebase-merge/strategy_opts")
|
2017-08-02 10:44:17 +00:00
|
|
|
static GIT_PATH_FUNC(rebase_path_allow_rerere_autoupdate, "rebase-merge/allow_rerere_autoupdate")
|
2016-10-21 12:25:04 +00:00
|
|
|
|
|
|
|
static inline int is_rebase_i(const struct replay_opts *opts)
|
|
|
|
{
|
2017-01-02 15:26:28 +00:00
|
|
|
return opts->action == REPLAY_INTERACTIVE_REBASE;
|
2016-10-21 12:25:04 +00:00
|
|
|
}
|
|
|
|
|
2016-10-14 13:17:20 +00:00
|
|
|
static const char *get_dir(const struct replay_opts *opts)
|
|
|
|
{
|
2017-01-02 15:26:28 +00:00
|
|
|
if (is_rebase_i(opts))
|
|
|
|
return rebase_path();
|
2016-10-14 13:17:20 +00:00
|
|
|
return git_path_seq_dir();
|
|
|
|
}
|
|
|
|
|
2016-10-21 12:24:32 +00:00
|
|
|
static const char *get_todo_path(const struct replay_opts *opts)
|
|
|
|
{
|
2017-01-02 15:26:28 +00:00
|
|
|
if (is_rebase_i(opts))
|
|
|
|
return rebase_path_todo();
|
2016-10-21 12:24:32 +00:00
|
|
|
return git_path_todo_file();
|
|
|
|
}
|
|
|
|
|
2013-02-12 10:17:35 +00:00
|
|
|
/*
|
|
|
|
* Returns 0 for non-conforming footer
|
|
|
|
* Returns 1 for conforming footer
|
|
|
|
* Returns 2 when sob exists within conforming footer
|
|
|
|
* Returns 3 when sob exists within conforming footer as last entry
|
|
|
|
*/
|
|
|
|
static int has_conforming_footer(struct strbuf *sb, struct strbuf *sob,
|
|
|
|
int ignore_footer)
|
2013-02-12 10:17:34 +00:00
|
|
|
{
|
2016-11-02 17:29:20 +00:00
|
|
|
struct trailer_info info;
|
|
|
|
int i;
|
|
|
|
int found_sob = 0, found_sob_last = 0;
|
2013-02-12 10:17:34 +00:00
|
|
|
|
2016-11-02 17:29:20 +00:00
|
|
|
trailer_info_get(&info, sb->buf);
|
2013-02-12 10:17:34 +00:00
|
|
|
|
2016-11-02 17:29:20 +00:00
|
|
|
if (info.trailer_start == info.trailer_end)
|
2013-02-12 10:17:34 +00:00
|
|
|
return 0;
|
|
|
|
|
2016-11-02 17:29:20 +00:00
|
|
|
for (i = 0; i < info.trailer_nr; i++)
|
|
|
|
if (sob && !strncmp(info.trailers[i], sob->buf, sob->len)) {
|
|
|
|
found_sob = 1;
|
|
|
|
if (i == info.trailer_nr - 1)
|
|
|
|
found_sob_last = 1;
|
|
|
|
}
|
2013-02-12 10:17:34 +00:00
|
|
|
|
2016-11-02 17:29:20 +00:00
|
|
|
trailer_info_release(&info);
|
2013-02-12 10:17:35 +00:00
|
|
|
|
2016-11-02 17:29:20 +00:00
|
|
|
if (found_sob_last)
|
2013-02-12 10:17:35 +00:00
|
|
|
return 3;
|
|
|
|
if (found_sob)
|
|
|
|
return 2;
|
2013-02-12 10:17:34 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2012-09-14 06:52:03 +00:00
|
|
|
|
2016-10-21 12:25:12 +00:00
|
|
|
static const char *gpg_sign_opt_quoted(struct replay_opts *opts)
|
|
|
|
{
|
|
|
|
static struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
strbuf_reset(&buf);
|
|
|
|
if (opts->gpg_sign)
|
|
|
|
sq_quotef(&buf, "-S%s", opts->gpg_sign);
|
|
|
|
return buf.buf;
|
|
|
|
}
|
|
|
|
|
2016-10-21 12:24:55 +00:00
|
|
|
int sequencer_remove_state(struct replay_opts *opts)
|
2011-08-04 10:39:11 +00:00
|
|
|
{
|
2016-10-14 13:17:20 +00:00
|
|
|
struct strbuf dir = STRBUF_INIT;
|
2016-10-21 12:24:13 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
free(opts->gpg_sign);
|
|
|
|
free(opts->strategy);
|
|
|
|
for (i = 0; i < opts->xopts_nr; i++)
|
|
|
|
free(opts->xopts[i]);
|
|
|
|
free(opts->xopts);
|
2011-08-04 10:39:11 +00:00
|
|
|
|
2017-10-01 14:44:20 +00:00
|
|
|
strbuf_addstr(&dir, get_dir(opts));
|
2016-10-14 13:17:20 +00:00
|
|
|
remove_dir_recursively(&dir, 0);
|
|
|
|
strbuf_release(&dir);
|
2016-10-21 12:24:55 +00:00
|
|
|
|
|
|
|
return 0;
|
2011-08-04 10:39:11 +00:00
|
|
|
}
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
static const char *action_name(const struct replay_opts *opts)
|
|
|
|
{
|
2017-01-02 15:26:28 +00:00
|
|
|
switch (opts->action) {
|
|
|
|
case REPLAY_REVERT:
|
|
|
|
return N_("revert");
|
|
|
|
case REPLAY_PICK:
|
|
|
|
return N_("cherry-pick");
|
|
|
|
case REPLAY_INTERACTIVE_REBASE:
|
|
|
|
return N_("rebase -i");
|
|
|
|
}
|
|
|
|
die(_("Unknown action: %d"), opts->action);
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct commit_message {
|
|
|
|
char *parent_label;
|
2016-02-22 22:44:57 +00:00
|
|
|
char *label;
|
|
|
|
char *subject;
|
2012-01-11 18:15:57 +00:00
|
|
|
const char *message;
|
|
|
|
};
|
|
|
|
|
2016-10-21 12:24:37 +00:00
|
|
|
static const char *short_commit_name(struct commit *commit)
|
|
|
|
{
|
|
|
|
return find_unique_abbrev(commit->object.oid.hash, DEFAULT_ABBREV);
|
|
|
|
}
|
|
|
|
|
2012-01-11 18:15:57 +00:00
|
|
|
static int get_message(struct commit *commit, struct commit_message *out)
|
|
|
|
{
|
|
|
|
const char *abbrev, *subject;
|
2016-02-22 22:44:57 +00:00
|
|
|
int subject_len;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
2016-02-22 22:44:57 +00:00
|
|
|
out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding());
|
2016-10-21 12:24:37 +00:00
|
|
|
abbrev = short_commit_name(commit);
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
subject_len = find_commit_subject(out->message, &subject);
|
|
|
|
|
2016-02-22 22:44:57 +00:00
|
|
|
out->subject = xmemdupz(subject, subject_len);
|
|
|
|
out->label = xstrfmt("%s... %s", abbrev, out->subject);
|
|
|
|
out->parent_label = xstrfmt("parent of %s", out->label);
|
|
|
|
|
2012-01-11 18:15:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-10 21:39:35 +00:00
|
|
|
static void free_message(struct commit *commit, struct commit_message *msg)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
|
|
|
free(msg->parent_label);
|
2016-02-22 22:44:57 +00:00
|
|
|
free(msg->label);
|
|
|
|
free(msg->subject);
|
2014-06-10 21:41:39 +00:00
|
|
|
unuse_commit_buffer(commit, msg->message);
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2012-02-22 00:44:17 +00:00
|
|
|
static void print_advice(int show_hint, struct replay_opts *opts)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
|
|
|
char *msg = getenv("GIT_CHERRY_PICK_HELP");
|
|
|
|
|
|
|
|
if (msg) {
|
|
|
|
fprintf(stderr, "%s\n", msg);
|
|
|
|
/*
|
2013-04-11 22:36:10 +00:00
|
|
|
* A conflict has occurred but the porcelain
|
2012-01-11 18:15:57 +00:00
|
|
|
* (typically rebase --interactive) wants to take care
|
|
|
|
* of the commit itself so remove CHERRY_PICK_HEAD
|
|
|
|
*/
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
unlink(git_path_cherry_pick_head());
|
2012-01-11 18:15:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-02-22 00:44:17 +00:00
|
|
|
if (show_hint) {
|
|
|
|
if (opts->no_commit)
|
|
|
|
advise(_("after resolving the conflicts, mark the corrected paths\n"
|
|
|
|
"with 'git add <paths>' or 'git rm <paths>'"));
|
|
|
|
else
|
|
|
|
advise(_("after resolving the conflicts, mark the corrected paths\n"
|
|
|
|
"with 'git add <paths>' or 'git rm <paths>'\n"
|
|
|
|
"and commit the result with 'git commit'"));
|
|
|
|
}
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2016-10-21 12:26:09 +00:00
|
|
|
static int write_message(const void *buf, size_t len, const char *filename,
|
|
|
|
int append_eol)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
|
|
|
static struct lock_file msg_file;
|
|
|
|
|
2016-09-09 14:37:05 +00:00
|
|
|
int msg_fd = hold_lock_file_for_update(&msg_file, filename, 0);
|
|
|
|
if (msg_fd < 0)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error_errno(_("could not lock '%s'"), filename);
|
2016-10-21 12:26:05 +00:00
|
|
|
if (write_in_full(msg_fd, buf, len) < 0) {
|
2016-10-21 12:26:00 +00:00
|
|
|
rollback_lock_file(&msg_file);
|
2016-10-21 12:26:25 +00:00
|
|
|
return error_errno(_("could not write to '%s'"), filename);
|
2016-10-21 12:26:00 +00:00
|
|
|
}
|
2016-10-21 12:26:09 +00:00
|
|
|
if (append_eol && write(msg_fd, "\n", 1) < 0) {
|
|
|
|
rollback_lock_file(&msg_file);
|
2016-11-20 12:26:17 +00:00
|
|
|
return error_errno(_("could not write eol to '%s'"), filename);
|
2016-10-21 12:26:09 +00:00
|
|
|
}
|
2016-10-21 12:26:00 +00:00
|
|
|
if (commit_lock_file(&msg_file) < 0) {
|
|
|
|
rollback_lock_file(&msg_file);
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("failed to finalize '%s'."), filename);
|
2016-10-21 12:26:00 +00:00
|
|
|
}
|
2016-09-09 14:37:05 +00:00
|
|
|
|
|
|
|
return 0;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2016-10-21 12:25:08 +00:00
|
|
|
/*
|
|
|
|
* Reads a file that was presumably written by a shell script, i.e. with an
|
|
|
|
* end-of-line marker that needs to be stripped.
|
|
|
|
*
|
|
|
|
* Note that only the last end-of-line marker is stripped, consistent with the
|
|
|
|
* behavior of "$(cat path)" in a shell script.
|
|
|
|
*
|
|
|
|
* Returns 1 if the file was read, 0 if it could not be read or does not exist.
|
|
|
|
*/
|
|
|
|
static int read_oneliner(struct strbuf *buf,
|
|
|
|
const char *path, int skip_if_empty)
|
|
|
|
{
|
|
|
|
int orig_len = buf->len;
|
|
|
|
|
|
|
|
if (!file_exists(path))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (strbuf_read_file(buf, path, 0) < 0) {
|
|
|
|
warning_errno(_("could not read '%s'"), path);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (buf->len > orig_len && buf->buf[buf->len - 1] == '\n') {
|
|
|
|
if (--buf->len > orig_len && buf->buf[buf->len - 1] == '\r')
|
|
|
|
--buf->len;
|
|
|
|
buf->buf[buf->len] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (skip_if_empty && buf->len == orig_len)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-01-11 18:15:57 +00:00
|
|
|
static struct tree *empty_tree(void)
|
|
|
|
{
|
2017-05-06 22:10:17 +00:00
|
|
|
return lookup_tree(&empty_tree_oid);
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int error_dirty_index(struct replay_opts *opts)
|
|
|
|
{
|
|
|
|
if (read_cache_unmerged())
|
2016-10-21 12:26:17 +00:00
|
|
|
return error_resolve_conflict(_(action_name(opts)));
|
2012-01-11 18:15:57 +00:00
|
|
|
|
2016-10-21 12:26:25 +00:00
|
|
|
error(_("your local changes would be overwritten by %s."),
|
2016-10-21 12:26:17 +00:00
|
|
|
_(action_name(opts)));
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
if (advice_commit_before_merge)
|
2016-10-21 12:26:25 +00:00
|
|
|
advise(_("commit your changes or stash them to proceed."));
|
2012-01-11 18:15:57 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-12-07 21:51:32 +00:00
|
|
|
static void update_abort_safety_file(void)
|
|
|
|
{
|
|
|
|
struct object_id head;
|
|
|
|
|
|
|
|
/* Do nothing on a single-pick */
|
|
|
|
if (!file_exists(git_path_seq_dir()))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!get_oid("HEAD", &head))
|
|
|
|
write_file(git_path_abort_safety_file(), "%s", oid_to_hex(&head));
|
|
|
|
else
|
|
|
|
write_file(git_path_abort_safety_file(), "%s", "");
|
|
|
|
}
|
|
|
|
|
2017-05-06 22:10:32 +00:00
|
|
|
static int fast_forward_to(const struct object_id *to, const struct object_id *from,
|
2013-06-19 07:37:09 +00:00
|
|
|
int unborn, struct replay_opts *opts)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
2014-04-16 22:37:45 +00:00
|
|
|
struct ref_transaction *transaction;
|
2013-06-19 07:37:09 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2014-04-16 22:37:45 +00:00
|
|
|
struct strbuf err = STRBUF_INIT;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
read_cache();
|
2012-10-26 15:53:49 +00:00
|
|
|
if (checkout_fast_forward(from, to, 1))
|
2016-09-09 14:37:55 +00:00
|
|
|
return -1; /* the callee should have complained already */
|
2014-04-16 18:56:52 +00:00
|
|
|
|
2016-10-21 12:26:17 +00:00
|
|
|
strbuf_addf(&sb, _("%s: fast-forward"), _(action_name(opts)));
|
2014-04-16 22:37:45 +00:00
|
|
|
|
|
|
|
transaction = ref_transaction_begin(&err);
|
|
|
|
if (!transaction ||
|
|
|
|
ref_transaction_update(transaction, "HEAD",
|
2017-10-15 22:06:53 +00:00
|
|
|
to, unborn ? &null_oid : from,
|
2015-02-17 17:00:15 +00:00
|
|
|
0, sb.buf, &err) ||
|
2014-04-30 19:22:42 +00:00
|
|
|
ref_transaction_commit(transaction, &err)) {
|
2014-04-16 22:37:45 +00:00
|
|
|
ref_transaction_free(transaction);
|
|
|
|
error("%s", err.buf);
|
|
|
|
strbuf_release(&sb);
|
|
|
|
strbuf_release(&err);
|
|
|
|
return -1;
|
|
|
|
}
|
2014-04-16 18:56:52 +00:00
|
|
|
|
2013-06-19 07:37:09 +00:00
|
|
|
strbuf_release(&sb);
|
2014-04-16 22:37:45 +00:00
|
|
|
strbuf_release(&err);
|
|
|
|
ref_transaction_free(transaction);
|
2016-12-07 21:51:32 +00:00
|
|
|
update_abort_safety_file();
|
2014-04-16 22:37:45 +00:00
|
|
|
return 0;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2014-10-24 18:34:59 +00:00
|
|
|
void append_conflicts_hint(struct strbuf *msgbuf)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2014-10-28 20:04:38 +00:00
|
|
|
strbuf_addch(msgbuf, '\n');
|
|
|
|
strbuf_commented_addf(msgbuf, "Conflicts:\n");
|
2014-10-24 18:34:59 +00:00
|
|
|
for (i = 0; i < active_nr;) {
|
|
|
|
const struct cache_entry *ce = active_cache[i++];
|
|
|
|
if (ce_stage(ce)) {
|
2014-10-28 20:04:38 +00:00
|
|
|
strbuf_commented_addf(msgbuf, "\t%s\n", ce->name);
|
2014-10-24 18:34:59 +00:00
|
|
|
while (i < active_nr && !strcmp(ce->name,
|
|
|
|
active_cache[i]->name))
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-11 18:15:57 +00:00
|
|
|
static int do_recursive_merge(struct commit *base, struct commit *next,
|
|
|
|
const char *base_label, const char *next_label,
|
2017-05-06 22:10:36 +00:00
|
|
|
struct object_id *head, struct strbuf *msgbuf,
|
2012-01-11 18:15:57 +00:00
|
|
|
struct replay_opts *opts)
|
|
|
|
{
|
|
|
|
struct merge_options o;
|
|
|
|
struct tree *result, *next_tree, *base_tree, *head_tree;
|
2014-06-13 12:19:23 +00:00
|
|
|
int clean;
|
2016-10-21 12:24:13 +00:00
|
|
|
char **xopt;
|
2012-01-11 18:15:57 +00:00
|
|
|
static struct lock_file index_lock;
|
|
|
|
|
2016-12-07 18:33:54 +00:00
|
|
|
hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
read_cache();
|
|
|
|
|
|
|
|
init_merge_options(&o);
|
|
|
|
o.ancestor = base ? base_label : "(empty tree)";
|
|
|
|
o.branch1 = "HEAD";
|
|
|
|
o.branch2 = next ? next_label : "(empty tree)";
|
2017-01-02 15:35:39 +00:00
|
|
|
if (is_rebase_i(opts))
|
|
|
|
o.buffer_output = 2;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
head_tree = parse_tree_indirect(head);
|
|
|
|
next_tree = next ? next->tree : empty_tree();
|
|
|
|
base_tree = base ? base->tree : empty_tree();
|
|
|
|
|
|
|
|
for (xopt = opts->xopts; xopt != opts->xopts + opts->xopts_nr; xopt++)
|
|
|
|
parse_merge_opt(&o, *xopt);
|
|
|
|
|
|
|
|
clean = merge_trees(&o,
|
|
|
|
head_tree,
|
|
|
|
next_tree, base_tree, &result);
|
2017-01-02 15:35:39 +00:00
|
|
|
if (is_rebase_i(opts) && clean <= 0)
|
|
|
|
fputs(o.obuf.buf, stdout);
|
2016-08-01 11:44:53 +00:00
|
|
|
strbuf_release(&o.obuf);
|
prepare the builtins for a libified merge_recursive()
Previously, callers of merge_trees() or merge_recursive() expected that
code to die() with an error message. This used to be okay because we
called those commands from scripts, and had a chance to print out a
message in case the command failed fatally (read: with exit code 128).
As scripting incurs its own set of problems (portability, speed,
idiosyncrasies of different shells, limited data structures leading to
inefficient code), we are converting more and more of these scripts into
builtins, using library functions directly.
We already tried to use merge_recursive() directly in the builtin
git-am, for example. Unfortunately, we had to roll it back temporarily
because some of the code in merge-recursive.c still deemed it okay to
call die(), when the builtin am code really wanted to print out a useful
advice after the merge failed fatally. In the next commits, we want to
fix that.
The code touched by this commit expected merge_trees() to die() with
some useful message when there is an error condition, but merge_trees()
is going to be improved by converting all die() calls to return error()
instead (i.e. return value -1 after printing out the message as before),
so that the caller can react more flexibly.
This is a step to prepare for the version of merge_trees() that no
longer dies, even if we just imitate the previous behavior by calling
exit(128): this is what callers of e.g. `git merge` have come to expect.
Note that the callers of the sequencer (revert and cherry-pick) already
fail fast even for the return value -1; The only difference is that they
now get a chance to say "<command> failed".
A caller of merge_trees() might want handle error messages themselves
(or even suppress them). As this patch is already complex enough, we
leave that change for a later patch.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-26 16:06:02 +00:00
|
|
|
if (clean < 0)
|
|
|
|
return clean;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
if (active_cache_changed &&
|
2014-06-13 12:19:23 +00:00
|
|
|
write_locked_index(&the_index, &index_lock, COMMIT_LOCK))
|
C style: use standard style for "TRANSLATORS" comments
Change all the "TRANSLATORS: [...]" comments in the C code to use the
regular Git coding style, and amend the style guide so that the
example there uses that style.
This custom style was necessary back in 2010 when the gettext support
was initially added, and was subsequently documented in commit
cbcfd4e3ea ("i18n: mention "TRANSLATORS:" marker in
Documentation/CodingGuidelines", 2014-04-18).
GNU xgettext hasn't had the parsing limitation that necessitated this
exception for almost 3 years. Since its 0.19 release on 2014-06-02
it's been able to recognize TRANSLATOR comments in the standard Git
comment syntax[1].
Usually we'd like to keep compatibility with software that's that
young, but in this case literally the only person who needs to be
using a gettext newer than 3 years old is Jiang Xin (the only person
who runs & commits "make pot" results), so I think in this case we can
make an exception.
This xgettext parsing feature was added after a thread on the Git
mailing list[2] which continued on the bug-gettext[3] list, but we
never subsequently changed our style & styleguide, do so.
There are already longstanding changes in git that use the standard
comment style & have their TRANSLATORS comments extracted properly
without getting the literal "*"'s mixed up in the text, as would
happen before xgettext 0.19.
Commit 7ff2683253 ("builtin-am: implement -i/--interactive",
2015-08-04) added one such comment, which in commit df0617bfa7 ("l10n:
git.pot: v2.6.0 round 1 (123 new, 41 removed)", 2015-09-05) got picked
up in the po/git.pot file with the right format, showing that Jiang
already runs a modern xgettext.
The xgettext parser does not handle the sort of non-standard comment
style that I'm amending here in sequencer.c, but that isn't standard
Git comment syntax anyway. With this change to sequencer.c & "make
pot" the comment in the pot file is now correct:
#. TRANSLATORS: %s will be "revert", "cherry-pick" or
-#. * "rebase -i".
+#. "rebase -i".
1. http://git.savannah.gnu.org/cgit/gettext.git/commit/?id=10af7fe6bd
2. <2ce9ec406501d112e032c8208417f8100bed04c6.1397712142.git.worldhello.net@gmail.com>
(https://public-inbox.org/git/2ce9ec406501d112e032c8208417f8100bed04c6.1397712142.git.worldhello.net@gmail.com/)
3. https://lists.gnu.org/archive/html/bug-gettext/2014-04/msg00016.html
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Acked-by: Jiang Xin <worldhello.net@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-11 21:20:12 +00:00
|
|
|
/*
|
|
|
|
* TRANSLATORS: %s will be "revert", "cherry-pick" or
|
2017-01-02 15:26:28 +00:00
|
|
|
* "rebase -i".
|
|
|
|
*/
|
2016-09-09 14:37:10 +00:00
|
|
|
return error(_("%s: Unable to write new index file"),
|
2016-10-21 12:26:17 +00:00
|
|
|
_(action_name(opts)));
|
2012-01-11 18:15:57 +00:00
|
|
|
rollback_lock_file(&index_lock);
|
|
|
|
|
2012-09-14 06:52:03 +00:00
|
|
|
if (opts->signoff)
|
2013-02-12 10:17:35 +00:00
|
|
|
append_signoff(msgbuf, 0, 0);
|
2012-09-14 06:52:03 +00:00
|
|
|
|
2014-10-24 18:34:59 +00:00
|
|
|
if (!clean)
|
|
|
|
append_conflicts_hint(msgbuf);
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
return !clean;
|
|
|
|
}
|
|
|
|
|
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 14:36:15 +00:00
|
|
|
static int is_index_unchanged(void)
|
|
|
|
{
|
2017-05-06 22:10:07 +00:00
|
|
|
struct object_id head_oid;
|
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 14:36:15 +00:00
|
|
|
struct commit *head_commit;
|
|
|
|
|
refs: convert resolve_ref_unsafe to struct object_id
Convert resolve_ref_unsafe to take a pointer to struct object_id by
converting one remaining caller to use struct object_id, removing the
temporary NULL pointer check in expand_ref, converting the declaration
and definition, and applying the following semantic patch:
@@
expression E1, E2, E3, E4;
@@
- resolve_ref_unsafe(E1, E2, E3.hash, E4)
+ resolve_ref_unsafe(E1, E2, &E3, E4)
@@
expression E1, E2, E3, E4;
@@
- resolve_ref_unsafe(E1, E2, E3->hash, E4)
+ resolve_ref_unsafe(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-10-15 22:07:09 +00:00
|
|
|
if (!resolve_ref_unsafe("HEAD", RESOLVE_REF_READING, &head_oid, NULL))
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("could not resolve HEAD commit\n"));
|
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 14:36:15 +00:00
|
|
|
|
Convert lookup_commit* to struct object_id
Convert lookup_commit, lookup_commit_or_die,
lookup_commit_reference, and lookup_commit_reference_gently to take
struct object_id arguments.
Introduce a temporary in parse_object buffer in order to convert this
function. This is required since in order to convert parse_object and
parse_object_buffer, lookup_commit_reference_gently and
lookup_commit_or_die would need to be converted. Not introducing a
temporary would therefore require that lookup_commit_or_die take a
struct object_id *, but lookup_commit would take unsigned char *,
leaving a confusing and hard-to-use interface.
parse_object_buffer will lose this temporary in a later patch.
This commit was created with manual changes to commit.c, commit.h, and
object.c, plus the following semantic patch:
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1.hash, E2)
+ lookup_commit_reference_gently(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1->hash, E2)
+ lookup_commit_reference_gently(E1, E2)
@@
expression E1;
@@
- lookup_commit_reference(E1.hash)
+ lookup_commit_reference(&E1)
@@
expression E1;
@@
- lookup_commit_reference(E1->hash)
+ lookup_commit_reference(E1)
@@
expression E1;
@@
- lookup_commit(E1.hash)
+ lookup_commit(&E1)
@@
expression E1;
@@
- lookup_commit(E1->hash)
+ lookup_commit(E1)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1.hash, E2)
+ lookup_commit_or_die(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1->hash, E2)
+ lookup_commit_or_die(E1, E2)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-06 22:10:10 +00:00
|
|
|
head_commit = lookup_commit(&head_oid);
|
2012-05-03 12:10:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If head_commit is NULL, check_commit, called from
|
|
|
|
* lookup_commit, would have indicated that head_commit is not
|
|
|
|
* a commit object already. parse_commit() will return failure
|
|
|
|
* without further complaints in such a case. Otherwise, if
|
|
|
|
* the commit is invalid, parse_commit() will complain. So
|
|
|
|
* there is nothing for us to say here. Just return failure.
|
|
|
|
*/
|
|
|
|
if (parse_commit(head_commit))
|
|
|
|
return -1;
|
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 14:36:15 +00:00
|
|
|
|
|
|
|
if (!active_cache_tree)
|
|
|
|
active_cache_tree = cache_tree();
|
|
|
|
|
|
|
|
if (!cache_tree_fully_valid(active_cache_tree))
|
2014-06-13 12:19:32 +00:00
|
|
|
if (cache_tree_update(&the_index, 0))
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("unable to update cache tree\n"));
|
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 14:36:15 +00:00
|
|
|
|
2017-05-01 02:28:56 +00:00
|
|
|
return !oidcmp(&active_cache_tree->oid,
|
|
|
|
&head_commit->tree->object.oid);
|
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 14:36:15 +00:00
|
|
|
}
|
|
|
|
|
2017-01-02 15:27:18 +00:00
|
|
|
static int write_author_script(const char *message)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
const char *eol;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
if (!*message || starts_with(message, "\n")) {
|
|
|
|
missing_author:
|
|
|
|
/* Missing 'author' line? */
|
|
|
|
unlink(rebase_path_author_script());
|
|
|
|
return 0;
|
|
|
|
} else if (skip_prefix(message, "author ", &message))
|
|
|
|
break;
|
|
|
|
else if ((eol = strchr(message, '\n')))
|
|
|
|
message = eol + 1;
|
|
|
|
else
|
|
|
|
goto missing_author;
|
|
|
|
|
|
|
|
strbuf_addstr(&buf, "GIT_AUTHOR_NAME='");
|
|
|
|
while (*message && *message != '\n' && *message != '\r')
|
|
|
|
if (skip_prefix(message, " <", &message))
|
|
|
|
break;
|
|
|
|
else if (*message != '\'')
|
|
|
|
strbuf_addch(&buf, *(message++));
|
|
|
|
else
|
|
|
|
strbuf_addf(&buf, "'\\\\%c'", *(message++));
|
|
|
|
strbuf_addstr(&buf, "'\nGIT_AUTHOR_EMAIL='");
|
|
|
|
while (*message && *message != '\n' && *message != '\r')
|
|
|
|
if (skip_prefix(message, "> ", &message))
|
|
|
|
break;
|
|
|
|
else if (*message != '\'')
|
|
|
|
strbuf_addch(&buf, *(message++));
|
|
|
|
else
|
|
|
|
strbuf_addf(&buf, "'\\\\%c'", *(message++));
|
|
|
|
strbuf_addstr(&buf, "'\nGIT_AUTHOR_DATE='@");
|
|
|
|
while (*message && *message != '\n' && *message != '\r')
|
|
|
|
if (*message != '\'')
|
|
|
|
strbuf_addch(&buf, *(message++));
|
|
|
|
else
|
|
|
|
strbuf_addf(&buf, "'\\\\%c'", *(message++));
|
|
|
|
res = write_message(buf.buf, buf.len, rebase_path_author_script(), 1);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2016-10-21 12:25:04 +00:00
|
|
|
/*
|
2017-01-02 15:35:25 +00:00
|
|
|
* Read a list of environment variable assignments (such as the author-script
|
|
|
|
* file) into an environment block. Returns -1 on error, 0 otherwise.
|
2016-10-21 12:25:04 +00:00
|
|
|
*/
|
2017-01-02 15:35:25 +00:00
|
|
|
static int read_env_script(struct argv_array *env)
|
2016-10-21 12:25:04 +00:00
|
|
|
{
|
|
|
|
struct strbuf script = STRBUF_INIT;
|
|
|
|
int i, count = 0;
|
2017-01-02 15:35:25 +00:00
|
|
|
char *p, *p2;
|
2016-10-21 12:25:04 +00:00
|
|
|
|
|
|
|
if (strbuf_read_file(&script, rebase_path_author_script(), 256) <= 0)
|
2017-01-02 15:35:25 +00:00
|
|
|
return -1;
|
2016-10-21 12:25:04 +00:00
|
|
|
|
|
|
|
for (p = script.buf; *p; p++)
|
|
|
|
if (skip_prefix(p, "'\\\\''", (const char **)&p2))
|
|
|
|
strbuf_splice(&script, p - script.buf, p2 - p, "'", 1);
|
|
|
|
else if (*p == '\'')
|
|
|
|
strbuf_splice(&script, p-- - script.buf, 1, "", 0);
|
|
|
|
else if (*p == '\n') {
|
|
|
|
*p = '\0';
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:35:25 +00:00
|
|
|
for (i = 0, p = script.buf; i < count; i++) {
|
|
|
|
argv_array_push(env, p);
|
2016-10-21 12:25:04 +00:00
|
|
|
p += strlen(p) + 1;
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:35:25 +00:00
|
|
|
return 0;
|
2016-10-21 12:25:04 +00:00
|
|
|
}
|
|
|
|
|
2016-10-21 12:26:32 +00:00
|
|
|
static const char staged_changes_advice[] =
|
|
|
|
N_("you have staged changes in your working tree\n"
|
|
|
|
"If these changes are meant to be squashed into the previous commit, run:\n"
|
|
|
|
"\n"
|
|
|
|
" git commit --amend %s\n"
|
|
|
|
"\n"
|
|
|
|
"If they are meant to go into a new commit, run:\n"
|
|
|
|
"\n"
|
|
|
|
" git commit %s\n"
|
|
|
|
"\n"
|
|
|
|
"In both cases, once you're done, continue with:\n"
|
|
|
|
"\n"
|
|
|
|
" git rebase --continue\n");
|
|
|
|
|
2017-03-23 16:07:11 +00:00
|
|
|
#define ALLOW_EMPTY (1<<0)
|
|
|
|
#define EDIT_MSG (1<<1)
|
|
|
|
#define AMEND_MSG (1<<2)
|
|
|
|
#define CLEANUP_MSG (1<<3)
|
2017-03-23 16:07:17 +00:00
|
|
|
#define VERIFY_MSG (1<<4)
|
2017-03-23 16:07:11 +00:00
|
|
|
|
2012-01-11 18:15:57 +00:00
|
|
|
/*
|
|
|
|
* If we are cherry-pick, and if the merge did not result in
|
|
|
|
* hand-editing, we will hit this commit and inherit the original
|
|
|
|
* author date and name.
|
2016-10-21 12:25:04 +00:00
|
|
|
*
|
2012-01-11 18:15:57 +00:00
|
|
|
* If we are revert, or if our cherry-pick results in a hand merge,
|
|
|
|
* we had better say that the current user is responsible for that.
|
2016-10-21 12:25:04 +00:00
|
|
|
*
|
|
|
|
* An exception is when run_git_commit() is called during an
|
|
|
|
* interactive rebase: in that case, we will want to retain the
|
|
|
|
* author metadata.
|
2012-01-11 18:15:57 +00:00
|
|
|
*/
|
2012-05-30 00:14:41 +00:00
|
|
|
static int run_git_commit(const char *defmsg, struct replay_opts *opts,
|
2017-03-23 16:07:11 +00:00
|
|
|
unsigned int flags)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
2017-01-02 15:35:29 +00:00
|
|
|
struct child_process cmd = CHILD_PROCESS_INIT;
|
2015-03-06 13:55:32 +00:00
|
|
|
const char *value;
|
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 14:36:15 +00:00
|
|
|
|
2017-01-02 15:35:29 +00:00
|
|
|
cmd.git_cmd = 1;
|
|
|
|
|
2016-10-21 12:25:04 +00:00
|
|
|
if (is_rebase_i(opts)) {
|
2017-03-23 16:07:11 +00:00
|
|
|
if (!(flags & EDIT_MSG)) {
|
2017-01-02 15:35:34 +00:00
|
|
|
cmd.stdout_to_stderr = 1;
|
|
|
|
cmd.err = -1;
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:35:29 +00:00
|
|
|
if (read_env_script(&cmd.env_array)) {
|
2016-10-21 12:25:12 +00:00
|
|
|
const char *gpg_opt = gpg_sign_opt_quoted(opts);
|
|
|
|
|
2016-10-21 12:26:32 +00:00
|
|
|
return error(_(staged_changes_advice),
|
|
|
|
gpg_opt, gpg_opt);
|
2016-10-21 12:25:12 +00:00
|
|
|
}
|
2016-10-21 12:25:04 +00:00
|
|
|
}
|
|
|
|
|
2017-01-02 15:35:29 +00:00
|
|
|
argv_array_push(&cmd.args, "commit");
|
2012-01-11 18:15:57 +00:00
|
|
|
|
2017-03-23 16:07:17 +00:00
|
|
|
if (!(flags & VERIFY_MSG))
|
|
|
|
argv_array_push(&cmd.args, "-n");
|
2017-03-23 16:07:11 +00:00
|
|
|
if ((flags & AMEND_MSG))
|
2017-01-02 15:35:29 +00:00
|
|
|
argv_array_push(&cmd.args, "--amend");
|
2014-06-19 21:28:20 +00:00
|
|
|
if (opts->gpg_sign)
|
2017-01-02 15:35:29 +00:00
|
|
|
argv_array_pushf(&cmd.args, "-S%s", opts->gpg_sign);
|
2012-01-11 18:15:57 +00:00
|
|
|
if (opts->signoff)
|
2017-01-02 15:35:29 +00:00
|
|
|
argv_array_push(&cmd.args, "-s");
|
2016-10-21 12:25:04 +00:00
|
|
|
if (defmsg)
|
2017-01-02 15:35:29 +00:00
|
|
|
argv_array_pushl(&cmd.args, "-F", defmsg, NULL);
|
2017-03-23 16:07:11 +00:00
|
|
|
if ((flags & CLEANUP_MSG))
|
2017-01-02 15:35:29 +00:00
|
|
|
argv_array_push(&cmd.args, "--cleanup=strip");
|
2017-03-23 16:07:11 +00:00
|
|
|
if ((flags & EDIT_MSG))
|
2017-01-02 15:35:29 +00:00
|
|
|
argv_array_push(&cmd.args, "-e");
|
2017-03-23 16:07:11 +00:00
|
|
|
else if (!(flags & CLEANUP_MSG) &&
|
2016-10-21 12:25:28 +00:00
|
|
|
!opts->signoff && !opts->record_origin &&
|
2016-10-21 12:25:04 +00:00
|
|
|
git_config_get_value("commit.cleanup", &value))
|
2017-01-02 15:35:29 +00:00
|
|
|
argv_array_push(&cmd.args, "--cleanup=verbatim");
|
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 14:36:15 +00:00
|
|
|
|
2017-03-23 16:07:11 +00:00
|
|
|
if ((flags & ALLOW_EMPTY))
|
2017-01-02 15:35:29 +00:00
|
|
|
argv_array_push(&cmd.args, "--allow-empty");
|
2012-04-11 20:21:53 +00:00
|
|
|
|
2012-08-02 10:38:51 +00:00
|
|
|
if (opts->allow_empty_message)
|
2017-01-02 15:35:29 +00:00
|
|
|
argv_array_push(&cmd.args, "--allow-empty-message");
|
2012-08-02 10:38:51 +00:00
|
|
|
|
2017-01-02 15:35:34 +00:00
|
|
|
if (cmd.err == -1) {
|
|
|
|
/* hide stderr on success */
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int rc = pipe_command(&cmd,
|
|
|
|
NULL, 0,
|
|
|
|
/* stdout is already redirected */
|
|
|
|
NULL, 0,
|
|
|
|
&buf, 0);
|
|
|
|
if (rc)
|
|
|
|
fputs(buf.buf, stderr);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return rc;
|
|
|
|
}
|
2016-10-21 12:25:04 +00:00
|
|
|
|
2017-01-02 15:35:29 +00:00
|
|
|
return run_command(&cmd);
|
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 14:36:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int is_original_commit_empty(struct commit *commit)
|
|
|
|
{
|
2017-07-13 23:49:22 +00:00
|
|
|
const struct object_id *ptree_oid;
|
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 14:36:15 +00:00
|
|
|
|
|
|
|
if (parse_commit(commit))
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("could not parse commit %s\n"),
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&commit->object.oid));
|
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 14:36:15 +00:00
|
|
|
if (commit->parents) {
|
|
|
|
struct commit *parent = commit->parents->item;
|
|
|
|
if (parse_commit(parent))
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("could not parse parent commit %s\n"),
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&parent->object.oid));
|
2017-07-13 23:49:22 +00:00
|
|
|
ptree_oid = &parent->tree->object.oid;
|
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 14:36:15 +00:00
|
|
|
} else {
|
2017-07-13 23:49:22 +00:00
|
|
|
ptree_oid = &empty_tree_oid; /* commit is root */
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2017-07-13 23:49:22 +00:00
|
|
|
return !oidcmp(ptree_oid, &commit->tree->object.oid);
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2012-05-30 00:14:41 +00:00
|
|
|
/*
|
|
|
|
* Do we run "git commit" with "--allow-empty"?
|
|
|
|
*/
|
|
|
|
static int allow_empty(struct replay_opts *opts, struct commit *commit)
|
|
|
|
{
|
|
|
|
int index_unchanged, empty_commit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Three cases:
|
|
|
|
*
|
|
|
|
* (1) we do not allow empty at all and error out.
|
|
|
|
*
|
|
|
|
* (2) we allow ones that were initially empty, but
|
|
|
|
* forbid the ones that become empty;
|
|
|
|
*
|
|
|
|
* (3) we allow both.
|
|
|
|
*/
|
|
|
|
if (!opts->allow_empty)
|
|
|
|
return 0; /* let "git commit" barf as necessary */
|
|
|
|
|
|
|
|
index_unchanged = is_index_unchanged();
|
|
|
|
if (index_unchanged < 0)
|
|
|
|
return index_unchanged;
|
|
|
|
if (!index_unchanged)
|
|
|
|
return 0; /* we do not have to say --allow-empty */
|
|
|
|
|
|
|
|
if (opts->keep_redundant_commits)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
empty_commit = is_original_commit_empty(commit);
|
|
|
|
if (empty_commit < 0)
|
|
|
|
return empty_commit;
|
|
|
|
if (!empty_commit)
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:26:38 +00:00
|
|
|
/*
|
|
|
|
* Note that ordering matters in this enum. Not only must it match the mapping
|
|
|
|
* below, it is also divided into several sections that matter. When adding
|
|
|
|
* new commands, make sure you add it in the right section.
|
|
|
|
*/
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
enum todo_command {
|
2017-01-02 15:26:38 +00:00
|
|
|
/* commands that handle commits */
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
TODO_PICK = 0,
|
2017-01-02 15:26:38 +00:00
|
|
|
TODO_REVERT,
|
2017-01-02 15:26:43 +00:00
|
|
|
TODO_EDIT,
|
2017-01-02 15:28:00 +00:00
|
|
|
TODO_REWORD,
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
TODO_FIXUP,
|
|
|
|
TODO_SQUASH,
|
2017-01-02 15:26:47 +00:00
|
|
|
/* commands that do something else than handling a single commit */
|
|
|
|
TODO_EXEC,
|
2017-01-02 15:26:38 +00:00
|
|
|
/* commands that do nothing but are counted for reporting progress */
|
2017-01-02 15:34:34 +00:00
|
|
|
TODO_NOOP,
|
2017-01-02 15:34:39 +00:00
|
|
|
TODO_DROP,
|
|
|
|
/* comments (not counted for reporting progress) */
|
|
|
|
TODO_COMMENT
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
};
|
|
|
|
|
2017-01-02 15:27:15 +00:00
|
|
|
static struct {
|
|
|
|
char c;
|
|
|
|
const char *str;
|
|
|
|
} todo_command_info[] = {
|
|
|
|
{ 'p', "pick" },
|
|
|
|
{ 0, "revert" },
|
|
|
|
{ 'e', "edit" },
|
2017-01-02 15:28:00 +00:00
|
|
|
{ 'r', "reword" },
|
2017-01-02 15:27:15 +00:00
|
|
|
{ 'f', "fixup" },
|
|
|
|
{ 's', "squash" },
|
|
|
|
{ 'x', "exec" },
|
2017-01-02 15:34:34 +00:00
|
|
|
{ 0, "noop" },
|
2017-01-02 15:34:39 +00:00
|
|
|
{ 'd', "drop" },
|
|
|
|
{ 0, NULL }
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const char *command_to_string(const enum todo_command command)
|
|
|
|
{
|
2017-01-02 15:34:39 +00:00
|
|
|
if (command < TODO_COMMENT)
|
2017-01-02 15:27:15 +00:00
|
|
|
return todo_command_info[command].str;
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
die("Unknown command: %d", command);
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:26:38 +00:00
|
|
|
static int is_noop(const enum todo_command command)
|
|
|
|
{
|
2017-01-02 15:34:34 +00:00
|
|
|
return TODO_NOOP <= command;
|
2017-01-02 15:26:38 +00:00
|
|
|
}
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
static int is_fixup(enum todo_command command)
|
|
|
|
{
|
|
|
|
return command == TODO_FIXUP || command == TODO_SQUASH;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int update_squash_messages(enum todo_command command,
|
|
|
|
struct commit *commit, struct replay_opts *opts)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int count, res;
|
|
|
|
const char *message, *body;
|
|
|
|
|
|
|
|
if (file_exists(rebase_path_squash_msg())) {
|
|
|
|
struct strbuf header = STRBUF_INIT;
|
|
|
|
char *eol, *p;
|
|
|
|
|
|
|
|
if (strbuf_read_file(&buf, rebase_path_squash_msg(), 2048) <= 0)
|
|
|
|
return error(_("could not read '%s'"),
|
|
|
|
rebase_path_squash_msg());
|
|
|
|
|
|
|
|
p = buf.buf + 1;
|
|
|
|
eol = strchrnul(buf.buf, '\n');
|
|
|
|
if (buf.buf[0] != comment_line_char ||
|
|
|
|
(p += strcspn(p, "0123456789\n")) == eol)
|
|
|
|
return error(_("unexpected 1st line of squash message:"
|
|
|
|
"\n\n\t%.*s"),
|
|
|
|
(int)(eol - buf.buf), buf.buf);
|
|
|
|
count = strtol(p, NULL, 10);
|
|
|
|
|
|
|
|
if (count < 1)
|
|
|
|
return error(_("invalid 1st line of squash message:\n"
|
|
|
|
"\n\t%.*s"),
|
|
|
|
(int)(eol - buf.buf), buf.buf);
|
|
|
|
|
|
|
|
strbuf_addf(&header, "%c ", comment_line_char);
|
|
|
|
strbuf_addf(&header,
|
|
|
|
_("This is a combination of %d commits."), ++count);
|
|
|
|
strbuf_splice(&buf, 0, eol - buf.buf, header.buf, header.len);
|
|
|
|
strbuf_release(&header);
|
|
|
|
} else {
|
2017-05-06 22:10:07 +00:00
|
|
|
struct object_id head;
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
struct commit *head_commit;
|
|
|
|
const char *head_message, *body;
|
|
|
|
|
2017-05-06 22:10:07 +00:00
|
|
|
if (get_oid("HEAD", &head))
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
return error(_("need a HEAD to fixup"));
|
Convert lookup_commit* to struct object_id
Convert lookup_commit, lookup_commit_or_die,
lookup_commit_reference, and lookup_commit_reference_gently to take
struct object_id arguments.
Introduce a temporary in parse_object buffer in order to convert this
function. This is required since in order to convert parse_object and
parse_object_buffer, lookup_commit_reference_gently and
lookup_commit_or_die would need to be converted. Not introducing a
temporary would therefore require that lookup_commit_or_die take a
struct object_id *, but lookup_commit would take unsigned char *,
leaving a confusing and hard-to-use interface.
parse_object_buffer will lose this temporary in a later patch.
This commit was created with manual changes to commit.c, commit.h, and
object.c, plus the following semantic patch:
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1.hash, E2)
+ lookup_commit_reference_gently(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1->hash, E2)
+ lookup_commit_reference_gently(E1, E2)
@@
expression E1;
@@
- lookup_commit_reference(E1.hash)
+ lookup_commit_reference(&E1)
@@
expression E1;
@@
- lookup_commit_reference(E1->hash)
+ lookup_commit_reference(E1)
@@
expression E1;
@@
- lookup_commit(E1.hash)
+ lookup_commit(&E1)
@@
expression E1;
@@
- lookup_commit(E1->hash)
+ lookup_commit(E1)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1.hash, E2)
+ lookup_commit_or_die(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1->hash, E2)
+ lookup_commit_or_die(E1, E2)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-06 22:10:10 +00:00
|
|
|
if (!(head_commit = lookup_commit_reference(&head)))
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
return error(_("could not read HEAD"));
|
|
|
|
if (!(head_message = get_commit_buffer(head_commit, NULL)))
|
|
|
|
return error(_("could not read HEAD's commit message"));
|
|
|
|
|
|
|
|
find_commit_subject(head_message, &body);
|
|
|
|
if (write_message(body, strlen(body),
|
|
|
|
rebase_path_fixup_msg(), 0)) {
|
|
|
|
unuse_commit_buffer(head_commit, head_message);
|
|
|
|
return error(_("cannot write '%s'"),
|
|
|
|
rebase_path_fixup_msg());
|
|
|
|
}
|
|
|
|
|
|
|
|
count = 2;
|
|
|
|
strbuf_addf(&buf, "%c ", comment_line_char);
|
|
|
|
strbuf_addf(&buf, _("This is a combination of %d commits."),
|
|
|
|
count);
|
|
|
|
strbuf_addf(&buf, "\n%c ", comment_line_char);
|
|
|
|
strbuf_addstr(&buf, _("This is the 1st commit message:"));
|
|
|
|
strbuf_addstr(&buf, "\n\n");
|
|
|
|
strbuf_addstr(&buf, body);
|
|
|
|
|
|
|
|
unuse_commit_buffer(head_commit, head_message);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(message = get_commit_buffer(commit, NULL)))
|
|
|
|
return error(_("could not read commit message of %s"),
|
|
|
|
oid_to_hex(&commit->object.oid));
|
|
|
|
find_commit_subject(message, &body);
|
|
|
|
|
|
|
|
if (command == TODO_SQUASH) {
|
|
|
|
unlink(rebase_path_fixup_msg());
|
|
|
|
strbuf_addf(&buf, "\n%c ", comment_line_char);
|
|
|
|
strbuf_addf(&buf, _("This is the commit message #%d:"), count);
|
|
|
|
strbuf_addstr(&buf, "\n\n");
|
|
|
|
strbuf_addstr(&buf, body);
|
|
|
|
} else if (command == TODO_FIXUP) {
|
|
|
|
strbuf_addf(&buf, "\n%c ", comment_line_char);
|
|
|
|
strbuf_addf(&buf, _("The commit message #%d will be skipped:"),
|
|
|
|
count);
|
|
|
|
strbuf_addstr(&buf, "\n\n");
|
|
|
|
strbuf_add_commented_lines(&buf, body, strlen(body));
|
|
|
|
} else
|
|
|
|
return error(_("unknown command: %d"), command);
|
|
|
|
unuse_commit_buffer(commit, message);
|
|
|
|
|
|
|
|
res = write_message(buf.buf, buf.len, rebase_path_squash_msg(), 0);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:28:16 +00:00
|
|
|
static void flush_rewritten_pending(void) {
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2017-07-13 23:49:22 +00:00
|
|
|
struct object_id newoid;
|
2017-01-02 15:28:16 +00:00
|
|
|
FILE *out;
|
|
|
|
|
2017-07-13 23:49:22 +00:00
|
|
|
if (strbuf_read_file(&buf, rebase_path_rewritten_pending(), (GIT_MAX_HEXSZ + 1) * 2) > 0 &&
|
|
|
|
!get_oid("HEAD", &newoid) &&
|
2017-05-03 10:16:50 +00:00
|
|
|
(out = fopen_or_warn(rebase_path_rewritten_list(), "a"))) {
|
2017-01-02 15:28:16 +00:00
|
|
|
char *bol = buf.buf, *eol;
|
|
|
|
|
|
|
|
while (*bol) {
|
|
|
|
eol = strchrnul(bol, '\n');
|
|
|
|
fprintf(out, "%.*s %s\n", (int)(eol - bol),
|
2017-07-13 23:49:22 +00:00
|
|
|
bol, oid_to_hex(&newoid));
|
2017-01-02 15:28:16 +00:00
|
|
|
if (!*eol)
|
|
|
|
break;
|
|
|
|
bol = eol + 1;
|
|
|
|
}
|
|
|
|
fclose(out);
|
|
|
|
unlink(rebase_path_rewritten_pending());
|
|
|
|
}
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void record_in_rewritten(struct object_id *oid,
|
|
|
|
enum todo_command next_command) {
|
2017-05-03 10:16:50 +00:00
|
|
|
FILE *out = fopen_or_warn(rebase_path_rewritten_pending(), "a");
|
2017-01-02 15:28:16 +00:00
|
|
|
|
|
|
|
if (!out)
|
|
|
|
return;
|
|
|
|
|
|
|
|
fprintf(out, "%s\n", oid_to_hex(oid));
|
|
|
|
fclose(out);
|
|
|
|
|
|
|
|
if (!is_fixup(next_command))
|
|
|
|
flush_rewritten_pending();
|
|
|
|
}
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
static int do_pick_commit(enum todo_command command, struct commit *commit,
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
struct replay_opts *opts, int final_fixup)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
2017-03-23 16:07:11 +00:00
|
|
|
unsigned int flags = opts->edit ? EDIT_MSG : 0;
|
|
|
|
const char *msg_file = opts->edit ? NULL : git_path_merge_msg();
|
2017-05-06 22:10:32 +00:00
|
|
|
struct object_id head;
|
2012-01-11 18:15:57 +00:00
|
|
|
struct commit *base, *next, *parent;
|
|
|
|
const char *base_label, *next_label;
|
2014-06-10 21:39:35 +00:00
|
|
|
struct commit_message msg = { NULL, NULL, NULL, NULL };
|
2012-01-11 18:15:57 +00:00
|
|
|
struct strbuf msgbuf = STRBUF_INIT;
|
2017-03-23 16:07:11 +00:00
|
|
|
int res, unborn = 0, allow;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
if (opts->no_commit) {
|
|
|
|
/*
|
|
|
|
* We do not intend to commit immediately. We just want to
|
|
|
|
* merge the differences in, so let's compute the tree
|
|
|
|
* that represents the "current" state for merge-recursive
|
|
|
|
* to work on.
|
|
|
|
*/
|
2017-05-06 22:10:32 +00:00
|
|
|
if (write_cache_as_tree(head.hash, 0, NULL))
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("your index file is unmerged."));
|
2012-01-11 18:15:57 +00:00
|
|
|
} else {
|
2017-05-06 22:10:32 +00:00
|
|
|
unborn = get_oid("HEAD", &head);
|
2012-12-21 19:10:11 +00:00
|
|
|
if (unborn)
|
2017-05-06 22:10:32 +00:00
|
|
|
oidcpy(&head, &empty_tree_oid);
|
2016-10-24 10:42:21 +00:00
|
|
|
if (index_differs_from(unborn ? EMPTY_TREE_SHA1_HEX : "HEAD", 0, 0))
|
2012-01-11 18:15:57 +00:00
|
|
|
return error_dirty_index(opts);
|
|
|
|
}
|
|
|
|
discard_cache();
|
|
|
|
|
2017-01-02 15:26:08 +00:00
|
|
|
if (!commit->parents)
|
2012-01-11 18:15:57 +00:00
|
|
|
parent = NULL;
|
|
|
|
else if (commit->parents->next) {
|
|
|
|
/* Reverting or cherry-picking a merge commit */
|
|
|
|
int cnt;
|
|
|
|
struct commit_list *p;
|
|
|
|
|
|
|
|
if (!opts->mainline)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("commit %s is a merge but no -m option was given."),
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&commit->object.oid));
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
for (cnt = 1, p = commit->parents;
|
|
|
|
cnt != opts->mainline && p;
|
|
|
|
cnt++)
|
|
|
|
p = p->next;
|
|
|
|
if (cnt != opts->mainline || !p)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("commit %s does not have parent %d"),
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&commit->object.oid), opts->mainline);
|
2012-01-11 18:15:57 +00:00
|
|
|
parent = p->item;
|
|
|
|
} else if (0 < opts->mainline)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("mainline was specified but commit %s is not a merge."),
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&commit->object.oid));
|
2012-01-11 18:15:57 +00:00
|
|
|
else
|
|
|
|
parent = commit->parents->item;
|
|
|
|
|
2017-01-02 15:28:05 +00:00
|
|
|
if (get_message(commit, &msg) != 0)
|
|
|
|
return error(_("cannot get commit message for %s"),
|
|
|
|
oid_to_hex(&commit->object.oid));
|
|
|
|
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
if (opts->allow_ff && !is_fixup(command) &&
|
2017-05-06 22:10:32 +00:00
|
|
|
((parent && !oidcmp(&parent->object.oid, &head)) ||
|
2017-01-02 15:28:05 +00:00
|
|
|
(!parent && unborn))) {
|
|
|
|
if (is_rebase_i(opts))
|
|
|
|
write_author_script(msg.message);
|
2017-05-06 22:10:32 +00:00
|
|
|
res = fast_forward_to(&commit->object.oid, &head, unborn,
|
2017-01-02 15:28:05 +00:00
|
|
|
opts);
|
|
|
|
if (res || command != TODO_REWORD)
|
|
|
|
goto leave;
|
2017-03-23 16:07:11 +00:00
|
|
|
flags |= EDIT_MSG | AMEND_MSG;
|
2017-03-23 16:07:17 +00:00
|
|
|
if (command == TODO_REWORD)
|
|
|
|
flags |= VERIFY_MSG;
|
2017-01-02 15:28:05 +00:00
|
|
|
msg_file = NULL;
|
|
|
|
goto fast_forward_edit;
|
|
|
|
}
|
2012-01-11 18:15:57 +00:00
|
|
|
if (parent && parse_commit(parent) < 0)
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
/* TRANSLATORS: The first %s will be a "todo" command like
|
|
|
|
"revert" or "pick", the second %s a SHA1. */
|
2012-01-11 18:15:57 +00:00
|
|
|
return error(_("%s: cannot parse parent commit %s"),
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
command_to_string(command),
|
|
|
|
oid_to_hex(&parent->object.oid));
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* "commit" is an existing commit. We would want to apply
|
|
|
|
* the difference it introduces since its first parent "prev"
|
|
|
|
* on top of the current HEAD if we are cherry-pick. Or the
|
|
|
|
* reverse of it if we are revert.
|
|
|
|
*/
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
if (command == TODO_REVERT) {
|
2012-01-11 18:15:57 +00:00
|
|
|
base = commit;
|
|
|
|
base_label = msg.label;
|
|
|
|
next = parent;
|
|
|
|
next_label = msg.parent_label;
|
|
|
|
strbuf_addstr(&msgbuf, "Revert \"");
|
|
|
|
strbuf_addstr(&msgbuf, msg.subject);
|
|
|
|
strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
|
2015-11-10 02:22:28 +00:00
|
|
|
strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
if (commit->parents && commit->parents->next) {
|
|
|
|
strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
|
2015-11-10 02:22:28 +00:00
|
|
|
strbuf_addstr(&msgbuf, oid_to_hex(&parent->object.oid));
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
strbuf_addstr(&msgbuf, ".\n");
|
|
|
|
} else {
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
base = parent;
|
|
|
|
base_label = msg.parent_label;
|
|
|
|
next = commit;
|
|
|
|
next_label = msg.label;
|
|
|
|
|
2017-01-02 15:26:20 +00:00
|
|
|
/* Append the commit log message to msgbuf. */
|
|
|
|
if (find_commit_subject(msg.message, &p))
|
|
|
|
strbuf_addstr(&msgbuf, p);
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
if (opts->record_origin) {
|
2017-04-26 20:50:03 +00:00
|
|
|
strbuf_complete_line(&msgbuf);
|
2013-02-12 10:17:35 +00:00
|
|
|
if (!has_conforming_footer(&msgbuf, NULL, 0))
|
2013-02-12 10:17:34 +00:00
|
|
|
strbuf_addch(&msgbuf, '\n');
|
2013-02-12 10:17:32 +00:00
|
|
|
strbuf_addstr(&msgbuf, cherry_picked_prefix);
|
2015-11-10 02:22:28 +00:00
|
|
|
strbuf_addstr(&msgbuf, oid_to_hex(&commit->object.oid));
|
2012-01-11 18:15:57 +00:00
|
|
|
strbuf_addstr(&msgbuf, ")\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:28:00 +00:00
|
|
|
if (command == TODO_REWORD)
|
2017-03-23 16:07:17 +00:00
|
|
|
flags |= EDIT_MSG | VERIFY_MSG;
|
2017-01-02 15:28:00 +00:00
|
|
|
else if (is_fixup(command)) {
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
if (update_squash_messages(command, commit, opts))
|
|
|
|
return -1;
|
2017-03-23 16:07:11 +00:00
|
|
|
flags |= AMEND_MSG;
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
if (!final_fixup)
|
|
|
|
msg_file = rebase_path_squash_msg();
|
|
|
|
else if (file_exists(rebase_path_fixup_msg())) {
|
2017-03-23 16:07:11 +00:00
|
|
|
flags |= CLEANUP_MSG;
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
msg_file = rebase_path_fixup_msg();
|
|
|
|
} else {
|
2017-04-20 21:08:54 +00:00
|
|
|
const char *dest = git_path_squash_msg();
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
unlink(dest);
|
|
|
|
if (copy_file(dest, rebase_path_squash_msg(), 0666))
|
|
|
|
return error(_("could not rename '%s' to '%s'"),
|
|
|
|
rebase_path_squash_msg(), dest);
|
2017-04-20 21:08:54 +00:00
|
|
|
unlink(git_path_merge_msg());
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
msg_file = dest;
|
2017-03-23 16:07:11 +00:00
|
|
|
flags |= EDIT_MSG;
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:27:18 +00:00
|
|
|
if (is_rebase_i(opts) && write_author_script(msg.message) < 0)
|
|
|
|
res = -1;
|
|
|
|
else if (!opts->strategy || !strcmp(opts->strategy, "recursive") || command == TODO_REVERT) {
|
2012-01-11 18:15:57 +00:00
|
|
|
res = do_recursive_merge(base, next, base_label, next_label,
|
2017-05-06 22:10:36 +00:00
|
|
|
&head, &msgbuf, opts);
|
prepare the builtins for a libified merge_recursive()
Previously, callers of merge_trees() or merge_recursive() expected that
code to die() with an error message. This used to be okay because we
called those commands from scripts, and had a chance to print out a
message in case the command failed fatally (read: with exit code 128).
As scripting incurs its own set of problems (portability, speed,
idiosyncrasies of different shells, limited data structures leading to
inefficient code), we are converting more and more of these scripts into
builtins, using library functions directly.
We already tried to use merge_recursive() directly in the builtin
git-am, for example. Unfortunately, we had to roll it back temporarily
because some of the code in merge-recursive.c still deemed it okay to
call die(), when the builtin am code really wanted to print out a useful
advice after the merge failed fatally. In the next commits, we want to
fix that.
The code touched by this commit expected merge_trees() to die() with
some useful message when there is an error condition, but merge_trees()
is going to be improved by converting all die() calls to return error()
instead (i.e. return value -1 after printing out the message as before),
so that the caller can react more flexibly.
This is a step to prepare for the version of merge_trees() that no
longer dies, even if we just imitate the previous behavior by calling
exit(128): this is what callers of e.g. `git merge` have come to expect.
Note that the callers of the sequencer (revert and cherry-pick) already
fail fast even for the return value -1; The only difference is that they
now get a chance to say "<command> failed".
A caller of merge_trees() might want handle error messages themselves
(or even suppress them). As this patch is already complex enough, we
leave that change for a later patch.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-26 16:06:02 +00:00
|
|
|
if (res < 0)
|
|
|
|
return res;
|
2016-10-21 12:26:05 +00:00
|
|
|
res |= write_message(msgbuf.buf, msgbuf.len,
|
2016-10-21 12:26:09 +00:00
|
|
|
git_path_merge_msg(), 0);
|
2012-01-11 18:15:57 +00:00
|
|
|
} else {
|
|
|
|
struct commit_list *common = NULL;
|
|
|
|
struct commit_list *remotes = NULL;
|
|
|
|
|
2016-10-21 12:26:05 +00:00
|
|
|
res = write_message(msgbuf.buf, msgbuf.len,
|
2016-10-21 12:26:09 +00:00
|
|
|
git_path_merge_msg(), 0);
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
commit_list_insert(base, &common);
|
|
|
|
commit_list_insert(next, &remotes);
|
2016-10-21 12:24:13 +00:00
|
|
|
res |= try_merge_command(opts->strategy,
|
|
|
|
opts->xopts_nr, (const char **)opts->xopts,
|
2017-05-06 22:10:32 +00:00
|
|
|
common, oid_to_hex(&head), remotes);
|
2012-01-11 18:15:57 +00:00
|
|
|
free_commit_list(common);
|
|
|
|
free_commit_list(remotes);
|
|
|
|
}
|
2016-10-21 12:25:41 +00:00
|
|
|
strbuf_release(&msgbuf);
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the merge was clean or if it failed due to conflict, we write
|
|
|
|
* CHERRY_PICK_HEAD for the subsequent invocation of commit to use.
|
|
|
|
* However, if the merge did not even start, then we don't want to
|
|
|
|
* write it at all.
|
|
|
|
*/
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
if (command == TODO_PICK && !opts->no_commit && (res == 0 || res == 1) &&
|
2017-10-15 22:06:51 +00:00
|
|
|
update_ref(NULL, "CHERRY_PICK_HEAD", &commit->object.oid, NULL,
|
2016-08-26 13:47:14 +00:00
|
|
|
REF_NODEREF, UPDATE_REFS_MSG_ON_ERR))
|
|
|
|
res = -1;
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
if (command == TODO_REVERT && ((opts->no_commit && res == 0) || res == 1) &&
|
2017-10-15 22:06:51 +00:00
|
|
|
update_ref(NULL, "REVERT_HEAD", &commit->object.oid, NULL,
|
2016-08-26 13:47:14 +00:00
|
|
|
REF_NODEREF, UPDATE_REFS_MSG_ON_ERR))
|
|
|
|
res = -1;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
if (res) {
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
error(command == TODO_REVERT
|
2012-01-11 18:15:57 +00:00
|
|
|
? _("could not revert %s... %s")
|
|
|
|
: _("could not apply %s... %s"),
|
2016-10-21 12:24:37 +00:00
|
|
|
short_commit_name(commit), msg.subject);
|
2012-02-22 00:44:17 +00:00
|
|
|
print_advice(res == 1, opts);
|
2012-01-11 18:15:57 +00:00
|
|
|
rerere(opts->allow_rerere_auto);
|
2013-05-29 03:56:21 +00:00
|
|
|
goto leave;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2013-05-29 03:56:21 +00:00
|
|
|
allow = allow_empty(opts, commit);
|
2013-06-06 08:58:57 +00:00
|
|
|
if (allow < 0) {
|
|
|
|
res = allow;
|
|
|
|
goto leave;
|
2017-03-23 16:07:11 +00:00
|
|
|
} else if (allow)
|
|
|
|
flags |= ALLOW_EMPTY;
|
2013-05-29 03:56:21 +00:00
|
|
|
if (!opts->no_commit)
|
2017-01-02 15:28:05 +00:00
|
|
|
fast_forward_edit:
|
2017-03-23 16:07:11 +00:00
|
|
|
res = run_git_commit(msg_file, opts, flags);
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
|
|
|
|
if (!res && final_fixup) {
|
|
|
|
unlink(rebase_path_fixup_msg());
|
|
|
|
unlink(rebase_path_squash_msg());
|
|
|
|
}
|
2013-05-29 03:56:21 +00:00
|
|
|
|
|
|
|
leave:
|
2014-06-10 21:39:35 +00:00
|
|
|
free_message(commit, &msg);
|
2016-12-07 21:51:32 +00:00
|
|
|
update_abort_safety_file();
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2016-09-09 14:37:18 +00:00
|
|
|
static int prepare_revs(struct replay_opts *opts)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
2012-08-29 06:15:56 +00:00
|
|
|
/*
|
|
|
|
* picking (but not reverting) ranges (but not individual revisions)
|
|
|
|
* should be done in reverse
|
|
|
|
*/
|
|
|
|
if (opts->action == REPLAY_PICK && !opts->revs->no_walk)
|
2012-01-11 18:15:57 +00:00
|
|
|
opts->revs->reverse ^= 1;
|
|
|
|
|
|
|
|
if (prepare_revision_walk(opts->revs))
|
2016-09-09 14:37:18 +00:00
|
|
|
return error(_("revision walk setup failed"));
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
if (!opts->revs->commits)
|
2016-09-09 14:37:18 +00:00
|
|
|
return error(_("empty commit set passed"));
|
|
|
|
return 0;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2016-09-09 14:37:21 +00:00
|
|
|
static int read_and_refresh_cache(struct replay_opts *opts)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
|
|
|
static struct lock_file index_lock;
|
|
|
|
int index_fd = hold_locked_index(&index_lock, 0);
|
2016-09-09 14:38:20 +00:00
|
|
|
if (read_index_preload(&the_index, NULL) < 0) {
|
|
|
|
rollback_lock_file(&index_lock);
|
2016-09-09 14:37:21 +00:00
|
|
|
return error(_("git %s: failed to read the index"),
|
2016-10-21 12:26:17 +00:00
|
|
|
_(action_name(opts)));
|
2016-09-09 14:38:20 +00:00
|
|
|
}
|
2012-01-11 18:15:57 +00:00
|
|
|
refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL);
|
2014-04-28 10:55:24 +00:00
|
|
|
if (the_index.cache_changed && index_fd >= 0) {
|
2016-09-09 14:38:20 +00:00
|
|
|
if (write_locked_index(&the_index, &index_lock, COMMIT_LOCK)) {
|
|
|
|
rollback_lock_file(&index_lock);
|
2016-09-09 14:37:21 +00:00
|
|
|
return error(_("git %s: failed to refresh the index"),
|
2016-10-21 12:26:17 +00:00
|
|
|
_(action_name(opts)));
|
2016-09-09 14:38:20 +00:00
|
|
|
}
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
rollback_lock_file(&index_lock);
|
2016-09-09 14:37:21 +00:00
|
|
|
return 0;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
struct todo_item {
|
|
|
|
enum todo_command command;
|
|
|
|
struct commit *commit;
|
2016-10-21 12:25:00 +00:00
|
|
|
const char *arg;
|
|
|
|
int arg_len;
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
size_t offset_in_buf;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct todo_list {
|
|
|
|
struct strbuf buf;
|
|
|
|
struct todo_item *items;
|
|
|
|
int nr, alloc, current;
|
2017-01-02 15:35:46 +00:00
|
|
|
int done_nr, total_nr;
|
2017-04-26 19:17:40 +00:00
|
|
|
struct stat_data stat;
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define TODO_LIST_INIT { STRBUF_INIT }
|
|
|
|
|
|
|
|
static void todo_list_release(struct todo_list *todo_list)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
strbuf_release(&todo_list->buf);
|
2017-06-15 23:15:46 +00:00
|
|
|
FREE_AND_NULL(todo_list->items);
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
todo_list->nr = todo_list->alloc = 0;
|
|
|
|
}
|
2012-01-11 18:15:57 +00:00
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
static struct todo_item *append_new_todo(struct todo_list *todo_list)
|
|
|
|
{
|
|
|
|
ALLOC_GROW(todo_list->items, todo_list->nr + 1, todo_list->alloc);
|
|
|
|
return todo_list->items + todo_list->nr++;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
static int parse_insn_line(struct todo_item *item, const char *bol, char *eol)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
2017-05-06 22:10:09 +00:00
|
|
|
struct object_id commit_oid;
|
2012-01-11 18:15:57 +00:00
|
|
|
char *end_of_object_name;
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
int i, saved, status, padding;
|
|
|
|
|
2016-10-21 12:25:36 +00:00
|
|
|
/* left-trim */
|
|
|
|
bol += strspn(bol, " \t");
|
|
|
|
|
2017-01-02 15:26:38 +00:00
|
|
|
if (bol == eol || *bol == '\r' || *bol == comment_line_char) {
|
2017-01-02 15:34:39 +00:00
|
|
|
item->command = TODO_COMMENT;
|
2017-01-02 15:26:38 +00:00
|
|
|
item->commit = NULL;
|
|
|
|
item->arg = bol;
|
|
|
|
item->arg_len = eol - bol;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:34:39 +00:00
|
|
|
for (i = 0; i < TODO_COMMENT; i++)
|
2017-01-02 15:27:15 +00:00
|
|
|
if (skip_prefix(bol, todo_command_info[i].str, &bol)) {
|
|
|
|
item->command = i;
|
|
|
|
break;
|
|
|
|
} else if (bol[1] == ' ' && *bol == todo_command_info[i].c) {
|
|
|
|
bol++;
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
item->command = i;
|
|
|
|
break;
|
|
|
|
}
|
2017-01-02 15:34:39 +00:00
|
|
|
if (i >= TODO_COMMENT)
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
return -1;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
2017-01-02 15:26:38 +00:00
|
|
|
if (item->command == TODO_NOOP) {
|
|
|
|
item->commit = NULL;
|
|
|
|
item->arg = bol;
|
|
|
|
item->arg_len = eol - bol;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-11 18:15:57 +00:00
|
|
|
/* Eat up extra spaces/ tabs before object name */
|
|
|
|
padding = strspn(bol, " \t");
|
|
|
|
if (!padding)
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
return -1;
|
2012-01-11 18:15:57 +00:00
|
|
|
bol += padding;
|
|
|
|
|
2017-01-02 15:26:47 +00:00
|
|
|
if (item->command == TODO_EXEC) {
|
|
|
|
item->arg = bol;
|
|
|
|
item->arg_len = (int)(eol - bol);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
end_of_object_name = (char *) bol + strcspn(bol, " \t\n");
|
2012-01-11 18:15:57 +00:00
|
|
|
saved = *end_of_object_name;
|
|
|
|
*end_of_object_name = '\0';
|
2017-05-06 22:10:09 +00:00
|
|
|
status = get_oid(bol, &commit_oid);
|
2012-01-11 18:15:57 +00:00
|
|
|
*end_of_object_name = saved;
|
|
|
|
|
2016-10-21 12:25:00 +00:00
|
|
|
item->arg = end_of_object_name + strspn(end_of_object_name, " \t");
|
|
|
|
item->arg_len = (int)(eol - item->arg);
|
|
|
|
|
2012-01-11 18:15:57 +00:00
|
|
|
if (status < 0)
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
return -1;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
Convert lookup_commit* to struct object_id
Convert lookup_commit, lookup_commit_or_die,
lookup_commit_reference, and lookup_commit_reference_gently to take
struct object_id arguments.
Introduce a temporary in parse_object buffer in order to convert this
function. This is required since in order to convert parse_object and
parse_object_buffer, lookup_commit_reference_gently and
lookup_commit_or_die would need to be converted. Not introducing a
temporary would therefore require that lookup_commit_or_die take a
struct object_id *, but lookup_commit would take unsigned char *,
leaving a confusing and hard-to-use interface.
parse_object_buffer will lose this temporary in a later patch.
This commit was created with manual changes to commit.c, commit.h, and
object.c, plus the following semantic patch:
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1.hash, E2)
+ lookup_commit_reference_gently(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1->hash, E2)
+ lookup_commit_reference_gently(E1, E2)
@@
expression E1;
@@
- lookup_commit_reference(E1.hash)
+ lookup_commit_reference(&E1)
@@
expression E1;
@@
- lookup_commit_reference(E1->hash)
+ lookup_commit_reference(E1)
@@
expression E1;
@@
- lookup_commit(E1.hash)
+ lookup_commit(&E1)
@@
expression E1;
@@
- lookup_commit(E1->hash)
+ lookup_commit(E1)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1.hash, E2)
+ lookup_commit_or_die(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1->hash, E2)
+ lookup_commit_or_die(E1, E2)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-06 22:10:10 +00:00
|
|
|
item->commit = lookup_commit_reference(&commit_oid);
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
return !item->commit;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
static int parse_insn_buffer(char *buf, struct todo_list *todo_list)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
struct todo_item *item;
|
|
|
|
char *p = buf, *next_p;
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
int i, res = 0, fixup_okay = file_exists(rebase_path_done());
|
2012-01-11 18:15:57 +00:00
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
for (i = 1; *p; i++, p = next_p) {
|
2012-01-11 18:15:57 +00:00
|
|
|
char *eol = strchrnul(p, '\n');
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
|
|
|
|
next_p = *eol ? eol + 1 /* skip LF */ : eol;
|
|
|
|
|
2016-10-21 12:24:46 +00:00
|
|
|
if (p != eol && eol[-1] == '\r')
|
|
|
|
eol--; /* strip Carriage Return */
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
item = append_new_todo(todo_list);
|
|
|
|
item->offset_in_buf = p - todo_list->buf.buf;
|
|
|
|
if (parse_insn_line(item, p, eol)) {
|
2016-10-21 12:26:25 +00:00
|
|
|
res = error(_("invalid line %d: %.*s"),
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
i, (int)(eol - p), p);
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
item->command = TODO_NOOP;
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
}
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
|
|
|
|
if (fixup_okay)
|
|
|
|
; /* do nothing */
|
|
|
|
else if (is_fixup(item->command))
|
|
|
|
return error(_("cannot '%s' without a previous commit"),
|
|
|
|
command_to_string(item->command));
|
|
|
|
else if (!is_noop(item->command))
|
|
|
|
fixup_okay = 1;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
2017-01-02 15:27:34 +00:00
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
return res;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2017-01-02 15:35:46 +00:00
|
|
|
static int count_commands(struct todo_list *todo_list)
|
|
|
|
{
|
|
|
|
int count = 0, i;
|
|
|
|
|
|
|
|
for (i = 0; i < todo_list->nr; i++)
|
|
|
|
if (todo_list->items[i].command != TODO_COMMENT)
|
|
|
|
count++;
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
static int read_populate_todo(struct todo_list *todo_list,
|
2012-01-11 18:15:57 +00:00
|
|
|
struct replay_opts *opts)
|
|
|
|
{
|
2017-04-26 19:17:40 +00:00
|
|
|
struct stat st;
|
2016-10-21 12:24:32 +00:00
|
|
|
const char *todo_file = get_todo_path(opts);
|
2012-01-11 18:15:57 +00:00
|
|
|
int fd, res;
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
strbuf_reset(&todo_list->buf);
|
2016-10-21 12:24:32 +00:00
|
|
|
fd = open(todo_file, O_RDONLY);
|
2012-01-11 18:15:57 +00:00
|
|
|
if (fd < 0)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error_errno(_("could not open '%s'"), todo_file);
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
if (strbuf_read(&todo_list->buf, fd, 0) < 0) {
|
2012-01-11 18:15:57 +00:00
|
|
|
close(fd);
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("could not read '%s'."), todo_file);
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
|
2017-04-26 19:17:40 +00:00
|
|
|
res = stat(todo_file, &st);
|
|
|
|
if (res)
|
|
|
|
return error(_("could not stat '%s'"), todo_file);
|
|
|
|
fill_stat_data(&todo_list->stat, &st);
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
res = parse_insn_buffer(todo_list->buf.buf, todo_list);
|
2017-01-02 15:35:42 +00:00
|
|
|
if (res) {
|
|
|
|
if (is_rebase_i(opts))
|
|
|
|
return error(_("please fix this using "
|
|
|
|
"'git rebase --edit-todo'."));
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("unusable instruction sheet: '%s'"), todo_file);
|
2017-01-02 15:35:42 +00:00
|
|
|
}
|
2016-10-21 12:26:13 +00:00
|
|
|
|
2017-01-02 15:27:34 +00:00
|
|
|
if (!todo_list->nr &&
|
|
|
|
(!is_rebase_i(opts) || !file_exists(rebase_path_done())))
|
|
|
|
return error(_("no commits parsed."));
|
|
|
|
|
2016-10-21 12:26:13 +00:00
|
|
|
if (!is_rebase_i(opts)) {
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
enum todo_command valid =
|
|
|
|
opts->action == REPLAY_PICK ? TODO_PICK : TODO_REVERT;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < todo_list->nr; i++)
|
|
|
|
if (valid == todo_list->items[i].command)
|
|
|
|
continue;
|
|
|
|
else if (valid == TODO_PICK)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("cannot cherry-pick during a revert."));
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
else
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("cannot revert during a cherry-pick."));
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
}
|
|
|
|
|
2017-01-02 15:35:46 +00:00
|
|
|
if (is_rebase_i(opts)) {
|
|
|
|
struct todo_list done = TODO_LIST_INIT;
|
2017-05-03 10:16:50 +00:00
|
|
|
FILE *f = fopen_or_warn(rebase_path_msgtotal(), "w");
|
2017-01-02 15:35:46 +00:00
|
|
|
|
|
|
|
if (strbuf_read_file(&done.buf, rebase_path_done(), 0) > 0 &&
|
|
|
|
!parse_insn_buffer(done.buf.buf, &done))
|
|
|
|
todo_list->done_nr = count_commands(&done);
|
|
|
|
else
|
|
|
|
todo_list->done_nr = 0;
|
|
|
|
|
|
|
|
todo_list->total_nr = todo_list->done_nr
|
|
|
|
+ count_commands(todo_list);
|
|
|
|
todo_list_release(&done);
|
2017-01-02 15:36:20 +00:00
|
|
|
|
|
|
|
if (f) {
|
|
|
|
fprintf(f, "%d\n", todo_list->total_nr);
|
|
|
|
fclose(f);
|
|
|
|
}
|
2017-01-02 15:35:46 +00:00
|
|
|
}
|
|
|
|
|
2016-09-09 14:37:24 +00:00
|
|
|
return 0;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2016-10-21 12:24:13 +00:00
|
|
|
static int git_config_string_dup(char **dest,
|
|
|
|
const char *var, const char *value)
|
|
|
|
{
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
free(*dest);
|
|
|
|
*dest = xstrdup(value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-11 18:15:57 +00:00
|
|
|
static int populate_opts_cb(const char *key, const char *value, void *data)
|
|
|
|
{
|
|
|
|
struct replay_opts *opts = data;
|
|
|
|
int error_flag = 1;
|
|
|
|
|
|
|
|
if (!value)
|
|
|
|
error_flag = 0;
|
|
|
|
else if (!strcmp(key, "options.no-commit"))
|
|
|
|
opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
|
|
|
|
else if (!strcmp(key, "options.edit"))
|
|
|
|
opts->edit = git_config_bool_or_int(key, value, &error_flag);
|
|
|
|
else if (!strcmp(key, "options.signoff"))
|
|
|
|
opts->signoff = git_config_bool_or_int(key, value, &error_flag);
|
|
|
|
else if (!strcmp(key, "options.record-origin"))
|
|
|
|
opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
|
|
|
|
else if (!strcmp(key, "options.allow-ff"))
|
|
|
|
opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
|
|
|
|
else if (!strcmp(key, "options.mainline"))
|
|
|
|
opts->mainline = git_config_int(key, value);
|
|
|
|
else if (!strcmp(key, "options.strategy"))
|
2016-10-21 12:24:13 +00:00
|
|
|
git_config_string_dup(&opts->strategy, key, value);
|
2014-01-24 00:50:58 +00:00
|
|
|
else if (!strcmp(key, "options.gpg-sign"))
|
2016-10-21 12:24:13 +00:00
|
|
|
git_config_string_dup(&opts->gpg_sign, key, value);
|
2012-01-11 18:15:57 +00:00
|
|
|
else if (!strcmp(key, "options.strategy-option")) {
|
|
|
|
ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
|
|
|
|
opts->xopts[opts->xopts_nr++] = xstrdup(value);
|
2017-08-02 10:44:19 +00:00
|
|
|
} else if (!strcmp(key, "options.allow-rerere-auto"))
|
|
|
|
opts->allow_rerere_auto =
|
|
|
|
git_config_bool_or_int(key, value, &error_flag) ?
|
|
|
|
RERERE_AUTOUPDATE : RERERE_NOAUTOUPDATE;
|
|
|
|
else
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("invalid key: %s"), key);
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
if (!error_flag)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("invalid value for %s: %s"), key, value);
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:28:30 +00:00
|
|
|
static void read_strategy_opts(struct replay_opts *opts, struct strbuf *buf)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
strbuf_reset(buf);
|
|
|
|
if (!read_oneliner(buf, rebase_path_strategy(), 0))
|
|
|
|
return;
|
|
|
|
opts->strategy = strbuf_detach(buf, NULL);
|
|
|
|
if (!read_oneliner(buf, rebase_path_strategy_opts(), 0))
|
|
|
|
return;
|
|
|
|
|
|
|
|
opts->xopts_nr = split_cmdline(buf->buf, (const char ***)&opts->xopts);
|
|
|
|
for (i = 0; i < opts->xopts_nr; i++) {
|
|
|
|
const char *arg = opts->xopts[i];
|
|
|
|
|
|
|
|
skip_prefix(arg, "--", &arg);
|
|
|
|
opts->xopts[i] = xstrdup(arg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-14 13:17:16 +00:00
|
|
|
static int read_populate_opts(struct replay_opts *opts)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
2016-10-21 12:25:12 +00:00
|
|
|
if (is_rebase_i(opts)) {
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (read_oneliner(&buf, rebase_path_gpg_sign_opt(), 1)) {
|
|
|
|
if (!starts_with(buf.buf, "-S"))
|
|
|
|
strbuf_reset(&buf);
|
|
|
|
else {
|
|
|
|
free(opts->gpg_sign);
|
|
|
|
opts->gpg_sign = xstrdup(buf.buf + 2);
|
|
|
|
}
|
2017-08-02 10:44:17 +00:00
|
|
|
strbuf_reset(&buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (read_oneliner(&buf, rebase_path_allow_rerere_autoupdate(), 1)) {
|
|
|
|
if (!strcmp(buf.buf, "--rerere-autoupdate"))
|
|
|
|
opts->allow_rerere_auto = RERERE_AUTOUPDATE;
|
|
|
|
else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))
|
|
|
|
opts->allow_rerere_auto = RERERE_NOAUTOUPDATE;
|
|
|
|
strbuf_reset(&buf);
|
2016-10-21 12:25:12 +00:00
|
|
|
}
|
|
|
|
|
2017-01-02 15:26:53 +00:00
|
|
|
if (file_exists(rebase_path_verbose()))
|
|
|
|
opts->verbose = 1;
|
|
|
|
|
2017-01-02 15:28:30 +00:00
|
|
|
read_strategy_opts(opts, &buf);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
2016-10-21 12:25:04 +00:00
|
|
|
return 0;
|
2016-10-21 12:25:12 +00:00
|
|
|
}
|
2016-10-21 12:25:04 +00:00
|
|
|
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
if (!file_exists(git_path_opts_file()))
|
sequencer: lib'ify read_populate_opts()
Instead of dying there, let the caller high up in the callchain notice
the error and handle it (by dying, still).
The only caller of read_populate_opts(), sequencer_continue() can
already return errors, so its caller must be already prepared to
handle error returns, and with this step, we make it notice an error
return from this function.
So this is a safe conversion to make read_populate_opts() callable
from new callers that want it not to die, without changing the
external behaviour of anything existing.
Note that the function git_config_from_file(), called from
read_populate_opts(), can currently still die() (in git_parse_source(),
because the do_config_from_file() function sets die_on_error = 1). We do
not try to fix that here, as it would have larger ramifications on the
config code, and we also assume that we write the opts file
programmatically, hence any parse errors would be bugs.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-09-09 14:37:27 +00:00
|
|
|
return 0;
|
|
|
|
/*
|
|
|
|
* The function git_parse_source(), called from git_config_from_file(),
|
|
|
|
* may die() in case of a syntactically incorrect file. We do not care
|
|
|
|
* about this case, though, because we wrote that file ourselves, so we
|
|
|
|
* are pretty certain that it is syntactically correct.
|
|
|
|
*/
|
2016-10-14 13:17:16 +00:00
|
|
|
if (git_config_from_file(populate_opts_cb, git_path_opts_file(), opts) < 0)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("malformed options sheet: '%s'"),
|
sequencer: lib'ify read_populate_opts()
Instead of dying there, let the caller high up in the callchain notice
the error and handle it (by dying, still).
The only caller of read_populate_opts(), sequencer_continue() can
already return errors, so its caller must be already prepared to
handle error returns, and with this step, we make it notice an error
return from this function.
So this is a safe conversion to make read_populate_opts() callable
from new callers that want it not to die, without changing the
external behaviour of anything existing.
Note that the function git_config_from_file(), called from
read_populate_opts(), can currently still die() (in git_parse_source(),
because the do_config_from_file() function sets die_on_error = 1). We do
not try to fix that here, as it would have larger ramifications on the
config code, and we also assume that we write the opts file
programmatically, hence any parse errors would be bugs.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-09-09 14:37:27 +00:00
|
|
|
git_path_opts_file());
|
|
|
|
return 0;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
static int walk_revs_populate_todo(struct todo_list *todo_list,
|
2012-01-11 18:15:57 +00:00
|
|
|
struct replay_opts *opts)
|
|
|
|
{
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
enum todo_command command = opts->action == REPLAY_PICK ?
|
|
|
|
TODO_PICK : TODO_REVERT;
|
2017-01-02 15:27:15 +00:00
|
|
|
const char *command_string = todo_command_info[command].str;
|
2012-01-11 18:15:57 +00:00
|
|
|
struct commit *commit;
|
|
|
|
|
2016-09-09 14:37:15 +00:00
|
|
|
if (prepare_revs(opts))
|
|
|
|
return -1;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
while ((commit = get_revision(opts->revs))) {
|
|
|
|
struct todo_item *item = append_new_todo(todo_list);
|
|
|
|
const char *commit_buffer = get_commit_buffer(commit, NULL);
|
|
|
|
const char *subject;
|
|
|
|
int subject_len;
|
|
|
|
|
|
|
|
item->command = command;
|
|
|
|
item->commit = commit;
|
2016-10-21 12:25:00 +00:00
|
|
|
item->arg = NULL;
|
|
|
|
item->arg_len = 0;
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
item->offset_in_buf = todo_list->buf.len;
|
|
|
|
subject_len = find_commit_subject(commit_buffer, &subject);
|
|
|
|
strbuf_addf(&todo_list->buf, "%s %s %.*s\n", command_string,
|
|
|
|
short_commit_name(commit), subject_len, subject);
|
|
|
|
unuse_commit_buffer(commit, commit_buffer);
|
|
|
|
}
|
2016-09-09 14:37:15 +00:00
|
|
|
return 0;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int create_seq_dir(void)
|
|
|
|
{
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
if (file_exists(git_path_seq_dir())) {
|
2012-01-11 18:15:57 +00:00
|
|
|
error(_("a cherry-pick or revert is already in progress"));
|
|
|
|
advise(_("try \"git cherry-pick (--continue | --quit | --abort)\""));
|
|
|
|
return -1;
|
2017-01-02 15:26:14 +00:00
|
|
|
} else if (mkdir(git_path_seq_dir(), 0777) < 0)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error_errno(_("could not create sequencer directory '%s'"),
|
2016-09-09 14:37:44 +00:00
|
|
|
git_path_seq_dir());
|
2012-01-11 18:15:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-09-09 14:37:47 +00:00
|
|
|
static int save_head(const char *head)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
|
|
|
static struct lock_file head_lock;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int fd;
|
2017-08-30 18:20:14 +00:00
|
|
|
ssize_t written;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
2016-09-09 14:37:47 +00:00
|
|
|
fd = hold_lock_file_for_update(&head_lock, git_path_head_file(), 0);
|
|
|
|
if (fd < 0) {
|
|
|
|
rollback_lock_file(&head_lock);
|
2016-10-21 12:26:25 +00:00
|
|
|
return error_errno(_("could not lock HEAD"));
|
2016-09-09 14:37:47 +00:00
|
|
|
}
|
2012-01-11 18:15:57 +00:00
|
|
|
strbuf_addf(&buf, "%s\n", head);
|
2017-08-30 18:20:14 +00:00
|
|
|
written = write_in_full(fd, buf.buf, buf.len);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
if (written < 0) {
|
2016-09-09 14:37:47 +00:00
|
|
|
rollback_lock_file(&head_lock);
|
2016-10-21 12:26:25 +00:00
|
|
|
return error_errno(_("could not write to '%s'"),
|
2016-09-09 14:37:47 +00:00
|
|
|
git_path_head_file());
|
|
|
|
}
|
|
|
|
if (commit_lock_file(&head_lock) < 0) {
|
|
|
|
rollback_lock_file(&head_lock);
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("failed to finalize '%s'."), git_path_head_file());
|
2016-09-09 14:37:47 +00:00
|
|
|
}
|
|
|
|
return 0;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2016-12-07 21:51:32 +00:00
|
|
|
static int rollback_is_safe(void)
|
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
struct object_id expected_head, actual_head;
|
|
|
|
|
|
|
|
if (strbuf_read_file(&sb, git_path_abort_safety_file(), 0) >= 0) {
|
|
|
|
strbuf_trim(&sb);
|
|
|
|
if (get_oid_hex(sb.buf, &expected_head)) {
|
|
|
|
strbuf_release(&sb);
|
|
|
|
die(_("could not parse %s"), git_path_abort_safety_file());
|
|
|
|
}
|
|
|
|
strbuf_release(&sb);
|
|
|
|
}
|
|
|
|
else if (errno == ENOENT)
|
|
|
|
oidclr(&expected_head);
|
|
|
|
else
|
|
|
|
die_errno(_("could not read '%s'"), git_path_abort_safety_file());
|
|
|
|
|
|
|
|
if (get_oid("HEAD", &actual_head))
|
|
|
|
oidclr(&actual_head);
|
|
|
|
|
|
|
|
return !oidcmp(&actual_head, &expected_head);
|
|
|
|
}
|
|
|
|
|
2017-07-13 23:49:22 +00:00
|
|
|
static int reset_for_rollback(const struct object_id *oid)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
|
|
|
const char *argv[4]; /* reset --merge <arg> + NULL */
|
2016-12-07 21:51:32 +00:00
|
|
|
|
2012-01-11 18:15:57 +00:00
|
|
|
argv[0] = "reset";
|
|
|
|
argv[1] = "--merge";
|
2017-07-13 23:49:22 +00:00
|
|
|
argv[2] = oid_to_hex(oid);
|
2012-01-11 18:15:57 +00:00
|
|
|
argv[3] = NULL;
|
|
|
|
return run_command_v_opt(argv, RUN_GIT_CMD);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rollback_single_pick(void)
|
|
|
|
{
|
2017-07-13 23:49:22 +00:00
|
|
|
struct object_id head_oid;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
if (!file_exists(git_path_cherry_pick_head()) &&
|
|
|
|
!file_exists(git_path_revert_head()))
|
2012-01-11 18:15:57 +00:00
|
|
|
return error(_("no cherry-pick or revert in progress"));
|
2017-10-15 22:06:56 +00:00
|
|
|
if (read_ref_full("HEAD", 0, &head_oid, NULL))
|
2012-01-11 18:15:57 +00:00
|
|
|
return error(_("cannot resolve HEAD"));
|
2017-07-13 23:49:22 +00:00
|
|
|
if (is_null_oid(&head_oid))
|
2012-01-11 18:15:57 +00:00
|
|
|
return error(_("cannot abort from a branch yet to be born"));
|
2017-07-13 23:49:22 +00:00
|
|
|
return reset_for_rollback(&head_oid);
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2016-10-21 12:24:55 +00:00
|
|
|
int sequencer_rollback(struct replay_opts *opts)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
|
|
|
FILE *f;
|
2017-07-13 23:49:22 +00:00
|
|
|
struct object_id oid;
|
2012-01-11 18:15:57 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2017-07-13 23:49:22 +00:00
|
|
|
const char *p;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
f = fopen(git_path_head_file(), "r");
|
2012-01-11 18:15:57 +00:00
|
|
|
if (!f && errno == ENOENT) {
|
|
|
|
/*
|
|
|
|
* There is no multiple-cherry-pick in progress.
|
|
|
|
* If CHERRY_PICK_HEAD or REVERT_HEAD indicates
|
|
|
|
* a single-cherry-pick in progress, abort that.
|
|
|
|
*/
|
|
|
|
return rollback_single_pick();
|
|
|
|
}
|
|
|
|
if (!f)
|
2016-10-21 12:26:21 +00:00
|
|
|
return error_errno(_("cannot open '%s'"), git_path_head_file());
|
2016-01-13 23:31:17 +00:00
|
|
|
if (strbuf_getline_lf(&buf, f)) {
|
2016-10-21 12:26:21 +00:00
|
|
|
error(_("cannot read '%s': %s"), git_path_head_file(),
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
ferror(f) ? strerror(errno) : _("unexpected end of file"));
|
2012-01-11 18:15:57 +00:00
|
|
|
fclose(f);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
fclose(f);
|
2017-07-13 23:49:22 +00:00
|
|
|
if (parse_oid_hex(buf.buf, &oid, &p) || *p != '\0') {
|
2012-01-11 18:15:57 +00:00
|
|
|
error(_("stored pre-cherry-pick HEAD file '%s' is corrupt"),
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
git_path_head_file());
|
2012-01-11 18:15:57 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
2017-07-13 23:49:22 +00:00
|
|
|
if (is_null_oid(&oid)) {
|
2016-06-06 13:23:54 +00:00
|
|
|
error(_("cannot abort from a branch yet to be born"));
|
|
|
|
goto fail;
|
|
|
|
}
|
2016-12-07 21:51:32 +00:00
|
|
|
|
|
|
|
if (!rollback_is_safe()) {
|
|
|
|
/* Do not error, just do not rollback */
|
|
|
|
warning(_("You seem to have moved HEAD. "
|
|
|
|
"Not rewinding, check your HEAD!"));
|
|
|
|
} else
|
2017-07-13 23:49:22 +00:00
|
|
|
if (reset_for_rollback(&oid))
|
2012-01-11 18:15:57 +00:00
|
|
|
goto fail;
|
|
|
|
strbuf_release(&buf);
|
2016-10-21 12:24:55 +00:00
|
|
|
return sequencer_remove_state(opts);
|
2012-01-11 18:15:57 +00:00
|
|
|
fail:
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
static int save_todo(struct todo_list *todo_list, struct replay_opts *opts)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
|
|
|
static struct lock_file todo_lock;
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
const char *todo_path = get_todo_path(opts);
|
|
|
|
int next = todo_list->current, offset, fd;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
2017-01-02 15:26:28 +00:00
|
|
|
/*
|
|
|
|
* rebase -i writes "git-rebase-todo" without the currently executing
|
|
|
|
* command, appending it to "done" instead.
|
|
|
|
*/
|
|
|
|
if (is_rebase_i(opts))
|
|
|
|
next++;
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
fd = hold_lock_file_for_update(&todo_lock, todo_path, 0);
|
2016-09-09 14:37:50 +00:00
|
|
|
if (fd < 0)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error_errno(_("could not lock '%s'"), todo_path);
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
offset = next < todo_list->nr ?
|
|
|
|
todo_list->items[next].offset_in_buf : todo_list->buf.len;
|
|
|
|
if (write_in_full(fd, todo_list->buf.buf + offset,
|
|
|
|
todo_list->buf.len - offset) < 0)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error_errno(_("could not write to '%s'"), todo_path);
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
if (commit_lock_file(&todo_lock) < 0)
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("failed to finalize '%s'."), todo_path);
|
2017-01-02 15:27:00 +00:00
|
|
|
|
|
|
|
if (is_rebase_i(opts)) {
|
|
|
|
const char *done_path = rebase_path_done();
|
|
|
|
int fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
|
|
|
|
int prev_offset = !next ? 0 :
|
|
|
|
todo_list->items[next - 1].offset_in_buf;
|
|
|
|
|
|
|
|
if (fd >= 0 && offset > prev_offset &&
|
|
|
|
write_in_full(fd, todo_list->buf.buf + prev_offset,
|
|
|
|
offset - prev_offset) < 0) {
|
|
|
|
close(fd);
|
|
|
|
return error_errno(_("could not write to '%s'"),
|
|
|
|
done_path);
|
|
|
|
}
|
|
|
|
if (fd >= 0)
|
|
|
|
close(fd);
|
|
|
|
}
|
2016-09-09 14:37:50 +00:00
|
|
|
return 0;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2016-09-09 14:37:53 +00:00
|
|
|
static int save_opts(struct replay_opts *opts)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
const char *opts_file = git_path_opts_file();
|
2016-09-09 14:37:53 +00:00
|
|
|
int res = 0;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
if (opts->no_commit)
|
2016-09-09 14:37:53 +00:00
|
|
|
res |= git_config_set_in_file_gently(opts_file, "options.no-commit", "true");
|
2012-01-11 18:15:57 +00:00
|
|
|
if (opts->edit)
|
2016-09-09 14:37:53 +00:00
|
|
|
res |= git_config_set_in_file_gently(opts_file, "options.edit", "true");
|
2012-01-11 18:15:57 +00:00
|
|
|
if (opts->signoff)
|
2016-09-09 14:37:53 +00:00
|
|
|
res |= git_config_set_in_file_gently(opts_file, "options.signoff", "true");
|
2012-01-11 18:15:57 +00:00
|
|
|
if (opts->record_origin)
|
2016-09-09 14:37:53 +00:00
|
|
|
res |= git_config_set_in_file_gently(opts_file, "options.record-origin", "true");
|
2012-01-11 18:15:57 +00:00
|
|
|
if (opts->allow_ff)
|
2016-09-09 14:37:53 +00:00
|
|
|
res |= git_config_set_in_file_gently(opts_file, "options.allow-ff", "true");
|
2012-01-11 18:15:57 +00:00
|
|
|
if (opts->mainline) {
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
strbuf_addf(&buf, "%d", opts->mainline);
|
2016-09-09 14:37:53 +00:00
|
|
|
res |= git_config_set_in_file_gently(opts_file, "options.mainline", buf.buf);
|
2012-01-11 18:15:57 +00:00
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
if (opts->strategy)
|
2016-09-09 14:37:53 +00:00
|
|
|
res |= git_config_set_in_file_gently(opts_file, "options.strategy", opts->strategy);
|
2014-01-24 00:50:58 +00:00
|
|
|
if (opts->gpg_sign)
|
2016-09-09 14:37:53 +00:00
|
|
|
res |= git_config_set_in_file_gently(opts_file, "options.gpg-sign", opts->gpg_sign);
|
2012-01-11 18:15:57 +00:00
|
|
|
if (opts->xopts) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < opts->xopts_nr; i++)
|
2016-09-09 14:37:53 +00:00
|
|
|
res |= git_config_set_multivar_in_file_gently(opts_file,
|
2012-01-11 18:15:57 +00:00
|
|
|
"options.strategy-option",
|
|
|
|
opts->xopts[i], "^$", 0);
|
|
|
|
}
|
2017-08-02 10:44:19 +00:00
|
|
|
if (opts->allow_rerere_auto)
|
|
|
|
res |= git_config_set_in_file_gently(opts_file, "options.allow-rerere-auto",
|
|
|
|
opts->allow_rerere_auto == RERERE_AUTOUPDATE ?
|
|
|
|
"true" : "false");
|
2016-09-09 14:37:53 +00:00
|
|
|
return res;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
2017-01-02 15:26:43 +00:00
|
|
|
static int make_patch(struct commit *commit, struct replay_opts *opts)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct rev_info log_tree_opt;
|
|
|
|
const char *subject, *p;
|
|
|
|
int res = 0;
|
|
|
|
|
|
|
|
p = short_commit_name(commit);
|
|
|
|
if (write_message(p, strlen(p), rebase_path_stopped_sha(), 1) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
strbuf_addf(&buf, "%s/patch", get_dir(opts));
|
|
|
|
memset(&log_tree_opt, 0, sizeof(log_tree_opt));
|
|
|
|
init_revisions(&log_tree_opt, NULL);
|
|
|
|
log_tree_opt.abbrev = 0;
|
|
|
|
log_tree_opt.diff = 1;
|
|
|
|
log_tree_opt.diffopt.output_format = DIFF_FORMAT_PATCH;
|
|
|
|
log_tree_opt.disable_stdin = 1;
|
|
|
|
log_tree_opt.no_commit_id = 1;
|
|
|
|
log_tree_opt.diffopt.file = fopen(buf.buf, "w");
|
|
|
|
log_tree_opt.diffopt.use_color = GIT_COLOR_NEVER;
|
|
|
|
if (!log_tree_opt.diffopt.file)
|
|
|
|
res |= error_errno(_("could not open '%s'"), buf.buf);
|
|
|
|
else {
|
|
|
|
res |= log_tree_commit(&log_tree_opt, commit);
|
|
|
|
fclose(log_tree_opt.diffopt.file);
|
|
|
|
}
|
|
|
|
strbuf_reset(&buf);
|
|
|
|
|
|
|
|
strbuf_addf(&buf, "%s/message", get_dir(opts));
|
|
|
|
if (!file_exists(buf.buf)) {
|
|
|
|
const char *commit_buffer = get_commit_buffer(commit, NULL);
|
|
|
|
find_commit_subject(commit_buffer, &subject);
|
|
|
|
res |= write_message(subject, strlen(subject), buf.buf, 1);
|
|
|
|
unuse_commit_buffer(commit, commit_buffer);
|
|
|
|
}
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int intend_to_amend(void)
|
|
|
|
{
|
2017-07-13 23:49:22 +00:00
|
|
|
struct object_id head;
|
2017-01-02 15:26:43 +00:00
|
|
|
char *p;
|
|
|
|
|
2017-07-13 23:49:22 +00:00
|
|
|
if (get_oid("HEAD", &head))
|
2017-01-02 15:26:43 +00:00
|
|
|
return error(_("cannot read HEAD"));
|
|
|
|
|
2017-07-13 23:49:22 +00:00
|
|
|
p = oid_to_hex(&head);
|
2017-01-02 15:26:43 +00:00
|
|
|
return write_message(p, strlen(p), rebase_path_amend(), 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int error_with_patch(struct commit *commit,
|
|
|
|
const char *subject, int subject_len,
|
|
|
|
struct replay_opts *opts, int exit_code, int to_amend)
|
|
|
|
{
|
|
|
|
if (make_patch(commit, opts))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (to_amend) {
|
|
|
|
if (intend_to_amend())
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
fprintf(stderr, "You can amend the commit now, with\n"
|
|
|
|
"\n"
|
|
|
|
" git commit --amend %s\n"
|
|
|
|
"\n"
|
|
|
|
"Once you are satisfied with your changes, run\n"
|
|
|
|
"\n"
|
|
|
|
" git rebase --continue\n", gpg_sign_opt_quoted(opts));
|
|
|
|
} else if (exit_code)
|
|
|
|
fprintf(stderr, "Could not apply %s... %.*s\n",
|
|
|
|
short_commit_name(commit), subject_len, subject);
|
|
|
|
|
|
|
|
return exit_code;
|
|
|
|
}
|
|
|
|
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
static int error_failed_squash(struct commit *commit,
|
|
|
|
struct replay_opts *opts, int subject_len, const char *subject)
|
|
|
|
{
|
|
|
|
if (rename(rebase_path_squash_msg(), rebase_path_message()))
|
|
|
|
return error(_("could not rename '%s' to '%s'"),
|
|
|
|
rebase_path_squash_msg(), rebase_path_message());
|
|
|
|
unlink(rebase_path_fixup_msg());
|
2017-04-20 21:08:54 +00:00
|
|
|
unlink(git_path_merge_msg());
|
|
|
|
if (copy_file(git_path_merge_msg(), rebase_path_message(), 0666))
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
return error(_("could not copy '%s' to '%s'"),
|
2017-04-20 21:08:54 +00:00
|
|
|
rebase_path_message(), git_path_merge_msg());
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
return error_with_patch(commit, subject, subject_len, opts, 1, 0);
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:26:47 +00:00
|
|
|
static int do_exec(const char *command_line)
|
|
|
|
{
|
|
|
|
const char *child_argv[] = { NULL, NULL };
|
|
|
|
int dirty, status;
|
|
|
|
|
|
|
|
fprintf(stderr, "Executing: %s\n", command_line);
|
|
|
|
child_argv[0] = command_line;
|
|
|
|
status = run_command_v_opt(child_argv, RUN_USING_SHELL);
|
|
|
|
|
|
|
|
/* force re-reading of the cache */
|
|
|
|
if (discard_cache() < 0 || read_cache() < 0)
|
|
|
|
return error(_("could not read index"));
|
|
|
|
|
|
|
|
dirty = require_clean_work_tree("rebase", NULL, 1, 1);
|
|
|
|
|
|
|
|
if (status) {
|
|
|
|
warning(_("execution failed: %s\n%s"
|
|
|
|
"You can fix the problem, and then run\n"
|
|
|
|
"\n"
|
|
|
|
" git rebase --continue\n"
|
|
|
|
"\n"),
|
|
|
|
command_line,
|
|
|
|
dirty ? N_("and made changes to the index and/or the "
|
|
|
|
"working tree\n") : "");
|
|
|
|
if (status == 127)
|
|
|
|
/* command not found */
|
|
|
|
status = 1;
|
|
|
|
} else if (dirty) {
|
|
|
|
warning(_("execution succeeded: %s\nbut "
|
|
|
|
"left changes to the index and/or the working tree\n"
|
|
|
|
"Commit or stash your changes, and then run\n"
|
|
|
|
"\n"
|
|
|
|
" git rebase --continue\n"
|
|
|
|
"\n"), command_line);
|
|
|
|
status = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
static int is_final_fixup(struct todo_list *todo_list)
|
|
|
|
{
|
|
|
|
int i = todo_list->current;
|
|
|
|
|
|
|
|
if (!is_fixup(todo_list->items[i].command))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
while (++i < todo_list->nr)
|
|
|
|
if (is_fixup(todo_list->items[i].command))
|
|
|
|
return 0;
|
|
|
|
else if (!is_noop(todo_list->items[i].command))
|
|
|
|
break;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:28:16 +00:00
|
|
|
static enum todo_command peek_command(struct todo_list *todo_list, int offset)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = todo_list->current + offset; i < todo_list->nr; i++)
|
|
|
|
if (!is_noop(todo_list->items[i].command))
|
|
|
|
return todo_list->items[i].command;
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:28:27 +00:00
|
|
|
static int apply_autostash(struct replay_opts *opts)
|
|
|
|
{
|
|
|
|
struct strbuf stash_sha1 = STRBUF_INIT;
|
|
|
|
struct child_process child = CHILD_PROCESS_INIT;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!read_oneliner(&stash_sha1, rebase_path_autostash(), 1)) {
|
|
|
|
strbuf_release(&stash_sha1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
strbuf_trim(&stash_sha1);
|
|
|
|
|
|
|
|
child.git_cmd = 1;
|
2017-05-18 10:02:33 +00:00
|
|
|
child.no_stdout = 1;
|
|
|
|
child.no_stderr = 1;
|
2017-01-02 15:28:27 +00:00
|
|
|
argv_array_push(&child.args, "stash");
|
|
|
|
argv_array_push(&child.args, "apply");
|
|
|
|
argv_array_push(&child.args, stash_sha1.buf);
|
|
|
|
if (!run_command(&child))
|
2017-06-19 17:56:02 +00:00
|
|
|
fprintf(stderr, _("Applied autostash.\n"));
|
2017-01-02 15:28:27 +00:00
|
|
|
else {
|
|
|
|
struct child_process store = CHILD_PROCESS_INIT;
|
|
|
|
|
|
|
|
store.git_cmd = 1;
|
|
|
|
argv_array_push(&store.args, "stash");
|
|
|
|
argv_array_push(&store.args, "store");
|
|
|
|
argv_array_push(&store.args, "-m");
|
|
|
|
argv_array_push(&store.args, "autostash");
|
|
|
|
argv_array_push(&store.args, "-q");
|
|
|
|
argv_array_push(&store.args, stash_sha1.buf);
|
|
|
|
if (run_command(&store))
|
|
|
|
ret = error(_("cannot store %s"), stash_sha1.buf);
|
|
|
|
else
|
2017-06-19 17:56:02 +00:00
|
|
|
fprintf(stderr,
|
|
|
|
_("Applying autostash resulted in conflicts.\n"
|
|
|
|
"Your changes are safe in the stash.\n"
|
|
|
|
"You can run \"git stash pop\" or"
|
|
|
|
" \"git stash drop\" at any time.\n"));
|
2017-01-02 15:28:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_release(&stash_sha1);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:28:09 +00:00
|
|
|
static const char *reflog_message(struct replay_opts *opts,
|
|
|
|
const char *sub_action, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
static struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
strbuf_reset(&buf);
|
|
|
|
strbuf_addstr(&buf, action_name(opts));
|
|
|
|
if (sub_action)
|
|
|
|
strbuf_addf(&buf, " (%s)", sub_action);
|
|
|
|
if (fmt) {
|
|
|
|
strbuf_addstr(&buf, ": ");
|
|
|
|
strbuf_vaddf(&buf, fmt, ap);
|
|
|
|
}
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
return buf.buf;
|
|
|
|
}
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
static int pick_commits(struct todo_list *todo_list, struct replay_opts *opts)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
2017-01-02 15:26:43 +00:00
|
|
|
int res = 0;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
|
|
|
setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
|
|
|
|
if (opts->allow_ff)
|
|
|
|
assert(!(opts->signoff || opts->no_commit ||
|
|
|
|
opts->record_origin || opts->edit));
|
2016-09-09 14:37:21 +00:00
|
|
|
if (read_and_refresh_cache(opts))
|
|
|
|
return -1;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
while (todo_list->current < todo_list->nr) {
|
|
|
|
struct todo_item *item = todo_list->items + todo_list->current;
|
|
|
|
if (save_todo(todo_list, opts))
|
2016-09-09 14:37:50 +00:00
|
|
|
return -1;
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
if (is_rebase_i(opts)) {
|
2017-01-02 15:36:20 +00:00
|
|
|
if (item->command != TODO_COMMENT) {
|
|
|
|
FILE *f = fopen(rebase_path_msgnum(), "w");
|
|
|
|
|
|
|
|
todo_list->done_nr++;
|
|
|
|
|
|
|
|
if (f) {
|
|
|
|
fprintf(f, "%d\n", todo_list->done_nr);
|
|
|
|
fclose(f);
|
|
|
|
}
|
2017-01-02 15:35:46 +00:00
|
|
|
fprintf(stderr, "Rebasing (%d/%d)%s",
|
2017-01-02 15:36:20 +00:00
|
|
|
todo_list->done_nr,
|
2017-01-02 15:35:46 +00:00
|
|
|
todo_list->total_nr,
|
|
|
|
opts->verbose ? "\n" : "\r");
|
2017-01-02 15:36:20 +00:00
|
|
|
}
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
unlink(rebase_path_message());
|
|
|
|
unlink(rebase_path_author_script());
|
|
|
|
unlink(rebase_path_stopped_sha());
|
|
|
|
unlink(rebase_path_amend());
|
|
|
|
}
|
|
|
|
if (item->command <= TODO_SQUASH) {
|
2017-01-02 15:28:13 +00:00
|
|
|
if (is_rebase_i(opts))
|
|
|
|
setenv("GIT_REFLOG_ACTION", reflog_message(opts,
|
|
|
|
command_to_string(item->command), NULL),
|
|
|
|
1);
|
2017-01-02 15:26:38 +00:00
|
|
|
res = do_pick_commit(item->command, item->commit,
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
opts, is_final_fixup(todo_list));
|
2017-01-02 15:28:34 +00:00
|
|
|
if (is_rebase_i(opts) && res < 0) {
|
|
|
|
/* Reschedule */
|
|
|
|
todo_list->current--;
|
|
|
|
if (save_todo(todo_list, opts))
|
|
|
|
return -1;
|
|
|
|
}
|
2017-01-02 15:26:43 +00:00
|
|
|
if (item->command == TODO_EDIT) {
|
|
|
|
struct commit *commit = item->commit;
|
|
|
|
if (!res)
|
2017-03-17 00:19:42 +00:00
|
|
|
fprintf(stderr,
|
2017-03-23 17:02:33 +00:00
|
|
|
_("Stopped at %s... %.*s\n"),
|
2017-01-02 15:26:43 +00:00
|
|
|
short_commit_name(commit),
|
|
|
|
item->arg_len, item->arg);
|
|
|
|
return error_with_patch(commit,
|
|
|
|
item->arg, item->arg_len, opts, res,
|
|
|
|
!res);
|
|
|
|
}
|
2017-01-02 15:28:16 +00:00
|
|
|
if (is_rebase_i(opts) && !res)
|
|
|
|
record_in_rewritten(&item->commit->object.oid,
|
|
|
|
peek_command(todo_list, 1));
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
if (res && is_fixup(item->command)) {
|
|
|
|
if (res == 1)
|
|
|
|
intend_to_amend();
|
|
|
|
return error_failed_squash(item->commit, opts,
|
|
|
|
item->arg_len, item->arg);
|
2017-01-02 15:27:57 +00:00
|
|
|
} else if (res && is_rebase_i(opts))
|
|
|
|
return res | error_with_patch(item->commit,
|
2017-01-02 15:28:00 +00:00
|
|
|
item->arg, item->arg_len, opts, res,
|
|
|
|
item->command == TODO_REWORD);
|
2017-01-02 15:26:47 +00:00
|
|
|
} else if (item->command == TODO_EXEC) {
|
|
|
|
char *end_of_arg = (char *)(item->arg + item->arg_len);
|
|
|
|
int saved = *end_of_arg;
|
2017-04-26 19:17:40 +00:00
|
|
|
struct stat st;
|
2017-01-02 15:26:47 +00:00
|
|
|
|
|
|
|
*end_of_arg = '\0';
|
|
|
|
res = do_exec(item->arg);
|
|
|
|
*end_of_arg = saved;
|
2017-04-26 19:17:40 +00:00
|
|
|
|
|
|
|
/* Reread the todo file if it has changed. */
|
|
|
|
if (res)
|
|
|
|
; /* fall through */
|
|
|
|
else if (stat(get_todo_path(opts), &st))
|
|
|
|
res = error_errno(_("could not stat '%s'"),
|
|
|
|
get_todo_path(opts));
|
|
|
|
else if (match_stat_data(&todo_list->stat, &st)) {
|
|
|
|
todo_list_release(todo_list);
|
|
|
|
if (read_populate_todo(todo_list, opts))
|
|
|
|
res = -1; /* message was printed */
|
|
|
|
/* `current` will be incremented below */
|
|
|
|
todo_list->current = -1;
|
|
|
|
}
|
2017-01-02 15:26:43 +00:00
|
|
|
} else if (!is_noop(item->command))
|
2017-01-02 15:26:38 +00:00
|
|
|
return error(_("unknown command %d"), item->command);
|
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
todo_list->current++;
|
2012-01-11 18:15:57 +00:00
|
|
|
if (res)
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:26:43 +00:00
|
|
|
if (is_rebase_i(opts)) {
|
2017-01-02 15:27:53 +00:00
|
|
|
struct strbuf head_ref = STRBUF_INIT, buf = STRBUF_INIT;
|
2017-01-02 15:28:16 +00:00
|
|
|
struct stat st;
|
2017-01-02 15:26:53 +00:00
|
|
|
|
2017-01-02 15:26:43 +00:00
|
|
|
/* Stopped in the middle, as planned? */
|
|
|
|
if (todo_list->current < todo_list->nr)
|
|
|
|
return 0;
|
2017-01-02 15:26:53 +00:00
|
|
|
|
2017-01-02 15:27:53 +00:00
|
|
|
if (read_oneliner(&head_ref, rebase_path_head_name(), 0) &&
|
|
|
|
starts_with(head_ref.buf, "refs/")) {
|
2017-01-02 15:28:09 +00:00
|
|
|
const char *msg;
|
2017-07-13 23:49:22 +00:00
|
|
|
struct object_id head, orig;
|
2017-01-02 15:27:53 +00:00
|
|
|
int res;
|
|
|
|
|
2017-07-13 23:49:22 +00:00
|
|
|
if (get_oid("HEAD", &head)) {
|
2017-01-02 15:27:53 +00:00
|
|
|
res = error(_("cannot read HEAD"));
|
|
|
|
cleanup_head_ref:
|
|
|
|
strbuf_release(&head_ref);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
if (!read_oneliner(&buf, rebase_path_orig_head(), 0) ||
|
2017-07-13 23:49:22 +00:00
|
|
|
get_oid_hex(buf.buf, &orig)) {
|
2017-01-02 15:27:53 +00:00
|
|
|
res = error(_("could not read orig-head"));
|
|
|
|
goto cleanup_head_ref;
|
|
|
|
}
|
2017-05-18 10:02:32 +00:00
|
|
|
strbuf_reset(&buf);
|
2017-01-02 15:27:53 +00:00
|
|
|
if (!read_oneliner(&buf, rebase_path_onto(), 0)) {
|
|
|
|
res = error(_("could not read 'onto'"));
|
|
|
|
goto cleanup_head_ref;
|
|
|
|
}
|
2017-01-02 15:28:09 +00:00
|
|
|
msg = reflog_message(opts, "finish", "%s onto %s",
|
|
|
|
head_ref.buf, buf.buf);
|
2017-10-15 22:06:51 +00:00
|
|
|
if (update_ref(msg, head_ref.buf, &head, &orig,
|
|
|
|
REF_NODEREF, UPDATE_REFS_MSG_ON_ERR)) {
|
2017-01-02 15:27:53 +00:00
|
|
|
res = error(_("could not update %s"),
|
|
|
|
head_ref.buf);
|
|
|
|
goto cleanup_head_ref;
|
|
|
|
}
|
2017-01-02 15:28:09 +00:00
|
|
|
msg = reflog_message(opts, "finish", "returning to %s",
|
2017-01-02 15:27:53 +00:00
|
|
|
head_ref.buf);
|
2017-01-02 15:28:09 +00:00
|
|
|
if (create_symref("HEAD", head_ref.buf, msg)) {
|
2017-01-02 15:27:53 +00:00
|
|
|
res = error(_("could not update HEAD to %s"),
|
|
|
|
head_ref.buf);
|
|
|
|
goto cleanup_head_ref;
|
|
|
|
}
|
|
|
|
strbuf_reset(&buf);
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:26:53 +00:00
|
|
|
if (opts->verbose) {
|
|
|
|
struct rev_info log_tree_opt;
|
|
|
|
struct object_id orig, head;
|
|
|
|
|
|
|
|
memset(&log_tree_opt, 0, sizeof(log_tree_opt));
|
|
|
|
init_revisions(&log_tree_opt, NULL);
|
|
|
|
log_tree_opt.diff = 1;
|
|
|
|
log_tree_opt.diffopt.output_format =
|
|
|
|
DIFF_FORMAT_DIFFSTAT;
|
|
|
|
log_tree_opt.disable_stdin = 1;
|
|
|
|
|
|
|
|
if (read_oneliner(&buf, rebase_path_orig_head(), 0) &&
|
sha1_name: convert get_sha1* to get_oid*
Now that all the callers of get_sha1 directly or indirectly use struct
object_id, rename the functions starting with get_sha1 to start with
get_oid. Convert the internals in sha1_name.c to use struct object_id
as well, and eliminate explicit length checks where possible. Convert a
use of 40 in get_oid_basic to GIT_SHA1_HEXSZ.
Outside of sha1_name.c and cache.h, this transition was made with the
following semantic patch:
@@
expression E1, E2;
@@
- get_sha1(E1, E2.hash)
+ get_oid(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1(E1, E2->hash)
+ get_oid(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2.hash)
+ get_oid_committish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2->hash)
+ get_oid_committish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2.hash)
+ get_oid_treeish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2->hash)
+ get_oid_treeish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2.hash)
+ get_oid_commit(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2->hash)
+ get_oid_commit(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2.hash)
+ get_oid_tree(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2->hash)
+ get_oid_tree(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2.hash)
+ get_oid_blob(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2->hash)
+ get_oid_blob(E1, E2)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3.hash, E4)
+ get_oid_with_context(E1, E2, &E3, E4)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3->hash, E4)
+ get_oid_with_context(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-07-13 23:49:28 +00:00
|
|
|
!get_oid(buf.buf, &orig) &&
|
|
|
|
!get_oid("HEAD", &head)) {
|
2017-05-30 17:31:03 +00:00
|
|
|
diff_tree_oid(&orig, &head, "",
|
|
|
|
&log_tree_opt.diffopt);
|
2017-01-02 15:26:53 +00:00
|
|
|
log_tree_diff_flush(&log_tree_opt);
|
|
|
|
}
|
|
|
|
}
|
2017-01-02 15:28:16 +00:00
|
|
|
flush_rewritten_pending();
|
|
|
|
if (!stat(rebase_path_rewritten_list(), &st) &&
|
|
|
|
st.st_size > 0) {
|
|
|
|
struct child_process child = CHILD_PROCESS_INIT;
|
2017-01-02 15:28:23 +00:00
|
|
|
const char *post_rewrite_hook =
|
|
|
|
find_hook("post-rewrite");
|
2017-01-02 15:28:16 +00:00
|
|
|
|
|
|
|
child.in = open(rebase_path_rewritten_list(), O_RDONLY);
|
|
|
|
child.git_cmd = 1;
|
|
|
|
argv_array_push(&child.args, "notes");
|
|
|
|
argv_array_push(&child.args, "copy");
|
|
|
|
argv_array_push(&child.args, "--for-rewrite=rebase");
|
|
|
|
/* we don't care if this copying failed */
|
|
|
|
run_command(&child);
|
2017-01-02 15:28:23 +00:00
|
|
|
|
|
|
|
if (post_rewrite_hook) {
|
|
|
|
struct child_process hook = CHILD_PROCESS_INIT;
|
|
|
|
|
|
|
|
hook.in = open(rebase_path_rewritten_list(),
|
|
|
|
O_RDONLY);
|
|
|
|
hook.stdout_to_stderr = 1;
|
|
|
|
argv_array_push(&hook.args, post_rewrite_hook);
|
|
|
|
argv_array_push(&hook.args, "rebase");
|
|
|
|
/* we don't care if this hook failed */
|
|
|
|
run_command(&hook);
|
|
|
|
}
|
2017-01-02 15:28:16 +00:00
|
|
|
}
|
2017-01-02 15:28:27 +00:00
|
|
|
apply_autostash(opts);
|
2017-01-02 15:28:16 +00:00
|
|
|
|
2017-01-02 15:36:25 +00:00
|
|
|
fprintf(stderr, "Successfully rebased and updated %s.\n",
|
|
|
|
head_ref.buf);
|
|
|
|
|
2017-01-02 15:26:53 +00:00
|
|
|
strbuf_release(&buf);
|
2017-01-02 15:27:53 +00:00
|
|
|
strbuf_release(&head_ref);
|
2017-01-02 15:26:43 +00:00
|
|
|
}
|
|
|
|
|
2012-01-11 18:15:57 +00:00
|
|
|
/*
|
|
|
|
* Sequence of picks finished successfully; cleanup by
|
|
|
|
* removing the .git/sequencer directory
|
|
|
|
*/
|
2016-10-21 12:24:55 +00:00
|
|
|
return sequencer_remove_state(opts);
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int continue_single_pick(void)
|
|
|
|
{
|
|
|
|
const char *argv[] = { "commit", NULL };
|
|
|
|
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
if (!file_exists(git_path_cherry_pick_head()) &&
|
|
|
|
!file_exists(git_path_revert_head()))
|
2012-01-11 18:15:57 +00:00
|
|
|
return error(_("no cherry-pick or revert in progress"));
|
|
|
|
return run_command_v_opt(argv, RUN_GIT_CMD);
|
|
|
|
}
|
|
|
|
|
2017-01-02 15:27:21 +00:00
|
|
|
static int commit_staged_changes(struct replay_opts *opts)
|
|
|
|
{
|
2017-03-23 16:07:11 +00:00
|
|
|
unsigned int flags = ALLOW_EMPTY | EDIT_MSG;
|
2017-01-02 15:27:21 +00:00
|
|
|
|
|
|
|
if (has_unstaged_changes(1))
|
|
|
|
return error(_("cannot rebase: You have unstaged changes."));
|
2017-01-02 15:27:25 +00:00
|
|
|
if (!has_uncommitted_changes(0)) {
|
2017-04-20 21:08:54 +00:00
|
|
|
const char *cherry_pick_head = git_path_cherry_pick_head();
|
2017-01-02 15:27:25 +00:00
|
|
|
|
|
|
|
if (file_exists(cherry_pick_head) && unlink(cherry_pick_head))
|
|
|
|
return error(_("could not remove CHERRY_PICK_HEAD"));
|
2017-01-02 15:27:21 +00:00
|
|
|
return 0;
|
2017-01-02 15:27:25 +00:00
|
|
|
}
|
2017-01-02 15:27:21 +00:00
|
|
|
|
|
|
|
if (file_exists(rebase_path_amend())) {
|
|
|
|
struct strbuf rev = STRBUF_INIT;
|
2017-07-13 23:49:22 +00:00
|
|
|
struct object_id head, to_amend;
|
2017-01-02 15:27:21 +00:00
|
|
|
|
2017-07-13 23:49:22 +00:00
|
|
|
if (get_oid("HEAD", &head))
|
2017-01-02 15:27:21 +00:00
|
|
|
return error(_("cannot amend non-existing commit"));
|
|
|
|
if (!read_oneliner(&rev, rebase_path_amend(), 0))
|
|
|
|
return error(_("invalid file: '%s'"), rebase_path_amend());
|
2017-07-13 23:49:22 +00:00
|
|
|
if (get_oid_hex(rev.buf, &to_amend))
|
2017-01-02 15:27:21 +00:00
|
|
|
return error(_("invalid contents: '%s'"),
|
|
|
|
rebase_path_amend());
|
2017-07-13 23:49:22 +00:00
|
|
|
if (oidcmp(&head, &to_amend))
|
2017-01-02 15:27:21 +00:00
|
|
|
return error(_("\nYou have uncommitted changes in your "
|
|
|
|
"working tree. Please, commit them\n"
|
|
|
|
"first and then run 'git rebase "
|
|
|
|
"--continue' again."));
|
|
|
|
|
|
|
|
strbuf_release(&rev);
|
2017-03-23 16:07:11 +00:00
|
|
|
flags |= AMEND_MSG;
|
2017-01-02 15:27:21 +00:00
|
|
|
}
|
|
|
|
|
2017-03-23 16:07:11 +00:00
|
|
|
if (run_git_commit(rebase_path_message(), opts, flags))
|
2017-01-02 15:27:21 +00:00
|
|
|
return error(_("could not commit staged changes."));
|
|
|
|
unlink(rebase_path_amend());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-10-21 12:24:55 +00:00
|
|
|
int sequencer_continue(struct replay_opts *opts)
|
2012-01-11 18:15:57 +00:00
|
|
|
{
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
struct todo_list todo_list = TODO_LIST_INIT;
|
|
|
|
int res;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
2016-10-21 12:24:55 +00:00
|
|
|
if (read_and_refresh_cache(opts))
|
|
|
|
return -1;
|
|
|
|
|
2017-01-02 15:27:21 +00:00
|
|
|
if (is_rebase_i(opts)) {
|
|
|
|
if (commit_staged_changes(opts))
|
|
|
|
return -1;
|
2017-01-02 15:27:30 +00:00
|
|
|
} else if (!file_exists(get_todo_path(opts)))
|
2012-01-11 18:15:57 +00:00
|
|
|
return continue_single_pick();
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
if (read_populate_opts(opts))
|
2016-09-09 14:37:24 +00:00
|
|
|
return -1;
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
if ((res = read_populate_todo(&todo_list, opts)))
|
|
|
|
goto release_todo_list;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
2017-01-02 15:27:30 +00:00
|
|
|
if (!is_rebase_i(opts)) {
|
|
|
|
/* Verify that the conflict has been resolved */
|
|
|
|
if (file_exists(git_path_cherry_pick_head()) ||
|
|
|
|
file_exists(git_path_revert_head())) {
|
|
|
|
res = continue_single_pick();
|
|
|
|
if (res)
|
|
|
|
goto release_todo_list;
|
|
|
|
}
|
|
|
|
if (index_differs_from("HEAD", 0, 0)) {
|
|
|
|
res = error_dirty_index(opts);
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
goto release_todo_list;
|
2017-01-02 15:27:30 +00:00
|
|
|
}
|
|
|
|
todo_list.current++;
|
2017-01-02 15:28:20 +00:00
|
|
|
} else if (file_exists(rebase_path_stopped_sha())) {
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct object_id oid;
|
|
|
|
|
|
|
|
if (read_oneliner(&buf, rebase_path_stopped_sha(), 1) &&
|
sha1_name: convert get_sha1* to get_oid*
Now that all the callers of get_sha1 directly or indirectly use struct
object_id, rename the functions starting with get_sha1 to start with
get_oid. Convert the internals in sha1_name.c to use struct object_id
as well, and eliminate explicit length checks where possible. Convert a
use of 40 in get_oid_basic to GIT_SHA1_HEXSZ.
Outside of sha1_name.c and cache.h, this transition was made with the
following semantic patch:
@@
expression E1, E2;
@@
- get_sha1(E1, E2.hash)
+ get_oid(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1(E1, E2->hash)
+ get_oid(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2.hash)
+ get_oid_committish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2->hash)
+ get_oid_committish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2.hash)
+ get_oid_treeish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2->hash)
+ get_oid_treeish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2.hash)
+ get_oid_commit(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2->hash)
+ get_oid_commit(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2.hash)
+ get_oid_tree(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2->hash)
+ get_oid_tree(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2.hash)
+ get_oid_blob(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2->hash)
+ get_oid_blob(E1, E2)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3.hash, E4)
+ get_oid_with_context(E1, E2, &E3, E4)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3->hash, E4)
+ get_oid_with_context(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-07-13 23:49:28 +00:00
|
|
|
!get_oid_committish(buf.buf, &oid))
|
2017-01-02 15:28:20 +00:00
|
|
|
record_in_rewritten(&oid, peek_command(&todo_list, 0));
|
|
|
|
strbuf_release(&buf);
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
2017-01-02 15:27:30 +00:00
|
|
|
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
res = pick_commits(&todo_list, opts);
|
|
|
|
release_todo_list:
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return res;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int single_pick(struct commit *cmit, struct replay_opts *opts)
|
|
|
|
{
|
|
|
|
setenv(GIT_REFLOG_ACTION, action_name(opts), 0);
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
return do_pick_commit(opts->action == REPLAY_PICK ?
|
sequencer (rebase -i): add support for the 'fixup' and 'squash' commands
This is a huge patch, and at the same time a huge step forward to
execute the performance-critical parts of the interactive rebase in a
builtin command.
Since 'fixup' and 'squash' are not only similar, but also need to know
about each other (we want to reduce a series of fixups/squashes into a
single, final commit message edit, from the user's point of view), we
really have to implement them both at the same time.
Most of the actual work is done by the existing code path that already
handles the "pick" and the "edit" commands; We added support for other
features (e.g. to amend the commit message) in the patches leading up to
this one, yet there are still quite a few bits in this patch that simply
would not make sense as individual patches (such as: determining whether
there was anything to "fix up" in the "todo" script, etc).
In theory, it would be possible to reuse the fast-forward code path also
for the fixup and the squash code paths, but in practice this would make
the code less readable. The end result cannot be fast-forwarded anyway,
therefore let's just extend the cherry-picking code path for now.
Since the sequencer parses the entire `git-rebase-todo` script in one go,
fixup or squash commands without a preceding pick can be reported early
(in git-rebase--interactive, we could only report such errors just before
executing the fixup/squash).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-02 15:27:07 +00:00
|
|
|
TODO_PICK : TODO_REVERT, cmit, opts, 0);
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int sequencer_pick_revisions(struct replay_opts *opts)
|
|
|
|
{
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
struct todo_list todo_list = TODO_LIST_INIT;
|
2017-05-06 22:10:09 +00:00
|
|
|
struct object_id oid;
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
int i, res;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
2016-10-21 12:24:55 +00:00
|
|
|
assert(opts->revs);
|
2016-09-09 14:37:21 +00:00
|
|
|
if (read_and_refresh_cache(opts))
|
|
|
|
return -1;
|
2012-01-11 18:15:57 +00:00
|
|
|
|
2013-04-11 13:06:52 +00:00
|
|
|
for (i = 0; i < opts->revs->pending.nr; i++) {
|
2017-05-06 22:10:09 +00:00
|
|
|
struct object_id oid;
|
2013-04-11 13:06:52 +00:00
|
|
|
const char *name = opts->revs->pending.objects[i].name;
|
|
|
|
|
|
|
|
/* This happens when using --stdin. */
|
|
|
|
if (!strlen(name))
|
|
|
|
continue;
|
|
|
|
|
2017-05-06 22:10:09 +00:00
|
|
|
if (!get_oid(name, &oid)) {
|
Convert lookup_commit* to struct object_id
Convert lookup_commit, lookup_commit_or_die,
lookup_commit_reference, and lookup_commit_reference_gently to take
struct object_id arguments.
Introduce a temporary in parse_object buffer in order to convert this
function. This is required since in order to convert parse_object and
parse_object_buffer, lookup_commit_reference_gently and
lookup_commit_or_die would need to be converted. Not introducing a
temporary would therefore require that lookup_commit_or_die take a
struct object_id *, but lookup_commit would take unsigned char *,
leaving a confusing and hard-to-use interface.
parse_object_buffer will lose this temporary in a later patch.
This commit was created with manual changes to commit.c, commit.h, and
object.c, plus the following semantic patch:
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1.hash, E2)
+ lookup_commit_reference_gently(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1->hash, E2)
+ lookup_commit_reference_gently(E1, E2)
@@
expression E1;
@@
- lookup_commit_reference(E1.hash)
+ lookup_commit_reference(&E1)
@@
expression E1;
@@
- lookup_commit_reference(E1->hash)
+ lookup_commit_reference(E1)
@@
expression E1;
@@
- lookup_commit(E1.hash)
+ lookup_commit(&E1)
@@
expression E1;
@@
- lookup_commit(E1->hash)
+ lookup_commit(E1)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1.hash, E2)
+ lookup_commit_or_die(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1->hash, E2)
+ lookup_commit_or_die(E1, E2)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-06 22:10:10 +00:00
|
|
|
if (!lookup_commit_reference_gently(&oid, 1)) {
|
2017-05-06 22:10:09 +00:00
|
|
|
enum object_type type = sha1_object_info(oid.hash, NULL);
|
2016-08-26 13:47:10 +00:00
|
|
|
return error(_("%s: can't cherry-pick a %s"),
|
|
|
|
name, typename(type));
|
2013-05-09 20:27:49 +00:00
|
|
|
}
|
2013-04-11 13:06:52 +00:00
|
|
|
} else
|
2016-08-26 13:47:10 +00:00
|
|
|
return error(_("%s: bad revision"), name);
|
2013-04-11 13:06:52 +00:00
|
|
|
}
|
|
|
|
|
2012-01-11 18:15:57 +00:00
|
|
|
/*
|
|
|
|
* If we were called as "git cherry-pick <commit>", just
|
|
|
|
* cherry-pick/revert it, set CHERRY_PICK_HEAD /
|
|
|
|
* REVERT_HEAD, and don't touch the sequencer state.
|
|
|
|
* This means it is possible to cherry-pick in the middle
|
|
|
|
* of a cherry-pick sequence.
|
|
|
|
*/
|
|
|
|
if (opts->revs->cmdline.nr == 1 &&
|
|
|
|
opts->revs->cmdline.rev->whence == REV_CMD_REV &&
|
|
|
|
opts->revs->no_walk &&
|
|
|
|
!opts->revs->cmdline.rev->flags) {
|
|
|
|
struct commit *cmit;
|
|
|
|
if (prepare_revision_walk(opts->revs))
|
2016-08-26 13:47:10 +00:00
|
|
|
return error(_("revision walk setup failed"));
|
2012-01-11 18:15:57 +00:00
|
|
|
cmit = get_revision(opts->revs);
|
|
|
|
if (!cmit || get_revision(opts->revs))
|
2016-08-26 13:47:10 +00:00
|
|
|
return error("BUG: expected exactly one commit from walk");
|
2012-01-11 18:15:57 +00:00
|
|
|
return single_pick(cmit, opts);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start a new cherry-pick/ revert sequence; but
|
|
|
|
* first, make sure that an existing one isn't in
|
|
|
|
* progress
|
|
|
|
*/
|
|
|
|
|
2016-09-09 14:37:15 +00:00
|
|
|
if (walk_revs_populate_todo(&todo_list, opts) ||
|
|
|
|
create_seq_dir() < 0)
|
2012-01-11 18:15:57 +00:00
|
|
|
return -1;
|
2017-05-06 22:10:09 +00:00
|
|
|
if (get_oid("HEAD", &oid) && (opts->action == REPLAY_REVERT))
|
2016-10-21 12:26:25 +00:00
|
|
|
return error(_("can't revert as initial commit"));
|
2017-05-06 22:10:09 +00:00
|
|
|
if (save_head(oid_to_hex(&oid)))
|
2016-09-09 14:37:47 +00:00
|
|
|
return -1;
|
2016-09-09 14:37:53 +00:00
|
|
|
if (save_opts(opts))
|
|
|
|
return -1;
|
2016-12-07 21:51:32 +00:00
|
|
|
update_abort_safety_file();
|
sequencer: completely revamp the "todo" script parsing
When we came up with the "sequencer" idea, we really wanted to have
kind of a plumbing equivalent of the interactive rebase. Hence the
choice of words: the "todo" script, a "pick", etc.
However, when it came time to implement the entire shebang, somehow this
idea got lost and the sequencer was used as working horse for
cherry-pick and revert instead. So as not to interfere with the
interactive rebase, it even uses a separate directory to store its
state.
Furthermore, it also is stupidly strict about the "todo" script it
accepts: while it parses commands in a way that was *designed* to be
similar to the interactive rebase, it then goes on to *error out* if the
commands disagree with the overall action (cherry-pick or revert).
Finally, the sequencer code chose to deviate from the interactive rebase
code insofar that when it comes to writing the file with the remaining
commands, it *reformats* the "todo" script instead of just writing the
part of the parsed script that were not yet processed. This is not only
unnecessary churn, but might well lose information that is valuable to
the user (i.e. comments after the commands).
Let's just bite the bullet and rewrite the entire parser; the code now
becomes not only more elegant: it allows us to go on and teach the
sequencer how to parse *true* "todo" scripts as used by the interactive
rebase itself. In a way, the sequencer is about to grow up to do its
older brother's job. Better.
In particular, we choose to maintain the list of commands in an array
instead of a linked list: this is flexible enough to allow us later on to
even implement rebase -i's reordering of fixup!/squash! commits very
easily (and with a very nice speed bonus, at least on Windows).
While at it, do not stop at the first problem, but list *all* of the
problems. This will help the user when the sequencer will do `rebase
-i`'s work by allowing to address all issues in one go rather than going
back and forth until the todo list is valid.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-21 12:24:41 +00:00
|
|
|
res = pick_commits(&todo_list, opts);
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return res;
|
2012-01-11 18:15:57 +00:00
|
|
|
}
|
2012-09-14 06:52:03 +00:00
|
|
|
|
2013-02-12 10:17:35 +00:00
|
|
|
void append_signoff(struct strbuf *msgbuf, int ignore_footer, unsigned flag)
|
2012-09-14 06:52:03 +00:00
|
|
|
{
|
2013-02-12 10:17:35 +00:00
|
|
|
unsigned no_dup_sob = flag & APPEND_SIGNOFF_DEDUP;
|
2012-09-14 06:52:03 +00:00
|
|
|
struct strbuf sob = STRBUF_INIT;
|
2013-02-12 10:17:35 +00:00
|
|
|
int has_footer;
|
2012-09-14 06:52:03 +00:00
|
|
|
|
|
|
|
strbuf_addstr(&sob, sign_off_header);
|
|
|
|
strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
|
|
|
|
getenv("GIT_COMMITTER_EMAIL")));
|
|
|
|
strbuf_addch(&sob, '\n');
|
2013-02-12 10:17:35 +00:00
|
|
|
|
2017-04-26 20:50:03 +00:00
|
|
|
if (!ignore_footer)
|
|
|
|
strbuf_complete_line(msgbuf);
|
|
|
|
|
2013-02-12 10:17:35 +00:00
|
|
|
/*
|
|
|
|
* If the whole message buffer is equal to the sob, pretend that we
|
|
|
|
* found a conforming footer with a matching sob
|
|
|
|
*/
|
|
|
|
if (msgbuf->len - ignore_footer == sob.len &&
|
|
|
|
!strncmp(msgbuf->buf, sob.buf, sob.len))
|
|
|
|
has_footer = 3;
|
|
|
|
else
|
|
|
|
has_footer = has_conforming_footer(msgbuf, &sob, ignore_footer);
|
|
|
|
|
2013-02-12 10:33:42 +00:00
|
|
|
if (!has_footer) {
|
|
|
|
const char *append_newlines = NULL;
|
|
|
|
size_t len = msgbuf->len - ignore_footer;
|
|
|
|
|
2013-02-22 22:05:27 +00:00
|
|
|
if (!len) {
|
|
|
|
/*
|
|
|
|
* The buffer is completely empty. Leave foom for
|
|
|
|
* the title and body to be filled in by the user.
|
|
|
|
*/
|
2013-02-12 10:33:42 +00:00
|
|
|
append_newlines = "\n\n";
|
2013-02-22 22:05:27 +00:00
|
|
|
} else if (len == 1) {
|
|
|
|
/*
|
|
|
|
* Buffer contains a single newline. Add another
|
|
|
|
* so that we leave room for the title and body.
|
|
|
|
*/
|
|
|
|
append_newlines = "\n";
|
|
|
|
} else if (msgbuf->buf[len - 2] != '\n') {
|
|
|
|
/*
|
|
|
|
* Buffer ends with a single newline. Add another
|
|
|
|
* so that there is an empty line between the message
|
|
|
|
* body and the sob.
|
|
|
|
*/
|
2013-02-12 10:33:42 +00:00
|
|
|
append_newlines = "\n";
|
2013-02-22 22:05:27 +00:00
|
|
|
} /* else, the buffer already ends with two newlines. */
|
2013-02-12 10:33:42 +00:00
|
|
|
|
|
|
|
if (append_newlines)
|
|
|
|
strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
|
|
|
|
append_newlines, strlen(append_newlines));
|
2012-09-14 06:52:03 +00:00
|
|
|
}
|
2013-02-12 10:17:35 +00:00
|
|
|
|
|
|
|
if (has_footer != 3 && (!no_dup_sob || has_footer != 2))
|
|
|
|
strbuf_splice(msgbuf, msgbuf->len - ignore_footer, 0,
|
|
|
|
sob.buf, sob.len);
|
|
|
|
|
2012-09-14 06:52:03 +00:00
|
|
|
strbuf_release(&sob);
|
|
|
|
}
|
2017-07-14 14:44:58 +00:00
|
|
|
|
|
|
|
int sequencer_make_script(int keep_empty, FILE *out,
|
|
|
|
int argc, const char **argv)
|
|
|
|
{
|
|
|
|
char *format = NULL;
|
|
|
|
struct pretty_print_context pp = {0};
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct rev_info revs;
|
|
|
|
struct commit *commit;
|
|
|
|
|
|
|
|
init_revisions(&revs, NULL);
|
|
|
|
revs.verbose_header = 1;
|
|
|
|
revs.max_parents = 1;
|
|
|
|
revs.cherry_pick = 1;
|
|
|
|
revs.limited = 1;
|
|
|
|
revs.reverse = 1;
|
|
|
|
revs.right_only = 1;
|
|
|
|
revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
|
|
|
|
revs.topo_order = 1;
|
|
|
|
|
|
|
|
revs.pretty_given = 1;
|
|
|
|
git_config_get_string("rebase.instructionFormat", &format);
|
|
|
|
if (!format || !*format) {
|
|
|
|
free(format);
|
|
|
|
format = xstrdup("%s");
|
|
|
|
}
|
|
|
|
get_commit_format(format, &revs);
|
|
|
|
free(format);
|
|
|
|
pp.fmt = revs.commit_format;
|
|
|
|
pp.output_encoding = get_log_output_encoding();
|
|
|
|
|
|
|
|
if (setup_revisions(argc, argv, &revs, NULL) > 1)
|
|
|
|
return error(_("make_script: unhandled options"));
|
|
|
|
|
|
|
|
if (prepare_revision_walk(&revs) < 0)
|
|
|
|
return error(_("make_script: error preparing revisions"));
|
|
|
|
|
|
|
|
while ((commit = get_revision(&revs))) {
|
|
|
|
strbuf_reset(&buf);
|
|
|
|
if (!keep_empty && is_original_commit_empty(commit))
|
|
|
|
strbuf_addf(&buf, "%c ", comment_line_char);
|
|
|
|
strbuf_addf(&buf, "pick %s ", oid_to_hex(&commit->object.oid));
|
|
|
|
pretty_print_commit(&pp, commit, &buf);
|
|
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
fputs(buf.buf, out);
|
|
|
|
}
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return 0;
|
|
|
|
}
|
2017-07-14 14:45:11 +00:00
|
|
|
|
|
|
|
|
|
|
|
int transform_todo_ids(int shorten_ids)
|
|
|
|
{
|
|
|
|
const char *todo_file = rebase_path_todo();
|
|
|
|
struct todo_list todo_list = TODO_LIST_INIT;
|
|
|
|
int fd, res, i;
|
|
|
|
FILE *out;
|
|
|
|
|
|
|
|
strbuf_reset(&todo_list.buf);
|
|
|
|
fd = open(todo_file, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return error_errno(_("could not open '%s'"), todo_file);
|
|
|
|
if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
|
|
|
|
close(fd);
|
|
|
|
return error(_("could not read '%s'."), todo_file);
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
res = parse_insn_buffer(todo_list.buf.buf, &todo_list);
|
|
|
|
if (res) {
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return error(_("unusable todo list: '%s'"), todo_file);
|
|
|
|
}
|
|
|
|
|
|
|
|
out = fopen(todo_file, "w");
|
|
|
|
if (!out) {
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return error(_("unable to open '%s' for writing"), todo_file);
|
|
|
|
}
|
|
|
|
for (i = 0; i < todo_list.nr; i++) {
|
|
|
|
struct todo_item *item = todo_list.items + i;
|
|
|
|
int bol = item->offset_in_buf;
|
|
|
|
const char *p = todo_list.buf.buf + bol;
|
|
|
|
int eol = i + 1 < todo_list.nr ?
|
|
|
|
todo_list.items[i + 1].offset_in_buf :
|
|
|
|
todo_list.buf.len;
|
|
|
|
|
|
|
|
if (item->command >= TODO_EXEC && item->command != TODO_DROP)
|
|
|
|
fwrite(p, eol - bol, 1, out);
|
|
|
|
else {
|
|
|
|
const char *id = shorten_ids ?
|
|
|
|
short_commit_name(item->commit) :
|
|
|
|
oid_to_hex(&item->commit->object.oid);
|
|
|
|
int len;
|
|
|
|
|
|
|
|
p += strspn(p, " \t"); /* left-trim command */
|
|
|
|
len = strcspn(p, " \t"); /* length of command */
|
|
|
|
|
|
|
|
fprintf(out, "%.*s %s %.*s\n",
|
|
|
|
len, p, id, item->arg_len, item->arg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(out);
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return 0;
|
|
|
|
}
|
2017-07-14 14:45:21 +00:00
|
|
|
|
|
|
|
enum check_level {
|
|
|
|
CHECK_IGNORE = 0, CHECK_WARN, CHECK_ERROR
|
|
|
|
};
|
|
|
|
|
|
|
|
static enum check_level get_missing_commit_check_level(void)
|
|
|
|
{
|
|
|
|
const char *value;
|
|
|
|
|
|
|
|
if (git_config_get_value("rebase.missingcommitscheck", &value) ||
|
|
|
|
!strcasecmp("ignore", value))
|
|
|
|
return CHECK_IGNORE;
|
|
|
|
if (!strcasecmp("warn", value))
|
|
|
|
return CHECK_WARN;
|
|
|
|
if (!strcasecmp("error", value))
|
|
|
|
return CHECK_ERROR;
|
2017-10-08 12:18:39 +00:00
|
|
|
warning(_("unrecognized setting %s for option "
|
2017-07-14 14:45:21 +00:00
|
|
|
"rebase.missingCommitsCheck. Ignoring."), value);
|
|
|
|
return CHECK_IGNORE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if the user dropped some commits by mistake
|
|
|
|
* Behaviour determined by rebase.missingCommitsCheck.
|
|
|
|
* Check if there is an unrecognized command or a
|
|
|
|
* bad SHA-1 in a command.
|
|
|
|
*/
|
|
|
|
int check_todo_list(void)
|
|
|
|
{
|
|
|
|
enum check_level check_level = get_missing_commit_check_level();
|
|
|
|
struct strbuf todo_file = STRBUF_INIT;
|
|
|
|
struct todo_list todo_list = TODO_LIST_INIT;
|
|
|
|
struct strbuf missing = STRBUF_INIT;
|
|
|
|
int advise_to_edit_todo = 0, res = 0, fd, i;
|
|
|
|
|
|
|
|
strbuf_addstr(&todo_file, rebase_path_todo());
|
|
|
|
fd = open(todo_file.buf, O_RDONLY);
|
|
|
|
if (fd < 0) {
|
|
|
|
res = error_errno(_("could not open '%s'"), todo_file.buf);
|
|
|
|
goto leave_check;
|
|
|
|
}
|
|
|
|
if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
|
|
|
|
close(fd);
|
|
|
|
res = error(_("could not read '%s'."), todo_file.buf);
|
|
|
|
goto leave_check;
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
advise_to_edit_todo = res =
|
|
|
|
parse_insn_buffer(todo_list.buf.buf, &todo_list);
|
|
|
|
|
|
|
|
if (res || check_level == CHECK_IGNORE)
|
|
|
|
goto leave_check;
|
|
|
|
|
|
|
|
/* Mark the commits in git-rebase-todo as seen */
|
|
|
|
for (i = 0; i < todo_list.nr; i++) {
|
|
|
|
struct commit *commit = todo_list.items[i].commit;
|
|
|
|
if (commit)
|
|
|
|
commit->util = (void *)1;
|
|
|
|
}
|
|
|
|
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
strbuf_addstr(&todo_file, ".backup");
|
|
|
|
fd = open(todo_file.buf, O_RDONLY);
|
|
|
|
if (fd < 0) {
|
|
|
|
res = error_errno(_("could not open '%s'"), todo_file.buf);
|
|
|
|
goto leave_check;
|
|
|
|
}
|
|
|
|
if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
|
|
|
|
close(fd);
|
|
|
|
res = error(_("could not read '%s'."), todo_file.buf);
|
|
|
|
goto leave_check;
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
strbuf_release(&todo_file);
|
|
|
|
res = !!parse_insn_buffer(todo_list.buf.buf, &todo_list);
|
|
|
|
|
|
|
|
/* Find commits in git-rebase-todo.backup yet unseen */
|
|
|
|
for (i = todo_list.nr - 1; i >= 0; i--) {
|
|
|
|
struct todo_item *item = todo_list.items + i;
|
|
|
|
struct commit *commit = item->commit;
|
|
|
|
if (commit && !commit->util) {
|
|
|
|
strbuf_addf(&missing, " - %s %.*s\n",
|
|
|
|
short_commit_name(commit),
|
|
|
|
item->arg_len, item->arg);
|
|
|
|
commit->util = (void *)1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Warn about missing commits */
|
|
|
|
if (!missing.len)
|
|
|
|
goto leave_check;
|
|
|
|
|
|
|
|
if (check_level == CHECK_ERROR)
|
|
|
|
advise_to_edit_todo = res = 1;
|
|
|
|
|
|
|
|
fprintf(stderr,
|
|
|
|
_("Warning: some commits may have been dropped accidentally.\n"
|
|
|
|
"Dropped commits (newer to older):\n"));
|
|
|
|
|
|
|
|
/* Make the list user-friendly and display */
|
|
|
|
fputs(missing.buf, stderr);
|
|
|
|
strbuf_release(&missing);
|
|
|
|
|
|
|
|
fprintf(stderr, _("To avoid this message, use \"drop\" to "
|
|
|
|
"explicitly remove a commit.\n\n"
|
|
|
|
"Use 'git config rebase.missingCommitsCheck' to change "
|
|
|
|
"the level of warnings.\n"
|
|
|
|
"The possible behaviours are: ignore, warn, error.\n\n"));
|
|
|
|
|
|
|
|
leave_check:
|
|
|
|
strbuf_release(&todo_file);
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
|
|
|
|
if (advise_to_edit_todo)
|
|
|
|
fprintf(stderr,
|
|
|
|
_("You can fix this with 'git rebase --edit-todo' "
|
|
|
|
"and then run 'git rebase --continue'.\n"
|
|
|
|
"Or you can abort the rebase with 'git rebase"
|
|
|
|
" --abort'.\n"));
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
2017-07-14 14:45:25 +00:00
|
|
|
|
|
|
|
/* skip picking commits whose parents are unchanged */
|
|
|
|
int skip_unnecessary_picks(void)
|
|
|
|
{
|
|
|
|
const char *todo_file = rebase_path_todo();
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct todo_list todo_list = TODO_LIST_INIT;
|
|
|
|
struct object_id onto_oid, *oid = &onto_oid, *parent_oid;
|
|
|
|
int fd, i;
|
|
|
|
|
|
|
|
if (!read_oneliner(&buf, rebase_path_onto(), 0))
|
|
|
|
return error(_("could not read 'onto'"));
|
|
|
|
if (get_oid(buf.buf, &onto_oid)) {
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return error(_("need a HEAD to fixup"));
|
|
|
|
}
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
fd = open(todo_file, O_RDONLY);
|
|
|
|
if (fd < 0) {
|
|
|
|
return error_errno(_("could not open '%s'"), todo_file);
|
|
|
|
}
|
|
|
|
if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
|
|
|
|
close(fd);
|
|
|
|
return error(_("could not read '%s'."), todo_file);
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < todo_list.nr; i++) {
|
|
|
|
struct todo_item *item = todo_list.items + i;
|
|
|
|
|
|
|
|
if (item->command >= TODO_NOOP)
|
|
|
|
continue;
|
|
|
|
if (item->command != TODO_PICK)
|
|
|
|
break;
|
|
|
|
if (parse_commit(item->commit)) {
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return error(_("could not parse commit '%s'"),
|
|
|
|
oid_to_hex(&item->commit->object.oid));
|
|
|
|
}
|
|
|
|
if (!item->commit->parents)
|
|
|
|
break; /* root commit */
|
|
|
|
if (item->commit->parents->next)
|
|
|
|
break; /* merge commit */
|
|
|
|
parent_oid = &item->commit->parents->item->object.oid;
|
|
|
|
if (hashcmp(parent_oid->hash, oid->hash))
|
|
|
|
break;
|
|
|
|
oid = &item->commit->object.oid;
|
|
|
|
}
|
|
|
|
if (i > 0) {
|
|
|
|
int offset = i < todo_list.nr ?
|
|
|
|
todo_list.items[i].offset_in_buf : todo_list.buf.len;
|
|
|
|
const char *done_path = rebase_path_done();
|
|
|
|
|
|
|
|
fd = open(done_path, O_CREAT | O_WRONLY | O_APPEND, 0666);
|
|
|
|
if (fd < 0) {
|
|
|
|
error_errno(_("could not open '%s' for writing"),
|
|
|
|
done_path);
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (write_in_full(fd, todo_list.buf.buf, offset) < 0) {
|
|
|
|
error_errno(_("could not write to '%s'"), done_path);
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
fd = open(rebase_path_todo(), O_WRONLY, 0666);
|
|
|
|
if (fd < 0) {
|
|
|
|
error_errno(_("could not open '%s' for writing"),
|
|
|
|
rebase_path_todo());
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (write_in_full(fd, todo_list.buf.buf + offset,
|
|
|
|
todo_list.buf.len - offset) < 0) {
|
|
|
|
error_errno(_("could not write to '%s'"),
|
|
|
|
rebase_path_todo());
|
|
|
|
close(fd);
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (ftruncate(fd, todo_list.buf.len - offset) < 0) {
|
|
|
|
error_errno(_("could not truncate '%s'"),
|
|
|
|
rebase_path_todo());
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
todo_list.current = i;
|
|
|
|
if (is_fixup(peek_command(&todo_list, 0)))
|
|
|
|
record_in_rewritten(oid, peek_command(&todo_list, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
printf("%s\n", oid_to_hex(oid));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2017-07-14 14:45:31 +00:00
|
|
|
|
|
|
|
struct subject2item_entry {
|
|
|
|
struct hashmap_entry entry;
|
|
|
|
int i;
|
|
|
|
char subject[FLEX_ARRAY];
|
|
|
|
};
|
|
|
|
|
|
|
|
static int subject2item_cmp(const void *fndata,
|
|
|
|
const struct subject2item_entry *a,
|
|
|
|
const struct subject2item_entry *b, const void *key)
|
|
|
|
{
|
|
|
|
return key ? strcmp(a->subject, key) : strcmp(a->subject, b->subject);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rearrange the todo list that has both "pick commit-id msg" and "pick
|
|
|
|
* commit-id fixup!/squash! msg" in it so that the latter is put immediately
|
|
|
|
* after the former, and change "pick" to "fixup"/"squash".
|
|
|
|
*
|
|
|
|
* Note that if the config has specified a custom instruction format, each log
|
|
|
|
* message will have to be retrieved from the commit (as the oneline in the
|
|
|
|
* script cannot be trusted) in order to normalize the autosquash arrangement.
|
|
|
|
*/
|
|
|
|
int rearrange_squash(void)
|
|
|
|
{
|
|
|
|
const char *todo_file = rebase_path_todo();
|
|
|
|
struct todo_list todo_list = TODO_LIST_INIT;
|
|
|
|
struct hashmap subject2item;
|
|
|
|
int res = 0, rearranged = 0, *next, *tail, fd, i;
|
|
|
|
char **subjects;
|
|
|
|
|
|
|
|
fd = open(todo_file, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return error_errno(_("could not open '%s'"), todo_file);
|
|
|
|
if (strbuf_read(&todo_list.buf, fd, 0) < 0) {
|
|
|
|
close(fd);
|
|
|
|
return error(_("could not read '%s'."), todo_file);
|
|
|
|
}
|
|
|
|
close(fd);
|
|
|
|
if (parse_insn_buffer(todo_list.buf.buf, &todo_list) < 0) {
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The hashmap maps onelines to the respective todo list index.
|
|
|
|
*
|
|
|
|
* If any items need to be rearranged, the next[i] value will indicate
|
|
|
|
* which item was moved directly after the i'th.
|
|
|
|
*
|
|
|
|
* In that case, last[i] will indicate the index of the latest item to
|
|
|
|
* be moved to appear after the i'th.
|
|
|
|
*/
|
|
|
|
hashmap_init(&subject2item, (hashmap_cmp_fn) subject2item_cmp,
|
|
|
|
NULL, todo_list.nr);
|
|
|
|
ALLOC_ARRAY(next, todo_list.nr);
|
|
|
|
ALLOC_ARRAY(tail, todo_list.nr);
|
|
|
|
ALLOC_ARRAY(subjects, todo_list.nr);
|
|
|
|
for (i = 0; i < todo_list.nr; i++) {
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct todo_item *item = todo_list.items + i;
|
|
|
|
const char *commit_buffer, *subject, *p;
|
|
|
|
size_t subject_len;
|
|
|
|
int i2 = -1;
|
|
|
|
struct subject2item_entry *entry;
|
|
|
|
|
|
|
|
next[i] = tail[i] = -1;
|
|
|
|
if (item->command >= TODO_EXEC) {
|
|
|
|
subjects[i] = NULL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_fixup(item->command)) {
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
return error(_("the script was already rearranged."));
|
|
|
|
}
|
|
|
|
|
|
|
|
item->commit->util = item;
|
|
|
|
|
|
|
|
parse_commit(item->commit);
|
|
|
|
commit_buffer = get_commit_buffer(item->commit, NULL);
|
|
|
|
find_commit_subject(commit_buffer, &subject);
|
|
|
|
format_subject(&buf, subject, " ");
|
|
|
|
subject = subjects[i] = strbuf_detach(&buf, &subject_len);
|
|
|
|
unuse_commit_buffer(item->commit, commit_buffer);
|
|
|
|
if ((skip_prefix(subject, "fixup! ", &p) ||
|
|
|
|
skip_prefix(subject, "squash! ", &p))) {
|
|
|
|
struct commit *commit2;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
while (isspace(*p))
|
|
|
|
p++;
|
|
|
|
if (!skip_prefix(p, "fixup! ", &p) &&
|
|
|
|
!skip_prefix(p, "squash! ", &p))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((entry = hashmap_get_from_hash(&subject2item,
|
|
|
|
strhash(p), p)))
|
|
|
|
/* found by title */
|
|
|
|
i2 = entry->i;
|
|
|
|
else if (!strchr(p, ' ') &&
|
|
|
|
(commit2 =
|
|
|
|
lookup_commit_reference_by_name(p)) &&
|
|
|
|
commit2->util)
|
|
|
|
/* found by commit name */
|
|
|
|
i2 = (struct todo_item *)commit2->util
|
|
|
|
- todo_list.items;
|
|
|
|
else {
|
|
|
|
/* copy can be a prefix of the commit subject */
|
|
|
|
for (i2 = 0; i2 < i; i2++)
|
|
|
|
if (subjects[i2] &&
|
|
|
|
starts_with(subjects[i2], p))
|
|
|
|
break;
|
|
|
|
if (i2 == i)
|
|
|
|
i2 = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (i2 >= 0) {
|
|
|
|
rearranged = 1;
|
|
|
|
todo_list.items[i].command =
|
|
|
|
starts_with(subject, "fixup!") ?
|
|
|
|
TODO_FIXUP : TODO_SQUASH;
|
|
|
|
if (next[i2] < 0)
|
|
|
|
next[i2] = i;
|
|
|
|
else
|
|
|
|
next[tail[i2]] = i;
|
|
|
|
tail[i2] = i;
|
|
|
|
} else if (!hashmap_get_from_hash(&subject2item,
|
|
|
|
strhash(subject), subject)) {
|
|
|
|
FLEX_ALLOC_MEM(entry, subject, subject, subject_len);
|
|
|
|
entry->i = i;
|
|
|
|
hashmap_entry_init(entry, strhash(entry->subject));
|
|
|
|
hashmap_put(&subject2item, entry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rearranged) {
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
for (i = 0; i < todo_list.nr; i++) {
|
|
|
|
enum todo_command command = todo_list.items[i].command;
|
|
|
|
int cur = i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initially, all commands are 'pick's. If it is a
|
|
|
|
* fixup or a squash now, we have rearranged it.
|
|
|
|
*/
|
|
|
|
if (is_fixup(command))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
while (cur >= 0) {
|
|
|
|
int offset = todo_list.items[cur].offset_in_buf;
|
|
|
|
int end_offset = cur + 1 < todo_list.nr ?
|
|
|
|
todo_list.items[cur + 1].offset_in_buf :
|
|
|
|
todo_list.buf.len;
|
|
|
|
char *bol = todo_list.buf.buf + offset;
|
|
|
|
char *eol = todo_list.buf.buf + end_offset;
|
|
|
|
|
|
|
|
/* replace 'pick', by 'fixup' or 'squash' */
|
|
|
|
command = todo_list.items[cur].command;
|
|
|
|
if (is_fixup(command)) {
|
|
|
|
strbuf_addstr(&buf,
|
|
|
|
todo_command_info[command].str);
|
|
|
|
bol += strcspn(bol, " \t");
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_add(&buf, bol, eol - bol);
|
|
|
|
|
|
|
|
cur = next[cur];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fd = open(todo_file, O_WRONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
res = error_errno(_("could not open '%s'"), todo_file);
|
|
|
|
else if (write(fd, buf.buf, buf.len) < 0)
|
|
|
|
res = error_errno(_("could not read '%s'."), todo_file);
|
|
|
|
else if (ftruncate(fd, buf.len) < 0)
|
|
|
|
res = error_errno(_("could not finish '%s'"),
|
|
|
|
todo_file);
|
|
|
|
close(fd);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(next);
|
|
|
|
free(tail);
|
|
|
|
for (i = 0; i < todo_list.nr; i++)
|
|
|
|
free(subjects[i]);
|
|
|
|
free(subjects);
|
|
|
|
hashmap_free(&subject2item, 1);
|
|
|
|
todo_list_release(&todo_list);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|