src/stash.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 "commit.h"
  12 #include "message.h"
  13 #include "tree.h"
  14 #include "reflog.h"
  15 #include "blob.h"
  16 #include "git2/diff.h"
  17 #include "git2/stash.h"
  18 #include "git2/status.h"
  19 #include "git2/checkout.h"
  20 #include "git2/index.h"
  21 #include "git2/transaction.h"
  22 #include "git2/merge.h"
  23 #include "index.h"
  24 #include "signature.h"
  25 #include "iterator.h"
  26 #include "merge.h"
  27 #include "diff.h"
  28 #include "diff_generate.h"
  29
  30 static int create_error(int error, const char *msg)
  31 {
  32         git_error_set(GIT_ERROR_STASH, "cannot stash changes - %s", msg);
  33         return error;
  34 }
  35
  36 static int retrieve_head(git_reference **out, git_repository *repo)
  37 {
  38         int error = git_repository_head(out, repo);
  39
  40         if (error == GIT_EUNBORNBRANCH)
  41                 return create_error(error, "you do not have the initial commit yet.");
  42
  43         return error;
  44 }
  45
  46 static int append_abbreviated_oid(git_buf *out, const git_oid *b_commit)
  47 {
  48         char *formatted_oid;
  49
  50         formatted_oid = git_oid_allocfmt(b_commit);
  51         GIT_ERROR_CHECK_ALLOC(formatted_oid);
  52
  53         git_buf_put(out, formatted_oid, 7);
  54         git__free(formatted_oid);
  55
  56         return git_buf_oom(out) ? -1 : 0;
  57 }
  58
  59 static int append_commit_description(git_buf *out, git_commit* commit)
  60 {
  61         const char *summary = git_commit_summary(commit);
  62         GIT_ERROR_CHECK_ALLOC(summary);
  63
  64         if (append_abbreviated_oid(out, git_commit_id(commit)) < 0)
  65                 return -1;
  66
  67         git_buf_putc(out, ' ');
  68         git_buf_puts(out, summary);
  69         git_buf_putc(out, '\n');
  70
  71         return git_buf_oom(out) ? -1 : 0;
  72 }
  73
  74 static int retrieve_base_commit_and_message(
  75         git_commit **b_commit,
  76         git_buf *stash_message,
  77         git_repository *repo)
  78 {
  79         git_reference *head = NULL;
  80         int error;
  81
  82         if ((error = retrieve_head(&head, repo)) < 0)
  83                 return error;
  84
  85         if (strcmp("HEAD", git_reference_name(head)) == 0)
  86                 error = git_buf_puts(stash_message, "(no branch): ");
  87         else
  88                 error = git_buf_printf(
  89                         stash_message,
  90                         "%s: ",
  91                         git_reference_name(head) + strlen(GIT_REFS_HEADS_DIR));
  92         if (error < 0)
  93                 goto cleanup;
  94
  95         if ((error = git_commit_lookup(
  96                          b_commit, repo, git_reference_target(head))) < 0)
  97                 goto cleanup;
  98
  99         if ((error = append_commit_description(stash_message, *b_commit)) < 0)
 100                 goto cleanup;
 101
 102 cleanup:
 103         git_reference_free(head);
 104         return error;
 105 }
 106
 107 static int build_tree_from_index(
 108         git_tree **out,
 109         git_repository *repo,
 110         git_index *index)
 111 {
 112         int error;
 113         git_oid i_tree_oid;
 114
 115         if ((error = git_index_write_tree_to(&i_tree_oid, index, repo)) < 0)
 116                 return error;
 117
 118         return git_tree_lookup(out, repo, &i_tree_oid);
 119 }
 120
 121 static int commit_index(
 122         git_commit **i_commit,
 123         git_repository *repo,
 124         git_index *index,
 125         const git_signature *stasher,
 126         const char *message,
 127         const git_commit *parent)
 128 {
 129         git_tree *i_tree = NULL;
 130         git_oid i_commit_oid;
 131         git_buf msg = GIT_BUF_INIT;
 132         int error;
 133
 134         if ((error = build_tree_from_index(&i_tree, repo, index)) < 0)
 135                 goto cleanup;
 136
 137         if ((error = git_buf_printf(&msg, "index on %s\n", message)) < 0)
 138                 goto cleanup;
 139
 140         if ((error = git_commit_create(
 141                 &i_commit_oid,
 142                 git_index_owner(index),
 143                 NULL,
 144                 stasher,
 145                 stasher,
 146                 NULL,
 147                 git_buf_cstr(&msg),
 148                 i_tree,
 149                 1,
 150                 &parent)) < 0)
 151                 goto cleanup;
 152
 153         error = git_commit_lookup(i_commit, git_index_owner(index), &i_commit_oid);
 154
 155 cleanup:
 156         git_tree_free(i_tree);
 157         git_buf_dispose(&msg);
 158         return error;
 159 }
 160
 161 struct stash_update_rules {
 162         bool include_changed;
 163         bool include_untracked;
 164         bool include_ignored;
 165 };
 166
 167 /*
 168  * Similar to git_index_add_bypath but able to operate on any
 169  * index without making assumptions about the repository's index
 170  */
 171 static int stash_to_index(
 172         git_repository *repo,
 173         git_index *index,
 174         const char *path)
 175 {
 176         git_index *repo_index;
 177         git_index_entry entry = {{0}};
 178         struct stat st;
 179         int error;
 180
 181         if (!git_repository_is_bare(repo) &&
 182             (error = git_repository_index__weakptr(&repo_index, repo)) < 0)
 183                 return error;
 184
 185         if ((error = git_blob__create_from_paths(
 186             &entry.id, &st, repo, NULL, path, 0, true)) < 0)
 187                 return error;
 188
 189         git_index_entry__init_from_stat(&entry, &st,
 190                 (repo_index != NULL || !repo_index->distrust_filemode));
 191
 192         entry.path = path;
 193
 194         return git_index_add(index, &entry);
 195 }
 196
 197 static int stash_update_index_from_diff(
 198         git_repository *repo,
 199         git_index *index,
 200         const git_diff *diff,
 201         struct stash_update_rules *data)
 202 {
 203         int error = 0;
 204         size_t d, max_d = git_diff_num_deltas(diff);
 205
 206         for (d = 0; !error && d < max_d; ++d) {
 207                 const char *add_path = NULL;
 208                 const git_diff_delta *delta = git_diff_get_delta(diff, d);
 209
 210                 switch (delta->status) {
 211                 case GIT_DELTA_IGNORED:
 212                         if (data->include_ignored)
 213                                 add_path = delta->new_file.path;
 214                         break;
 215
 216                 case GIT_DELTA_UNTRACKED:
 217                         if (data->include_untracked &&
 218                                 delta->new_file.mode != GIT_FILEMODE_TREE)
 219                                 add_path = delta->new_file.path;
 220                         break;
 221
 222                 case GIT_DELTA_ADDED:
 223                 case GIT_DELTA_MODIFIED:
 224                         if (data->include_changed)
 225                                 add_path = delta->new_file.path;
 226                         break;
 227
 228                 case GIT_DELTA_DELETED:
 229                         if (data->include_changed &&
 230                                 !git_index_find(NULL, index, delta->old_file.path))
 231                                 error = git_index_remove(index, delta->old_file.path, 0);
 232                         break;
 233
 234                 default:
 235                         /* Unimplemented */
 236                         git_error_set(
 237                                 GIT_ERROR_INVALID,
 238                                 "cannot update index. Unimplemented status (%d)",
 239                                 delta->status);
 240                         return -1;
 241                 }
 242
 243                 if (add_path != NULL)
 244                         error = stash_to_index(repo, index, add_path);
 245         }
 246
 247         return error;
 248 }
 249
 250 static int build_untracked_tree(
 251         git_tree **tree_out,
 252         git_repository *repo,
 253         git_commit *i_commit,
 254         uint32_t flags)
 255 {
 256         git_index *i_index = NULL;
 257         git_tree *i_tree = NULL;
 258         git_diff *diff = NULL;
 259         git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 260         struct stash_update_rules data = {0};
 261         int error;
 262
 263         if ((error = git_index_new(&i_index)) < 0)
 264                 goto cleanup;
 265
 266         if (flags & GIT_STASH_INCLUDE_UNTRACKED) {
 267                 opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED |
 268                         GIT_DIFF_RECURSE_UNTRACKED_DIRS;
 269                 data.include_untracked = true;
 270         }
 271
 272         if (flags & GIT_STASH_INCLUDE_IGNORED) {
 273                 opts.flags |= GIT_DIFF_INCLUDE_IGNORED |
 274                         GIT_DIFF_RECURSE_IGNORED_DIRS;
 275                 data.include_ignored = true;
 276         }
 277
 278         if ((error = git_commit_tree(&i_tree, i_commit)) < 0)
 279                 goto cleanup;
 280
 281         if ((error = git_diff_tree_to_workdir(&diff, repo, i_tree, &opts)) < 0)
 282                 goto cleanup;
 283
 284         if ((error = stash_update_index_from_diff(repo, i_index, diff, &data)) < 0)
 285                 goto cleanup;
 286
 287         error = build_tree_from_index(tree_out, repo, i_index);
 288
 289 cleanup:
 290         git_diff_free(diff);
 291         git_tree_free(i_tree);
 292         git_index_free(i_index);
 293         return error;
 294 }
 295
 296 static int commit_untracked(
 297         git_commit **u_commit,
 298         git_repository *repo,
 299         const git_signature *stasher,
 300         const char *message,
 301         git_commit *i_commit,
 302         uint32_t flags)
 303 {
 304         git_tree *u_tree = NULL;
 305         git_oid u_commit_oid;
 306         git_buf msg = GIT_BUF_INIT;
 307         int error;
 308
 309         if ((error = build_untracked_tree(&u_tree, repo, i_commit, flags)) < 0)
 310                 goto cleanup;
 311
 312         if ((error = git_buf_printf(&msg, "untracked files on %s\n", message)) < 0)
 313                 goto cleanup;
 314
 315         if ((error = git_commit_create(
 316                 &u_commit_oid,
 317                 repo,
 318                 NULL,
 319                 stasher,
 320                 stasher,
 321                 NULL,
 322                 git_buf_cstr(&msg),
 323                 u_tree,
 324                 0,
 325                 NULL)) < 0)
 326                 goto cleanup;
 327
 328         error = git_commit_lookup(u_commit, repo, &u_commit_oid);
 329
 330 cleanup:
 331         git_tree_free(u_tree);
 332         git_buf_dispose(&msg);
 333         return error;
 334 }
 335
 336 static git_diff_delta *stash_delta_merge(
 337         const git_diff_delta *a,
 338         const git_diff_delta *b,
 339         git_pool *pool)
 340 {
 341         /* Special case for stash: if a file is deleted in the index, but exists
 342          * in the working tree, we need to stash the workdir copy for the workdir.
 343          */
 344         if (a->status == GIT_DELTA_DELETED && b->status == GIT_DELTA_UNTRACKED) {
 345                 git_diff_delta *dup = git_diff__delta_dup(b, pool);
 346
 347                 if (dup)
 348                         dup->status = GIT_DELTA_MODIFIED;
 349                 return dup;
 350         }
 351
 352         return git_diff__merge_like_cgit(a, b, pool);
 353 }
 354
 355 static int build_workdir_tree(
 356         git_tree **tree_out,
 357         git_repository *repo,
 358         git_index *i_index,
 359         git_commit *b_commit)
 360 {
 361         git_tree *b_tree = NULL;
 362         git_diff *diff = NULL, *idx_to_wd = NULL;
 363         git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 364         struct stash_update_rules data = {0};
 365         int error;
 366
 367         opts.flags = GIT_DIFF_IGNORE_SUBMODULES | GIT_DIFF_INCLUDE_UNTRACKED;
 368
 369         if ((error = git_commit_tree(&b_tree, b_commit)) < 0)
 370                 goto cleanup;
 371
 372         if ((error = git_diff_tree_to_index(&diff, repo, b_tree, i_index, &opts)) < 0 ||
 373                 (error = git_diff_index_to_workdir(&idx_to_wd, repo, i_index, &opts)) < 0 ||
 374                 (error = git_diff__merge(diff, idx_to_wd, stash_delta_merge)) < 0)
 375                 goto cleanup;
 376
 377         data.include_changed = true;
 378
 379         if ((error = stash_update_index_from_diff(repo, i_index, diff, &data)) < 0)
 380                 goto cleanup;
 381
 382         error = build_tree_from_index(tree_out, repo, i_index);
 383
 384 cleanup:
 385         git_diff_free(idx_to_wd);
 386         git_diff_free(diff);
 387         git_tree_free(b_tree);
 388
 389         return error;
 390 }
 391
 392 static int commit_worktree(
 393         git_oid *w_commit_oid,
 394         git_repository *repo,
 395         const git_signature *stasher,
 396         const char *message,
 397         git_commit *i_commit,
 398         git_commit *b_commit,
 399         git_commit *u_commit)
 400 {
 401         const git_commit *parents[] = { NULL, NULL, NULL };
 402         git_index *i_index = NULL, *r_index = NULL;
 403         git_tree *w_tree = NULL;
 404         int error = 0, ignorecase;
 405
 406         parents[0] = b_commit;
 407         parents[1] = i_commit;
 408         parents[2] = u_commit;
 409
 410         if ((error = git_repository_index(&r_index, repo) < 0) ||
 411             (error = git_index_new(&i_index)) < 0 ||
 412             (error = git_index__fill(i_index, &r_index->entries) < 0) ||
 413             (error = git_repository__configmap_lookup(&ignorecase, repo, GIT_CONFIGMAP_IGNORECASE)) < 0)
 414                 goto cleanup;
 415
 416         git_index__set_ignore_case(i_index, ignorecase);
 417
 418         if ((error = build_workdir_tree(&w_tree, repo, i_index, b_commit)) < 0)
 419                 goto cleanup;
 420
 421         error = git_commit_create(
 422                 w_commit_oid,
 423                 repo,
 424                 NULL,
 425                 stasher,
 426                 stasher,
 427                 NULL,
 428                 message,
 429                 w_tree,
 430                 u_commit ? 3 : 2,
 431                 parents);
 432
 433 cleanup:
 434         git_tree_free(w_tree);
 435         git_index_free(i_index);
 436         git_index_free(r_index);
 437         return error;
 438 }
 439
 440 static int prepare_worktree_commit_message(git_buf *out, const char *user_message)
 441 {
 442         git_buf buf = GIT_BUF_INIT;
 443         int error = 0;
 444
 445         if (!user_message) {
 446                 git_buf_printf(&buf, "WIP on %s", git_buf_cstr(out));
 447         } else {
 448                 const char *colon;
 449
 450                 if ((colon = strchr(git_buf_cstr(out), ':')) == NULL)
 451                         goto cleanup;
 452
 453                 git_buf_puts(&buf, "On ");
 454                 git_buf_put(&buf, git_buf_cstr(out), colon - out->ptr);
 455                 git_buf_printf(&buf, ": %s\n", user_message);
 456         }
 457
 458         if (git_buf_oom(&buf)) {
 459                 error = -1;
 460                 goto cleanup;
 461         }
 462
 463         git_buf_swap(out, &buf);
 464
 465 cleanup:
 466         git_buf_dispose(&buf);
 467         return error;
 468 }
 469
 470 static int update_reflog(
 471         git_oid *w_commit_oid,
 472         git_repository *repo,
 473         const char *message)
 474 {
 475         git_reference *stash;
 476         int error;
 477
 478         if ((error = git_reference_ensure_log(repo, GIT_REFS_STASH_FILE)) < 0)
 479                 return error;
 480
 481         error = git_reference_create(&stash, repo, GIT_REFS_STASH_FILE, w_commit_oid, 1, message);
 482
 483         git_reference_free(stash);
 484
 485         return error;
 486 }
 487
 488 static int is_dirty_cb(const char *path, unsigned int status, void *payload)
 489 {
 490         GIT_UNUSED(path);
 491         GIT_UNUSED(status);
 492         GIT_UNUSED(payload);
 493
 494         return GIT_PASSTHROUGH;
 495 }
 496
 497 static int ensure_there_are_changes_to_stash(git_repository *repo, uint32_t flags)
 498 {
 499         int error;
 500         git_status_options opts = GIT_STATUS_OPTIONS_INIT;
 501
 502         opts.show  = GIT_STATUS_SHOW_INDEX_AND_WORKDIR;
 503         opts.flags = GIT_STATUS_OPT_EXCLUDE_SUBMODULES;
 504
 505         if (flags & GIT_STASH_INCLUDE_UNTRACKED)
 506                 opts.flags |= GIT_STATUS_OPT_INCLUDE_UNTRACKED |
 507                         GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
 508
 509         if (flags & GIT_STASH_INCLUDE_IGNORED)
 510                 opts.flags |= GIT_STATUS_OPT_INCLUDE_IGNORED |
 511                         GIT_STATUS_OPT_RECURSE_IGNORED_DIRS;
 512
 513         error = git_status_foreach_ext(repo, &opts, is_dirty_cb, NULL);
 514
 515         if (error == GIT_PASSTHROUGH)
 516                 return 0;
 517
 518         if (!error)
 519                 return create_error(GIT_ENOTFOUND, "there is nothing to stash.");
 520
 521         return error;
 522 }
 523
 524 static int reset_index_and_workdir(git_repository *repo, git_commit *commit, uint32_t flags)
 525 {
 526         git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 527
 528         opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 529         if (flags & GIT_STASH_INCLUDE_UNTRACKED)
 530                 opts.checkout_strategy |= GIT_CHECKOUT_REMOVE_UNTRACKED;
 531         if (flags & GIT_STASH_INCLUDE_IGNORED)
 532                 opts.checkout_strategy |= GIT_CHECKOUT_REMOVE_IGNORED;
 533
 534         return git_checkout_tree(repo, (git_object *)commit, &opts);
 535 }
 536
 537 int git_stash_save(
 538         git_oid *out,
 539         git_repository *repo,
 540         const git_signature *stasher,
 541         const char *message,
 542         uint32_t flags)
 543 {
 544         git_index *index = NULL;
 545         git_commit *b_commit = NULL, *i_commit = NULL, *u_commit = NULL;
 546         git_buf msg = GIT_BUF_INIT;
 547         int error;
 548
 549         assert(out && repo && stasher);
 550
 551         if ((error = git_repository__ensure_not_bare(repo, "stash save")) < 0)
 552                 return error;
 553
 554         if ((error = retrieve_base_commit_and_message(&b_commit, &msg, repo)) < 0)
 555                 goto cleanup;
 556
 557         if ((error = ensure_there_are_changes_to_stash(repo, flags)) < 0)
 558                 goto cleanup;
 559
 560         if ((error = git_repository_index(&index, repo)) < 0)
 561                 goto cleanup;
 562
 563         if ((error = commit_index(&i_commit, repo, index, stasher,
 564                                   git_buf_cstr(&msg), b_commit)) < 0)
 565                 goto cleanup;
 566
 567         if ((flags & (GIT_STASH_INCLUDE_UNTRACKED | GIT_STASH_INCLUDE_IGNORED)) &&
 568             (error = commit_untracked(&u_commit, repo, stasher,
 569                                       git_buf_cstr(&msg), i_commit, flags)) < 0)
 570                 goto cleanup;
 571
 572         if ((error = prepare_worktree_commit_message(&msg, message)) < 0)
 573                 goto cleanup;
 574
 575         if ((error = commit_worktree(out, repo, stasher, git_buf_cstr(&msg),
 576                                      i_commit, b_commit, u_commit)) < 0)
 577                 goto cleanup;
 578
 579         git_buf_rtrim(&msg);
 580
 581         if ((error = update_reflog(out, repo, git_buf_cstr(&msg))) < 0)
 582                 goto cleanup;
 583
 584         if ((error = reset_index_and_workdir(repo, (flags & GIT_STASH_KEEP_INDEX) ? i_commit : b_commit,
 585                                              flags)) < 0)
 586                 goto cleanup;
 587
 588 cleanup:
 589
 590         git_buf_dispose(&msg);
 591         git_commit_free(i_commit);
 592         git_commit_free(b_commit);
 593         git_commit_free(u_commit);
 594         git_index_free(index);
 595
 596         return error;
 597 }
 598
 599 static int retrieve_stash_commit(
 600         git_commit **commit,
 601         git_repository *repo,
 602         size_t index)
 603 {
 604         git_reference *stash = NULL;
 605         git_reflog *reflog = NULL;
 606         int error;
 607         size_t max;
 608         const git_reflog_entry *entry;
 609
 610         if ((error = git_reference_lookup(&stash, repo, GIT_REFS_STASH_FILE)) < 0)
 611                 goto cleanup;
 612
 613         if ((error = git_reflog_read(&reflog, repo, GIT_REFS_STASH_FILE)) < 0)
 614                 goto cleanup;
 615
 616         max = git_reflog_entrycount(reflog);
 617         if (!max || index > max - 1) {
 618                 error = GIT_ENOTFOUND;
 619                 git_error_set(GIT_ERROR_STASH, "no stashed state at position %" PRIuZ, index);
 620                 goto cleanup;
 621         }
 622
 623         entry = git_reflog_entry_byindex(reflog, index);
 624         if ((error = git_commit_lookup(commit, repo, git_reflog_entry_id_new(entry))) < 0)
 625                 goto cleanup;
 626
 627 cleanup:
 628         git_reference_free(stash);
 629         git_reflog_free(reflog);
 630         return error;
 631 }
 632
 633 static int retrieve_stash_trees(
 634         git_tree **out_stash_tree,
 635         git_tree **out_base_tree,
 636         git_tree **out_index_tree,
 637         git_tree **out_index_parent_tree,
 638         git_tree **out_untracked_tree,
 639         git_commit *stash_commit)
 640 {
 641         git_tree *stash_tree = NULL;
 642         git_commit *base_commit = NULL;
 643         git_tree *base_tree = NULL;
 644         git_commit *index_commit = NULL;
 645         git_tree *index_tree = NULL;
 646         git_commit *index_parent_commit = NULL;
 647         git_tree *index_parent_tree = NULL;
 648         git_commit *untracked_commit = NULL;
 649         git_tree *untracked_tree = NULL;
 650         int error;
 651
 652         if ((error = git_commit_tree(&stash_tree, stash_commit)) < 0)
 653                 goto cleanup;
 654
 655         if ((error = git_commit_parent(&base_commit, stash_commit, 0)) < 0)
 656                 goto cleanup;
 657         if ((error = git_commit_tree(&base_tree, base_commit)) < 0)
 658                 goto cleanup;
 659
 660         if ((error = git_commit_parent(&index_commit, stash_commit, 1)) < 0)
 661                 goto cleanup;
 662         if ((error = git_commit_tree(&index_tree, index_commit)) < 0)
 663                 goto cleanup;
 664
 665         if ((error = git_commit_parent(&index_parent_commit, index_commit, 0)) < 0)
 666                 goto cleanup;
 667         if ((error = git_commit_tree(&index_parent_tree, index_parent_commit)) < 0)
 668                 goto cleanup;
 669
 670         if (git_commit_parentcount(stash_commit) == 3) {
 671                 if ((error = git_commit_parent(&untracked_commit, stash_commit, 2)) < 0)
 672                         goto cleanup;
 673                 if ((error = git_commit_tree(&untracked_tree, untracked_commit)) < 0)
 674                         goto cleanup;
 675         }
 676
 677         *out_stash_tree = stash_tree;
 678         *out_base_tree = base_tree;
 679         *out_index_tree = index_tree;
 680         *out_index_parent_tree = index_parent_tree;
 681         *out_untracked_tree = untracked_tree;
 682
 683 cleanup:
 684         git_commit_free(untracked_commit);
 685         git_commit_free(index_parent_commit);
 686         git_commit_free(index_commit);
 687         git_commit_free(base_commit);
 688         if (error < 0) {
 689                 git_tree_free(stash_tree);
 690                 git_tree_free(base_tree);
 691                 git_tree_free(index_tree);
 692                 git_tree_free(index_parent_tree);
 693                 git_tree_free(untracked_tree);
 694         }
 695         return error;
 696 }
 697
 698 static int merge_indexes(
 699         git_index **out,
 700         git_repository *repo,
 701         git_tree *ancestor_tree,
 702         git_index *ours_index,
 703         git_index *theirs_index)
 704 {
 705         git_iterator *ancestor = NULL, *ours = NULL, *theirs = NULL;
 706         git_iterator_options iter_opts = GIT_ITERATOR_OPTIONS_INIT;
 707         int error;
 708
 709         iter_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
 710
 711         if ((error = git_iterator_for_tree(&ancestor, ancestor_tree, &iter_opts)) < 0 ||
 712                 (error = git_iterator_for_index(&ours, repo, ours_index, &iter_opts)) < 0 ||
 713                 (error = git_iterator_for_index(&theirs, repo, theirs_index, &iter_opts)) < 0)
 714                 goto done;
 715
 716         error = git_merge__iterators(out, repo, ancestor, ours, theirs, NULL);
 717
 718 done:
 719         git_iterator_free(ancestor);
 720         git_iterator_free(ours);
 721         git_iterator_free(theirs);
 722         return error;
 723 }
 724
 725 static int merge_index_and_tree(
 726         git_index **out,
 727         git_repository *repo,
 728         git_tree *ancestor_tree,
 729         git_index *ours_index,
 730         git_tree *theirs_tree)
 731 {
 732         git_iterator *ancestor = NULL, *ours = NULL, *theirs = NULL;
 733         git_iterator_options iter_opts = GIT_ITERATOR_OPTIONS_INIT;
 734         int error;
 735
 736         iter_opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
 737
 738         if ((error = git_iterator_for_tree(&ancestor, ancestor_tree, &iter_opts)) < 0 ||
 739                 (error = git_iterator_for_index(&ours, repo, ours_index, &iter_opts)) < 0 ||
 740                 (error = git_iterator_for_tree(&theirs, theirs_tree, &iter_opts)) < 0)
 741                 goto done;
 742
 743         error = git_merge__iterators(out, repo, ancestor, ours, theirs, NULL);
 744
 745 done:
 746         git_iterator_free(ancestor);
 747         git_iterator_free(ours);
 748         git_iterator_free(theirs);
 749         return error;
 750 }
 751
 752 static void normalize_apply_options(
 753         git_stash_apply_options *opts,
 754         const git_stash_apply_options *given_apply_opts)
 755 {
 756         if (given_apply_opts != NULL) {
 757                 memcpy(opts, given_apply_opts, sizeof(git_stash_apply_options));
 758         } else {
 759                 git_stash_apply_options default_apply_opts = GIT_STASH_APPLY_OPTIONS_INIT;
 760                 memcpy(opts, &default_apply_opts, sizeof(git_stash_apply_options));
 761         }
 762
 763         opts->checkout_options.checkout_strategy |= GIT_CHECKOUT_NO_REFRESH;
 764
 765         if (!opts->checkout_options.our_label)
 766                 opts->checkout_options.our_label = "Updated upstream";
 767
 768         if (!opts->checkout_options.their_label)
 769                 opts->checkout_options.their_label = "Stashed changes";
 770 }
 771
 772 int git_stash_apply_options_init(git_stash_apply_options *opts, unsigned int version)
 773 {
 774         GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 775                 opts, version, git_stash_apply_options, GIT_STASH_APPLY_OPTIONS_INIT);
 776         return 0;
 777 }
 778
 779 int git_stash_apply_init_options(git_stash_apply_options *opts, unsigned int version)
 780 {
 781         return git_stash_apply_options_init(opts, version);
 782 }
 783
 784 #define NOTIFY_PROGRESS(opts, progress_type)                            \
 785         do {                                                            \
 786                 if ((opts).progress_cb &&                               \
 787                     (error = (opts).progress_cb((progress_type), (opts).progress_payload))) { \
 788                         error = (error < 0) ? error : -1;               \
 789                         goto cleanup;                                   \
 790                 }                                                       \
 791         } while(false);
 792
 793 static int ensure_clean_index(git_repository *repo, git_index *index)
 794 {
 795         git_tree *head_tree = NULL;
 796         git_diff *index_diff = NULL;
 797         int error = 0;
 798
 799         if ((error = git_repository_head_tree(&head_tree, repo)) < 0 ||
 800                 (error = git_diff_tree_to_index(
 801                         &index_diff, repo, head_tree, index, NULL)) < 0)
 802                 goto done;
 803
 804         if (git_diff_num_deltas(index_diff) > 0) {
 805                 git_error_set(GIT_ERROR_STASH, "%" PRIuZ " uncommitted changes exist in the index",
 806                         git_diff_num_deltas(index_diff));
 807                 error = GIT_EUNCOMMITTED;
 808         }
 809
 810 done:
 811         git_diff_free(index_diff);
 812         git_tree_free(head_tree);
 813         return error;
 814 }
 815
 816 static int stage_new_file(const git_index_entry **entries, void *data)
 817 {
 818         git_index *index = data;
 819
 820         if(entries[0] == NULL)
 821                 return git_index_add(index, entries[1]);
 822         else
 823                 return git_index_add(index, entries[0]);
 824 }
 825
 826 static int stage_new_files(
 827         git_index **out,
 828         git_tree *parent_tree,
 829         git_tree *tree)
 830 {
 831         git_iterator *iterators[2] = { NULL, NULL };
 832         git_iterator_options iterator_options = GIT_ITERATOR_OPTIONS_INIT;
 833         git_index *index = NULL;
 834         int error;
 835
 836         if ((error = git_index_new(&index)) < 0 ||
 837                 (error = git_iterator_for_tree(
 838                         &iterators[0], parent_tree, &iterator_options)) < 0 ||
 839                 (error = git_iterator_for_tree(
 840                         &iterators[1], tree, &iterator_options)) < 0)
 841                 goto done;
 842
 843         error = git_iterator_walk(iterators, 2, stage_new_file, index);
 844
 845 done:
 846         if (error < 0)
 847                 git_index_free(index);
 848         else
 849                 *out = index;
 850
 851         git_iterator_free(iterators[0]);
 852         git_iterator_free(iterators[1]);
 853
 854         return error;
 855 }
 856
 857 int git_stash_apply(
 858         git_repository *repo,
 859         size_t index,
 860         const git_stash_apply_options *given_opts)
 861 {
 862         git_stash_apply_options opts;
 863         unsigned int checkout_strategy;
 864         git_commit *stash_commit = NULL;
 865         git_tree *stash_tree = NULL;
 866         git_tree *stash_parent_tree = NULL;
 867         git_tree *index_tree = NULL;
 868         git_tree *index_parent_tree = NULL;
 869         git_tree *untracked_tree = NULL;
 870         git_index *stash_adds = NULL;
 871         git_index *repo_index = NULL;
 872         git_index *unstashed_index = NULL;
 873         git_index *modified_index = NULL;
 874         git_index *untracked_index = NULL;
 875         int error;
 876
 877         GIT_ERROR_CHECK_VERSION(given_opts, GIT_STASH_APPLY_OPTIONS_VERSION, "git_stash_apply_options");
 878
 879         normalize_apply_options(&opts, given_opts);
 880         checkout_strategy = opts.checkout_options.checkout_strategy;
 881
 882         NOTIFY_PROGRESS(opts, GIT_STASH_APPLY_PROGRESS_LOADING_STASH);
 883
 884         /* Retrieve commit corresponding to the given stash */
 885         if ((error = retrieve_stash_commit(&stash_commit, repo, index)) < 0)
 886                 goto cleanup;
 887
 888         /* Retrieve all trees in the stash */
 889         if ((error = retrieve_stash_trees(
 890                         &stash_tree, &stash_parent_tree, &index_tree,
 891                         &index_parent_tree, &untracked_tree, stash_commit)) < 0)
 892                 goto cleanup;
 893
 894         /* Load repo index */
 895         if ((error = git_repository_index(&repo_index, repo)) < 0)
 896                 goto cleanup;
 897
 898         NOTIFY_PROGRESS(opts, GIT_STASH_APPLY_PROGRESS_ANALYZE_INDEX);
 899
 900         if ((error = ensure_clean_index(repo, repo_index)) < 0)
 901                 goto cleanup;
 902
 903         /* Restore index if required */
 904         if ((opts.flags & GIT_STASH_APPLY_REINSTATE_INDEX) &&
 905                 git_oid_cmp(git_tree_id(stash_parent_tree), git_tree_id(index_tree))) {
 906
 907                 if ((error = merge_index_and_tree(
 908                                 &unstashed_index, repo, index_parent_tree, repo_index, index_tree)) < 0)
 909                         goto cleanup;
 910
 911                 if (git_index_has_conflicts(unstashed_index)) {
 912                         error = GIT_ECONFLICT;
 913                         goto cleanup;
 914                 }
 915
 916         /* Otherwise, stage any new files in the stash tree.  (Note: their
 917          * previously unstaged contents are staged, not the previously staged.)
 918          */
 919         } else if ((opts.flags & GIT_STASH_APPLY_REINSTATE_INDEX) == 0) {
 920                 if ((error = stage_new_files(
 921                                 &stash_adds, stash_parent_tree, stash_tree)) < 0 ||
 922                         (error = merge_indexes(
 923                                 &unstashed_index, repo, stash_parent_tree, repo_index, stash_adds)) < 0)
 924                         goto cleanup;
 925         }
 926
 927         NOTIFY_PROGRESS(opts, GIT_STASH_APPLY_PROGRESS_ANALYZE_MODIFIED);
 928
 929         /* Restore modified files in workdir */
 930         if ((error = merge_index_and_tree(
 931                         &modified_index, repo, stash_parent_tree, repo_index, stash_tree)) < 0)
 932                 goto cleanup;
 933
 934         /* If applicable, restore untracked / ignored files in workdir */
 935         if (untracked_tree) {
 936                 NOTIFY_PROGRESS(opts, GIT_STASH_APPLY_PROGRESS_ANALYZE_UNTRACKED);
 937
 938                 if ((error = merge_index_and_tree(&untracked_index, repo, NULL, repo_index, untracked_tree)) < 0)
 939                         goto cleanup;
 940         }
 941
 942         if (untracked_index) {
 943                 opts.checkout_options.checkout_strategy |= GIT_CHECKOUT_DONT_UPDATE_INDEX;
 944
 945                 NOTIFY_PROGRESS(opts, GIT_STASH_APPLY_PROGRESS_CHECKOUT_UNTRACKED);
 946
 947                 if ((error = git_checkout_index(repo, untracked_index, &opts.checkout_options)) < 0)
 948                         goto cleanup;
 949
 950                 opts.checkout_options.checkout_strategy = checkout_strategy;
 951         }
 952
 953
 954         /* If there are conflicts in the modified index, then we need to actually
 955          * check that out as the repo's index.  Otherwise, we don't update the
 956          * index.
 957          */
 958
 959         if (!git_index_has_conflicts(modified_index))
 960                 opts.checkout_options.checkout_strategy |= GIT_CHECKOUT_DONT_UPDATE_INDEX;
 961
 962         /* Check out the modified index using the existing repo index as baseline,
 963          * so that existing modifications in the index can be rewritten even when
 964          * checking out safely.
 965          */
 966         opts.checkout_options.baseline_index = repo_index;
 967
 968         NOTIFY_PROGRESS(opts, GIT_STASH_APPLY_PROGRESS_CHECKOUT_MODIFIED);
 969
 970         if ((error = git_checkout_index(repo, modified_index, &opts.checkout_options)) < 0)
 971                 goto cleanup;
 972
 973         if (unstashed_index && !git_index_has_conflicts(modified_index)) {
 974                 if ((error = git_index_read_index(repo_index, unstashed_index)) < 0)
 975                         goto cleanup;
 976         }
 977
 978         NOTIFY_PROGRESS(opts, GIT_STASH_APPLY_PROGRESS_DONE);
 979
 980         error = git_index_write(repo_index);
 981
 982 cleanup:
 983         git_index_free(untracked_index);
 984         git_index_free(modified_index);
 985         git_index_free(unstashed_index);
 986         git_index_free(stash_adds);
 987         git_index_free(repo_index);
 988         git_tree_free(untracked_tree);
 989         git_tree_free(index_parent_tree);
 990         git_tree_free(index_tree);
 991         git_tree_free(stash_parent_tree);
 992         git_tree_free(stash_tree);
 993         git_commit_free(stash_commit);
 994         return error;
 995 }
 996
 997 int git_stash_foreach(
 998         git_repository *repo,
 999         git_stash_cb callback,
1000         void *payload)
1001 {
1002         git_reference *stash;
1003         git_reflog *reflog = NULL;
1004         int error;
1005         size_t i, max;
1006         const git_reflog_entry *entry;
1007
1008         error = git_reference_lookup(&stash, repo, GIT_REFS_STASH_FILE);
1009         if (error == GIT_ENOTFOUND) {
1010                 git_error_clear();
1011                 return 0;
1012         }
1013         if (error < 0)
1014                 goto cleanup;
1015
1016         if ((error = git_reflog_read(&reflog, repo, GIT_REFS_STASH_FILE)) < 0)
1017                 goto cleanup;
1018
1019         max = git_reflog_entrycount(reflog);
1020         for (i = 0; i < max; i++) {
1021                 entry = git_reflog_entry_byindex(reflog, i);
1022
1023                 error = callback(i,
1024                         git_reflog_entry_message(entry),
1025                         git_reflog_entry_id_new(entry),
1026                         payload);
1027
1028                 if (error) {
1029                         git_error_set_after_callback(error);
1030                         break;
1031                 }
1032         }
1033
1034 cleanup:
1035         git_reference_free(stash);
1036         git_reflog_free(reflog);
1037         return error;
1038 }
1039
1040 int git_stash_drop(
1041         git_repository *repo,
1042         size_t index)
1043 {
1044         git_transaction *tx;
1045         git_reference *stash = NULL;
1046         git_reflog *reflog = NULL;
1047         size_t max;
1048         int error;
1049
1050         if ((error = git_transaction_new(&tx, repo)) < 0)
1051                 return error;
1052
1053         if ((error = git_transaction_lock_ref(tx, GIT_REFS_STASH_FILE)) < 0)
1054                 goto cleanup;
1055
1056         if ((error = git_reference_lookup(&stash, repo, GIT_REFS_STASH_FILE)) < 0)
1057                 goto cleanup;
1058
1059         if ((error = git_reflog_read(&reflog, repo, GIT_REFS_STASH_FILE)) < 0)
1060                 goto cleanup;
1061
1062         max = git_reflog_entrycount(reflog);
1063
1064         if (!max || index > max - 1) {
1065                 error = GIT_ENOTFOUND;
1066                 git_error_set(GIT_ERROR_STASH, "no stashed state at position %" PRIuZ, index);
1067                 goto cleanup;
1068         }
1069
1070         if ((error = git_reflog_drop(reflog, index, true)) < 0)
1071                 goto cleanup;
1072
1073         if ((error = git_transaction_set_reflog(tx, GIT_REFS_STASH_FILE, reflog)) < 0)
1074                 goto cleanup;
1075
1076         if (max == 1) {
1077                 if ((error = git_transaction_remove(tx, GIT_REFS_STASH_FILE)) < 0)
1078                         goto cleanup;
1079         } else if (index == 0) {
1080                 const git_reflog_entry *entry;
1081
1082                 entry = git_reflog_entry_byindex(reflog, 0);
1083                 if ((error = git_transaction_set_target(tx, GIT_REFS_STASH_FILE, &entry->oid_cur, NULL, NULL)) < 0)
1084                         goto cleanup;
1085         }
1086
1087         error = git_transaction_commit(tx);
1088
1089 cleanup:
1090         git_reference_free(stash);
1091         git_transaction_free(tx);
1092         git_reflog_free(reflog);
1093         return error;
1094 }
1095
1096 int git_stash_pop(
1097         git_repository *repo,
1098         size_t index,
1099         const git_stash_apply_options *options)
1100 {
1101         int error;
1102
1103         if ((error = git_stash_apply(repo, index, options)) < 0)
1104                 return error;
1105
1106         return git_stash_drop(repo, index);
1107 }