#include "diff.h"
#include "wt-status.h"
#include "revision.h"
+#include "commit-reach.h"
#include "rerere.h"
static char const * const builtin_rebase_usage[] = {
cp.git_cmd = 1;
if (capture_command(&cp, &out, 6)) {
strbuf_release(&out);
- return 0;
+ return 1;
}
strbuf_trim(&out);
if (!file_exists(path))
return 0;
- if (read_one(state_dir_path("autostash", opts), &autostash))
+ if (read_one(path, &autostash))
return error(_("Could not read '%s'"), path);
+ /* Ensure that the hash is not mistaken for a number */
+ strbuf_addstr(&autostash, "^0");
argv_array_pushl(&stash_apply.args,
"stash", "apply", autostash.buf, NULL);
stash_apply.git_cmd = 1;
}
}
+static const char *resolvemsg =
+N_("Resolve all conflicts manually, mark them as resolved with\n"
+"\"git add/rm <conflicted_files>\", then run \"git rebase --continue\".\n"
+"You can instead skip this commit: run \"git rebase --skip\".\n"
+"To abort and get back to the state before \"git rebase\", run "
+"\"git rebase --abort\".");
+
static int run_specific_rebase(struct rebase_options *opts)
{
const char *argv[] = { NULL, NULL };
int status;
const char *backend, *backend_func;
+ if (opts->type == REBASE_INTERACTIVE) {
+ /* Run builtin interactive rebase */
+ struct child_process child = CHILD_PROCESS_INIT;
+
+ argv_array_pushf(&child.env_array, "GIT_CHERRY_PICK_HELP=%s",
+ resolvemsg);
+ if (!(opts->flags & REBASE_INTERACTIVE_EXPLICIT)) {
+ argv_array_push(&child.env_array, "GIT_EDITOR=:");
+ opts->autosquash = 0;
+ }
+
+ child.git_cmd = 1;
+ argv_array_push(&child.args, "rebase--interactive");
+
+ if (opts->action)
+ argv_array_pushf(&child.args, "--%s", opts->action);
+ if (opts->keep_empty)
+ argv_array_push(&child.args, "--keep-empty");
+ if (opts->rebase_merges)
+ argv_array_push(&child.args, "--rebase-merges");
+ if (opts->rebase_cousins)
+ argv_array_push(&child.args, "--rebase-cousins");
+ if (opts->autosquash)
+ argv_array_push(&child.args, "--autosquash");
+ if (opts->flags & REBASE_VERBOSE)
+ argv_array_push(&child.args, "--verbose");
+ if (opts->flags & REBASE_FORCE)
+ argv_array_push(&child.args, "--no-ff");
+ if (opts->restrict_revision)
+ argv_array_pushf(&child.args,
+ "--restrict-revision=^%s",
+ oid_to_hex(&opts->restrict_revision->object.oid));
+ if (opts->upstream)
+ argv_array_pushf(&child.args, "--upstream=%s",
+ oid_to_hex(&opts->upstream->object.oid));
+ if (opts->onto)
+ argv_array_pushf(&child.args, "--onto=%s",
+ oid_to_hex(&opts->onto->object.oid));
+ if (opts->squash_onto)
+ argv_array_pushf(&child.args, "--squash-onto=%s",
+ oid_to_hex(opts->squash_onto));
+ if (opts->onto_name)
+ argv_array_pushf(&child.args, "--onto-name=%s",
+ opts->onto_name);
+ argv_array_pushf(&child.args, "--head-name=%s",
+ opts->head_name ?
+ opts->head_name : "detached HEAD");
+ if (opts->strategy)
+ argv_array_pushf(&child.args, "--strategy=%s",
+ opts->strategy);
+ if (opts->strategy_opts)
+ argv_array_pushf(&child.args, "--strategy-opts=%s",
+ opts->strategy_opts);
+ if (opts->switch_to)
+ argv_array_pushf(&child.args, "--switch-to=%s",
+ opts->switch_to);
+ if (opts->cmd)
+ argv_array_pushf(&child.args, "--cmd=%s", opts->cmd);
+ if (opts->allow_empty_message)
+ argv_array_push(&child.args, "--allow-empty-message");
+ if (opts->allow_rerere_autoupdate > 0)
+ argv_array_push(&child.args, "--rerere-autoupdate");
+ else if (opts->allow_rerere_autoupdate == 0)
+ argv_array_push(&child.args, "--no-rerere-autoupdate");
+ if (opts->gpg_sign_opt)
+ argv_array_push(&child.args, opts->gpg_sign_opt);
+ if (opts->signoff)
+ argv_array_push(&child.args, "--signoff");
+
+ status = run_command(&child);
+ goto finished_rebase;
+ }
+
add_var(&script_snippet, "GIT_DIR", absolute_path(get_git_dir()));
add_var(&script_snippet, "state_dir", opts->state_dir);
backend = "git-rebase--am";
backend_func = "git_rebase__am";
break;
- case REBASE_INTERACTIVE:
- backend = "git-rebase--interactive";
- backend_func = "git_rebase__interactive";
- break;
case REBASE_MERGE:
backend = "git-rebase--merge";
backend_func = "git_rebase__merge";
argv[0] = script_snippet.buf;
status = run_command_v_opt(argv, RUN_USING_SHELL);
+finished_rebase:
if (opts->dont_finish_rebase)
; /* do nothing */
+ else if (opts->type == REBASE_INTERACTIVE)
+ ; /* interactive rebase cleans up after itself */
else if (status == 0) {
if (!file_exists(state_dir_path("stopped-sha", opts)))
finish_rebase(opts);
}
tree = parse_tree_indirect(oid);
- prime_cache_tree(the_repository->index, tree);
+ prime_cache_tree(the_repository, the_repository->index, tree);
if (write_locked_index(the_repository->index, &lock, COMMIT_LOCK) < 0)
ret = error(_("could not write index"));
merge_bases = get_merge_bases(onto, head);
if (merge_bases && !merge_bases->next) {
oidcpy(merge_base, &merge_bases->item->object.oid);
- res = !oidcmp(merge_base, &onto->object.oid);
+ res = oideq(merge_base, &onto->object.oid);
} else {
oidcpy(merge_base, &null_oid);
res = 0;
&lock_file);
rollback_lock_file(&lock_file);
- if (has_unstaged_changes(1)) {
+ if (has_unstaged_changes(the_repository, 1)) {
puts(_("You must edit all merge conflicts and then\n"
"mark them as resolved using git add"));
exit(1);
break;
}
+ if (options.git_am_opt.len) {
+ const char *p;
+
+ /* all am options except -q are compatible only with --am */
+ strbuf_reset(&buf);
+ strbuf_addbuf(&buf, &options.git_am_opt);
+ strbuf_addch(&buf, ' ');
+ while ((p = strstr(buf.buf, " -q ")))
+ strbuf_splice(&buf, p - buf.buf, 4, " ", 1);
+ strbuf_trim(&buf);
+
+ if (is_interactive(&options) && buf.len)
+ die(_("error: cannot combine interactive options "
+ "(--interactive, --exec, --rebase-merges, "
+ "--preserve-merges, --keep-empty, --root + "
+ "--onto) with am options (%s)"), buf.buf);
+ if (options.type == REBASE_MERGE && buf.len)
+ die(_("error: cannot combine merge options (--merge, "
+ "--strategy, --strategy-option) with am options "
+ "(%s)"), buf.buf);
+ }
+
if (options.signoff) {
if (options.type == REBASE_PRESERVE_MERGES)
die("cannot combine '--signoff' with "
options.flags |= REBASE_FORCE;
}
+ if (options.type == REBASE_PRESERVE_MERGES)
+ /*
+ * Note: incompatibility with --signoff handled in signoff block above
+ * Note: incompatibility with --interactive is just a strong warning;
+ * git-rebase.txt caveats with "unless you know what you are doing"
+ */
+ if (options.rebase_merges)
+ die(_("error: cannot combine '--preserve-merges' with "
+ "'--rebase-merges'"));
+
+ if (options.rebase_merges) {
+ if (strategy_options.nr)
+ die(_("error: cannot combine '--rebase-merges' with "
+ "'--strategy-option'"));
+ if (options.strategy)
+ die(_("error: cannot combine '--rebase-merges' with "
+ "'--strategy'"));
+ }
+
if (!options.root) {
if (argc < 1) {
struct branch *branch;
update_index_if_able(&the_index, &lock_file);
rollback_lock_file(&lock_file);
- if (has_unstaged_changes(0) || has_uncommitted_changes(0)) {
+ if (has_unstaged_changes(the_repository, 1) ||
+ has_uncommitted_changes(the_repository, 1)) {
const char *autostash =
state_dir_path("autostash", &options);
struct child_process stash = CHILD_PROCESS_INIT;
if (safe_create_leading_directories_const(autostash))
die(_("Could not create directory for '%s'"),
options.state_dir);
- write_file(autostash, "%s", buf.buf);
+ write_file(autostash, "%s", oid_to_hex(&oid));
printf(_("Created autostash: %s\n"), buf.buf);
if (reset_head(&head->object.oid, "reset --hard",
NULL, 0, NULL, NULL) < 0)
}
}
- if (require_clean_work_tree("rebase",
+ if (require_clean_work_tree(the_repository, "rebase",
_("Please commit or stash them."), 1, 1)) {
ret = 1;
goto cleanup;