Add tests for the diff.ignoreSubmodules config option
[git/git.git] / builtin / checkout.c
CommitLineData
782c2d65
DB
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"
b9d37a54 8#include "cache-tree.h"
782c2d65
DB
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"
79a1e6b4 16#include "remote.h"
0cf8581e
JH
17#include "blob.h"
18#include "xdiff-interface.h"
19#include "ll-merge.h"
cfc5789a 20#include "resolve-undo.h"
782c2d65
DB
21
22static const char * const checkout_usage[] = {
23 "git checkout [options] <branch>",
24 "git checkout [options] [<branch>] -- <file>...",
25 NULL,
26};
27
db941099
JH
28struct checkout_opts {
29 int quiet;
30 int merge;
31 int force;
38901a48 32 int writeout_stage;
db941099
JH
33 int writeout_error;
34
35 const char *new_branch;
9db5ebf4 36 const char *new_orphan_branch;
db941099
JH
37 int new_branch_log;
38 enum branch_track track;
39};
40
782c2d65
DB
41static int post_checkout_hook(struct commit *old, struct commit *new,
42 int changed)
43{
ae98a008
SB
44 return run_hook(NULL, "post-checkout",
45 sha1_to_hex(old ? old->object.sha1 : null_sha1),
46 sha1_to_hex(new ? new->object.sha1 : null_sha1),
47 changed ? "1" : "0", NULL);
2292ce47
SB
48 /* "new" can be NULL when checking out from the index before
49 a commit exists. */
ae98a008 50
782c2d65
DB
51}
52
53static int update_some(const unsigned char *sha1, const char *base, int baselen,
671f0707 54 const char *pathname, unsigned mode, int stage, void *context)
782c2d65
DB
55{
56 int len;
57 struct cache_entry *ce;
58
782c2d65
DB
59 if (S_ISDIR(mode))
60 return READ_TREE_RECURSIVE;
61
62 len = baselen + strlen(pathname);
63 ce = xcalloc(1, cache_entry_size(len));
64 hashcpy(ce->sha1, sha1);
65 memcpy(ce->name, base, baselen);
66 memcpy(ce->name + baselen, pathname, len - baselen);
67 ce->ce_flags = create_ce_flags(len, 0);
68 ce->ce_mode = create_ce_mode(mode);
69 add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
70 return 0;
71}
72
73static int read_tree_some(struct tree *tree, const char **pathspec)
74{
671f0707 75 read_tree_recursive(tree, "", 0, 0, pathspec, update_some, NULL);
782c2d65 76
782c2d65
DB
77 /* update the index with the given tree's info
78 * for all args, expanding wildcards, and exit
79 * with any non-zero return code.
80 */
81 return 0;
82}
83
8fdcf312
JH
84static int skip_same_name(struct cache_entry *ce, int pos)
85{
86 while (++pos < active_nr &&
87 !strcmp(active_cache[pos]->name, ce->name))
88 ; /* skip */
89 return pos;
90}
91
38901a48
JH
92static int check_stage(int stage, struct cache_entry *ce, int pos)
93{
94 while (pos < active_nr &&
95 !strcmp(active_cache[pos]->name, ce->name)) {
96 if (ce_stage(active_cache[pos]) == stage)
97 return 0;
98 pos++;
99 }
100 return error("path '%s' does not have %s version",
101 ce->name,
102 (stage == 2) ? "our" : "their");
103}
104
0cf8581e
JH
105static int check_all_stages(struct cache_entry *ce, int pos)
106{
107 if (ce_stage(ce) != 1 ||
108 active_nr <= pos + 2 ||
109 strcmp(active_cache[pos+1]->name, ce->name) ||
110 ce_stage(active_cache[pos+1]) != 2 ||
111 strcmp(active_cache[pos+2]->name, ce->name) ||
112 ce_stage(active_cache[pos+2]) != 3)
113 return error("path '%s' does not have all three versions",
114 ce->name);
115 return 0;
116}
117
38901a48
JH
118static int checkout_stage(int stage, struct cache_entry *ce, int pos,
119 struct checkout *state)
120{
121 while (pos < active_nr &&
122 !strcmp(active_cache[pos]->name, ce->name)) {
123 if (ce_stage(active_cache[pos]) == stage)
124 return checkout_entry(active_cache[pos], state, NULL);
125 pos++;
126 }
127 return error("path '%s' does not have %s version",
128 ce->name,
129 (stage == 2) ? "our" : "their");
130}
8fdcf312 131
0cf8581e
JH
132static int checkout_merged(int pos, struct checkout *state)
133{
134 struct cache_entry *ce = active_cache[pos];
135 const char *path = ce->name;
136 mmfile_t ancestor, ours, theirs;
137 int status;
138 unsigned char sha1[20];
139 mmbuffer_t result_buf;
140
141 if (ce_stage(ce) != 1 ||
142 active_nr <= pos + 2 ||
143 strcmp(active_cache[pos+1]->name, path) ||
144 ce_stage(active_cache[pos+1]) != 2 ||
145 strcmp(active_cache[pos+2]->name, path) ||
146 ce_stage(active_cache[pos+2]) != 3)
147 return error("path '%s' does not have all 3 versions", path);
148
06b65939
ML
149 read_mmblob(&ancestor, active_cache[pos]->sha1);
150 read_mmblob(&ours, active_cache[pos+1]->sha1);
151 read_mmblob(&theirs, active_cache[pos+2]->sha1);
0cf8581e 152
f0531a29 153 status = ll_merge(&result_buf, path, &ancestor, "base",
6d6f9acc 154 &ours, "ours", &theirs, "theirs", 0);
0cf8581e
JH
155 free(ancestor.ptr);
156 free(ours.ptr);
157 free(theirs.ptr);
158 if (status < 0 || !result_buf.ptr) {
159 free(result_buf.ptr);
160 return error("path '%s': cannot merge", path);
161 }
162
163 /*
164 * NEEDSWORK:
165 * There is absolutely no reason to write this as a blob object
3ea3c215 166 * and create a phony cache entry just to leak. This hack is
0cf8581e
JH
167 * primarily to get to the write_entry() machinery that massages
168 * the contents to work-tree format and writes out which only
169 * allows it for a cache entry. The code in write_entry() needs
170 * to be refactored to allow us to feed a <buffer, size, mode>
171 * instead of a cache entry. Such a refactoring would help
172 * merge_recursive as well (it also writes the merge result to the
173 * object database even when it may contain conflicts).
174 */
175 if (write_sha1_file(result_buf.ptr, result_buf.size,
176 blob_type, sha1))
177 die("Unable to add merge result for '%s'", path);
178 ce = make_cache_entry(create_ce_mode(active_cache[pos+1]->ce_mode),
179 sha1,
180 path, 2, 0);
048f2762
DP
181 if (!ce)
182 die("make_cache_entry failed for path '%s'", path);
0cf8581e
JH
183 status = checkout_entry(ce, state, NULL);
184 return status;
185}
8fdcf312 186
db941099
JH
187static int checkout_paths(struct tree *source_tree, const char **pathspec,
188 struct checkout_opts *opts)
782c2d65
DB
189{
190 int pos;
191 struct checkout state;
192 static char *ps_matched;
193 unsigned char rev[20];
194 int flag;
195 struct commit *head;
d2b3691b 196 int errs = 0;
38901a48 197 int stage = opts->writeout_stage;
0cf8581e 198 int merge = opts->merge;
75336878
DB
199 int newfd;
200 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
201
202 newfd = hold_locked_index(lock_file, 1);
53996fe5 203 if (read_cache_preload(pathspec) < 0)
b96524f8 204 return error("corrupt index file");
75336878
DB
205
206 if (source_tree)
207 read_tree_some(source_tree, pathspec);
208
782c2d65
DB
209 for (pos = 0; pathspec[pos]; pos++)
210 ;
211 ps_matched = xcalloc(1, pos);
212
213 for (pos = 0; pos < active_nr; pos++) {
214 struct cache_entry *ce = active_cache[pos];
0b50922a 215 match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, ps_matched);
782c2d65
DB
216 }
217
218 if (report_path_error(ps_matched, pathspec, 0))
219 return 1;
220
4421a823
JH
221 /* "checkout -m path" to recreate conflicted state */
222 if (opts->merge)
223 unmerge_cache(pathspec);
224
8fdcf312
JH
225 /* Any unmerged paths? */
226 for (pos = 0; pos < active_nr; pos++) {
227 struct cache_entry *ce = active_cache[pos];
0b50922a 228 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
8fdcf312
JH
229 if (!ce_stage(ce))
230 continue;
db941099
JH
231 if (opts->force) {
232 warning("path '%s' is unmerged", ce->name);
38901a48
JH
233 } else if (stage) {
234 errs |= check_stage(stage, ce, pos);
0cf8581e
JH
235 } else if (opts->merge) {
236 errs |= check_all_stages(ce, pos);
db941099
JH
237 } else {
238 errs = 1;
239 error("path '%s' is unmerged", ce->name);
240 }
8fdcf312
JH
241 pos = skip_same_name(ce, pos) - 1;
242 }
243 }
244 if (errs)
245 return 1;
246
d2b3691b 247 /* Now we are committed to check them out */
782c2d65
DB
248 memset(&state, 0, sizeof(state));
249 state.force = 1;
250 state.refresh_cache = 1;
251 for (pos = 0; pos < active_nr; pos++) {
252 struct cache_entry *ce = active_cache[pos];
0b50922a 253 if (match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, NULL)) {
8fdcf312
JH
254 if (!ce_stage(ce)) {
255 errs |= checkout_entry(ce, &state, NULL);
256 continue;
257 }
38901a48
JH
258 if (stage)
259 errs |= checkout_stage(stage, ce, pos, &state);
0cf8581e
JH
260 else if (merge)
261 errs |= checkout_merged(pos, &state);
8fdcf312 262 pos = skip_same_name(ce, pos) - 1;
782c2d65
DB
263 }
264 }
265
75336878
DB
266 if (write_cache(newfd, active_cache, active_nr) ||
267 commit_locked_index(lock_file))
268 die("unable to write new index file");
269
782c2d65
DB
270 resolve_ref("HEAD", rev, 0, &flag);
271 head = lookup_commit_reference_gently(rev, 1);
272
d2b3691b
JH
273 errs |= post_checkout_hook(head, head, 0);
274 return errs;
782c2d65
DB
275}
276
277static void show_local_changes(struct object *head)
278{
279 struct rev_info rev;
280 /* I think we want full paths, even if we're in a subdirectory. */
281 init_revisions(&rev, NULL);
282 rev.abbrev = 0;
283 rev.diffopt.output_format |= DIFF_FORMAT_NAME_STATUS;
e752f4bb
KC
284 if (diff_setup_done(&rev.diffopt) < 0)
285 die("diff_setup_done failed");
782c2d65
DB
286 add_pending_object(&rev, head, NULL);
287 run_diff_index(&rev, 0);
288}
289
290static void describe_detached_head(char *msg, struct commit *commit)
291{
f285a2d7 292 struct strbuf sb = STRBUF_INIT;
dd2e794a 293 struct pretty_print_context ctx = {0};
782c2d65 294 parse_commit(commit);
dd2e794a 295 pretty_print_commit(CMIT_FMT_ONELINE, commit, &sb, &ctx);
782c2d65
DB
296 fprintf(stderr, "%s %s... %s\n", msg,
297 find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV), sb.buf);
298 strbuf_release(&sb);
299}
300
6286a08d 301static int reset_tree(struct tree *tree, struct checkout_opts *o, int worktree)
782c2d65
DB
302{
303 struct unpack_trees_options opts;
304 struct tree_desc tree_desc;
bc052d7f 305
782c2d65
DB
306 memset(&opts, 0, sizeof(opts));
307 opts.head_idx = -1;
6286a08d
JH
308 opts.update = worktree;
309 opts.skip_unmerged = !worktree;
782c2d65
DB
310 opts.reset = 1;
311 opts.merge = 1;
312 opts.fn = oneway_merge;
6286a08d 313 opts.verbose_update = !o->quiet;
34110cd4
LT
314 opts.src_index = &the_index;
315 opts.dst_index = &the_index;
782c2d65
DB
316 parse_tree(tree);
317 init_tree_desc(&tree_desc, tree->buffer, tree->size);
291d823e
JH
318 switch (unpack_trees(1, &tree_desc, &opts)) {
319 case -2:
320 o->writeout_error = 1;
321 /*
322 * We return 0 nevertheless, as the index is all right
323 * and more importantly we have made best efforts to
324 * update paths in the work tree, and we cannot revert
325 * them.
326 */
327 case 0:
328 return 0;
329 default:
84a5750b 330 return 128;
291d823e 331 }
782c2d65
DB
332}
333
782c2d65
DB
334struct branch_info {
335 const char *name; /* The short name used */
336 const char *path; /* The full name of a real branch */
337 struct commit *commit; /* The named commit */
338};
339
340static void setup_branch_path(struct branch_info *branch)
341{
f285a2d7 342 struct strbuf buf = STRBUF_INIT;
ae5a6c36 343
a552de75
JH
344 strbuf_branchname(&buf, branch->name);
345 if (strcmp(buf.buf, branch->name))
ae5a6c36 346 branch->name = xstrdup(buf.buf);
a552de75 347 strbuf_splice(&buf, 0, 0, "refs/heads/", 11);
782c2d65
DB
348 branch->path = strbuf_detach(&buf, NULL);
349}
350
351static int merge_working_tree(struct checkout_opts *opts,
75ea38df 352 struct branch_info *old, struct branch_info *new)
782c2d65
DB
353{
354 int ret;
355 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
356 int newfd = hold_locked_index(lock_file, 1);
b96524f8 357
53996fe5 358 if (read_cache_preload(NULL) < 0)
b96524f8 359 return error("corrupt index file");
782c2d65 360
cfc5789a 361 resolve_undo_clear();
782c2d65 362 if (opts->force) {
6286a08d 363 ret = reset_tree(new->commit->tree, opts, 1);
782c2d65
DB
364 if (ret)
365 return ret;
366 } else {
367 struct tree_desc trees[2];
368 struct tree *tree;
369 struct unpack_trees_options topts;
bc052d7f 370
782c2d65
DB
371 memset(&topts, 0, sizeof(topts));
372 topts.head_idx = -1;
34110cd4
LT
373 topts.src_index = &the_index;
374 topts.dst_index = &the_index;
782c2d65 375
8ccba008
JH
376 topts.msgs.not_uptodate_file = "You have local changes to '%s'; cannot switch branches.";
377
782c2d65
DB
378 refresh_cache(REFRESH_QUIET);
379
380 if (unmerged_cache()) {
04c9e11f
JH
381 error("you need to resolve your current index first");
382 return 1;
782c2d65 383 }
04c9e11f
JH
384
385 /* 2-way merge to the new branch */
fa7b3c2f 386 topts.initial_checkout = is_cache_unborn();
04c9e11f
JH
387 topts.update = 1;
388 topts.merge = 1;
64da3ae5 389 topts.gently = opts->merge && old->commit;
04c9e11f
JH
390 topts.verbose_update = !opts->quiet;
391 topts.fn = twoway_merge;
392 topts.dir = xcalloc(1, sizeof(*topts.dir));
7c4c97c0 393 topts.dir->flags |= DIR_SHOW_IGNORED;
04c9e11f 394 topts.dir->exclude_per_dir = ".gitignore";
cc580af8
JK
395 tree = parse_tree_indirect(old->commit ?
396 old->commit->object.sha1 :
397 (unsigned char *)EMPTY_TREE_SHA1_BIN);
04c9e11f
JH
398 init_tree_desc(&trees[0], tree->buffer, tree->size);
399 tree = parse_tree_indirect(new->commit->object.sha1);
400 init_tree_desc(&trees[1], tree->buffer, tree->size);
401
291d823e 402 ret = unpack_trees(2, trees, &topts);
49d833dc 403 if (ret == -1) {
782c2d65
DB
404 /*
405 * Unpack couldn't do a trivial merge; either
406 * give up or do a real merge, depending on
407 * whether the merge flag was used.
408 */
409 struct tree *result;
410 struct tree *work;
8a2fce18 411 struct merge_options o;
782c2d65
DB
412 if (!opts->merge)
413 return 1;
64da3ae5
JH
414
415 /*
416 * Without old->commit, the below is the same as
417 * the two-tree unpack we already tried and failed.
418 */
419 if (!old->commit)
420 return 1;
782c2d65
DB
421
422 /* Do more real merge */
423
424 /*
425 * We update the index fully, then write the
426 * tree from the index, then merge the new
427 * branch with the current tree, with the old
428 * branch as the base. Then we reset the index
429 * (but not the working tree) to the new
430 * branch, leaving the working tree as the
431 * merged version, but skipping unmerged
432 * entries in the index.
433 */
434
7ae02a30 435 add_files_to_cache(NULL, NULL, 0);
8a2fce18
MV
436 init_merge_options(&o);
437 o.verbosity = 0;
438 work = write_tree_from_memory(&o);
782c2d65 439
6286a08d 440 ret = reset_tree(new->commit->tree, opts, 1);
782c2d65
DB
441 if (ret)
442 return ret;
c4151629 443 o.ancestor = old->name;
8a2fce18
MV
444 o.branch1 = new->name;
445 o.branch2 = "local";
446 merge_trees(&o, new->commit->tree, work,
447 old->commit->tree, &result);
6286a08d 448 ret = reset_tree(new->commit->tree, opts, 0);
84a5750b
JH
449 if (ret)
450 return ret;
782c2d65
DB
451 }
452 }
453
454 if (write_cache(newfd, active_cache, active_nr) ||
455 commit_locked_index(lock_file))
456 die("unable to write new index file");
457
7fe4a728 458 if (!opts->force && !opts->quiet)
782c2d65
DB
459 show_local_changes(&new->commit->object);
460
461 return 0;
462}
463
6d21bf96 464static void report_tracking(struct branch_info *new)
79a1e6b4 465{
6d21bf96 466 struct strbuf sb = STRBUF_INIT;
b56fca07 467 struct branch *branch = branch_get(new->name);
79a1e6b4 468
6d21bf96 469 if (!format_tracking_info(branch, &sb))
79a1e6b4 470 return;
6d21bf96
JH
471 fputs(sb.buf, stdout);
472 strbuf_release(&sb);
b0030db3 473}
79a1e6b4 474
13be3e31
JH
475static void detach_advice(const char *old_path, const char *new_name)
476{
477 const char fmt[] =
478 "Note: checking out '%s'.\n\n"
479 "You are in 'detached HEAD' state. You can look around, make experimental\n"
480 "changes and commit them, and you can discard any commits you make in this\n"
481 "state without impacting any branches by performing another checkout.\n\n"
482 "If you want to create a new branch to retain commits you create, you may\n"
483 "do so (now or later) by using -b with the checkout command again. Example:\n\n"
484 " git checkout -b new_branch_name\n\n";
485
486 fprintf(stderr, fmt, new_name);
487}
488
782c2d65
DB
489static void update_refs_for_switch(struct checkout_opts *opts,
490 struct branch_info *old,
491 struct branch_info *new)
492{
f285a2d7 493 struct strbuf msg = STRBUF_INIT;
782c2d65
DB
494 const char *old_desc;
495 if (opts->new_branch) {
3631bf77
EM
496 if (opts->new_orphan_branch) {
497 if (opts->new_branch_log && !log_all_ref_updates) {
498 int temp;
157aaea5 499 char log_file[PATH_MAX];
3631bf77
EM
500 char *ref_name = mkpath("refs/heads/%s", opts->new_orphan_branch);
501
502 temp = log_all_ref_updates;
503 log_all_ref_updates = 1;
157aaea5 504 if (log_ref_setup(ref_name, log_file, sizeof(log_file))) {
3631bf77
EM
505 fprintf(stderr, "Can not do reflog for '%s'\n",
506 opts->new_orphan_branch);
507 log_all_ref_updates = temp;
508 return;
509 }
510 log_all_ref_updates = temp;
511 }
512 }
513 else
9db5ebf4
EM
514 create_branch(old->name, opts->new_branch, new->name, 0,
515 opts->new_branch_log, opts->track);
782c2d65
DB
516 new->name = opts->new_branch;
517 setup_branch_path(new);
518 }
519
782c2d65 520 old_desc = old->name;
323e00fd 521 if (!old_desc && old->commit)
782c2d65
DB
522 old_desc = sha1_to_hex(old->commit->object.sha1);
523 strbuf_addf(&msg, "checkout: moving from %s to %s",
323e00fd 524 old_desc ? old_desc : "(invalid)", new->name);
782c2d65
DB
525
526 if (new->path) {
527 create_symref("HEAD", new->path, msg.buf);
528 if (!opts->quiet) {
529 if (old->path && !strcmp(new->path, old->path))
714fddf2 530 fprintf(stderr, "Already on '%s'\n",
782c2d65
DB
531 new->name);
532 else
714fddf2 533 fprintf(stderr, "Switched to%s branch '%s'\n",
782c2d65
DB
534 opts->new_branch ? " a new" : "",
535 new->name);
536 }
3631bf77
EM
537 if (old->path && old->name) {
538 char log_file[PATH_MAX], ref_file[PATH_MAX];
539
540 git_snpath(log_file, sizeof(log_file), "logs/%s", old->path);
541 git_snpath(ref_file, sizeof(ref_file), "%s", old->path);
542 if (!file_exists(ref_file) && file_exists(log_file))
543 remove_path(log_file);
544 }
782c2d65
DB
545 } else if (strcmp(new->name, "HEAD")) {
546 update_ref(msg.buf, "HEAD", new->commit->object.sha1, NULL,
547 REF_NODEREF, DIE_ON_ERR);
548 if (!opts->quiet) {
13be3e31
JH
549 if (old->path && advice_detached_head)
550 detach_advice(old->path, new->name);
782c2d65
DB
551 describe_detached_head("HEAD is now at", new->commit);
552 }
553 }
554 remove_branch_state();
555 strbuf_release(&msg);
b0030db3 556 if (!opts->quiet && (new->path || !strcmp(new->name, "HEAD")))
6d21bf96 557 report_tracking(new);
782c2d65
DB
558}
559
75ea38df 560static int switch_branches(struct checkout_opts *opts, struct branch_info *new)
782c2d65
DB
561{
562 int ret = 0;
563 struct branch_info old;
564 unsigned char rev[20];
565 int flag;
566 memset(&old, 0, sizeof(old));
567 old.path = resolve_ref("HEAD", rev, 0, &flag);
568 old.commit = lookup_commit_reference_gently(rev, 1);
569 if (!(flag & REF_ISSYMREF))
570 old.path = NULL;
571
572 if (old.path && !prefixcmp(old.path, "refs/heads/"))
573 old.name = old.path + strlen("refs/heads/");
574
575 if (!new->name) {
576 new->name = "HEAD";
577 new->commit = old.commit;
578 if (!new->commit)
579 die("You are on a branch yet to be born");
580 parse_commit(new->commit);
581 }
582
75ea38df 583 ret = merge_working_tree(opts, &old, new);
782c2d65
DB
584 if (ret)
585 return ret;
586
77ebd56d
DC
587 /*
588 * If we were on a detached HEAD, but have now moved to
589 * a new commit, we want to mention the old commit once more
590 * to remind the user that it might be lost.
591 */
592 if (!opts->quiet && !old.path && old.commit && new->commit != old.commit)
593 describe_detached_head("Previous HEAD position was", old.commit);
594
782c2d65
DB
595 update_refs_for_switch(opts, &old, new);
596
291d823e
JH
597 ret = post_checkout_hook(old.commit, new->commit, 1);
598 return ret || opts->writeout_error;
782c2d65
DB
599}
600
0cf8581e
JH
601static int git_checkout_config(const char *var, const char *value, void *cb)
602{
603 return git_xmerge_config(var, value, cb);
604}
605
4f353658
TR
606static int interactive_checkout(const char *revision, const char **pathspec,
607 struct checkout_opts *opts)
608{
609 return run_add_interactive(revision, "--patch=checkout", pathspec);
610}
611
70c9ac2f
JH
612struct tracking_name_data {
613 const char *name;
614 char *remote;
615 int unique;
616};
617
618static int check_tracking_name(const char *refname, const unsigned char *sha1,
619 int flags, void *cb_data)
620{
621 struct tracking_name_data *cb = cb_data;
622 const char *slash;
623
624 if (prefixcmp(refname, "refs/remotes/"))
625 return 0;
626 slash = strchr(refname + 13, '/');
627 if (!slash || strcmp(slash + 1, cb->name))
628 return 0;
629 if (cb->remote) {
630 cb->unique = 0;
631 return 0;
632 }
633 cb->remote = xstrdup(refname);
634 return 0;
635}
636
637static const char *unique_tracking_name(const char *name)
638{
66dbfd55
GV
639 struct tracking_name_data cb_data = { NULL, NULL, 1 };
640 cb_data.name = name;
70c9ac2f
JH
641 for_each_ref(check_tracking_name, &cb_data);
642 if (cb_data.unique)
643 return cb_data.remote;
644 free(cb_data.remote);
645 return NULL;
646}
4f353658 647
782c2d65
DB
648int cmd_checkout(int argc, const char **argv, const char *prefix)
649{
650 struct checkout_opts opts;
651 unsigned char rev[20];
652 const char *arg;
653 struct branch_info new;
654 struct tree *source_tree = NULL;
eac5a401 655 char *conflict_style = NULL;
4f353658 656 int patch_mode = 0;
46148dd7 657 int dwim_new_local_branch = 1;
782c2d65
DB
658 struct option options[] = {
659 OPT__QUIET(&opts.quiet),
660 OPT_STRING('b', NULL, &opts.new_branch, "new branch", "branch"),
661 OPT_BOOLEAN('l', NULL, &opts.new_branch_log, "log for new branch"),
498a6e7e 662 OPT_SET_INT('t', "track", &opts.track, "track",
9ed36cfa 663 BRANCH_TRACK_EXPLICIT),
9db5ebf4 664 OPT_STRING(0, "orphan", &opts.new_orphan_branch, "new branch", "new unparented branch"),
38901a48
JH
665 OPT_SET_INT('2', "ours", &opts.writeout_stage, "stage",
666 2),
667 OPT_SET_INT('3', "theirs", &opts.writeout_stage, "stage",
668 3),
f7aec129 669 OPT_BOOLEAN('f', "force", &opts.force, "force"),
eac5a401
JH
670 OPT_BOOLEAN('m', "merge", &opts.merge, "merge"),
671 OPT_STRING(0, "conflict", &conflict_style, "style",
672 "conflict style (merge or diff3)"),
4f353658 673 OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
46148dd7
JH
674 { OPTION_BOOLEAN, 0, "guess", &dwim_new_local_branch, NULL,
675 "second guess 'git checkout no-such-branch'",
676 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
b249b552 677 OPT_END(),
782c2d65 678 };
859fdaba 679 int has_dash_dash;
782c2d65
DB
680
681 memset(&opts, 0, sizeof(opts));
682 memset(&new, 0, sizeof(new));
683
0cf8581e 684 git_config(git_checkout_config, NULL);
782c2d65 685
9188ed89 686 opts.track = BRANCH_TRACK_UNSPECIFIED;
782c2d65 687
37782920 688 argc = parse_options(argc, argv, prefix, options, checkout_usage,
f5242ebf 689 PARSE_OPT_KEEP_DASHDASH);
859fdaba 690
4f353658
TR
691 if (patch_mode && (opts.track > 0 || opts.new_branch
692 || opts.new_branch_log || opts.merge || opts.force))
693 die ("--patch is incompatible with all other options");
694
bb0ceb62 695 /* --track without -b should DWIM */
9188ed89
AR
696 if (0 < opts.track && !opts.new_branch) {
697 const char *argv0 = argv[0];
698 if (!argc || !strcmp(argv0, "--"))
bb0ceb62 699 die ("--track needs a branch name");
9188ed89
AR
700 if (!prefixcmp(argv0, "refs/"))
701 argv0 += 5;
702 if (!prefixcmp(argv0, "remotes/"))
703 argv0 += 8;
704 argv0 = strchr(argv0, '/');
705 if (!argv0 || !argv0[1])
bb0ceb62 706 die ("Missing branch name; try -b");
9188ed89 707 opts.new_branch = argv0 + 1;
bb0ceb62
JS
708 }
709
9db5ebf4
EM
710 if (opts.new_orphan_branch) {
711 if (opts.new_branch)
712 die("--orphan and -b are mutually exclusive");
3631bf77
EM
713 if (opts.track > 0)
714 die("--orphan cannot be used with -t");
9db5ebf4
EM
715 opts.new_branch = opts.new_orphan_branch;
716 }
717
eac5a401
JH
718 if (conflict_style) {
719 opts.merge = 1; /* implied */
720 git_xmerge_config("merge.conflictstyle", conflict_style, NULL);
721 }
722
859fdaba
PH
723 if (opts.force && opts.merge)
724 die("git checkout: -f and -m are incompatible");
725
726 /*
727 * case 1: git checkout <ref> -- [<paths>]
728 *
729 * <ref> must be a valid tree, everything after the '--' must be
730 * a path.
731 *
732 * case 2: git checkout -- [<paths>]
733 *
734 * everything after the '--' must be paths.
735 *
736 * case 3: git checkout <something> [<paths>]
737 *
738 * With no paths, if <something> is a commit, that is to
619a644d
JH
739 * switch to the branch or detach HEAD at it. As a special case,
740 * if <something> is A...B (missing A or B means HEAD but you can
741 * omit at most one side), and if there is a unique merge base
742 * between A and B, A...B names that merge base.
859fdaba 743 *
70c9ac2f
JH
744 * With no paths, if <something> is _not_ a commit, no -t nor -b
745 * was given, and there is a tracking branch whose name is
746 * <something> in one and only one remote, then this is a short-hand
747 * to fork local <something> from that remote tracking branch.
748 *
859fdaba
PH
749 * Otherwise <something> shall not be ambiguous.
750 * - If it's *only* a reference, treat it like case (1).
751 * - If it's only a path, treat it like case (2).
752 * - else: fail.
753 *
754 */
782c2d65 755 if (argc) {
859fdaba
PH
756 if (!strcmp(argv[0], "--")) { /* case (2) */
757 argv++;
758 argc--;
759 goto no_reference;
760 }
761
782c2d65 762 arg = argv[0];
859fdaba
PH
763 has_dash_dash = (argc > 1) && !strcmp(argv[1], "--");
764
696acf45
TR
765 if (!strcmp(arg, "-"))
766 arg = "@{-1}";
767
619a644d 768 if (get_sha1_mb(arg, rev)) {
859fdaba
PH
769 if (has_dash_dash) /* case (1) */
770 die("invalid reference: %s", arg);
70c9ac2f 771 if (!patch_mode &&
46148dd7 772 dwim_new_local_branch &&
70c9ac2f
JH
773 opts.track == BRANCH_TRACK_UNSPECIFIED &&
774 !opts.new_branch &&
775 !check_filename(NULL, arg) &&
776 argc == 1) {
777 const char *remote = unique_tracking_name(arg);
778 if (!remote || get_sha1(remote, rev))
779 goto no_reference;
780 opts.new_branch = arg;
781 arg = remote;
782 /* DWIMmed to create local branch */
783 }
784 else
785 goto no_reference;
859fdaba
PH
786 }
787
788 /* we can't end up being in (2) anymore, eat the argument */
789 argv++;
790 argc--;
791
3442ea4a 792 new.name = arg;
859fdaba 793 if ((new.commit = lookup_commit_reference_gently(rev, 1))) {
782c2d65 794 setup_branch_path(&new);
72a144e2
JH
795
796 if ((check_ref_format(new.path) == CHECK_REF_FORMAT_OK) &&
797 resolve_ref(new.path, rev, 1, NULL))
798 ;
782c2d65
DB
799 else
800 new.path = NULL;
801 parse_commit(new.commit);
802 source_tree = new.commit->tree;
859fdaba
PH
803 } else
804 source_tree = parse_tree_indirect(rev);
805
806 if (!source_tree) /* case (1): want a tree */
807 die("reference is not a tree: %s", arg);
808 if (!has_dash_dash) {/* case (3 -> 1) */
809 /*
810 * Do not complain the most common case
811 * git checkout branch
812 * even if there happen to be a file called 'branch';
813 * it would be extremely annoying.
814 */
815 if (argc)
816 verify_non_filename(NULL, arg);
817 }
818 else {
782c2d65
DB
819 argv++;
820 argc--;
821 }
822 }
823
859fdaba 824no_reference:
70c9ac2f
JH
825
826 if (opts.track == BRANCH_TRACK_UNSPECIFIED)
827 opts.track = git_branch_track;
828
782c2d65
DB
829 if (argc) {
830 const char **pathspec = get_pathspec(prefix, argv);
301e42ed
AR
831
832 if (!pathspec)
833 die("invalid path specification");
834
4f353658
TR
835 if (patch_mode)
836 return interactive_checkout(new.name, pathspec, &opts);
837
782c2d65 838 /* Checkout paths */
0cf8581e 839 if (opts.new_branch) {
782c2d65 840 if (argc == 1) {
db941099 841 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]);
782c2d65 842 } else {
db941099 843 die("git checkout: updating paths is incompatible with switching branches.");
782c2d65
DB
844 }
845 }
846
0cf8581e
JH
847 if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)
848 die("git checkout: --ours/--theirs, --force and --merge are incompatible when\nchecking out of the index.");
849
db941099 850 return checkout_paths(source_tree, pathspec, &opts);
782c2d65
DB
851 }
852
4f353658
TR
853 if (patch_mode)
854 return interactive_checkout(new.name, NULL, &opts);
855
352eadc4 856 if (opts.new_branch) {
f285a2d7 857 struct strbuf buf = STRBUF_INIT;
a2fab531
JH
858 if (strbuf_check_branch_ref(&buf, opts.new_branch))
859 die("git checkout: we do not like '%s' as a branch name.",
860 opts.new_branch);
352eadc4
DB
861 if (!get_sha1(buf.buf, rev))
862 die("git checkout: branch %s already exists", opts.new_branch);
352eadc4
DB
863 strbuf_release(&buf);
864 }
865
782c2d65
DB
866 if (new.name && !new.commit) {
867 die("Cannot switch branch to a non-commit.");
868 }
38901a48
JH
869 if (opts.writeout_stage)
870 die("--ours/--theirs is incompatible with switching branches.");
782c2d65 871
75ea38df 872 return switch_branches(&opts, &new);
782c2d65 873}