/*

 * "git rebase" builtin command

 *

 * Copyright (c) 2018 Pratik Karki

 */

#include "builtin.h"

#include "abspath.h"

#include "environment.h"

#include "gettext.h"

#include "hex.h"

#include "run-command.h"

#include "strvec.h"

#include "dir.h"

#include "refs.h"

#include "config.h"

#include "unpack-trees.h"

#include "lockfile.h"

#include "object-file.h"

#include "object-name.h"

#include "parse-options.h"

#include "path.h"

#include "commit.h"

#include "diff.h"

#include "wt-status.h"

#include "revision.h"

#include "commit-reach.h"

#include "rerere.h"

#include "branch.h"

#include "sequencer.h"

#include "rebase-interactive.h"

#include "reset.h"

#include "trace2.h"

#include "hook.h"

static char const * const builtin_rebase_usage[] = {

  N_("git rebase [-i] [options] [--exec <cmd>] "

    "[--onto <newbase> | --keep-base] [<upstream> [<branch>]]"),

  N_("git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] "

    "--root [<branch>]"),

  "git rebase --continue | --abort | --skip | --edit-todo",

  NULL

};

static GIT_PATH_FUNC(path_squash_onto, "rebase-merge/squash-onto")

static GIT_PATH_FUNC(path_interactive, "rebase-merge/interactive")

static GIT_PATH_FUNC(apply_dir, "rebase-apply")

static GIT_PATH_FUNC(merge_dir, "rebase-merge")

enum rebase_type {

  REBASE_UNSPECIFIED = -1,

  REBASE_APPLY,

  REBASE_MERGE

};

enum empty_type {

  EMPTY_UNSPECIFIED = -1,

  EMPTY_DROP,

  EMPTY_KEEP,

  EMPTY_STOP

};

enum action {

  ACTION_NONE = 0,

  ACTION_CONTINUE,

  ACTION_SKIP,

  ACTION_ABORT,

  ACTION_QUIT,

  ACTION_EDIT_TODO,

  ACTION_SHOW_CURRENT_PATCH

};

static const char *action_names[] = {

  "undefined",

  "continue",

  "skip",

  "abort",

  "quit",

  "edit_todo",

  "show_current_patch"

};

struct rebase_options {

  enum rebase_type type;

  enum empty_type empty;

  char *default_backend;

  const char *state_dir;

  struct commit *upstream;

  const char *upstream_name;

  const char *upstream_arg;

  char *head_name;

  struct commit *orig_head;

  struct commit *onto;

  const char *onto_name;

  const char *revisions;

  const char *switch_to;

  int root, root_with_onto;

  struct object_id *squash_onto;

  struct commit *restrict_revision;

  int dont_finish_rebase;

  enum {

    REBASE_NO_QUIET = 1<<0,

    REBASE_VERBOSE = 1<<1,

    REBASE_DIFFSTAT = 1<<2,

    REBASE_FORCE = 1<<3,

    REBASE_INTERACTIVE_EXPLICIT = 1<<4,

  } flags;

  struct strvec git_am_opts;

  enum action action;

  char *reflog_action;

  int signoff;

  int allow_rerere_autoupdate;

  int keep_empty;

  int autosquash;

  char *gpg_sign_opt;

  int autostash;

  int committer_date_is_author_date;

  int ignore_date;

  struct string_list exec;

  int allow_empty_message;

  int rebase_merges, rebase_cousins;

  char *strategy;

  struct string_list strategy_opts;

  struct strbuf git_format_patch_opt;

  int reschedule_failed_exec;

  int reapply_cherry_picks;

  int fork_point;

  int update_refs;

  int config_autosquash;

  int config_rebase_merges;

  int config_update_refs;

};

