* Copyright (c) 2018 Pratik Karki

*/

#include "builtin.h"

#include "abspath.h"

#include "environment.h"

EMPTY_UNSPECIFIED = -1,

EMPTY_DROP,

EMPTY_KEEP,

};

enum action {

struct rebase_options {

enum rebase_type type;

enum empty_type empty;

const char *state_dir;

struct commit *upstream;

const char *upstream_name;

.type = REBASE_UNSPECIFIED, \

.empty = EMPTY_UNSPECIFIED, \

.keep_empty = 1, \

.flags = REBASE_NO_QUIET, \

.git_am_opts = STRVEC_INIT, \

.exec = STRING_LIST_INIT_NODUP, \

.reapply_cherry_picks = -1, \

.allow_empty_message = 1, \

.autosquash = -1, \

.rebase_merges = -1, \

.config_rebase_merges = -1, \

.update_refs = -1, \

.strategy_opts = STRING_LIST_INIT_NODUP,\

}

static struct replay_opts get_replay_opts(const struct rebase_options *opts)

{

struct replay_opts replay = REPLAY_OPTS_INIT;

return replay;

}

{

const char *todo_file = rebase_path_todo();

struct todo_list todo_list = TODO_LIST_INIT,

if (strbuf_read_file(&todo_list.buf, todo_file, 0) < 0)

return error_errno(_("could not read '%s'."), todo_file);

if (!res && todo_list_write_to_file(the_repository, &new_todo, todo_file,

NULL, NULL, -1, flags & ~(TODO_LIST_SHORTEN_IDS)))

res = error_errno(_("could not write '%s'"), todo_file);

if (!is_directory(merge_dir()) && mkdir_in_gitdir(merge_dir()))

return error_errno(_("could not create temporary %s"), merge_dir());

interactive = fopen(path_interactive(), "w");

if (!interactive)

if (ret)

error(_("could not generate todo list"));

else {

BUG("unusable todo list");

ret = complete_action(the_repository, &replay, flags,

replay_opts_release(&replay_opts);

break;

}

break;

case ACTION_SHOW_CURRENT_PATCH: {

struct child_process cmd = CHILD_PROCESS_INIT;

struct strbuf dir = STRBUF_INIT;

int ret = 0;

apply_autostash(state_dir_path("autostash", opts));

/*

* We ignore errors in 'git maintenance run --auto', since the

return ret;

}

static int run_am(struct rebase_options *opts)

{

struct child_process am = CHILD_PROCESS_INIT;

opts->reflog_action);

if (opts->action == ACTION_CONTINUE) {

strvec_push(&am.args, "--resolved");

if (opts->gpg_sign_opt)

strvec_push(&am.args, opts->gpg_sign_opt);

status = run_command(&am);

}

if (opts->action == ACTION_SKIP) {

strvec_push(&am.args, "--skip");

status = run_command(&am);

if (status)

return status;

status = error_errno(_("could not open '%s' for writing"),

rebased_patches);

free(rebased_patches);

return status;

}

struct reset_head_opts ropts = { 0 };

unlink(rebased_patches);

free(rebased_patches);

ropts.oid = &opts->orig_head->object.oid;

ropts.branch = opts->head_name;

status = error_errno(_("could not open '%s' for reading"),

rebased_patches);

free(rebased_patches);

return status;

}

strvec_pushv(&am.args, opts->git_am_opts.v);

strvec_push(&am.args, "--rebasing");

strvec_push(&am.args, "--patch-format=mboxrd");

if (opts->allow_rerere_autoupdate == RERERE_AUTOUPDATE)

strvec_push(&am.args, "--rerere-autoupdate");

if (opts->type == REBASE_MERGE) {

/* Run sequencer-based rebase */

setenv("GIT_SEQUENCE_EDITOR", ":", 1);

if (opts->gpg_sign_opt) {

/* remove the leading "-S" */

char *tmp = xstrdup(opts->gpg_sign_opt + 2);

}

if (!strcmp(var, "rebase.backend")) {

return git_config_string(&opts->default_backend, var, value);

}

if (!upstream)

goto done;

if (!merge_bases || merge_bases->next)

goto done;

{

struct commit_list *merge_bases = NULL;

if (!merge_bases || merge_bases->next)

oidcpy(branch_base, null_oid());

else

return EMPTY_DROP;

else if (!strcasecmp(value, "keep"))

return EMPTY_KEEP;

}

static int parse_opt_keep_empty(const struct option *opt, const char *arg,

{

struct rebase_options options = REBASE_OPTIONS_INIT;

const char *branch_name;

int ret, flags, total_argc, in_progress = 0;

int keep_base = 0;

int ok_to_skip_pre_rebase = 0;

"instead of ignoring them"),

1, PARSE_OPT_HIDDEN),

OPT_RERERE_AUTOUPDATE(&options.allow_rerere_autoupdate),

N_("how to handle commits that become empty"),

PARSE_OPT_NONEG, parse_opt_empty),

OPT_CALLBACK_F('k', "keep-empty", &options, NULL,

PARSE_OPT_OPTARG, parse_opt_rebase_merges),

OPT_BOOL(0, "fork-point", &options.fork_point,

N_("use 'merge-base --fork-point' to refine upstream")),

N_("strategy"), N_("use the given merge strategy")),

OPT_STRING_LIST('X', "strategy-option", &options.strategy_opts,

N_("option"),

die(_("options '%s' and '%s' cannot be used together"), "--root", "--fork-point");

if (options.action != ACTION_NONE && !in_progress)

if (options.action == ACTION_EDIT_TODO && !is_merge(&options))

die(_("The --edit-todo action can only be used during "

if ((options.flags & REBASE_INTERACTIVE_EXPLICIT) ||

(options.action != ACTION_NONE) ||

(options.exec.nr > 0) ||

options.autosquash == 1) {

allow_preemptive_ff = 0;

}

}

}

imply_merge(&options, "--strategy");

if (options.root && !options.onto_name)

imply_merge(&options, "--root without --onto");

if (is_merge(&options))

die(_("apply options and merge options "

"cannot be used together"));

else if (options.rebase_merges == -1 && options.config_rebase_merges == 1)

die(_("apply options are incompatible with rebase.rebaseMerges. Consider adding --no-rebase-merges"));

else if (options.update_refs == -1 && options.config_update_refs == 1)

options.rebase_merges = (options.rebase_merges >= 0) ? options.rebase_merges :

((options.config_rebase_merges >= 0) ? options.config_rebase_merges : 0);

imply_merge(&options, "--autosquash");

if (options.type == REBASE_UNSPECIFIED) {

if (!strcmp(options.default_backend, "merge"))

if (options.empty == EMPTY_UNSPECIFIED) {

if (options.flags & REBASE_INTERACTIVE_EXPLICIT)

else if (options.exec.nr > 0)

options.empty = EMPTY_KEEP;

else

/* Is it a local branch? */

strbuf_reset(&buf);

strbuf_addf(&buf, "refs/heads/%s", branch_name);

die_if_checked_out(buf.buf, 1);

options.head_name = xstrdup(buf.buf);

options.orig_head =

} else if (argc == 0) {

/* Do not need to switch branches, we are already on it. */

options.head_name =

if (!options.head_name)

die(_("No such ref: %s"), "HEAD");

if (flags & REF_ISSYMREF) {

if (!(options.flags & REBASE_NO_QUIET))

; /* be quiet */

else if (!strcmp(branch_name, "HEAD") &&

puts(_("HEAD is up to date."));

else

printf(_("Current branch %s is up to date.\n"),

} else if (!(options.flags & REBASE_NO_QUIET))

; /* be quiet */

else if (!strcmp(branch_name, "HEAD") &&

puts(_("HEAD is up to date, rebase forced."));

else

printf(_("Current branch %s is up to date, rebase "

cleanup:

strbuf_release(&buf);

strbuf_release(&revisions);

free(squash_onto_name);

free(keep_base_onto_name);

return !!ret;