Merge branch 'sm/branch-sort-config'
[git/git.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 }