#define REBASE_OPTIONS_INIT {         \

    .type = REBASE_UNSPECIFIED,     \

    .empty = EMPTY_UNSPECIFIED,     \

    .keep_empty = 1,      \

    .default_backend = xstrdup("merge"),    \

    .flags = REBASE_NO_QUIET,     \

    .git_am_opts = STRVEC_INIT,   \

    .exec = STRING_LIST_INIT_NODUP,   \

    .git_format_patch_opt = STRBUF_INIT, \

    .fork_point = -1,     \

    .reapply_cherry_picks = -1,             \

    .allow_empty_message = 1,               \

    .autosquash = -1,                       \

    .rebase_merges = -1,                    \

    .config_rebase_merges = -1,             \

    .update_refs = -1,                      \

    .config_update_refs = -1,               \

    .strategy_opts = STRING_LIST_INIT_NODUP,\

  }

static void rebase_options_release(struct rebase_options *opts)

{

  free(opts->default_backend);

  free(opts->reflog_action);

  free(opts->head_name);

  strvec_clear(&opts->git_am_opts);

  free(opts->gpg_sign_opt);

  string_list_clear(&opts->exec, 0);

  free(opts->strategy);

  string_list_clear(&opts->strategy_opts, 0);

  strbuf_release(&opts->git_format_patch_opt);

}

static struct replay_opts get_replay_opts(const struct rebase_options *opts)

{

  struct replay_opts replay = REPLAY_OPTS_INIT;

  replay.action = REPLAY_INTERACTIVE_REBASE;

  replay.strategy = NULL;

  sequencer_init_config(&replay);

  replay.signoff = opts->signoff;

  replay.allow_ff = !(opts->flags & REBASE_FORCE);

  if (opts->allow_rerere_autoupdate)

    replay.allow_rerere_auto = opts->allow_rerere_autoupdate;

  replay.allow_empty = 1;

  replay.allow_empty_message = opts->allow_empty_message;

  replay.drop_redundant_commits = (opts->empty == EMPTY_DROP);

  replay.keep_redundant_commits = (opts->empty == EMPTY_KEEP);

  replay.quiet = !(opts->flags & REBASE_NO_QUIET);

  replay.verbose = opts->flags & REBASE_VERBOSE;

  replay.reschedule_failed_exec = opts->reschedule_failed_exec;

  replay.committer_date_is_author_date =

          opts->committer_date_is_author_date;

  replay.ignore_date = opts->ignore_date;

  free(replay.gpg_sign);

  replay.gpg_sign = xstrdup_or_null(opts->gpg_sign_opt);

  replay.reflog_action = xstrdup(opts->reflog_action);

  if (opts->strategy)

    replay.strategy = xstrdup_or_null(opts->strategy);

  else if (!replay.strategy && replay.default_strategy) {

    replay.strategy = replay.default_strategy;

    replay.default_strategy = NULL;

  }

  for (size_t i = 0; i < opts->strategy_opts.nr; i++)

    strvec_push(&replay.xopts, opts->strategy_opts.items[i].string);

  if (opts->squash_onto) {

    oidcpy(&replay.squash_onto, opts->squash_onto);

    replay.have_squash_onto = 1;

  }

  return replay;

}

static int edit_todo_file(unsigned flags, struct replay_opts *opts)

{

  const char *todo_file = rebase_path_todo();

  struct todo_list todo_list = TODO_LIST_INIT,

    new_todo = TODO_LIST_INIT;

  int res = 0;

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

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

  strbuf_stripspace(&todo_list.buf, comment_line_str);

  res = edit_todo_list(the_repository, opts, &todo_list, &new_todo,

           NULL, NULL, flags);

  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);

  todo_list_release(&todo_list);

  todo_list_release(&new_todo);

  return res;

}

static int get_revision_ranges(struct commit *upstream, struct commit *onto,

             struct object_id *orig_head, char **revisions,

             char **shortrevisions)

{

  struct commit *base_rev = upstream ? upstream : onto;

  const char *shorthead;

  *revisions = xstrfmt("%s...%s", oid_to_hex(&base_rev->object.oid),

           oid_to_hex(orig_head));

  shorthead = repo_find_unique_abbrev(the_repository, orig_head,

              DEFAULT_ABBREV);

  if (upstream) {

    const char *shortrev;

    shortrev = repo_find_unique_abbrev(the_repository,

               &base_rev->object.oid,

               DEFAULT_ABBREV);

    *shortrevisions = xstrfmt("%s..%s", shortrev, shorthead);

  } else

    *shortrevisions = xstrdup(shorthead);

  return 0;

}

