Merge branch 'sb/config-write-fix'
[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 "argv-array.h"
8 #include "branch.h"
9 #include "refs.h"
10 #include "run-command.h"
11 #include "sigchain.h"
12 #include "refs.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 checkout;
31         int keep_locked;
32 };
33
34 static int show_only;
35 static int verbose;
36 static int guess_remote;
37 static timestamp_t expire;
38
39 static int git_worktree_config(const char *var, const char *value, void *cb)
40 {
41         if (!strcmp(var, "worktree.guessremote")) {
42                 guess_remote = git_config_bool(var, value);
43                 return 0;
44         }
45
46         return git_default_config(var, value, cb);
47 }
48
49 static int prune_worktree(const char *id, struct strbuf *reason)
50 {
51         struct stat st;
52         char *path;
53         int fd;
54         size_t len;
55         ssize_t read_result;
56
57         if (!is_directory(git_path("worktrees/%s", id))) {
58                 strbuf_addf(reason, _("Removing worktrees/%s: not a valid directory"), id);
59                 return 1;
60         }
61         if (file_exists(git_path("worktrees/%s/locked", id)))
62                 return 0;
63         if (stat(git_path("worktrees/%s/gitdir", id), &st)) {
64                 strbuf_addf(reason, _("Removing worktrees/%s: gitdir file does not exist"), id);
65                 return 1;
66         }
67         fd = open(git_path("worktrees/%s/gitdir", id), O_RDONLY);
68         if (fd < 0) {
69                 strbuf_addf(reason, _("Removing worktrees/%s: unable to read gitdir file (%s)"),
70                             id, strerror(errno));
71                 return 1;
72         }
73         len = xsize_t(st.st_size);
74         path = xmallocz(len);
75
76         read_result = read_in_full(fd, path, len);
77         if (read_result < 0) {
78                 strbuf_addf(reason, _("Removing worktrees/%s: unable to read gitdir file (%s)"),
79                             id, strerror(errno));
80                 close(fd);
81                 free(path);
82                 return 1;
83         }
84         close(fd);
85
86         if (read_result != len) {
87                 strbuf_addf(reason,
88                             _("Removing worktrees/%s: short read (expected %"PRIuMAX" bytes, read %"PRIuMAX")"),
89                             id, (uintmax_t)len, (uintmax_t)read_result);
90                 free(path);
91                 return 1;
92         }
93         while (len && (path[len - 1] == '\n' || path[len - 1] == '\r'))
94                 len--;
95         if (!len) {
96                 strbuf_addf(reason, _("Removing worktrees/%s: invalid gitdir file"), id);
97                 free(path);
98                 return 1;
99         }
100         path[len] = '\0';
101         if (!file_exists(path)) {
102                 free(path);
103                 if (stat(git_path("worktrees/%s/index", id), &st) ||
104                     st.st_mtime <= expire) {
105                         strbuf_addf(reason, _("Removing worktrees/%s: gitdir file points to non-existent location"), id);
106                         return 1;
107                 } else {
108                         return 0;
109                 }
110         }
111         free(path);
112         return 0;
113 }
114
115 static void prune_worktrees(void)
116 {
117         struct strbuf reason = STRBUF_INIT;
118         struct strbuf path = STRBUF_INIT;
119         DIR *dir = opendir(git_path("worktrees"));
120         struct dirent *d;
121         int ret;
122         if (!dir)
123                 return;
124         while ((d = readdir(dir)) != NULL) {
125                 if (is_dot_or_dotdot(d->d_name))
126                         continue;
127                 strbuf_reset(&reason);
128                 if (!prune_worktree(d->d_name, &reason))
129                         continue;
130                 if (show_only || verbose)
131                         printf("%s\n", reason.buf);
132                 if (show_only)
133                         continue;
134                 git_path_buf(&path, "worktrees/%s", d->d_name);
135                 ret = remove_dir_recursively(&path, 0);
136                 if (ret < 0 && errno == ENOTDIR)
137                         ret = unlink(path.buf);
138                 if (ret)
139                         error_errno(_("failed to remove '%s'"), path.buf);
140         }
141         closedir(dir);
142         if (!show_only)
143                 rmdir(git_path("worktrees"));
144         strbuf_release(&reason);
145         strbuf_release(&path);
146 }
147
148 static int prune(int ac, const char **av, const char *prefix)
149 {
150         struct option options[] = {
151                 OPT__DRY_RUN(&show_only, N_("do not remove, show only")),
152                 OPT__VERBOSE(&verbose, N_("report pruned working trees")),
153                 OPT_EXPIRY_DATE(0, "expire", &expire,
154                                 N_("expire working trees older than <time>")),
155                 OPT_END()
156         };
157
158         expire = TIME_MAX;
159         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
160         if (ac)
161                 usage_with_options(worktree_usage, options);
162         prune_worktrees();
163         return 0;
164 }
165
166 static char *junk_work_tree;
167 static char *junk_git_dir;
168 static int is_junk;
169 static pid_t junk_pid;
170
171 static void remove_junk(void)
172 {
173         struct strbuf sb = STRBUF_INIT;
174         if (!is_junk || getpid() != junk_pid)
175                 return;
176         if (junk_git_dir) {
177                 strbuf_addstr(&sb, junk_git_dir);
178                 remove_dir_recursively(&sb, 0);
179                 strbuf_reset(&sb);
180         }
181         if (junk_work_tree) {
182                 strbuf_addstr(&sb, junk_work_tree);
183                 remove_dir_recursively(&sb, 0);
184         }
185         strbuf_release(&sb);
186 }
187
188 static void remove_junk_on_signal(int signo)
189 {
190         remove_junk();
191         sigchain_pop(signo);
192         raise(signo);
193 }
194
195 static const char *worktree_basename(const char *path, int *olen)
196 {
197         const char *name;
198         int len;
199
200         len = strlen(path);
201         while (len && is_dir_sep(path[len - 1]))
202                 len--;
203
204         for (name = path + len - 1; name > path; name--)
205                 if (is_dir_sep(*name)) {
206                         name++;
207                         break;
208                 }
209
210         *olen = len;
211         return name;
212 }
213
214 static int add_worktree(const char *path, const char *refname,
215                         const struct add_opts *opts)
216 {
217         struct strbuf sb_git = STRBUF_INIT, sb_repo = STRBUF_INIT;
218         struct strbuf sb = STRBUF_INIT;
219         const char *name;
220         struct stat st;
221         struct child_process cp = CHILD_PROCESS_INIT;
222         struct argv_array child_env = ARGV_ARRAY_INIT;
223         int counter = 0, len, ret;
224         struct strbuf symref = STRBUF_INIT;
225         struct commit *commit = NULL;
226         int is_branch = 0;
227
228         if (file_exists(path) && !is_empty_dir(path))
229                 die(_("'%s' already exists"), path);
230
231         /* is 'refname' a branch or commit? */
232         if (!opts->detach && !strbuf_check_branch_ref(&symref, refname) &&
233             ref_exists(symref.buf)) {
234                 is_branch = 1;
235                 if (!opts->force)
236                         die_if_checked_out(symref.buf, 0);
237         }
238         commit = lookup_commit_reference_by_name(refname);
239         if (!commit)
240                 die(_("invalid reference: %s"), refname);
241
242         name = worktree_basename(path, &len);
243         git_path_buf(&sb_repo, "worktrees/%.*s", (int)(path + len - name), name);
244         len = sb_repo.len;
245         if (safe_create_leading_directories_const(sb_repo.buf))
246                 die_errno(_("could not create leading directories of '%s'"),
247                           sb_repo.buf);
248         while (!stat(sb_repo.buf, &st)) {
249                 counter++;
250                 strbuf_setlen(&sb_repo, len);
251                 strbuf_addf(&sb_repo, "%d", counter);
252         }
253         name = strrchr(sb_repo.buf, '/') + 1;
254
255         junk_pid = getpid();
256         atexit(remove_junk);
257         sigchain_push_common(remove_junk_on_signal);
258
259         if (mkdir(sb_repo.buf, 0777))
260                 die_errno(_("could not create directory of '%s'"), sb_repo.buf);
261         junk_git_dir = xstrdup(sb_repo.buf);
262         is_junk = 1;
263
264         /*
265          * lock the incomplete repo so prune won't delete it, unlock
266          * after the preparation is over.
267          */
268         strbuf_addf(&sb, "%s/locked", sb_repo.buf);
269         if (!opts->keep_locked)
270                 write_file(sb.buf, "initializing");
271         else
272                 write_file(sb.buf, "added with --lock");
273
274         strbuf_addf(&sb_git, "%s/.git", path);
275         if (safe_create_leading_directories_const(sb_git.buf))
276                 die_errno(_("could not create leading directories of '%s'"),
277                           sb_git.buf);
278         junk_work_tree = xstrdup(path);
279
280         strbuf_reset(&sb);
281         strbuf_addf(&sb, "%s/gitdir", sb_repo.buf);
282         write_file(sb.buf, "%s", real_path(sb_git.buf));
283         write_file(sb_git.buf, "gitdir: %s/worktrees/%s",
284                    real_path(get_git_common_dir()), name);
285         /*
286          * This is to keep resolve_ref() happy. We need a valid HEAD
287          * or is_git_directory() will reject the directory. Any value which
288          * looks like an object ID will do since it will be immediately
289          * replaced by the symbolic-ref or update-ref invocation in the new
290          * worktree.
291          */
292         strbuf_reset(&sb);
293         strbuf_addf(&sb, "%s/HEAD", sb_repo.buf);
294         write_file(sb.buf, "%s", sha1_to_hex(null_sha1));
295         strbuf_reset(&sb);
296         strbuf_addf(&sb, "%s/commondir", sb_repo.buf);
297         write_file(sb.buf, "../..");
298
299         argv_array_pushf(&child_env, "%s=%s", GIT_DIR_ENVIRONMENT, sb_git.buf);
300         argv_array_pushf(&child_env, "%s=%s", GIT_WORK_TREE_ENVIRONMENT, path);
301         cp.git_cmd = 1;
302
303         if (!is_branch)
304                 argv_array_pushl(&cp.args, "update-ref", "HEAD",
305                                  oid_to_hex(&commit->object.oid), NULL);
306         else
307                 argv_array_pushl(&cp.args, "symbolic-ref", "HEAD",
308                                  symref.buf, NULL);
309         cp.env = child_env.argv;
310         ret = run_command(&cp);
311         if (ret)
312                 goto done;
313
314         if (opts->checkout) {
315                 cp.argv = NULL;
316                 argv_array_clear(&cp.args);
317                 argv_array_pushl(&cp.args, "reset", "--hard", NULL);
318                 cp.env = child_env.argv;
319                 ret = run_command(&cp);
320                 if (ret)
321                         goto done;
322         }
323
324         is_junk = 0;
325         FREE_AND_NULL(junk_work_tree);
326         FREE_AND_NULL(junk_git_dir);
327
328 done:
329         if (ret || !opts->keep_locked) {
330                 strbuf_reset(&sb);
331                 strbuf_addf(&sb, "%s/locked", sb_repo.buf);
332                 unlink_or_warn(sb.buf);
333         }
334
335         /*
336          * Hook failure does not warrant worktree deletion, so run hook after
337          * is_junk is cleared, but do return appropriate code when hook fails.
338          */
339         if (!ret && opts->checkout) {
340                 const char *hook = find_hook("post-checkout");
341                 if (hook) {
342                         const char *env[] = { "GIT_DIR", "GIT_WORK_TREE", NULL };
343                         cp.git_cmd = 0;
344                         cp.no_stdin = 1;
345                         cp.stdout_to_stderr = 1;
346                         cp.dir = path;
347                         cp.env = env;
348                         cp.argv = NULL;
349                         argv_array_pushl(&cp.args, absolute_path(hook),
350                                          oid_to_hex(&null_oid),
351                                          oid_to_hex(&commit->object.oid),
352                                          "1", NULL);
353                         ret = run_command(&cp);
354                 }
355         }
356
357         argv_array_clear(&child_env);
358         strbuf_release(&sb);
359         strbuf_release(&symref);
360         strbuf_release(&sb_repo);
361         strbuf_release(&sb_git);
362         return ret;
363 }
364
365 static void print_preparing_worktree_line(int detach,
366                                           const char *branch,
367                                           const char *new_branch,
368                                           int force_new_branch)
369 {
370         if (force_new_branch) {
371                 struct commit *commit = lookup_commit_reference_by_name(new_branch);
372                 if (!commit)
373                         printf_ln(_("Preparing worktree (new branch '%s')"), new_branch);
374                 else
375                         printf_ln(_("Preparing worktree (resetting branch '%s'; was at %s)"),
376                                   new_branch,
377                                   find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV));
378         } else if (new_branch) {
379                 printf_ln(_("Preparing worktree (new branch '%s')"), new_branch);
380         } else {
381                 struct strbuf s = STRBUF_INIT;
382                 if (!detach && !strbuf_check_branch_ref(&s, branch) &&
383                     ref_exists(s.buf))
384                         printf_ln(_("Preparing worktree (checking out '%s')"),
385                                   branch);
386                 else {
387                         struct commit *commit = lookup_commit_reference_by_name(branch);
388                         if (!commit)
389                                 die(_("invalid reference: %s"), branch);
390                         printf_ln(_("Preparing worktree (detached HEAD %s)"),
391                                   find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV));
392                 }
393                 strbuf_release(&s);
394         }
395 }
396
397 static const char *dwim_branch(const char *path, const char **new_branch)
398 {
399         int n;
400         const char *s = worktree_basename(path, &n);
401         const char *branchname = xstrndup(s, n);
402         struct strbuf ref = STRBUF_INIT;
403
404         UNLEAK(branchname);
405         if (!strbuf_check_branch_ref(&ref, branchname) &&
406             ref_exists(ref.buf)) {
407                 strbuf_release(&ref);
408                 return branchname;
409         }
410
411         *new_branch = branchname;
412         if (guess_remote) {
413                 struct object_id oid;
414                 const char *remote =
415                         unique_tracking_name(*new_branch, &oid, NULL);
416                 return remote;
417         }
418         return NULL;
419 }
420
421 static int add(int ac, const char **av, const char *prefix)
422 {
423         struct add_opts opts;
424         const char *new_branch_force = NULL;
425         char *path;
426         const char *branch;
427         const char *new_branch = NULL;
428         const char *opt_track = NULL;
429         struct option options[] = {
430                 OPT__FORCE(&opts.force,
431                            N_("checkout <branch> even if already checked out in other worktree"),
432                            PARSE_OPT_NOCOMPLETE),
433                 OPT_STRING('b', NULL, &new_branch, N_("branch"),
434                            N_("create a new branch")),
435                 OPT_STRING('B', NULL, &new_branch_force, N_("branch"),
436                            N_("create or reset a branch")),
437                 OPT_BOOL(0, "detach", &opts.detach, N_("detach HEAD at named commit")),
438                 OPT_BOOL(0, "checkout", &opts.checkout, N_("populate the new working tree")),
439                 OPT_BOOL(0, "lock", &opts.keep_locked, N_("keep the new working tree locked")),
440                 OPT_PASSTHRU(0, "track", &opt_track, NULL,
441                              N_("set up tracking mode (see git-branch(1))"),
442                              PARSE_OPT_NOARG | PARSE_OPT_OPTARG),
443                 OPT_BOOL(0, "guess-remote", &guess_remote,
444                          N_("try to match the new branch name with a remote-tracking branch")),
445                 OPT_END()
446         };
447
448         memset(&opts, 0, sizeof(opts));
449         opts.checkout = 1;
450         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
451         if (!!opts.detach + !!new_branch + !!new_branch_force > 1)
452                 die(_("-b, -B, and --detach are mutually exclusive"));
453         if (ac < 1 || ac > 2)
454                 usage_with_options(worktree_usage, options);
455
456         path = prefix_filename(prefix, av[0]);
457         branch = ac < 2 ? "HEAD" : av[1];
458
459         if (!strcmp(branch, "-"))
460                 branch = "@{-1}";
461
462         if (new_branch_force) {
463                 struct strbuf symref = STRBUF_INIT;
464
465                 new_branch = new_branch_force;
466
467                 if (!opts.force &&
468                     !strbuf_check_branch_ref(&symref, new_branch) &&
469                     ref_exists(symref.buf))
470                         die_if_checked_out(symref.buf, 0);
471                 strbuf_release(&symref);
472         }
473
474         if (ac < 2 && !new_branch && !opts.detach) {
475                 const char *s = dwim_branch(path, &new_branch);
476                 if (s)
477                         branch = s;
478         }
479
480         if (ac == 2 && !new_branch && !opts.detach) {
481                 struct object_id oid;
482                 struct commit *commit;
483                 const char *remote;
484
485                 commit = lookup_commit_reference_by_name(branch);
486                 if (!commit) {
487                         remote = unique_tracking_name(branch, &oid, NULL);
488                         if (remote) {
489                                 new_branch = branch;
490                                 branch = remote;
491                         }
492                 }
493         }
494
495         print_preparing_worktree_line(opts.detach, branch, new_branch, !!new_branch_force);
496
497         if (new_branch) {
498                 struct child_process cp = CHILD_PROCESS_INIT;
499                 cp.git_cmd = 1;
500                 argv_array_push(&cp.args, "branch");
501                 if (new_branch_force)
502                         argv_array_push(&cp.args, "--force");
503                 argv_array_push(&cp.args, new_branch);
504                 argv_array_push(&cp.args, branch);
505                 if (opt_track)
506                         argv_array_push(&cp.args, opt_track);
507                 if (run_command(&cp))
508                         return -1;
509                 branch = new_branch;
510         } else if (opt_track) {
511                 die(_("--[no-]track can only be used if a new branch is created"));
512         }
513
514         UNLEAK(path);
515         UNLEAK(opts);
516         return add_worktree(path, branch, &opts);
517 }
518
519 static void show_worktree_porcelain(struct worktree *wt)
520 {
521         printf("worktree %s\n", wt->path);
522         if (wt->is_bare)
523                 printf("bare\n");
524         else {
525                 printf("HEAD %s\n", oid_to_hex(&wt->head_oid));
526                 if (wt->is_detached)
527                         printf("detached\n");
528                 else if (wt->head_ref)
529                         printf("branch %s\n", wt->head_ref);
530         }
531         printf("\n");
532 }
533
534 static void show_worktree(struct worktree *wt, int path_maxlen, int abbrev_len)
535 {
536         struct strbuf sb = STRBUF_INIT;
537         int cur_path_len = strlen(wt->path);
538         int path_adj = cur_path_len - utf8_strwidth(wt->path);
539
540         strbuf_addf(&sb, "%-*s ", 1 + path_maxlen + path_adj, wt->path);
541         if (wt->is_bare)
542                 strbuf_addstr(&sb, "(bare)");
543         else {
544                 strbuf_addf(&sb, "%-*s ", abbrev_len,
545                                 find_unique_abbrev(&wt->head_oid, DEFAULT_ABBREV));
546                 if (wt->is_detached)
547                         strbuf_addstr(&sb, "(detached HEAD)");
548                 else if (wt->head_ref) {
549                         char *ref = shorten_unambiguous_ref(wt->head_ref, 0);
550                         strbuf_addf(&sb, "[%s]", ref);
551                         free(ref);
552                 } else
553                         strbuf_addstr(&sb, "(error)");
554         }
555         printf("%s\n", sb.buf);
556
557         strbuf_release(&sb);
558 }
559
560 static void measure_widths(struct worktree **wt, int *abbrev, int *maxlen)
561 {
562         int i;
563
564         for (i = 0; wt[i]; i++) {
565                 int sha1_len;
566                 int path_len = strlen(wt[i]->path);
567
568                 if (path_len > *maxlen)
569                         *maxlen = path_len;
570                 sha1_len = strlen(find_unique_abbrev(&wt[i]->head_oid, *abbrev));
571                 if (sha1_len > *abbrev)
572                         *abbrev = sha1_len;
573         }
574 }
575
576 static int list(int ac, const char **av, const char *prefix)
577 {
578         int porcelain = 0;
579
580         struct option options[] = {
581                 OPT_BOOL(0, "porcelain", &porcelain, N_("machine-readable output")),
582                 OPT_END()
583         };
584
585         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
586         if (ac)
587                 usage_with_options(worktree_usage, options);
588         else {
589                 struct worktree **worktrees = get_worktrees(GWT_SORT_LINKED);
590                 int path_maxlen = 0, abbrev = DEFAULT_ABBREV, i;
591
592                 if (!porcelain)
593                         measure_widths(worktrees, &abbrev, &path_maxlen);
594
595                 for (i = 0; worktrees[i]; i++) {
596                         if (porcelain)
597                                 show_worktree_porcelain(worktrees[i]);
598                         else
599                                 show_worktree(worktrees[i], path_maxlen, abbrev);
600                 }
601                 free_worktrees(worktrees);
602         }
603         return 0;
604 }
605
606 static int lock_worktree(int ac, const char **av, const char *prefix)
607 {
608         const char *reason = "", *old_reason;
609         struct option options[] = {
610                 OPT_STRING(0, "reason", &reason, N_("string"),
611                            N_("reason for locking")),
612                 OPT_END()
613         };
614         struct worktree **worktrees, *wt;
615
616         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
617         if (ac != 1)
618                 usage_with_options(worktree_usage, options);
619
620         worktrees = get_worktrees(0);
621         wt = find_worktree(worktrees, prefix, av[0]);
622         if (!wt)
623                 die(_("'%s' is not a working tree"), av[0]);
624         if (is_main_worktree(wt))
625                 die(_("The main working tree cannot be locked or unlocked"));
626
627         old_reason = is_worktree_locked(wt);
628         if (old_reason) {
629                 if (*old_reason)
630                         die(_("'%s' is already locked, reason: %s"),
631                             av[0], old_reason);
632                 die(_("'%s' is already locked"), av[0]);
633         }
634
635         write_file(git_common_path("worktrees/%s/locked", wt->id),
636                    "%s", reason);
637         free_worktrees(worktrees);
638         return 0;
639 }
640
641 static int unlock_worktree(int ac, const char **av, const char *prefix)
642 {
643         struct option options[] = {
644                 OPT_END()
645         };
646         struct worktree **worktrees, *wt;
647         int ret;
648
649         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
650         if (ac != 1)
651                 usage_with_options(worktree_usage, options);
652
653         worktrees = get_worktrees(0);
654         wt = find_worktree(worktrees, prefix, av[0]);
655         if (!wt)
656                 die(_("'%s' is not a working tree"), av[0]);
657         if (is_main_worktree(wt))
658                 die(_("The main working tree cannot be locked or unlocked"));
659         if (!is_worktree_locked(wt))
660                 die(_("'%s' is not locked"), av[0]);
661         ret = unlink_or_warn(git_common_path("worktrees/%s/locked", wt->id));
662         free_worktrees(worktrees);
663         return ret;
664 }
665
666 static void validate_no_submodules(const struct worktree *wt)
667 {
668         struct index_state istate = { NULL };
669         int i, found_submodules = 0;
670
671         if (read_index_from(&istate, worktree_git_path(wt, "index"),
672                             get_worktree_git_dir(wt)) > 0) {
673                 for (i = 0; i < istate.cache_nr; i++) {
674                         struct cache_entry *ce = istate.cache[i];
675
676                         if (S_ISGITLINK(ce->ce_mode)) {
677                                 found_submodules = 1;
678                                 break;
679                         }
680                 }
681         }
682         discard_index(&istate);
683
684         if (found_submodules)
685                 die(_("working trees containing submodules cannot be moved or removed"));
686 }
687
688 static int move_worktree(int ac, const char **av, const char *prefix)
689 {
690         struct option options[] = {
691                 OPT_END()
692         };
693         struct worktree **worktrees, *wt;
694         struct strbuf dst = STRBUF_INIT;
695         struct strbuf errmsg = STRBUF_INIT;
696         const char *reason;
697         char *path;
698
699         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
700         if (ac != 2)
701                 usage_with_options(worktree_usage, options);
702
703         path = prefix_filename(prefix, av[1]);
704         strbuf_addstr(&dst, path);
705         free(path);
706
707         worktrees = get_worktrees(0);
708         wt = find_worktree(worktrees, prefix, av[0]);
709         if (!wt)
710                 die(_("'%s' is not a working tree"), av[0]);
711         if (is_main_worktree(wt))
712                 die(_("'%s' is a main working tree"), av[0]);
713         if (is_directory(dst.buf)) {
714                 const char *sep = find_last_dir_sep(wt->path);
715
716                 if (!sep)
717                         die(_("could not figure out destination name from '%s'"),
718                             wt->path);
719                 strbuf_trim_trailing_dir_sep(&dst);
720                 strbuf_addstr(&dst, sep);
721         }
722         if (file_exists(dst.buf))
723                 die(_("target '%s' already exists"), dst.buf);
724
725         validate_no_submodules(wt);
726
727         reason = is_worktree_locked(wt);
728         if (reason) {
729                 if (*reason)
730                         die(_("cannot move a locked working tree, lock reason: %s"),
731                             reason);
732                 die(_("cannot move a locked working tree"));
733         }
734         if (validate_worktree(wt, &errmsg, 0))
735                 die(_("validation failed, cannot move working tree: %s"),
736                     errmsg.buf);
737         strbuf_release(&errmsg);
738
739         if (rename(wt->path, dst.buf) == -1)
740                 die_errno(_("failed to move '%s' to '%s'"), wt->path, dst.buf);
741
742         update_worktree_location(wt, dst.buf);
743
744         strbuf_release(&dst);
745         free_worktrees(worktrees);
746         return 0;
747 }
748
749 /*
750  * Note, "git status --porcelain" is used to determine if it's safe to
751  * delete a whole worktree. "git status" does not ignore user
752  * configuration, so if a normal "git status" shows "clean" for the
753  * user, then it's ok to remove it.
754  *
755  * This assumption may be a bad one. We may want to ignore
756  * (potentially bad) user settings and only delete a worktree when
757  * it's absolutely safe to do so from _our_ point of view because we
758  * know better.
759  */
760 static void check_clean_worktree(struct worktree *wt,
761                                  const char *original_path)
762 {
763         struct argv_array child_env = ARGV_ARRAY_INIT;
764         struct child_process cp;
765         char buf[1];
766         int ret;
767
768         /*
769          * Until we sort this out, all submodules are "dirty" and
770          * will abort this function.
771          */
772         validate_no_submodules(wt);
773
774         argv_array_pushf(&child_env, "%s=%s/.git",
775                          GIT_DIR_ENVIRONMENT, wt->path);
776         argv_array_pushf(&child_env, "%s=%s",
777                          GIT_WORK_TREE_ENVIRONMENT, wt->path);
778         memset(&cp, 0, sizeof(cp));
779         argv_array_pushl(&cp.args, "status",
780                          "--porcelain", "--ignore-submodules=none",
781                          NULL);
782         cp.env = child_env.argv;
783         cp.git_cmd = 1;
784         cp.dir = wt->path;
785         cp.out = -1;
786         ret = start_command(&cp);
787         if (ret)
788                 die_errno(_("failed to run 'git status' on '%s'"),
789                           original_path);
790         ret = xread(cp.out, buf, sizeof(buf));
791         if (ret)
792                 die(_("'%s' is dirty, use --force to delete it"),
793                     original_path);
794         close(cp.out);
795         ret = finish_command(&cp);
796         if (ret)
797                 die_errno(_("failed to run 'git status' on '%s', code %d"),
798                           original_path, ret);
799 }
800
801 static int delete_git_work_tree(struct worktree *wt)
802 {
803         struct strbuf sb = STRBUF_INIT;
804         int ret = 0;
805
806         strbuf_addstr(&sb, wt->path);
807         if (remove_dir_recursively(&sb, 0)) {
808                 error_errno(_("failed to delete '%s'"), sb.buf);
809                 ret = -1;
810         }
811         strbuf_release(&sb);
812         return ret;
813 }
814
815 static int delete_git_dir(struct worktree *wt)
816 {
817         struct strbuf sb = STRBUF_INIT;
818         int ret = 0;
819
820         strbuf_addstr(&sb, git_common_path("worktrees/%s", wt->id));
821         if (remove_dir_recursively(&sb, 0)) {
822                 error_errno(_("failed to delete '%s'"), sb.buf);
823                 ret = -1;
824         }
825         strbuf_release(&sb);
826         return ret;
827 }
828
829 static int remove_worktree(int ac, const char **av, const char *prefix)
830 {
831         int force = 0;
832         struct option options[] = {
833                 OPT__FORCE(&force,
834                          N_("force removing even if the worktree is dirty"),
835                          PARSE_OPT_NOCOMPLETE),
836                 OPT_END()
837         };
838         struct worktree **worktrees, *wt;
839         struct strbuf errmsg = STRBUF_INIT;
840         const char *reason;
841         int ret = 0;
842
843         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
844         if (ac != 1)
845                 usage_with_options(worktree_usage, options);
846
847         worktrees = get_worktrees(0);
848         wt = find_worktree(worktrees, prefix, av[0]);
849         if (!wt)
850                 die(_("'%s' is not a working tree"), av[0]);
851         if (is_main_worktree(wt))
852                 die(_("'%s' is a main working tree"), av[0]);
853         reason = is_worktree_locked(wt);
854         if (reason) {
855                 if (*reason)
856                         die(_("cannot remove a locked working tree, lock reason: %s"),
857                             reason);
858                 die(_("cannot remove a locked working tree"));
859         }
860         if (validate_worktree(wt, &errmsg, WT_VALIDATE_WORKTREE_MISSING_OK))
861                 die(_("validation failed, cannot remove working tree: %s"),
862                     errmsg.buf);
863         strbuf_release(&errmsg);
864
865         if (file_exists(wt->path)) {
866                 if (!force)
867                         check_clean_worktree(wt, av[0]);
868
869                 ret |= delete_git_work_tree(wt);
870         }
871         /*
872          * continue on even if ret is non-zero, there's no going back
873          * from here.
874          */
875         ret |= delete_git_dir(wt);
876
877         free_worktrees(worktrees);
878         return ret;
879 }
880
881 int cmd_worktree(int ac, const char **av, const char *prefix)
882 {
883         struct option options[] = {
884                 OPT_END()
885         };
886
887         git_config(git_worktree_config, NULL);
888
889         if (ac < 2)
890                 usage_with_options(worktree_usage, options);
891         if (!prefix)
892                 prefix = "";
893         if (!strcmp(av[1], "add"))
894                 return add(ac - 1, av + 1, prefix);
895         if (!strcmp(av[1], "prune"))
896                 return prune(ac - 1, av + 1, prefix);
897         if (!strcmp(av[1], "list"))
898                 return list(ac - 1, av + 1, prefix);
899         if (!strcmp(av[1], "lock"))
900                 return lock_worktree(ac - 1, av + 1, prefix);
901         if (!strcmp(av[1], "unlock"))
902                 return unlock_worktree(ac - 1, av + 1, prefix);
903         if (!strcmp(av[1], "move"))
904                 return move_worktree(ac - 1, av + 1, prefix);
905         if (!strcmp(av[1], "remove"))
906                 return remove_worktree(ac - 1, av + 1, prefix);
907         usage_with_options(worktree_usage, options);
908 }