src/libgit2/revert.c

   1 /*
   2 * Copyright (C) the libgit2 contributors. All rights reserved.
   3 *
   4 * This file is part of libgit2, distributed under the GNU GPL v2 with
   5 * a Linking Exception. For full terms see the included COPYING file.
   6 */
   7
   8 #include "common.h"
   9
  10 #include "repository.h"
  11 #include "filebuf.h"
  12 #include "merge.h"
  13 #include "index.h"
  14
  15 #include "git2/types.h"
  16 #include "git2/merge.h"
  17 #include "git2/revert.h"
  18 #include "git2/commit.h"
  19 #include "git2/sys/commit.h"
  20
  21 #define GIT_REVERT_FILE_MODE            0666
  22
  23 static int write_revert_head(
  24         git_repository *repo,
  25         const char *commit_oidstr)
  26 {
  27         git_filebuf file = GIT_FILEBUF_INIT;
  28         git_str file_path = GIT_STR_INIT;
  29         int error = 0;
  30
  31         if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_REVERT_HEAD_FILE)) >= 0 &&
  32                 (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_REVERT_FILE_MODE)) >= 0 &&
  33                 (error = git_filebuf_printf(&file, "%s\n", commit_oidstr)) >= 0)
  34                 error = git_filebuf_commit(&file);
  35
  36         if (error < 0)
  37                 git_filebuf_cleanup(&file);
  38
  39         git_str_dispose(&file_path);
  40
  41         return error;
  42 }
  43
  44 static int write_merge_msg(
  45         git_repository *repo,
  46         const char *commit_oidstr,
  47         const char *commit_msgline)
  48 {
  49         git_filebuf file = GIT_FILEBUF_INIT;
  50         git_str file_path = GIT_STR_INIT;
  51         int error = 0;
  52
  53         if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_MERGE_MSG_FILE)) < 0 ||
  54                 (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_REVERT_FILE_MODE)) < 0 ||
  55                 (error = git_filebuf_printf(&file, "Revert \"%s\"\n\nThis reverts commit %s.\n",
  56                 commit_msgline, commit_oidstr)) < 0)
  57                 goto cleanup;
  58
  59         error = git_filebuf_commit(&file);
  60
  61 cleanup:
  62         if (error < 0)
  63                 git_filebuf_cleanup(&file);
  64
  65         git_str_dispose(&file_path);
  66
  67         return error;
  68 }
  69
  70 static int revert_normalize_opts(
  71         git_repository *repo,
  72         git_revert_options *opts,
  73         const git_revert_options *given,
  74         const char *their_label)
  75 {
  76         int error = 0;
  77         unsigned int default_checkout_strategy = GIT_CHECKOUT_SAFE |
  78                 GIT_CHECKOUT_ALLOW_CONFLICTS;
  79
  80         GIT_UNUSED(repo);
  81
  82         if (given != NULL)
  83                 memcpy(opts, given, sizeof(git_revert_options));
  84         else {
  85                 git_revert_options default_opts = GIT_REVERT_OPTIONS_INIT;
  86                 memcpy(opts, &default_opts, sizeof(git_revert_options));
  87         }
  88
  89         if (!opts->checkout_opts.checkout_strategy)
  90                 opts->checkout_opts.checkout_strategy = default_checkout_strategy;
  91
  92         if (!opts->checkout_opts.our_label)
  93                 opts->checkout_opts.our_label = "HEAD";
  94
  95         if (!opts->checkout_opts.their_label)
  96                 opts->checkout_opts.their_label = their_label;
  97
  98         return error;
  99 }
 100
 101 static int revert_state_cleanup(git_repository *repo)
 102 {
 103         const char *state_files[] = { GIT_REVERT_HEAD_FILE, GIT_MERGE_MSG_FILE };
 104
 105         return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files));
 106 }
 107
 108 static int revert_seterr(git_commit *commit, const char *fmt)
 109 {
 110         char commit_oidstr[GIT_OID_HEXSZ + 1];
 111
 112         git_oid_fmt(commit_oidstr, git_commit_id(commit));
 113         commit_oidstr[GIT_OID_HEXSZ] = '\0';
 114
 115         git_error_set(GIT_ERROR_REVERT, fmt, commit_oidstr);
 116
 117         return -1;
 118 }
 119
 120 int git_revert_commit(
 121         git_index **out,
 122         git_repository *repo,
 123         git_commit *revert_commit,
 124         git_commit *our_commit,
 125         unsigned int mainline,
 126         const git_merge_options *merge_opts)
 127 {
 128         git_commit *parent_commit = NULL;
 129         git_tree *parent_tree = NULL, *our_tree = NULL, *revert_tree = NULL;
 130         int parent = 0, error = 0;
 131
 132         GIT_ASSERT_ARG(out);
 133         GIT_ASSERT_ARG(repo);
 134         GIT_ASSERT_ARG(revert_commit);
 135         GIT_ASSERT_ARG(our_commit);
 136
 137         if (git_commit_parentcount(revert_commit) > 1) {
 138                 if (!mainline)
 139                         return revert_seterr(revert_commit,
 140                                 "mainline branch is not specified but %s is a merge commit");
 141
 142                 parent = mainline;
 143         } else {
 144                 if (mainline)
 145                         return revert_seterr(revert_commit,
 146                                 "mainline branch specified but %s is not a merge commit");
 147
 148                 parent = git_commit_parentcount(revert_commit);
 149         }
 150
 151         if (parent &&
 152                 ((error = git_commit_parent(&parent_commit, revert_commit, (parent - 1))) < 0 ||
 153                 (error = git_commit_tree(&parent_tree, parent_commit)) < 0))
 154                 goto done;
 155
 156         if ((error = git_commit_tree(&revert_tree, revert_commit)) < 0 ||
 157                 (error = git_commit_tree(&our_tree, our_commit)) < 0)
 158                 goto done;
 159
 160         error = git_merge_trees(out, repo, revert_tree, our_tree, parent_tree, merge_opts);
 161
 162 done:
 163         git_tree_free(parent_tree);
 164         git_tree_free(our_tree);
 165         git_tree_free(revert_tree);
 166         git_commit_free(parent_commit);
 167
 168         return error;
 169 }
 170
 171 int git_revert(
 172         git_repository *repo,
 173         git_commit *commit,
 174         const git_revert_options *given_opts)
 175 {
 176         git_revert_options opts;
 177         git_reference *our_ref = NULL;
 178         git_commit *our_commit = NULL;
 179         char commit_oidstr[GIT_OID_HEXSZ + 1];
 180         const char *commit_msg;
 181         git_str their_label = GIT_STR_INIT;
 182         git_index *index = NULL;
 183         git_indexwriter indexwriter = GIT_INDEXWRITER_INIT;
 184         int error;
 185
 186         GIT_ASSERT_ARG(repo);
 187         GIT_ASSERT_ARG(commit);
 188
 189         GIT_ERROR_CHECK_VERSION(given_opts, GIT_REVERT_OPTIONS_VERSION, "git_revert_options");
 190
 191         if ((error = git_repository__ensure_not_bare(repo, "revert")) < 0)
 192                 return error;
 193
 194         git_oid_fmt(commit_oidstr, git_commit_id(commit));
 195         commit_oidstr[GIT_OID_HEXSZ] = '\0';
 196
 197         if ((commit_msg = git_commit_summary(commit)) == NULL) {
 198                 error = -1;
 199                 goto on_error;
 200         }
 201
 202         if ((error = git_str_printf(&their_label, "parent of %.7s... %s", commit_oidstr, commit_msg)) < 0 ||
 203                 (error = revert_normalize_opts(repo, &opts, given_opts, git_str_cstr(&their_label))) < 0 ||
 204                 (error = git_indexwriter_init_for_operation(&indexwriter, repo, &opts.checkout_opts.checkout_strategy)) < 0 ||
 205                 (error = write_revert_head(repo, commit_oidstr)) < 0 ||
 206                 (error = write_merge_msg(repo, commit_oidstr, commit_msg)) < 0 ||
 207                 (error = git_repository_head(&our_ref, repo)) < 0 ||
 208                 (error = git_reference_peel((git_object **)&our_commit, our_ref, GIT_OBJECT_COMMIT)) < 0 ||
 209                 (error = git_revert_commit(&index, repo, commit, our_commit, opts.mainline, &opts.merge_opts)) < 0 ||
 210                 (error = git_merge__check_result(repo, index)) < 0 ||
 211                 (error = git_merge__append_conflicts_to_merge_msg(repo, index)) < 0 ||
 212                 (error = git_checkout_index(repo, index, &opts.checkout_opts)) < 0 ||
 213                 (error = git_indexwriter_commit(&indexwriter)) < 0)
 214                 goto on_error;
 215
 216         goto done;
 217
 218 on_error:
 219         revert_state_cleanup(repo);
 220
 221 done:
 222         git_indexwriter_cleanup(&indexwriter);
 223         git_index_free(index);
 224         git_commit_free(our_commit);
 225         git_reference_free(our_ref);
 226         git_str_dispose(&their_label);
 227
 228         return error;
 229 }
 230
 231 int git_revert_options_init(git_revert_options *opts, unsigned int version)
 232 {
 233         GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 234                 opts, version, git_revert_options, GIT_REVERT_OPTIONS_INIT);
 235         return 0;
 236 }
 237
 238 #ifndef GIT_DEPRECATE_HARD
 239 int git_revert_init_options(git_revert_options *opts, unsigned int version)
 240 {
 241         return git_revert_options_init(opts, version);
 242 }
 243 #endif