static int init_basic_state(struct replay_opts *opts, const char *head_name,

          struct commit *onto,

          const struct object_id *orig_head)

{

  FILE *interactive;

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

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

  refs_delete_reflog(get_main_ref_store(the_repository), "REBASE_HEAD");

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

  if (!interactive)

    return error_errno(_("could not mark as interactive"));

  fclose(interactive);

  return write_basic_state(opts, head_name, onto, orig_head);

}

static int do_interactive_rebase(struct rebase_options *opts, unsigned flags)

{

  int ret = -1;

  char *revisions = NULL, *shortrevisions = NULL;

  struct strvec make_script_args = STRVEC_INIT;

  struct todo_list todo_list = TODO_LIST_INIT;

  struct replay_opts replay = get_replay_opts(opts);

  if (get_revision_ranges(opts->upstream, opts->onto, &opts->orig_head->object.oid,

        &revisions, &shortrevisions))

    goto cleanup;

  if (init_basic_state(&replay,

           opts->head_name ? opts->head_name : "detached HEAD",

           opts->onto, &opts->orig_head->object.oid))

    goto cleanup;

  if (!opts->upstream && opts->squash_onto)

    write_file(path_squash_onto(), "%s\n",

         oid_to_hex(opts->squash_onto));

  strvec_pushl(&make_script_args, "", revisions, NULL);

  if (opts->restrict_revision)

    strvec_pushf(&make_script_args, "^%s",

           oid_to_hex(&opts->restrict_revision->object.oid));

  ret = sequencer_make_script(the_repository, &todo_list.buf,

            make_script_args.nr, make_script_args.v,

            flags);

  if (ret)

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

  else {

    discard_index(the_repository->index);

    if (todo_list_parse_insn_buffer(the_repository, &replay,

            todo_list.buf.buf, &todo_list))

      BUG("unusable todo list");

    ret = complete_action(the_repository, &replay, flags,

      shortrevisions, opts->onto_name, opts->onto,

      &opts->orig_head->object.oid, &opts->exec,

      opts->autosquash, opts->update_refs, &todo_list);

  }

cleanup:

  replay_opts_release(&replay);

  free(revisions);

  free(shortrevisions);

  todo_list_release(&todo_list);

  strvec_clear(&make_script_args);

  return ret;

}

static int run_sequencer_rebase(struct rebase_options *opts)

{

  unsigned flags = 0;

  int abbreviate_commands = 0, ret = 0;

  git_config_get_bool("rebase.abbreviatecommands", &abbreviate_commands);

  flags |= opts->keep_empty ? TODO_LIST_KEEP_EMPTY : 0;

  flags |= abbreviate_commands ? TODO_LIST_ABBREVIATE_CMDS : 0;

  flags |= opts->rebase_merges ? TODO_LIST_REBASE_MERGES : 0;

  flags |= opts->rebase_cousins > 0 ? TODO_LIST_REBASE_COUSINS : 0;

  flags |= opts->root_with_onto ? TODO_LIST_ROOT_WITH_ONTO : 0;

  flags |= opts->reapply_cherry_picks ? TODO_LIST_REAPPLY_CHERRY_PICKS : 0;

  flags |= opts->flags & REBASE_NO_QUIET ? TODO_LIST_WARN_SKIPPED_CHERRY_PICKS : 0;

  switch (opts->action) {

  case ACTION_NONE: {

    if (!opts->onto && !opts->upstream)

      die(_("a base commit must be provided with --upstream or --onto"));

    ret = do_interactive_rebase(opts, flags);

    break;

  }

  case ACTION_SKIP: {

    struct string_list merge_rr = STRING_LIST_INIT_DUP;

    rerere_clear(the_repository, &merge_rr);

  }

    /* fallthrough */

  case ACTION_CONTINUE: {

    struct replay_opts replay_opts = get_replay_opts(opts);

    ret = sequencer_continue(the_repository, &replay_opts);

    replay_opts_release(&replay_opts);

    break;

  }

  case ACTION_EDIT_TODO: {

    struct replay_opts replay_opts = get_replay_opts(opts);

    ret = edit_todo_file(flags, &replay_opts);

    replay_opts_release(&replay_opts);

    break;

  }

  case ACTION_SHOW_CURRENT_PATCH: {

    struct child_process cmd = CHILD_PROCESS_INIT;

    cmd.git_cmd = 1;

    strvec_pushl(&cmd.args, "show", "REBASE_HEAD", "--", NULL);

    ret = run_command(&cmd);

    break;

  }

  default:

    BUG("invalid command '%d'", opts->action);

  }

  return ret;

}

