Merge branch 'so/log-diff-merge'
[git] / builtin / worktree.c
1 #include "cache.h"
2 #include "checkout.h"
3 #include "config.h"
4 #include "builtin.h"
5 #include "dir.h"
6 #include "parse-options.h"
7 #include "strvec.h"
8 #include "branch.h"
9 #include "refs.h"
10 #include "run-command.h"
11 #include "sigchain.h"
12 #include "submodule.h"
13 #include "utf8.h"
14 #include "worktree.h"
15
16 static const char * const worktree_usage[] = {
17         N_("git worktree add [<options>] <path> [<commit-ish>]"),
18         N_("git worktree list [<options>]"),
19         N_("git worktree lock [<options>] <path>"),
20         N_("git worktree move <worktree> <new-path>"),
21         N_("git worktree prune [<options>]"),
22         N_("git worktree remove [<options>] <worktree>"),
23         N_("git worktree unlock <path>"),
24         NULL
25 };
26
27 struct add_opts {
28         int force;
29         int detach;
30         int quiet;
31         int checkout;
32         int keep_locked;
33 };
34
35 static int show_only;
36 static int verbose;
37 static int guess_remote;
38 static timestamp_t expire;
39
40 static int git_worktree_config(const char *var, const char *value, void *cb)
41 {
42         if (!strcmp(var, "worktree.guessremote")) {
43                 guess_remote = git_config_bool(var, value);
44                 return 0;
45         }
46
47         return git_default_config(var, value, cb);
48 }
49
50 static int delete_git_dir(const char *id)
51 {
52         struct strbuf sb = STRBUF_INIT;
53         int ret;
54
55         strbuf_addstr(&sb, git_common_path("worktrees/%s", id));
56         ret = remove_dir_recursively(&sb, 0);
57         if (ret < 0 && errno == ENOTDIR)
58                 ret = unlink(sb.buf);
59         if (ret)
60                 error_errno(_("failed to delete '%s'"), sb.buf);
61         strbuf_release(&sb);
62         return ret;
63 }
64
65 static void delete_worktrees_dir_if_empty(void)
66 {
67         rmdir(git_path("worktrees")); /* ignore failed removal */
68 }
69
70 /*
71  * Return true if worktree entry should be pruned, along with the reason for
72  * pruning. Otherwise, return false and the worktree's path, or NULL if it
73  * cannot be determined. Caller is responsible for freeing returned path.
74  */
75 static int should_prune_worktree(const char *id, struct strbuf *reason, char **wtpath)
76 {
77         struct stat st;
78         char *path;
79         int fd;
80         size_t len;
81         ssize_t read_result;
82
83         *wtpath = NULL;
84         if (!is_directory(git_path("worktrees/%s", id))) {
85                 strbuf_addstr(reason, _("not a valid directory"));
86                 return 1;
87         }
88         if (file_exists(git_path("worktrees/%s/locked", id)))
89                 return 0;
90         if (stat(git_path("worktrees/%s/gitdir", id), &st)) {
91                 strbuf_addstr(reason, _("gitdir file does not exist"));
92                 return 1;
93         }
94         fd = open(git_path("worktrees/%s/gitdir", id), O_RDONLY);
95         if (fd < 0) {
96                 strbuf_addf(reason, _("unable to read gitdir file (%s)"),
97                             strerror(errno));
98                 return 1;
99         }
100         len = xsize_t(st.st_size);
101         path = xmallocz(len);
102
103         read_result = read_in_full(fd, path, len);
104         if (read_result < 0) {
105                 strbuf_addf(reason, _("unable to read gitdir file (%s)"),
106                             strerror(errno));
107                 close(fd);
108                 free(path);
109                 return 1;
110         }
111         close(fd);
112
113         if (read_result != len) {
114                 strbuf_addf(reason,
115                             _("short read (expected %"PRIuMAX" bytes, read %"PRIuMAX")"),
116                             (uintmax_t)len, (uintmax_t)read_result);
117                 free(path);
118                 return 1;
119         }
120         while (len && (path[len - 1] == '\n' || path[len - 1] == '\r'))
121                 len--;
122         if (!len) {
123                 strbuf_addstr(reason, _("invalid gitdir file"));
124                 free(path);
125                 return 1;
126         }
127         path[len] = '\0';
128         if (!file_exists(path)) {
129                 if (stat(git_path("worktrees/%s/index", id), &st) ||
130                     st.st_mtime <= expire) {
131                         strbuf_addstr(reason, _("gitdir file points to non-existent location"));
132                         free(path);
133                         return 1;
134                 } else {
135                         *wtpath = path;
136                         return 0;
137                 }
138         }
139         *wtpath = path;
140         return 0;
141 }
142
143 static void prune_worktree(const char *id, const char *reason)
144 {
145         if (show_only || verbose)
146                 printf_ln(_("Removing %s/%s: %s"), "worktrees", id, reason);
147         if (!show_only)
148                 delete_git_dir(id);
149 }
150
151 static int prune_cmp(const void *a, const void *b)
152 {
153         const struct string_list_item *x = a;
154         const struct string_list_item *y = b;
155         int c;
156
157         if ((c = fspathcmp(x->string, y->string)))
158             return c;
159         /*
160          * paths same; prune_dupes() removes all but the first worktree entry
161          * having the same path, so sort main worktree ('util' is NULL) above
162          * linked worktrees ('util' not NULL) since main worktree can't be
163          * removed
164          */
165         if (!x->util)
166                 return -1;
167         if (!y->util)
168                 return 1;
169         /* paths same; sort by .git/worktrees/<id> */
170         return strcmp(x->util, y->util);
171 }
172
173 static void prune_dups(struct string_list *l)
174 {
175         int i;
176
177         QSORT(l->items, l->nr, prune_cmp);
178         for (i = 1; i < l->nr; i++) {
179                 if (!fspathcmp(l->items[i].string, l->items[i - 1].string))
180                         prune_worktree(l->items[i].util, "duplicate entry");
181         }
182 }
183
184 static void prune_worktrees(void)
185 {
186         struct strbuf reason = STRBUF_INIT;
187         struct strbuf main_path = STRBUF_INIT;
188         struct string_list kept = STRING_LIST_INIT_NODUP;
189         DIR *dir = opendir(git_path("worktrees"));
190         struct dirent *d;
191         if (!dir)
192                 return;
193         while ((d = readdir(dir)) != NULL) {
194                 char *path;
195                 if (is_dot_or_dotdot(d->d_name))
196                         continue;
197                 strbuf_reset(&reason);
198                 if (should_prune_worktree(d->d_name, &reason, &path))
199                         prune_worktree(d->d_name, reason.buf);
200                 else if (path)
201                         string_list_append(&kept, path)->util = xstrdup(d->d_name);
202         }
203         closedir(dir);
204
205         strbuf_add_absolute_path(&main_path, get_git_common_dir());
206         /* massage main worktree absolute path to match 'gitdir' content */
207         strbuf_strip_suffix(&main_path, "/.");
208         string_list_append(&kept, strbuf_detach(&main_path, NULL));
209         prune_dups(&kept);
210         string_list_clear(&kept, 1);
211
212         if (!show_only)
213                 delete_worktrees_dir_if_empty();
214         strbuf_release(&reason);
215 }
216
217 static int prune(int ac, const char **av, const char *prefix)
218 {
219         struct option options[] = {
220                 OPT__DRY_RUN(&show_only, N_("do not remove, show only")),
221                 OPT__VERBOSE(&verbose, N_("report pruned working trees")),
222                 OPT_EXPIRY_DATE(0, "expire", &expire,
223                                 N_("expire working trees older than <time>")),
224                 OPT_END()
225         };
226
227         expire = TIME_MAX;
228         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
229         if (ac)
230                 usage_with_options(worktree_usage, options);
231         prune_worktrees();
232         return 0;
233 }
234
235 static char *junk_work_tree;
236 static char *junk_git_dir;
237 static int is_junk;
238 static pid_t junk_pid;
239
240 static void remove_junk(void)
241 {
242         struct strbuf sb = STRBUF_INIT;
243         if (!is_junk || getpid() != junk_pid)
244                 return;
245         if (junk_git_dir) {
246                 strbuf_addstr(&sb, junk_git_dir);
247                 remove_dir_recursively(&sb, 0);
248                 strbuf_reset(&sb);
249         }
250         if (junk_work_tree) {
251                 strbuf_addstr(&sb, junk_work_tree);
252                 remove_dir_recursively(&sb, 0);
253         }
254         strbuf_release(&sb);
255 }
256
257 static void remove_junk_on_signal(int signo)
258 {
259         remove_junk();
260         sigchain_pop(signo);
261         raise(signo);
262 }
263
264 static const char *worktree_basename(const char *path, int *olen)
265 {
266         const char *name;
267         int len;
268
269         len = strlen(path);
270         while (len && is_dir_sep(path[len - 1]))
271                 len--;
272
273         for (name = path + len - 1; name > path; name--)
274                 if (is_dir_sep(*name)) {
275                         name++;
276                         break;
277                 }
278
279         *olen = len;
280         return name;
281 }
282
283 /* check that path is viable location for worktree */
284 static void check_candidate_path(const char *path,
285                                  int force,
286                                  struct worktree **worktrees,
287                                  const char *cmd)
288 {
289         struct worktree *wt;
290         int locked;
291
292         if (file_exists(path) && !is_empty_dir(path))
293                 die(_("'%s' already exists"), path);
294
295         wt = find_worktree_by_path(worktrees, path);
296         if (!wt)
297                 return;
298
299         locked = !!worktree_lock_reason(wt);
300         if ((!locked && force) || (locked && force > 1)) {
301                 if (delete_git_dir(wt->id))
302                     die(_("unusable worktree destination '%s'"), path);
303                 return;
304         }
305
306         if (locked)
307                 die(_("'%s' is a missing but locked worktree;\nuse '%s -f -f' to override, or 'unlock' and 'prune' or 'remove' to clear"), path, cmd);
308         else
309                 die(_("'%s' is a missing but already registered worktree;\nuse '%s -f' to override, or 'prune' or 'remove' to clear"), path, cmd);
310 }
311
312 static int add_worktree(const char *path, const char *refname,
313                         const struct add_opts *opts)
314 {
315         struct strbuf sb_git = STRBUF_INIT, sb_repo = STRBUF_INIT;
316         struct strbuf sb = STRBUF_INIT, realpath = STRBUF_INIT;
317         const char *name;
318         struct child_process cp = CHILD_PROCESS_INIT;
319         struct strvec child_env = STRVEC_INIT;
320         unsigned int counter = 0;
321         int len, ret;
322         struct strbuf symref = STRBUF_INIT;
323         struct commit *commit = NULL;
324         int is_branch = 0;
325         struct strbuf sb_name = STRBUF_INIT;
326         struct worktree **worktrees;
327
328         worktrees = get_worktrees();
329         check_candidate_path(path, opts->force, worktrees, "add");
330         free_worktrees(worktrees);
331         worktrees = NULL;
332
333         /* is 'refname' a branch or commit? */
334         if (!opts->detach && !strbuf_check_branch_ref(&symref, refname) &&
335             ref_exists(symref.buf)) {
336                 is_branch = 1;
337                 if (!opts->force)
338                         die_if_checked_out(symref.buf, 0);
339         }
340         commit = lookup_commit_reference_by_name(refname);
341         if (!commit)
342                 die(_("invalid reference: %s"), refname);
343
344         name = worktree_basename(path, &len);
345         strbuf_add(&sb, name, path + len - name);
346         sanitize_refname_component(sb.buf, &sb_name);
347         if (!sb_name.len)
348                 BUG("How come '%s' becomes empty after sanitization?", sb.buf);
349         strbuf_reset(&sb);
350         name = sb_name.buf;
351         git_path_buf(&sb_repo, "worktrees/%s", name);
352         len = sb_repo.len;
353         if (safe_create_leading_directories_const(sb_repo.buf))
354                 die_errno(_("could not create leading directories of '%s'"),
355                           sb_repo.buf);
356
357         while (mkdir(sb_repo.buf, 0777)) {
358                 counter++;
359                 if ((errno != EEXIST) || !counter /* overflow */)
360                         die_errno(_("could not create directory of '%s'"),
361                                   sb_repo.buf);
362                 strbuf_setlen(&sb_repo, len);
363                 strbuf_addf(&sb_repo, "%d", counter);
364         }
365         name = strrchr(sb_repo.buf, '/') + 1;
366
367         junk_pid = getpid();
368         atexit(remove_junk);
369         sigchain_push_common(remove_junk_on_signal);
370
371         junk_git_dir = xstrdup(sb_repo.buf);
372         is_junk = 1;
373
374         /*
375          * lock the incomplete repo so prune won't delete it, unlock
376          * after the preparation is over.
377          */
378         strbuf_addf(&sb, "%s/locked", sb_repo.buf);
379         if (!opts->keep_locked)
380                 write_file(sb.buf, "initializing");
381         else
382                 write_file(sb.buf, "added with --lock");
383
384         strbuf_addf(&sb_git, "%s/.git", path);
385         if (safe_create_leading_directories_const(sb_git.buf))
386                 die_errno(_("could not create leading directories of '%s'"),
387                           sb_git.buf);
388         junk_work_tree = xstrdup(path);
389
390         strbuf_reset(&sb);
391         strbuf_addf(&sb, "%s/gitdir", sb_repo.buf);
392         strbuf_realpath(&realpath, sb_git.buf, 1);
393         write_file(sb.buf, "%s", realpath.buf);
394         strbuf_realpath(&realpath, get_git_common_dir(), 1);
395         write_file(sb_git.buf, "gitdir: %s/worktrees/%s",
396                    realpath.buf, name);
397         /*
398          * This is to keep resolve_ref() happy. We need a valid HEAD
399          * or is_git_directory() will reject the directory. Any value which
400          * looks like an object ID will do since it will be immediately
401          * replaced by the symbolic-ref or update-ref invocation in the new
402          * worktree.
403          */
404         strbuf_reset(&sb);
405         strbuf_addf(&sb, "%s/HEAD", sb_repo.buf);
406         write_file(sb.buf, "%s", oid_to_hex(&null_oid));
407         strbuf_reset(&sb);
408         strbuf_addf(&sb, "%s/commondir", sb_repo.buf);
409         write_file(sb.buf, "../..");
410
411         strvec_pushf(&child_env, "%s=%s", GIT_DIR_ENVIRONMENT, sb_git.buf);
412         strvec_pushf(&child_env, "%s=%s", GIT_WORK_TREE_ENVIRONMENT, path);
413         cp.git_cmd = 1;
414
415         if (!is_branch)
416                 strvec_pushl(&cp.args, "update-ref", "HEAD",
417                              oid_to_hex(&commit->object.oid), NULL);
418         else {
419                 strvec_pushl(&cp.args, "symbolic-ref", "HEAD",
420                              symref.buf, NULL);
421                 if (opts->quiet)
422                         strvec_push(&cp.args, "--quiet");
423         }
424
425         cp.env = child_env.v;
426         ret = run_command(&cp);
427         if (ret)
428                 goto done;
429
430         if (opts->checkout) {
431                 cp.argv = NULL;
432                 strvec_clear(&cp.args);
433                 strvec_pushl(&cp.args, "reset", "--hard", "--no-recurse-submodules", NULL);
434                 if (opts->quiet)
435                         strvec_push(&cp.args, "--quiet");
436                 cp.env = child_env.v;
437                 ret = run_command(&cp);
438                 if (ret)
439                         goto done;
440         }
441
442         is_junk = 0;
443         FREE_AND_NULL(junk_work_tree);
444         FREE_AND_NULL(junk_git_dir);
445
446 done:
447         if (ret || !opts->keep_locked) {
448                 strbuf_reset(&sb);
449                 strbuf_addf(&sb, "%s/locked", sb_repo.buf);
450                 unlink_or_warn(sb.buf);
451         }
452
453         /*
454          * Hook failure does not warrant worktree deletion, so run hook after
455          * is_junk is cleared, but do return appropriate code when hook fails.
456          */
457         if (!ret && opts->checkout) {
458                 const char *hook = find_hook("post-checkout");
459                 if (hook) {
460                         const char *env[] = { "GIT_DIR", "GIT_WORK_TREE", NULL };
461                         cp.git_cmd = 0;
462                         cp.no_stdin = 1;
463                         cp.stdout_to_stderr = 1;
464                         cp.dir = path;
465                         cp.env = env;
466                         cp.argv = NULL;
467                         cp.trace2_hook_name = "post-checkout";
468                         strvec_pushl(&cp.args, absolute_path(hook),
469                                      oid_to_hex(&null_oid),
470                                      oid_to_hex(&commit->object.oid),
471                                      "1", NULL);
472                         ret = run_command(&cp);
473                 }
474         }
475
476         strvec_clear(&child_env);
477         strbuf_release(&sb);
478         strbuf_release(&symref);
479         strbuf_release(&sb_repo);
480         strbuf_release(&sb_git);
481         strbuf_release(&sb_name);
482         strbuf_release(&realpath);
483         return ret;
484 }
485
486 static void print_preparing_worktree_line(int detach,
487                                           const char *branch,
488                                           const char *new_branch,
489                                           int force_new_branch)
490 {
491         if (force_new_branch) {
492                 struct commit *commit = lookup_commit_reference_by_name(new_branch);
493                 if (!commit)
494                         printf_ln(_("Preparing worktree (new branch '%s')"), new_branch);
495                 else
496                         printf_ln(_("Preparing worktree (resetting branch '%s'; was at %s)"),
497                                   new_branch,
498                                   find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV));
499         } else if (new_branch) {
500                 printf_ln(_("Preparing worktree (new branch '%s')"), new_branch);
501         } else {
502                 struct strbuf s = STRBUF_INIT;
503                 if (!detach && !strbuf_check_branch_ref(&s, branch) &&
504                     ref_exists(s.buf))
505                         printf_ln(_("Preparing worktree (checking out '%s')"),
506                                   branch);
507                 else {
508                         struct commit *commit = lookup_commit_reference_by_name(branch);
509                         if (!commit)
510                                 die(_("invalid reference: %s"), branch);
511                         printf_ln(_("Preparing worktree (detached HEAD %s)"),
512                                   find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV));
513                 }
514                 strbuf_release(&s);
515         }
516 }
517
518 static const char *dwim_branch(const char *path, const char **new_branch)
519 {
520         int n;
521         const char *s = worktree_basename(path, &n);
522         const char *branchname = xstrndup(s, n);
523         struct strbuf ref = STRBUF_INIT;
524
525         UNLEAK(branchname);
526         if (!strbuf_check_branch_ref(&ref, branchname) &&
527             ref_exists(ref.buf)) {
528                 strbuf_release(&ref);
529                 return branchname;
530         }
531
532         *new_branch = branchname;
533         if (guess_remote) {
534                 struct object_id oid;
535                 const char *remote =
536                         unique_tracking_name(*new_branch, &oid, NULL);
537                 return remote;
538         }
539         return NULL;
540 }
541
542 static int add(int ac, const char **av, const char *prefix)
543 {
544         struct add_opts opts;
545         const char *new_branch_force = NULL;
546         char *path;
547         const char *branch;
548         const char *new_branch = NULL;
549         const char *opt_track = NULL;
550         struct option options[] = {
551                 OPT__FORCE(&opts.force,
552                            N_("checkout <branch> even if already checked out in other worktree"),
553                            PARSE_OPT_NOCOMPLETE),
554                 OPT_STRING('b', NULL, &new_branch, N_("branch"),
555                            N_("create a new branch")),
556                 OPT_STRING('B', NULL, &new_branch_force, N_("branch"),
557                            N_("create or reset a branch")),
558                 OPT_BOOL('d', "detach", &opts.detach, N_("detach HEAD at named commit")),
559                 OPT_BOOL(0, "checkout", &opts.checkout, N_("populate the new working tree")),
560                 OPT_BOOL(0, "lock", &opts.keep_locked, N_("keep the new working tree locked")),
561                 OPT__QUIET(&opts.quiet, N_("suppress progress reporting")),
562                 OPT_PASSTHRU(0, "track", &opt_track, NULL,
563                              N_("set up tracking mode (see git-branch(1))"),
564                              PARSE_OPT_NOARG | PARSE_OPT_OPTARG),
565                 OPT_BOOL(0, "guess-remote", &guess_remote,
566                          N_("try to match the new branch name with a remote-tracking branch")),
567                 OPT_END()
568         };
569
570         memset(&opts, 0, sizeof(opts));
571         opts.checkout = 1;
572         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
573         if (!!opts.detach + !!new_branch + !!new_branch_force > 1)
574                 die(_("-b, -B, and --detach are mutually exclusive"));
575         if (ac < 1 || ac > 2)
576                 usage_with_options(worktree_usage, options);
577
578         path = prefix_filename(prefix, av[0]);
579         branch = ac < 2 ? "HEAD" : av[1];
580
581         if (!strcmp(branch, "-"))
582                 branch = "@{-1}";
583
584         if (new_branch_force) {
585                 struct strbuf symref = STRBUF_INIT;
586
587                 new_branch = new_branch_force;
588
589                 if (!opts.force &&
590                     !strbuf_check_branch_ref(&symref, new_branch) &&
591                     ref_exists(symref.buf))
592                         die_if_checked_out(symref.buf, 0);
593                 strbuf_release(&symref);
594         }
595
596         if (ac < 2 && !new_branch && !opts.detach) {
597                 const char *s = dwim_branch(path, &new_branch);
598                 if (s)
599                         branch = s;
600         }
601
602         if (ac == 2 && !new_branch && !opts.detach) {
603                 struct object_id oid;
604                 struct commit *commit;
605                 const char *remote;
606
607                 commit = lookup_commit_reference_by_name(branch);
608                 if (!commit) {
609                         remote = unique_tracking_name(branch, &oid, NULL);
610                         if (remote) {
611                                 new_branch = branch;
612                                 branch = remote;
613                         }
614                 }
615         }
616         if (!opts.quiet)
617                 print_preparing_worktree_line(opts.detach, branch, new_branch, !!new_branch_force);
618
619         if (new_branch) {
620                 struct child_process cp = CHILD_PROCESS_INIT;
621                 cp.git_cmd = 1;
622                 strvec_push(&cp.args, "branch");
623                 if (new_branch_force)
624                         strvec_push(&cp.args, "--force");
625                 if (opts.quiet)
626                         strvec_push(&cp.args, "--quiet");
627                 strvec_push(&cp.args, new_branch);
628                 strvec_push(&cp.args, branch);
629                 if (opt_track)
630                         strvec_push(&cp.args, opt_track);
631                 if (run_command(&cp))
632                         return -1;
633                 branch = new_branch;
634         } else if (opt_track) {
635                 die(_("--[no-]track can only be used if a new branch is created"));
636         }
637
638         UNLEAK(path);
639         UNLEAK(opts);
640         return add_worktree(path, branch, &opts);
641 }
642
643 static void show_worktree_porcelain(struct worktree *wt)
644 {
645         printf("worktree %s\n", wt->path);
646         if (wt->is_bare)
647                 printf("bare\n");
648         else {
649                 printf("HEAD %s\n", oid_to_hex(&wt->head_oid));
650                 if (wt->is_detached)
651                         printf("detached\n");
652                 else if (wt->head_ref)
653                         printf("branch %s\n", wt->head_ref);
654         }
655         printf("\n");
656 }
657
658 static void show_worktree(struct worktree *wt, int path_maxlen, int abbrev_len)
659 {
660         struct strbuf sb = STRBUF_INIT;
661         int cur_path_len = strlen(wt->path);
662         int path_adj = cur_path_len - utf8_strwidth(wt->path);
663
664         strbuf_addf(&sb, "%-*s ", 1 + path_maxlen + path_adj, wt->path);
665         if (wt->is_bare)
666                 strbuf_addstr(&sb, "(bare)");
667         else {
668                 strbuf_addf(&sb, "%-*s ", abbrev_len,
669                                 find_unique_abbrev(&wt->head_oid, DEFAULT_ABBREV));
670                 if (wt->is_detached)
671                         strbuf_addstr(&sb, "(detached HEAD)");
672                 else if (wt->head_ref) {
673                         char *ref = shorten_unambiguous_ref(wt->head_ref, 0);
674                         strbuf_addf(&sb, "[%s]", ref);
675                         free(ref);
676                 } else
677                         strbuf_addstr(&sb, "(error)");
678         }
679
680         if (!is_main_worktree(wt) && worktree_lock_reason(wt))
681                 strbuf_addstr(&sb, " locked");
682
683         printf("%s\n", sb.buf);
684         strbuf_release(&sb);
685 }
686
687 static void measure_widths(struct worktree **wt, int *abbrev, int *maxlen)
688 {
689         int i;
690
691         for (i = 0; wt[i]; i++) {
692                 int sha1_len;
693                 int path_len = strlen(wt[i]->path);
694
695                 if (path_len > *maxlen)
696                         *maxlen = path_len;
697                 sha1_len = strlen(find_unique_abbrev(&wt[i]->head_oid, *abbrev));
698                 if (sha1_len > *abbrev)
699                         *abbrev = sha1_len;
700         }
701 }
702
703 static int pathcmp(const void *a_, const void *b_)
704 {
705         const struct worktree *const *a = a_;
706         const struct worktree *const *b = b_;
707         return fspathcmp((*a)->path, (*b)->path);
708 }
709
710 static void pathsort(struct worktree **wt)
711 {
712         int n = 0;
713         struct worktree **p = wt;
714
715         while (*p++)
716                 n++;
717         QSORT(wt, n, pathcmp);
718 }
719
720 static int list(int ac, const char **av, const char *prefix)
721 {
722         int porcelain = 0;
723
724         struct option options[] = {
725                 OPT_BOOL(0, "porcelain", &porcelain, N_("machine-readable output")),
726                 OPT_END()
727         };
728
729         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
730         if (ac)
731                 usage_with_options(worktree_usage, options);
732         else {
733                 struct worktree **worktrees = get_worktrees();
734                 int path_maxlen = 0, abbrev = DEFAULT_ABBREV, i;
735
736                 /* sort worktrees by path but keep main worktree at top */
737                 pathsort(worktrees + 1);
738
739                 if (!porcelain)
740                         measure_widths(worktrees, &abbrev, &path_maxlen);
741
742                 for (i = 0; worktrees[i]; i++) {
743                         if (porcelain)
744                                 show_worktree_porcelain(worktrees[i]);
745                         else
746                                 show_worktree(worktrees[i], path_maxlen, abbrev);
747                 }
748                 free_worktrees(worktrees);
749         }
750         return 0;
751 }
752
753 static int lock_worktree(int ac, const char **av, const char *prefix)
754 {
755         const char *reason = "", *old_reason;
756         struct option options[] = {
757                 OPT_STRING(0, "reason", &reason, N_("string"),
758                            N_("reason for locking")),
759                 OPT_END()
760         };
761         struct worktree **worktrees, *wt;
762
763         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
764         if (ac != 1)
765                 usage_with_options(worktree_usage, options);
766
767         worktrees = get_worktrees();
768         wt = find_worktree(worktrees, prefix, av[0]);
769         if (!wt)
770                 die(_("'%s' is not a working tree"), av[0]);
771         if (is_main_worktree(wt))
772                 die(_("The main working tree cannot be locked or unlocked"));
773
774         old_reason = worktree_lock_reason(wt);
775         if (old_reason) {
776                 if (*old_reason)
777                         die(_("'%s' is already locked, reason: %s"),
778                             av[0], old_reason);
779                 die(_("'%s' is already locked"), av[0]);
780         }
781
782         write_file(git_common_path("worktrees/%s/locked", wt->id),
783                    "%s", reason);
784         free_worktrees(worktrees);
785         return 0;
786 }
787
788 static int unlock_worktree(int ac, const char **av, const char *prefix)
789 {
790         struct option options[] = {
791                 OPT_END()
792         };
793         struct worktree **worktrees, *wt;
794         int ret;
795
796         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
797         if (ac != 1)
798                 usage_with_options(worktree_usage, options);
799
800         worktrees = get_worktrees();
801         wt = find_worktree(worktrees, prefix, av[0]);
802         if (!wt)
803                 die(_("'%s' is not a working tree"), av[0]);
804         if (is_main_worktree(wt))
805                 die(_("The main working tree cannot be locked or unlocked"));
806         if (!worktree_lock_reason(wt))
807                 die(_("'%s' is not locked"), av[0]);
808         ret = unlink_or_warn(git_common_path("worktrees/%s/locked", wt->id));
809         free_worktrees(worktrees);
810         return ret;
811 }
812
813 static void validate_no_submodules(const struct worktree *wt)
814 {
815         struct index_state istate = { NULL };
816         struct strbuf path = STRBUF_INIT;
817         int i, found_submodules = 0;
818
819         if (is_directory(worktree_git_path(wt, "modules"))) {
820                 /*
821                  * There could be false positives, e.g. the "modules"
822                  * directory exists but is empty. But it's a rare case and
823                  * this simpler check is probably good enough for now.
824                  */
825                 found_submodules = 1;
826         } else if (read_index_from(&istate, worktree_git_path(wt, "index"),
827                                    get_worktree_git_dir(wt)) > 0) {
828                 for (i = 0; i < istate.cache_nr; i++) {
829                         struct cache_entry *ce = istate.cache[i];
830                         int err;
831
832                         if (!S_ISGITLINK(ce->ce_mode))
833                                 continue;
834
835                         strbuf_reset(&path);
836                         strbuf_addf(&path, "%s/%s", wt->path, ce->name);
837                         if (!is_submodule_populated_gently(path.buf, &err))
838                                 continue;
839
840                         found_submodules = 1;
841                         break;
842                 }
843         }
844         discard_index(&istate);
845         strbuf_release(&path);
846
847         if (found_submodules)
848                 die(_("working trees containing submodules cannot be moved or removed"));
849 }
850
851 static int move_worktree(int ac, const char **av, const char *prefix)
852 {
853         int force = 0;
854         struct option options[] = {
855                 OPT__FORCE(&force,
856                          N_("force move even if worktree is dirty or locked"),
857                          PARSE_OPT_NOCOMPLETE),
858                 OPT_END()
859         };
860         struct worktree **worktrees, *wt;
861         struct strbuf dst = STRBUF_INIT;
862         struct strbuf errmsg = STRBUF_INIT;
863         const char *reason = NULL;
864         char *path;
865
866         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
867         if (ac != 2)
868                 usage_with_options(worktree_usage, options);
869
870         path = prefix_filename(prefix, av[1]);
871         strbuf_addstr(&dst, path);
872         free(path);
873
874         worktrees = get_worktrees();
875         wt = find_worktree(worktrees, prefix, av[0]);
876         if (!wt)
877                 die(_("'%s' is not a working tree"), av[0]);
878         if (is_main_worktree(wt))
879                 die(_("'%s' is a main working tree"), av[0]);
880         if (is_directory(dst.buf)) {
881                 const char *sep = find_last_dir_sep(wt->path);
882
883                 if (!sep)
884                         die(_("could not figure out destination name from '%s'"),
885                             wt->path);
886                 strbuf_trim_trailing_dir_sep(&dst);
887                 strbuf_addstr(&dst, sep);
888         }
889         check_candidate_path(dst.buf, force, worktrees, "move");
890
891         validate_no_submodules(wt);
892
893         if (force < 2)
894                 reason = worktree_lock_reason(wt);
895         if (reason) {
896                 if (*reason)
897                         die(_("cannot move a locked working tree, lock reason: %s\nuse 'move -f -f' to override or unlock first"),
898                             reason);
899                 die(_("cannot move a locked working tree;\nuse 'move -f -f' to override or unlock first"));
900         }
901         if (validate_worktree(wt, &errmsg, 0))
902                 die(_("validation failed, cannot move working tree: %s"),
903                     errmsg.buf);
904         strbuf_release(&errmsg);
905
906         if (rename(wt->path, dst.buf) == -1)
907                 die_errno(_("failed to move '%s' to '%s'"), wt->path, dst.buf);
908
909         update_worktree_location(wt, dst.buf);
910
911         strbuf_release(&dst);
912         free_worktrees(worktrees);
913         return 0;
914 }
915
916 /*
917  * Note, "git status --porcelain" is used to determine if it's safe to
918  * delete a whole worktree. "git status" does not ignore user
919  * configuration, so if a normal "git status" shows "clean" for the
920  * user, then it's ok to remove it.
921  *
922  * This assumption may be a bad one. We may want to ignore
923  * (potentially bad) user settings and only delete a worktree when
924  * it's absolutely safe to do so from _our_ point of view because we
925  * know better.
926  */
927 static void check_clean_worktree(struct worktree *wt,
928                                  const char *original_path)
929 {
930         struct child_process cp;
931         char buf[1];
932         int ret;
933
934         /*
935          * Until we sort this out, all submodules are "dirty" and
936          * will abort this function.
937          */
938         validate_no_submodules(wt);
939
940         child_process_init(&cp);
941         strvec_pushf(&cp.env_array, "%s=%s/.git",
942                      GIT_DIR_ENVIRONMENT, wt->path);
943         strvec_pushf(&cp.env_array, "%s=%s",
944                      GIT_WORK_TREE_ENVIRONMENT, wt->path);
945         strvec_pushl(&cp.args, "status",
946                      "--porcelain", "--ignore-submodules=none",
947                      NULL);
948         cp.git_cmd = 1;
949         cp.dir = wt->path;
950         cp.out = -1;
951         ret = start_command(&cp);
952         if (ret)
953                 die_errno(_("failed to run 'git status' on '%s'"),
954                           original_path);
955         ret = xread(cp.out, buf, sizeof(buf));
956         if (ret)
957                 die(_("'%s' contains modified or untracked files, use --force to delete it"),
958                     original_path);
959         close(cp.out);
960         ret = finish_command(&cp);
961         if (ret)
962                 die_errno(_("failed to run 'git status' on '%s', code %d"),
963                           original_path, ret);
964 }
965
966 static int delete_git_work_tree(struct worktree *wt)
967 {
968         struct strbuf sb = STRBUF_INIT;
969         int ret = 0;
970
971         strbuf_addstr(&sb, wt->path);
972         if (remove_dir_recursively(&sb, 0)) {
973                 error_errno(_("failed to delete '%s'"), sb.buf);
974                 ret = -1;
975         }
976         strbuf_release(&sb);
977         return ret;
978 }
979
980 static int remove_worktree(int ac, const char **av, const char *prefix)
981 {
982         int force = 0;
983         struct option options[] = {
984                 OPT__FORCE(&force,
985                          N_("force removal even if worktree is dirty or locked"),
986                          PARSE_OPT_NOCOMPLETE),
987                 OPT_END()
988         };
989         struct worktree **worktrees, *wt;
990         struct strbuf errmsg = STRBUF_INIT;
991         const char *reason = NULL;
992         int ret = 0;
993
994         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
995         if (ac != 1)
996                 usage_with_options(worktree_usage, options);
997
998         worktrees = get_worktrees();
999         wt = find_worktree(worktrees, prefix, av[0]);
1000         if (!wt)
1001                 die(_("'%s' is not a working tree"), av[0]);
1002         if (is_main_worktree(wt))
1003                 die(_("'%s' is a main working tree"), av[0]);
1004         if (force < 2)
1005                 reason = worktree_lock_reason(wt);
1006         if (reason) {
1007                 if (*reason)
1008                         die(_("cannot remove a locked working tree, lock reason: %s\nuse 'remove -f -f' to override or unlock first"),
1009                             reason);
1010                 die(_("cannot remove a locked working tree;\nuse 'remove -f -f' to override or unlock first"));
1011         }
1012         if (validate_worktree(wt, &errmsg, WT_VALIDATE_WORKTREE_MISSING_OK))
1013                 die(_("validation failed, cannot remove working tree: %s"),
1014                     errmsg.buf);
1015         strbuf_release(&errmsg);
1016
1017         if (file_exists(wt->path)) {
1018                 if (!force)
1019                         check_clean_worktree(wt, av[0]);
1020
1021                 ret |= delete_git_work_tree(wt);
1022         }
1023         /*
1024          * continue on even if ret is non-zero, there's no going back
1025          * from here.
1026          */
1027         ret |= delete_git_dir(wt->id);
1028         delete_worktrees_dir_if_empty();
1029
1030         free_worktrees(worktrees);
1031         return ret;
1032 }
1033
1034 static void report_repair(int iserr, const char *path, const char *msg, void *cb_data)
1035 {
1036         if (!iserr) {
1037                 printf_ln(_("repair: %s: %s"), msg, path);
1038         } else {
1039                 int *exit_status = (int *)cb_data;
1040                 fprintf_ln(stderr, _("error: %s: %s"), msg, path);
1041                 *exit_status = 1;
1042         }
1043 }
1044
1045 static int repair(int ac, const char **av, const char *prefix)
1046 {
1047         const char **p;
1048         const char *self[] = { ".", NULL };
1049         struct option options[] = {
1050                 OPT_END()
1051         };
1052         int rc = 0;
1053
1054         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
1055         p = ac > 0 ? av : self;
1056         for (; *p; p++)
1057                 repair_worktree_at_path(*p, report_repair, &rc);
1058         repair_worktrees(report_repair, &rc);
1059         return rc;
1060 }
1061
1062 int cmd_worktree(int ac, const char **av, const char *prefix)
1063 {
1064         struct option options[] = {
1065                 OPT_END()
1066         };
1067
1068         git_config(git_worktree_config, NULL);
1069
1070         if (ac < 2)
1071                 usage_with_options(worktree_usage, options);
1072         if (!prefix)
1073                 prefix = "";
1074         if (!strcmp(av[1], "add"))
1075                 return add(ac - 1, av + 1, prefix);
1076         if (!strcmp(av[1], "prune"))
1077                 return prune(ac - 1, av + 1, prefix);
1078         if (!strcmp(av[1], "list"))
1079                 return list(ac - 1, av + 1, prefix);
1080         if (!strcmp(av[1], "lock"))
1081                 return lock_worktree(ac - 1, av + 1, prefix);
1082         if (!strcmp(av[1], "unlock"))
1083                 return unlock_worktree(ac - 1, av + 1, prefix);
1084         if (!strcmp(av[1], "move"))
1085                 return move_worktree(ac - 1, av + 1, prefix);
1086         if (!strcmp(av[1], "remove"))
1087                 return remove_worktree(ac - 1, av + 1, prefix);
1088         if (!strcmp(av[1], "repair"))
1089                 return repair(ac - 1, av + 1, prefix);
1090         usage_with_options(worktree_usage, options);
1091 }