builtin/checkout.c

   1 #include "cache.h"
   2 #include "builtin.h"
   3 #include "parse-options.h"
   4 #include "refs.h"
   5 #include "commit.h"
   6 #include "tree.h"
   7 #include "tree-walk.h"
   8 #include "cache-tree.h"
   9 #include "unpack-trees.h"
  10 #include "dir.h"
  11 #include "run-command.h"
  12 #include "merge-recursive.h"
  13 #include "branch.h"
  14 #include "diff.h"
  15 #include "revision.h"
  16 #include "remote.h"
  17 #include "blob.h"
  18 #include "xdiff-interface.h"
  19 #include "ll-merge.h"
  20 #include "resolve-undo.h"
  21 #include "submodule.h"
  22
  23 static const char * const checkout_usage[] = {
  24         "git checkout [options] <branch>",
  25         "git checkout [options] [<branch>] -- <file>...",
  26         NULL,
  27 };
  28
  29 struct checkout_opts {
  30         int quiet;
  31         int merge;
  32         int force;
  33         int force_detach;
  34         int writeout_stage;
  35         int writeout_error;
  36
  37         /* not set by parse_options */
  38         int branch_exists;
  39
  40         const char *new_branch;
  41         const char *new_branch_force;
  42         const char *new_orphan_branch;
  43         int new_branch_log;
  44         enum branch_track track;
  45         struct diff_options diff_options;
  46 };
  47
  48 static int post_checkout_hook(struct commit *old, struct commit *new,
  49                               int changed)
  50 {
  51         return run_hook(NULL, "post-checkout",
  52                         sha1_to_hex(old ? old->object.sha1 : null_sha1),
  53                         sha1_to_hex(new ? new->object.sha1 : null_sha1),
  54                         changed ? "1" : "0", NULL);
  55         /* "new" can be NULL when checking out from the index before
  56            a commit exists. */
  57
  58 }
  59
  60 static int update_some(const unsigned char *sha1, const char *base, int baselen,
  61                 const char *pathname, unsigned mode, int stage, void *context)
  62 {
  63         int len;
  64         struct cache_entry *ce;
  65
  66         if (S_ISDIR(mode))
  67                 return READ_TREE_RECURSIVE;
  68
  69         len = baselen + strlen(pathname);
  70         ce = xcalloc(1, cache_entry_size(len));
  71         hashcpy(ce->sha1, sha1);
  72         memcpy(ce->name, base, baselen);
  73         memcpy(ce->name + baselen, pathname, len - baselen);
  74         ce->ce_flags = create_ce_flags(len, 0);
  75         ce->ce_mode = create_ce_mode(mode);
  76         add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
  77         return 0;
  78 }
  79
  80 static int read_tree_some(struct tree *tree, const char **pathspec)
  81 {
  82         read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
  83
  84         /* update the index with the given tree's info
  85          * for all args, expanding wildcards, and exit
  86          * with any non-zero return code.
  87          */
  88         return 0;
  89 }
  90
  91 static int skip_same_name(struct cache_entry *ce, int pos)
  92 {
  93         while (++pos < active_nr &&
  94                !strcmp(active_cache[pos]->name, ce->name))
  95                 ; /* skip */
  96         return pos;
  97 }
  98
  99 static int check_stage(int stage, struct cache_entry *ce, int pos)
 100 {
 101         while (pos < active_nr &&
 102                !strcmp(active_cache[pos]->name, ce->name)) {
 103                 if (ce_stage(active_cache[pos]) == stage)
 104                         return 0;
 105                 pos++;
 106         }
 107         return error("path '%s' does not have %s version",
 108                      ce->name,
 109                      (stage == 2) ? "our" : "their");
 110 }
 111
 112 static int check_all_stages(struct cache_entry *ce, int pos)
 113 {
 114         if (ce_stage(ce) != 1 ||
 115             active_nr <= pos + 2 ||
 116             strcmp(active_cache[pos+1]->name, ce->name) ||
 117             ce_stage(active_cache[pos+1]) != 2 ||
 118             strcmp(active_cache[pos+2]->name, ce->name) ||
 119             ce_stage(active_cache[pos+2]) != 3)
 120                 return error("path '%s' does not have all three versions",
 121                              ce->name);
 122         return 0;
 123 }
 124
 125 static int checkout_stage(int stage, struct cache_entry *ce, int pos,
 126                           struct checkout *state)
 127 {
 128         while (pos < active_nr &&
 129                !strcmp(active_cache[pos]->name, ce->name)) {
 130                 if (ce_stage(active_cache[pos]) == stage)
 131                         return checkout_entry(active_cache[pos], state, NULL);
 132                 pos++;
 133         }
 134         return error("path '%s' does not have %s version",
 135                      ce->name,
 136                      (stage == 2) ? "our" : "their");
 137 }
 138
 139 static int checkout_merged(int pos, struct checkout *state)
 140 {
 141         struct cache_entry *ce = active_cache[pos];
 142         const char *path = ce->name;
 143         mmfile_t ancestor, ours, theirs;
 144         int status;
 145         unsigned char sha1[20];
 146         mmbuffer_t result_buf;
 147
 148         if (ce_stage(ce) != 1 ||
 149             active_nr <= pos + 2 ||
 150             strcmp(active_cache[pos+1]->name, path) ||
 151             ce_stage(active_cache[pos+1]) != 2 ||
 152             strcmp(active_cache[pos+2]->name, path) ||
 153             ce_stage(active_cache[pos+2]) != 3)
 154                 return error("path '%s' does not have all 3 versions", path);
 155
 156         read_mmblob(&ancestor, active_cache[pos]->sha1);
 157         read_mmblob(&ours, active_cache[pos+1]->sha1);
 158         read_mmblob(&theirs, active_cache[pos+2]->sha1);
 159
 160         /*
 161          * NEEDSWORK: re-create conflicts from merges with
 162          * merge.renormalize set, too
 163          */
 164         status = ll_merge(&result_buf, path, &ancestor, "base",
 165                           &ours, "ours", &theirs, "theirs", NULL);
 166         free(ancestor.ptr);
 167         free(ours.ptr);
 168         free(theirs.ptr);
 169         if (status < 0 || !result_buf.ptr) {
 170                 free(result_buf.ptr);
 171                 return error("path '%s': cannot merge", path);
 172         }
 173
 174         /*
 175          * NEEDSWORK:
 176          * There is absolutely no reason to write this as a blob object
 177          * and create a phony cache entry just to leak.  This hack is
 178          * primarily to get to the write_entry() machinery that massages
 179          * the contents to work-tree format and writes out which only
 180          * allows it for a cache entry.  The code in write_entry() needs
 181          * to be refactored to allow us to feed a <buffer, size, mode>
 182          * instead of a cache entry.  Such a refactoring would help
 183          * merge_recursive as well (it also writes the merge result to the
 184          * object database even when it may contain conflicts).
 185          */
 186         if (write_sha1_file(result_buf.ptr, result_buf.size,
 187                             blob_type, sha1))
 188                 die("Unable to add merge result for '%s'", path);
 189         ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
 190                               sha1,
 191                               path, 2, 0);
 192         if (!ce)
 193                 die("make_cache_entry failed for path '%s'", path);
 194         status = checkout_entry(ce, state, NULL);
 195         return status;
 196 }
 197
 198 static int checkout_paths(struct tree *source_tree, const char **pathspec,
 199                           struct checkout_opts *opts)
 200 {
 201         int pos;
 202         struct checkout state;
 203         static char *ps_matched;
 204         unsigned char rev[20];
 205         int flag;
 206         struct commit *head;
 207         int errs = 0;
 208         int stage = opts->writeout_stage;
 209         int merge = opts->merge;
 210         int newfd;
 211         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 212
 213         newfd = hold_locked_index(lock_file, 1);
 214         if (read_cache_preload(pathspec) < 0)
 215                 return error("corrupt index file");
 216
 217         if (source_tree)
 218                 read_tree_some(source_tree, pathspec);
 219
 220         for (pos = 0; pathspec[pos]; pos++)
 221                 ;
 222         ps_matched = xcalloc(1, pos);
 223
 224         for (pos = 0; pos < active_nr; pos++) {
 225                 struct cache_entry *ce = active_cache[pos];
 226                 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
 227         }
 228
 229         if (report_path_error(ps_matched, pathspec, 0))
 230                 return 1;
 231
 232         /* "checkout -m path" to recreate conflicted state */
 233         if (opts->merge)
 234                 unmerge_cache(pathspec);
 235
 236         /* Any unmerged paths? */
 237         for (pos = 0; pos < active_nr; pos++) {
 238                 struct cache_entry *ce = active_cache[pos];
 239                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 240                         if (!ce_stage(ce))
 241                                 continue;
 242                         if (opts->force) {
 243                                 warning("path '%s' is unmerged", ce->name);
 244                         } else if (stage) {
 245                                 errs |= check_stage(stage, ce, pos);
 246                         } else if (opts->merge) {
 247                                 errs |= check_all_stages(ce, pos);
 248                         } else {
 249                                 errs = 1;
 250                                 error("path '%s' is unmerged", ce->name);
 251                         }
 252                         pos = skip_same_name(ce, pos) - 1;
 253                 }
 254         }
 255         if (errs)
 256                 return 1;
 257
 258         /* Now we are committed to check them out */
 259         memset(&state, 0, sizeof(state));
 260         state.force = 1;
 261         state.refresh_cache = 1;
 262         for (pos = 0; pos < active_nr; pos++) {
 263                 struct cache_entry *ce = active_cache[pos];
 264                 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
 265                         if (!ce_stage(ce)) {
 266                                 errs |= checkout_entry(ce, &state, NULL);
 267                                 continue;
 268                         }
 269                         if (stage)
 270                                 errs |= checkout_stage(stage, ce, pos, &state);
 271                         else if (merge)
 272                                 errs |= checkout_merged(pos, &state);
 273                         pos = skip_same_name(ce, pos) - 1;
 274                 }
 275         }
 276
 277         if (write_cache(newfd, active_cache, active_nr) ||
 278             commit_locked_index(lock_file))
 279                 die("unable to write new index file");
 280
 281         resolve_ref("HEAD", rev, 0, &flag);
 282         head = lookup_commit_reference_gently(rev, 1);
 283
 284         errs |= post_checkout_hook(head, head, 0);
 285         return errs;
 286 }
 287
 288 static void show_local_changes(struct object *head, struct diff_options *opts)
 289 {
 290         struct rev_info rev;
 291         /* I think we want full paths, even if we're in a subdirectory. */
 292         init_revisions(&rev, NULL);
 293         rev.diffopt.flags = opts->flags;
 294         rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
 295         if (diff_setup_done(&rev.diffopt) < 0)
 296                 die("diff_setup_done failed");
 297         add_pending_object(&rev, head, NULL);
 298         run_diff_index(&rev, 0);
 299 }
 300
 301 static void describe_detached_head(const char *msg, struct commit *commit)
 302 {
 303         struct strbuf sb = STRBUF_INIT;
 304         struct pretty_print_context ctx = {0};
 305         parse_commit(commit);
 306         pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
 307         fprintf(stderr, "%s %s... %s\n", msg,
 308                 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
 309         strbuf_release(&sb);
 310 }
 311
 312 static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
 313 {
 314         struct unpack_trees_options opts;
 315         struct tree_desc tree_desc;
 316
 317         memset(&opts, 0, sizeof(opts));
 318         opts.head_idx = -1;
 319         opts.update = worktree;
 320         opts.skip_unmerged = !worktree;
 321         opts.reset = 1;
 322         opts.merge = 1;
 323         opts.fn = oneway_merge;
 324         opts.verbose_update = !o->quiet;
 325         opts.src_index = &the_index;
 326         opts.dst_index = &the_index;
 327         parse_tree(tree);
 328         init_tree_desc(&tree_desc, tree->buffer, tree->size);
 329         switch (unpack_trees(1, &tree_desc, &opts)) {
 330         case -2:
 331                 o->writeout_error = 1;
 332                 /*
 333                  * We return 0 nevertheless, as the index is all right
 334                  * and more importantly we have made best efforts to
 335                  * update paths in the work tree, and we cannot revert
 336                  * them.
 337                  */
 338         case 0:
 339                 return 0;
 340         default:
 341                 return 128;
 342         }
 343 }
 344
 345 struct branch_info {
 346         const char *name; /* The short name used */
 347         const char *path; /* The full name of a real branch */
 348         struct commit *commit; /* The named commit */
 349 };
 350
 351 static void setup_branch_path(struct branch_info *branch)
 352 {
 353         struct strbuf buf = STRBUF_INIT;
 354
 355         strbuf_branchname(&buf, branch->name);
 356         if (strcmp(buf.buf, branch->name))
 357                 branch->name = xstrdup(buf.buf);
 358         strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
 359         branch->path = strbuf_detach(&buf, NULL);
 360 }
 361
 362 static int merge_working_tree(struct checkout_opts *opts,
 363                               struct branch_info *old, struct branch_info *new)
 364 {
 365         int ret;
 366         struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
 367         int newfd = hold_locked_index(lock_file, 1);
 368
 369         if (read_cache_preload(NULL) < 0)
 370                 return error("corrupt index file");
 371
 372         resolve_undo_clear();
 373         if (opts->force) {
 374                 ret = reset_tree(new->commit->tree, opts, 1);
 375                 if (ret)
 376                         return ret;
 377         } else {
 378                 struct tree_desc trees[2];
 379                 struct tree *tree;
 380                 struct unpack_trees_options topts;
 381
 382                 memset(&topts, 0, sizeof(topts));
 383                 topts.head_idx = -1;
 384                 topts.src_index = &the_index;
 385                 topts.dst_index = &the_index;
 386
 387                 setup_unpack_trees_porcelain(&topts, "checkout");
 388
 389                 refresh_cache(REFRESH_QUIET);
 390
 391                 if (unmerged_cache()) {
 392                         error("you need to resolve your current index first");
 393                         return 1;
 394                 }
 395
 396                 /* 2-way merge to the new branch */
 397                 topts.initial_checkout = is_cache_unborn();
 398                 topts.update = 1;
 399                 topts.merge = 1;
 400                 topts.gently = opts->merge && old->commit;
 401                 topts.verbose_update = !opts->quiet;
 402                 topts.fn = twoway_merge;
 403                 topts.dir = xcalloc(1, sizeof(*topts.dir));
 404                 topts.dir->flags |= DIR_SHOW_IGNORED;
 405                 topts.dir->exclude_per_dir = ".gitignore";
 406                 tree = parse_tree_indirect(old->commit ?
 407                                            old->commit->object.sha1 :
 408                                            EMPTY_TREE_SHA1_BIN);
 409                 init_tree_desc(&trees[0], tree->buffer, tree->size);
 410                 tree = parse_tree_indirect(new->commit->object.sha1);
 411                 init_tree_desc(&trees[1], tree->buffer, tree->size);
 412
 413                 ret = unpack_trees(2, trees, &topts);
 414                 if (ret == -1) {
 415                         /*
 416                          * Unpack couldn't do a trivial merge; either
 417                          * give up or do a real merge, depending on
 418                          * whether the merge flag was used.
 419                          */
 420                         struct tree *result;
 421                         struct tree *work;
 422                         struct merge_options o;
 423                         if (!opts->merge)
 424                                 return 1;
 425
 426                         /*
 427                          * Without old->commit, the below is the same as
 428                          * the two-tree unpack we already tried and failed.
 429                          */
 430                         if (!old->commit)
 431                                 return 1;
 432
 433                         /* Do more real merge */
 434
 435                         /*
 436                          * We update the index fully, then write the
 437                          * tree from the index, then merge the new
 438                          * branch with the current tree, with the old
 439                          * branch as the base. Then we reset the index
 440                          * (but not the working tree) to the new
 441                          * branch, leaving the working tree as the
 442                          * merged version, but skipping unmerged
 443                          * entries in the index.
 444                          */
 445
 446                         add_files_to_cache(NULL, NULL, 0);
 447                         /*
 448                          * NEEDSWORK: carrying over local changes
 449                          * when branches have different end-of-line
 450                          * normalization (or clean+smudge rules) is
 451                          * a pain; plumb in an option to set
 452                          * o.renormalize?
 453                          */
 454                         init_merge_options(&o);
 455                         o.verbosity = 0;
 456                         work = write_tree_from_memory(&o);
 457
 458                         ret = reset_tree(new->commit->tree, opts, 1);
 459                         if (ret)
 460                                 return ret;
 461                         o.ancestor = old->name;
 462                         o.branch1 = new->name;
 463                         o.branch2 = "local";
 464                         merge_trees(&o, new->commit->tree, work,
 465                                 old->commit->tree, &result);
 466                         ret = reset_tree(new->commit->tree, opts, 0);
 467                         if (ret)
 468                                 return ret;
 469                 }
 470         }
 471
 472         if (write_cache(newfd, active_cache, active_nr) ||
 473             commit_locked_index(lock_file))
 474                 die("unable to write new index file");
 475
 476         if (!opts->force && !opts->quiet)
 477                 show_local_changes(&new->commit->object, &opts->diff_options);
 478
 479         return 0;
 480 }
 481
 482 static void report_tracking(struct branch_info *new)
 483 {
 484         struct strbuf sb = STRBUF_INIT;
 485         struct branch *branch = branch_get(new->name);
 486
 487         if (!format_tracking_info(branch, &sb))
 488                 return;
 489         fputs(sb.buf, stdout);
 490         strbuf_release(&sb);
 491 }
 492
 493 static void detach_advice(const char *old_path, const char *new_name)
 494 {
 495         const char fmt[] =
 496         "Note: checking out '%s'.\n\n"
 497         "You are in 'detached HEAD' state. You can look around, make experimental\n"
 498         "changes and commit them, and you can discard any commits you make in this\n"
 499         "state without impacting any branches by performing another checkout.\n\n"
 500         "If you want to create a new branch to retain commits you create, you may\n"
 501         "do so (now or later) by using -b with the checkout command again. Example:\n\n"
 502         "  git checkout -b new_branch_name\n\n";
 503
 504         fprintf(stderr, fmt, new_name);
 505 }
 506
 507 static void update_refs_for_switch(struct checkout_opts *opts,
 508                                    struct branch_info *old,
 509                                    struct branch_info *new)
 510 {
 511         struct strbuf msg = STRBUF_INIT;
 512         const char *old_desc;
 513         if (opts->new_branch) {
 514                 if (opts->new_orphan_branch) {
 515                         if (opts->new_branch_log && !log_all_ref_updates) {
 516                                 int temp;
 517                                 char log_file[PATH_MAX];
 518                                 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
 519
 520                                 temp = log_all_ref_updates;
 521                                 log_all_ref_updates = 1;
 522                                 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
 523                                         fprintf(stderr, "Can not do reflog for '%s'\n",
 524                                             opts->new_orphan_branch);
 525                                         log_all_ref_updates = temp;
 526                                         return;
 527                                 }
 528                                 log_all_ref_updates = temp;
 529                         }
 530                 }
 531                 else
 532                         create_branch(old->name, opts->new_branch, new->name,
 533                                       opts->new_branch_force ? 1 : 0,
 534                                       opts->new_branch_log, opts->track);
 535                 new->name = opts->new_branch;
 536                 setup_branch_path(new);
 537         }
 538
 539         old_desc = old->name;
 540         if (!old_desc && old->commit)
 541                 old_desc = sha1_to_hex(old->commit->object.sha1);
 542         strbuf_addf(&msg, "checkout: moving from %s to %s",
 543                     old_desc ? old_desc : "(invalid)", new->name);
 544
 545         if (!strcmp(new->name, "HEAD") && !new->path && !opts->force_detach) {
 546                 /* Nothing to do. */
 547         } else if (opts->force_detach || !new->path) {  /* No longer on any branch. */
 548                 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
 549                            REF_NODEREF, DIE_ON_ERR);
 550                 if (!opts->quiet) {
 551                         if (old->path && advice_detached_head)
 552                                 detach_advice(old->path, new->name);
 553                         describe_detached_head("HEAD is now at", new->commit);
 554                 }
 555         } else if (new->path) { /* Switch branches. */
 556                 create_symref("HEAD", new->path, msg.buf);
 557                 if (!opts->quiet) {
 558                         if (old->path && !strcmp(new->path, old->path))
 559                                 fprintf(stderr, "Already on '%s'\n",
 560                                         new->name);
 561                         else if (opts->new_branch)
 562                                 fprintf(stderr, "Switched to%s branch '%s'\n",
 563                                         opts->branch_exists ? " and reset" : " a new",
 564                                         new->name);
 565                         else
 566                                 fprintf(stderr, "Switched to branch '%s'\n",
 567                                         new->name);
 568                 }
 569                 if (old->path && old->name) {
 570                         char log_file[PATH_MAX], ref_file[PATH_MAX];
 571
 572                         git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
 573                         git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
 574                         if (!file_exists(ref_file) && file_exists(log_file))
 575                                 remove_path(log_file);
 576                 }
 577         }
 578         remove_branch_state();
 579         strbuf_release(&msg);
 580         if (!opts->quiet &&
 581             (new->path || (!opts->force_detach && !strcmp(new->name, "HEAD"))))
 582                 report_tracking(new);
 583 }
 584
 585 struct rev_list_args {
 586         int argc;
 587         int alloc;
 588         const char **argv;
 589 };
 590
 591 static void add_one_rev_list_arg(struct rev_list_args *args, const char *s)
 592 {
 593         ALLOC_GROW(args->argv, args->argc + 1, args->alloc);
 594         args->argv[args->argc++] = s;
 595 }
 596
 597 static int add_one_ref_to_rev_list_arg(const char *refname,
 598                                        const unsigned char *sha1,
 599                                        int flags,
 600                                        void *cb_data)
 601 {
 602         add_one_rev_list_arg(cb_data, refname);
 603         return 0;
 604 }
 605
 606
 607 static void describe_one_orphan(struct strbuf *sb, struct commit *commit)
 608 {
 609         struct pretty_print_context ctx = { 0 };
 610
 611         parse_commit(commit);
 612         strbuf_addstr(sb, " - ");
 613         pretty_print_commit(CMIT_FMT_ONELINE, commit, sb, &ctx);
 614         strbuf_addch(sb, '\n');
 615 }
 616
 617 #define ORPHAN_CUTOFF 4
 618 static void suggest_reattach(struct commit *commit, struct rev_info *revs)
 619 {
 620         struct commit *c, *last = NULL;
 621         struct strbuf sb = STRBUF_INIT;
 622         int lost = 0;
 623         while ((c = get_revision(revs)) != NULL) {
 624                 if (lost < ORPHAN_CUTOFF)
 625                         describe_one_orphan(&sb, c);
 626                 last = c;
 627                 lost++;
 628         }
 629         if (ORPHAN_CUTOFF < lost) {
 630                 int more = lost - ORPHAN_CUTOFF;
 631                 if (more == 1)
 632                         describe_one_orphan(&sb, last);
 633                 else
 634                         strbuf_addf(&sb, " ... and %d more.\n", more);
 635         }
 636
 637         fprintf(stderr,
 638                 "Warning: you are leaving %d commit%s behind, "
 639                 "not connected to\n"
 640                 "any of your branches:\n\n"
 641                 "%s\n"
 642                 "If you want to keep them by creating a new branch, "
 643                 "this may be a good time\nto do so with:\n\n"
 644                 " git branch new_branch_name %s\n\n",
 645                 lost, ((1 < lost) ? "s" : ""),
 646                 sb.buf,
 647                 sha1_to_hex(commit->object.sha1));
 648         strbuf_release(&sb);
 649 }
 650
 651 /*
 652  * We are about to leave commit that was at the tip of a detached
 653  * HEAD.  If it is not reachable from any ref, this is the last chance
 654  * for the user to do so without resorting to reflog.
 655  */
 656 static void orphaned_commit_warning(struct commit *commit)
 657 {
 658         struct rev_list_args args = { 0, 0, NULL };
 659         struct rev_info revs;
 660
 661         add_one_rev_list_arg(&args, "(internal)");
 662         add_one_rev_list_arg(&args, sha1_to_hex(commit->object.sha1));
 663         add_one_rev_list_arg(&args, "--not");
 664         for_each_ref(add_one_ref_to_rev_list_arg, &args);
 665         add_one_rev_list_arg(&args, "--");
 666         add_one_rev_list_arg(&args, NULL);
 667
 668         init_revisions(&revs, NULL);
 669         if (setup_revisions(args.argc - 1, args.argv, &revs, NULL) != 1)
 670                 die("internal error: only -- alone should have been left");
 671         if (prepare_revision_walk(&revs))
 672                 die("internal error in revision walk");
 673         if (!(commit->object.flags & UNINTERESTING))
 674                 suggest_reattach(commit, &revs);
 675         else
 676                 describe_detached_head("Previous HEAD position was", commit);
 677 }
 678
 679 static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
 680 {
 681         int ret = 0;
 682         struct branch_info old;
 683         unsigned char rev[20];
 684         int flag;
 685         memset(&old, 0, sizeof(old));
 686         old.path = resolve_ref("HEAD", rev, 0, &flag);
 687         old.commit = lookup_commit_reference_gently(rev, 1);
 688         if (!(flag & REF_ISSYMREF))
 689                 old.path = NULL;
 690
 691         if (old.path && !prefixcmp(old.path, "refs/heads/"))
 692                 old.name = old.path + strlen("refs/heads/");
 693
 694         if (!new->name) {
 695                 new->name = "HEAD";
 696                 new->commit = old.commit;
 697                 if (!new->commit)
 698                         die("You are on a branch yet to be born");
 699                 parse_commit(new->commit);
 700         }
 701
 702         ret = merge_working_tree(opts, &old, new);
 703         if (ret)
 704                 return ret;
 705
 706         if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
 707                 orphaned_commit_warning(old.commit);
 708
 709         update_refs_for_switch(opts, &old, new);
 710
 711         ret = post_checkout_hook(old.commit, new->commit, 1);
 712         return ret || opts->writeout_error;
 713 }
 714
 715 static int git_checkout_config(const char *var, const char *value, void *cb)
 716 {
 717         if (!strcmp(var, "diff.ignoresubmodules")) {
 718                 struct checkout_opts *opts = cb;
 719                 handle_ignore_submodules_arg(&opts->diff_options, value);
 720                 return 0;
 721         }
 722
 723         if (!prefixcmp(var, "submodule."))
 724                 return parse_submodule_config_option(var, value);
 725
 726         return git_xmerge_config(var, value, NULL);
 727 }
 728
 729 static int interactive_checkout(const char *revision, const char **pathspec,
 730                                 struct checkout_opts *opts)
 731 {
 732         return run_add_interactive(revision, "--patch=checkout", pathspec);
 733 }
 734
 735 struct tracking_name_data {
 736         const char *name;
 737         char *remote;
 738         int unique;
 739 };
 740
 741 static int check_tracking_name(const char *refname, const unsigned char *sha1,
 742                                int flags, void *cb_data)
 743 {
 744         struct tracking_name_data *cb = cb_data;
 745         const char *slash;
 746
 747         if (prefixcmp(refname, "refs/remotes/"))
 748                 return 0;
 749         slash = strchr(refname + 13, '/');
 750         if (!slash || strcmp(slash + 1, cb->name))
 751                 return 0;
 752         if (cb->remote) {
 753                 cb->unique = 0;
 754                 return 0;
 755         }
 756         cb->remote = xstrdup(refname);
 757         return 0;
 758 }
 759
 760 static const char *unique_tracking_name(const char *name)
 761 {
 762         struct tracking_name_data cb_data = { NULL, NULL, 1 };
 763         cb_data.name = name;
 764         for_each_ref(check_tracking_name, &cb_data);
 765         if (cb_data.unique)
 766                 return cb_data.remote;
 767         free(cb_data.remote);
 768         return NULL;
 769 }
 770
 771 static int parse_branchname_arg(int argc, const char **argv,
 772                                 int dwim_new_local_branch_ok,
 773                                 struct branch_info *new,
 774                                 struct tree **source_tree,
 775                                 unsigned char rev[20],
 776                                 const char **new_branch)
 777 {
 778         int argcount = 0;
 779         unsigned char branch_rev[20];
 780         const char *arg;
 781         int has_dash_dash;
 782
 783         /*
 784          * case 1: git checkout <ref> -- [<paths>]
 785          *
 786          *   <ref> must be a valid tree, everything after the '--' must be
 787          *   a path.
 788          *
 789          * case 2: git checkout -- [<paths>]
 790          *
 791          *   everything after the '--' must be paths.
 792          *
 793          * case 3: git checkout <something> [<paths>]
 794          *
 795          *   With no paths, if <something> is a commit, that is to
 796          *   switch to the branch or detach HEAD at it.  As a special case,
 797          *   if <something> is A...B (missing A or B means HEAD but you can
 798          *   omit at most one side), and if there is a unique merge base
 799          *   between A and B, A...B names that merge base.
 800          *
 801          *   With no paths, if <something> is _not_ a commit, no -t nor -b
 802          *   was given, and there is a tracking branch whose name is
 803          *   <something> in one and only one remote, then this is a short-hand
 804          *   to fork local <something> from that remote-tracking branch.
 805          *
 806          *   Otherwise <something> shall not be ambiguous.
 807          *   - If it's *only* a reference, treat it like case (1).
 808          *   - If it's only a path, treat it like case (2).
 809          *   - else: fail.
 810          *
 811          */
 812         if (!argc)
 813                 return 0;
 814
 815         if (!strcmp(argv[0], "--"))     /* case (2) */
 816                 return 1;
 817
 818         arg = argv[0];
 819         has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
 820
 821         if (!strcmp(arg, "-"))
 822                 arg = "@{-1}";
 823
 824         if (get_sha1_mb(arg, rev)) {
 825                 if (has_dash_dash)          /* case (1) */
 826                         die("invalid reference: %s", arg);
 827                 if (dwim_new_local_branch_ok &&
 828                     !check_filename(NULL, arg) &&
 829                     argc == 1) {
 830                         const char *remote = unique_tracking_name(arg);
 831                         if (!remote || get_sha1(remote, rev))
 832                                 return argcount;
 833                         *new_branch = arg;
 834                         arg = remote;
 835                         /* DWIMmed to create local branch */
 836                 } else {
 837                         return argcount;
 838                 }
 839         }
 840
 841         /* we can't end up being in (2) anymore, eat the argument */
 842         argcount++;
 843         argv++;
 844         argc--;
 845
 846         new->name = arg;
 847         setup_branch_path(new);
 848
 849         if (check_ref_format(new->path) == CHECK_REF_FORMAT_OK &&
 850             resolve_ref(new->path, branch_rev, 1, NULL))
 851                 hashcpy(rev, branch_rev);
 852         else
 853                 new->path = NULL; /* not an existing branch */
 854
 855         new->commit = lookup_commit_reference_gently(rev, 1);
 856         if (!new->commit) {
 857                 /* not a commit */
 858                 *source_tree = parse_tree_indirect(rev);
 859         } else {
 860                 parse_commit(new->commit);
 861                 *source_tree = new->commit->tree;
 862         }
 863
 864         if (!*source_tree)                   /* case (1): want a tree */
 865                 die("reference is not a tree: %s", arg);
 866         if (!has_dash_dash) {/* case (3 -> 1) */
 867                 /*
 868                  * Do not complain the most common case
 869                  *      git checkout branch
 870                  * even if there happen to be a file called 'branch';
 871                  * it would be extremely annoying.
 872                  */
 873                 if (argc)
 874                         verify_non_filename(NULL, arg);
 875         } else {
 876                 argcount++;
 877                 argv++;
 878                 argc--;
 879         }
 880
 881         return argcount;
 882 }
 883
 884 int cmd_checkout(int argc, const char **argv, const char *prefix)
 885 {
 886         struct checkout_opts opts;
 887         unsigned char rev[20];
 888         struct branch_info new;
 889         struct tree *source_tree = NULL;
 890         char *conflict_style = NULL;
 891         int patch_mode = 0;
 892         int dwim_new_local_branch = 1;
 893         struct option options[] = {
 894                 OPT__QUIET(&opts.quiet, "suppress progress reporting"),
 895                 OPT_STRING('b', NULL, &opts.new_branch, "branch",
 896                            "create and checkout a new branch"),
 897                 OPT_STRING('B', NULL, &opts.new_branch_force, "branch",
 898                            "create/reset and checkout a branch"),
 899                 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "create reflog for new branch"),
 900                 OPT_BOOLEAN(0, "detach", &opts.force_detach, "detach the HEAD at named commit"),
 901                 OPT_SET_INT('t', "track",  &opts.track, "set upstream info for new branch",
 902                         BRANCH_TRACK_EXPLICIT),
 903                 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
 904                 OPT_SET_INT('2', "ours", &opts.writeout_stage, "checkout our version for unmerged files",
 905                             2),
 906                 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "checkout their version for unmerged files",
 907                             3),
 908                 OPT__FORCE(&opts.force, "force checkout (throw away local modifications)"),
 909                 OPT_BOOLEAN('m', "merge", &opts.merge, "perform a 3-way merge with the new branch"),
 910                 OPT_STRING(0, "conflict", &conflict_style, "style",
 911                            "conflict style (merge or diff3)"),
 912                 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
 913                 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
 914                   "second guess 'git checkout no-such-branch'",
 915                   PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 916                 OPT_END(),
 917         };
 918
 919         memset(&opts, 0, sizeof(opts));
 920         memset(&new, 0, sizeof(new));
 921
 922         gitmodules_config();
 923         git_config(git_checkout_config, &opts);
 924
 925         opts.track = BRANCH_TRACK_UNSPECIFIED;
 926
 927         argc = parse_options(argc, argv, prefix, options, checkout_usage,
 928                              PARSE_OPT_KEEP_DASHDASH);
 929
 930         /* we can assume from now on new_branch = !new_branch_force */
 931         if (opts.new_branch && opts.new_branch_force)
 932                 die("-B cannot be used with -b");
 933
 934         /* copy -B over to -b, so that we can just check the latter */
 935         if (opts.new_branch_force)
 936                 opts.new_branch = opts.new_branch_force;
 937
 938         if (patch_mode && (opts.track > 0 || opts.new_branch
 939                            || opts.new_branch_log || opts.merge || opts.force
 940                            || opts.force_detach))
 941                 die ("--patch is incompatible with all other options");
 942
 943         if (opts.force_detach && (opts.new_branch || opts.new_orphan_branch))
 944                 die("--detach cannot be used with -b/-B/--orphan");
 945         if (opts.force_detach && 0 < opts.track)
 946                 die("--detach cannot be used with -t");
 947
 948         /* --track without -b should DWIM */
 949         if (0 < opts.track && !opts.new_branch) {
 950                 const char *argv0 = argv[0];
 951                 if (!argc || !strcmp(argv0, "--"))
 952                         die ("--track needs a branch name");
 953                 if (!prefixcmp(argv0, "refs/"))
 954                         argv0 += 5;
 955                 if (!prefixcmp(argv0, "remotes/"))
 956                         argv0 += 8;
 957                 argv0 = strchr(argv0, '/');
 958                 if (!argv0 || !argv0[1])
 959                         die ("Missing branch name; try -b");
 960                 opts.new_branch = argv0 + 1;
 961         }
 962
 963         if (opts.new_orphan_branch) {
 964                 if (opts.new_branch)
 965                         die("--orphan and -b|-B are mutually exclusive");
 966                 if (opts.track > 0)
 967                         die("--orphan cannot be used with -t");
 968                 opts.new_branch = opts.new_orphan_branch;
 969         }
 970
 971         if (conflict_style) {
 972                 opts.merge = 1; /* implied */
 973                 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
 974         }
 975
 976         if (opts.force && opts.merge)
 977                 die("git checkout: -f and -m are incompatible");
 978
 979         /*
 980          * Extract branch name from command line arguments, so
 981          * all that is left is pathspecs.
 982          *
 983          * Handle
 984          *
 985          *  1) git checkout <tree> -- [<paths>]
 986          *  2) git checkout -- [<paths>]
 987          *  3) git checkout <something> [<paths>]
 988          *
 989          * including "last branch" syntax and DWIM-ery for names of
 990          * remote branches, erroring out for invalid or ambiguous cases.
 991          */
 992         if (argc) {
 993                 int dwim_ok =
 994                         !patch_mode &&
 995                         dwim_new_local_branch &&
 996                         opts.track == BRANCH_TRACK_UNSPECIFIED &&
 997                         !opts.new_branch;
 998                 int n = parse_branchname_arg(argc, argv, dwim_ok,
 999                                 &new, &source_tree, rev, &opts.new_branch);
1000                 argv += n;
1001                 argc -= n;
1002         }
1003
1004         if (opts.track == BRANCH_TRACK_UNSPECIFIED)
1005                 opts.track = git_branch_track;
1006
1007         if (argc) {
1008                 const char **pathspec = get_pathspec(prefix, argv);
1009
1010                 if (!pathspec)
1011                         die("invalid path specification");
1012
1013                 if (patch_mode)
1014                         return interactive_checkout(new.name, pathspec, &opts);
1015
1016                 /* Checkout paths */
1017                 if (opts.new_branch) {
1018                         if (argc == 1) {
1019                                 die("git checkout: updating paths is incompatible with switching branches.\nDid you intend to checkout '%s' which can not be resolved as commit?", argv[0]);
1020                         } else {
1021                                 die("git checkout: updating paths is incompatible with switching branches.");
1022                         }
1023                 }
1024
1025                 if (opts.force_detach)
1026                         die("git checkout: --detach does not take a path argument");
1027
1028                 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
1029                         die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
1030
1031                 return checkout_paths(source_tree, pathspec, &opts);
1032         }
1033
1034         if (patch_mode)
1035                 return interactive_checkout(new.name, NULL, &opts);
1036
1037         if (opts.new_branch) {
1038                 struct strbuf buf = STRBUF_INIT;
1039                 if (strbuf_check_branch_ref(&buf, opts.new_branch))
1040                         die("git checkout: we do not like '%s' as a branch name.",
1041                             opts.new_branch);
1042                 if (!get_sha1(buf.buf, rev)) {
1043                         opts.branch_exists = 1;
1044                         if (!opts.new_branch_force)
1045                                 die("git checkout: branch %s already exists",
1046                                     opts.new_branch);
1047                 }
1048                 strbuf_release(&buf);
1049         }
1050
1051         if (new.name && !new.commit) {
1052                 die("Cannot switch branch to a non-commit.");
1053         }
1054         if (opts.writeout_stage)
1055                 die("--ours/--theirs is incompatible with switching branches.");
1056
1057         return switch_branches(&opts, &new);
1058 }