static int is_merge(struct rebase_options *opts)

{

  return opts->type == REBASE_MERGE;

}

static void imply_merge(struct rebase_options *opts, const char *option)

{

  switch (opts->type) {

  case REBASE_APPLY:

    die(_("%s requires the merge backend"), option);

    break;

  case REBASE_MERGE:

    break;

  default:

    opts->type = REBASE_MERGE; /* implied */

    break;

  }

}

/* Returns the filename prefixed by the state_dir */

static const char *state_dir_path(const char *filename, struct rebase_options *opts)

{

  static struct strbuf path = STRBUF_INIT;

  static size_t prefix_len;

  if (!prefix_len) {

    strbuf_addf(&path, "%s/", opts->state_dir);

    prefix_len = path.len;

  }

  strbuf_setlen(&path, prefix_len);

  strbuf_addstr(&path, filename);

  return path.buf;

}

/* Initialize the rebase options from the state directory. */

static int read_basic_state(struct rebase_options *opts)

{

  struct strbuf head_name = STRBUF_INIT;

  struct strbuf buf = STRBUF_INIT;

  struct object_id oid;

  if (!read_oneliner(&head_name, state_dir_path("head-name", opts),

         READ_ONELINER_WARN_MISSING) ||

      !read_oneliner(&buf, state_dir_path("onto", opts),

         READ_ONELINER_WARN_MISSING))

    return -1;

  opts->head_name = starts_with(head_name.buf, "refs/") ?

    xstrdup(head_name.buf) : NULL;

  strbuf_release(&head_name);

  if (get_oid_hex(buf.buf, &oid) ||

      !(opts->onto = lookup_commit_object(the_repository, &oid)))

    return error(_("invalid onto: '%s'"), buf.buf);

  /*

   * We always write to orig-head, but interactive rebase used to write to

   * head. Fall back to reading from head to cover for the case that the

   * user upgraded git with an ongoing interactive rebase.

   */

  strbuf_reset(&buf);

  if (file_exists(state_dir_path("orig-head", opts))) {

    if (!read_oneliner(&buf, state_dir_path("orig-head", opts),

           READ_ONELINER_WARN_MISSING))

      return -1;

  } else if (!read_oneliner(&buf, state_dir_path("head", opts),

          READ_ONELINER_WARN_MISSING))

    return -1;

  if (get_oid_hex(buf.buf, &oid) ||

      !(opts->orig_head = lookup_commit_object(the_repository, &oid)))

    return error(_("invalid orig-head: '%s'"), buf.buf);

  if (file_exists(state_dir_path("quiet", opts)))

    opts->flags &= ~REBASE_NO_QUIET;

  else

    opts->flags |= REBASE_NO_QUIET;

  if (file_exists(state_dir_path("verbose", opts)))

    opts->flags |= REBASE_VERBOSE;

  if (file_exists(state_dir_path("signoff", opts))) {

    opts->signoff = 1;

    opts->flags |= REBASE_FORCE;

  }

  if (file_exists(state_dir_path("allow_rerere_autoupdate", opts))) {

    strbuf_reset(&buf);

    if (!read_oneliner(&buf, state_dir_path("allow_rerere_autoupdate", opts),

           READ_ONELINER_WARN_MISSING))

      return -1;

    if (!strcmp(buf.buf, "--rerere-autoupdate"))

      opts->allow_rerere_autoupdate = RERERE_AUTOUPDATE;

    else if (!strcmp(buf.buf, "--no-rerere-autoupdate"))

      opts->allow_rerere_autoupdate = RERERE_NOAUTOUPDATE;

    else

      warning(_("ignoring invalid allow_rerere_autoupdate: "

          "'%s'"), buf.buf);

  }

  if (file_exists(state_dir_path("gpg_sign_opt", opts))) {

    strbuf_reset(&buf);

    if (!read_oneliner(&buf, state_dir_path("gpg_sign_opt", opts),

           READ_ONELINER_WARN_MISSING))

      return -1;

    free(opts->gpg_sign_opt);

    opts->gpg_sign_opt = xstrdup(buf.buf);

  }

  strbuf_release(&buf);

  return 0;

}

static int rebase_write_basic_state(struct rebase_options *opts)

{

  write_file(state_dir_path("head-name", opts), "%s",

       opts->head_name ? opts->head_name : "detached HEAD");

  write_file(state_dir_path("onto", opts), "%s",

       opts->onto ? oid_to_hex(&opts->onto->object.oid) : "");

  write_file(state_dir_path("orig-head", opts), "%s",

       oid_to_hex(&opts->orig_head->object.oid));

  if (!(opts->flags & REBASE_NO_QUIET))

    write_file(state_dir_path("quiet", opts), "%s", "");

  if (opts->flags & REBASE_VERBOSE)

    write_file(state_dir_path("verbose", opts), "%s", "");

  if (opts->allow_rerere_autoupdate > 0)

    write_file(state_dir_path("allow_rerere_autoupdate", opts),

         "-%s-rerere-autoupdate",

         opts->allow_rerere_autoupdate == RERERE_AUTOUPDATE ?

        "" : "-no");

  if (opts->gpg_sign_opt)

    write_file(state_dir_path("gpg_sign_opt", opts), "%s",

         opts->gpg_sign_opt);

  if (opts->signoff)

    write_file(state_dir_path("signoff", opts), "--signoff");

  return 0;

}

static int finish_rebase(struct rebase_options *opts)

{

  struct strbuf dir = STRBUF_INIT;

  int ret = 0;

  refs_delete_ref(get_main_ref_store(the_repository), NULL,

      "REBASE_HEAD", NULL, REF_NO_DEREF);

  refs_delete_ref(get_main_ref_store(the_repository), NULL,

      "AUTO_MERGE", NULL, REF_NO_DEREF);

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

  /*

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

   * user should see them.

   */

  run_auto_maintenance(!(opts->flags & (REBASE_NO_QUIET|REBASE_VERBOSE)));

  if (opts->type == REBASE_MERGE) {

    struct replay_opts replay = REPLAY_OPTS_INIT;

    replay.action = REPLAY_INTERACTIVE_REBASE;

    ret = sequencer_remove_state(&replay);

    replay_opts_release(&replay);

  } else {

    strbuf_addstr(&dir, opts->state_dir);

    if (remove_dir_recursively(&dir, 0))

      ret = error(_("could not remove '%s'"),

            opts->state_dir);

    strbuf_release(&dir);

  }

  return ret;

}

static int move_to_original_branch(struct rebase_options *opts)

{

  struct strbuf branch_reflog = STRBUF_INIT, head_reflog = STRBUF_INIT;

  struct reset_head_opts ropts = { 0 };

  int ret;

  if (!opts->head_name)

    return 0; /* nothing to move back to */

  if (!opts->onto)

    BUG("move_to_original_branch without onto");

  strbuf_addf(&branch_reflog, "%s (finish): %s onto %s",

        opts->reflog_action,

        opts->head_name, oid_to_hex(&opts->onto->object.oid));

  strbuf_addf(&head_reflog, "%s (finish): returning to %s",

        opts->reflog_action, opts->head_name);

  ropts.branch = opts->head_name;

  ropts.flags = RESET_HEAD_REFS_ONLY;

  ropts.branch_msg = branch_reflog.buf;

  ropts.head_msg = head_reflog.buf;

  ret = reset_head(the_repository, &ropts);

  strbuf_release(&branch_reflog);

  strbuf_release(&head_reflog);

  return ret;

}

static int run_am(struct rebase_options *opts)

{

  struct child_process am = CHILD_PROCESS_INIT;

  struct child_process format_patch = CHILD_PROCESS_INIT;

  int status;

  char *rebased_patches;

  am.git_cmd = 1;

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

  strvec_pushf(&am.env, GIT_REFLOG_ACTION_ENVIRONMENT "=%s (pick)",

         opts->reflog_action);

  if (opts->action == ACTION_CONTINUE) {

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

    strvec_pushf(&am.args, "--resolvemsg=%s", rebase_resolvemsg);

    if (opts->gpg_sign_opt)

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

    status = run_command(&am);

    if (status)

      return status;

    return move_to_original_branch(opts);

  }

  if (opts->action == ACTION_SKIP) {

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

    strvec_pushf(&am.args, "--resolvemsg=%s", rebase_resolvemsg);

    status = run_command(&am);

    if (status)

      return status;

    return move_to_original_branch(opts);

  }

  if (opts->action == ACTION_SHOW_CURRENT_PATCH) {

    strvec_push(&am.args, "--show-current-patch");

    return run_command(&am);

  }

  rebased_patches = xstrdup(git_path("rebased-patches"));

  format_patch.out = open(rebased_patches,

        O_WRONLY | O_CREAT | O_TRUNC, 0666);

  if (format_patch.out < 0) {

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

             rebased_patches);

    free(rebased_patches);

    child_process_clear(&am);

    return status;

  }

  format_patch.git_cmd = 1;

  strvec_pushl(&format_patch.args, "format-patch", "-k", "--stdout",

         "--full-index", "--cherry-pick", "--right-only",

         "--default-prefix", "--no-renames",

         "--no-cover-letter", "--pretty=mboxrd", "--topo-order",

         "--no-base", NULL);

  if (opts->git_format_patch_opt.len)

    strvec_split(&format_patch.args,

           opts->git_format_patch_opt.buf);

  strvec_pushf(&format_patch.args, "%s...%s",

         oid_to_hex(opts->root ?

        /* this is now equivalent to !opts->upstream */

        &opts->onto->object.oid :

        &opts->upstream->object.oid),

         oid_to_hex(&opts->orig_head->object.oid));

  if (opts->restrict_revision)

    strvec_pushf(&format_patch.args, "^%s",

           oid_to_hex(&opts->restrict_revision->object.oid));

  status = run_command(&format_patch);

  if (status) {

    struct reset_head_opts ropts = { 0 };

    unlink(rebased_patches);

    free(rebased_patches);

    child_process_clear(&am);

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

    ropts.branch = opts->head_name;

    ropts.default_reflog_action = opts->reflog_action;

    reset_head(the_repository, &ropts);

    error(_("\ngit encountered an error while preparing the "

      "patches to replay\n"

      "these revisions:\n"

      "\n    %s\n\n"

      "As a result, git cannot rebase them."),

          opts->revisions);

    return status;

  }

  am.in = open(rebased_patches, O_RDONLY);

  if (am.in < 0) {

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

             rebased_patches);

    free(rebased_patches);

    child_process_clear(&am);

    return status;

  }

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

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

  strvec_pushf(&am.args, "--resolvemsg=%s", rebase_resolvemsg);

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

  if (opts->allow_rerere_autoupdate == RERERE_AUTOUPDATE)

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

  else if (opts->allow_rerere_autoupdate == RERERE_NOAUTOUPDATE)

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

  if (opts->gpg_sign_opt)

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

  status = run_command(&am);

  unlink(rebased_patches);

  free(rebased_patches);

  if (!status) {

    return move_to_original_branch(opts);

  }

  if (is_directory(opts->state_dir))

    rebase_write_basic_state(opts);

  return status;

}

static int run_specific_rebase(struct rebase_options *opts)

{

  int status;

  if (opts->type == REBASE_MERGE) {

    /* Run sequencer-based rebase */

    if (!(opts->flags & REBASE_INTERACTIVE_EXPLICIT))

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

    if (opts->gpg_sign_opt) {

      /* remove the leading "-S" */

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

      free(opts->gpg_sign_opt);

      opts->gpg_sign_opt = tmp;

    }

    status = run_sequencer_rebase(opts);

  } else if (opts->type == REBASE_APPLY)

    status = run_am(opts);

  else

    BUG("Unhandled rebase type %d", opts->type);

  if (opts->dont_finish_rebase)

    ; /* do nothing */

  else if (opts->type == REBASE_MERGE)

    ; /* merge backend cleans up after itself */

  else if (status == 0) {

    if (!file_exists(state_dir_path("stopped-sha", opts)))

      finish_rebase(opts);

  } else if (status == 2) {

    struct strbuf dir = STRBUF_INIT;

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

    strbuf_addstr(&dir, opts->state_dir);

    remove_dir_recursively(&dir, 0);

    strbuf_release(&dir);

    die("Nothing to do");

  }

  return status ? -1 : 0;

}

static void parse_rebase_merges_value(struct rebase_options *options, const char *value)

{

  if (!strcmp("no-rebase-cousins", value))

    options->rebase_cousins = 0;

  else if (!strcmp("rebase-cousins", value))

    options->rebase_cousins = 1;

  else

    die(_("Unknown rebase-merges mode: %s"), value);

}

static int rebase_config(const char *var, const char *value,

       const struct config_context *ctx, void *data)

{

  struct rebase_options *opts = data;

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

    if (git_config_bool(var, value))

      opts->flags |= REBASE_DIFFSTAT;

    else

      opts->flags &= ~REBASE_DIFFSTAT;

    return 0;

  }

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

    opts->config_autosquash = git_config_bool(var, value);

    return 0;

  }

  if (!strcmp(var, "commit.gpgsign")) {

    free(opts->gpg_sign_opt);

    opts->gpg_sign_opt = git_config_bool(var, value) ?

      xstrdup("-S") : NULL;

    return 0;

  }

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

    opts->autostash = git_config_bool(var, value);

    return 0;

  }

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

    opts->config_rebase_merges = git_parse_maybe_bool(value);

    if (opts->config_rebase_merges < 0) {

      opts->config_rebase_merges = 1;

      parse_rebase_merges_value(opts, value);

    } else {

      opts->rebase_cousins = 0;

    }

    return 0;

  }

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

    opts->config_update_refs = git_config_bool(var, value);

    return 0;

  }

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

    opts->reschedule_failed_exec = git_config_bool(var, value);

    return 0;

  }

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

    opts->fork_point = git_config_bool(var, value) ? -1 : 0;

    return 0;

  }

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

    FREE_AND_NULL(opts->default_backend);

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

  }

  return git_default_config(var, value, ctx, data);

}

static int checkout_up_to_date(struct rebase_options *options)

{

  struct strbuf buf = STRBUF_INIT;

  struct reset_head_opts ropts = { 0 };

  int ret = 0;

  strbuf_addf(&buf, "%s: checkout %s",

        options->reflog_action, options->switch_to);

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

  ropts.branch = options->head_name;

  ropts.flags = RESET_HEAD_RUN_POST_CHECKOUT_HOOK;

  if (!ropts.branch)

    ropts.flags |=  RESET_HEAD_DETACH;

  ropts.head_msg = buf.buf;

  if (reset_head(the_repository, &ropts) < 0)

    ret = error(_("could not switch to %s"), options->switch_to);

  strbuf_release(&buf);

  return ret;

}

/*

 * Determines whether the commits in from..to are linear, i.e. contain

 * no merge commits. This function *expects* `from` to be an ancestor of

 * `to`.

 */

static int is_linear_history(struct commit *from, struct commit *to)

{

  while (to && to != from) {

    repo_parse_commit(the_repository, to);

    if (!to->parents)

      return 1;

    if (to->parents->next)

      return 0;

    to = to->parents->item;

  }

  return 1;

}

static int can_fast_forward(struct commit *onto, struct commit *upstream,

          struct commit *restrict_revision,

          struct commit *head, struct object_id *branch_base)

{

  struct commit_list *merge_bases = NULL;

  int res = 0;

  if (is_null_oid(branch_base))

    goto done; /* fill_branch_base() found multiple merge bases */

  if (!oideq(branch_base, &onto->object.oid))

    goto done;

  if (restrict_revision && !oideq(&restrict_revision->object.oid, branch_base))

    goto done;