shorten_unambiguous_ref: use xsnprintf
[git.git] / builtin / worktree.c
blob670555deddaca8ff8050c03ea68c83c7b4e459e6
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"
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
27 struct add_opts {
28 int force;
29 int detach;
30 int checkout;
31 int keep_locked;
32 const char *new_branch;
33 int force_new_branch;
36 static int show_only;
37 static int verbose;
38 static int guess_remote;
39 static timestamp_t expire;
41 static int git_worktree_config(const char *var, const char *value, void *cb)
43 if (!strcmp(var, "worktree.guessremote")) {
44 guess_remote = git_config_bool(var, value);
45 return 0;
48 return git_default_config(var, value, cb);
51 static int prune_worktree(const char *id, struct strbuf *reason)
53 struct stat st;
54 char *path;
55 int fd;
56 size_t len;
57 ssize_t read_result;
59 if (!is_directory(git_path("worktrees/%s", id))) {
60 strbuf_addf(reason, _("Removing worktrees/%s: not a valid directory"), id);
61 return 1;
63 if (file_exists(git_path("worktrees/%s/locked", id)))
64 return 0;
65 if (stat(git_path("worktrees/%s/gitdir", id), &st)) {
66 strbuf_addf(reason, _("Removing worktrees/%s: gitdir file does not exist"), id);
67 return 1;
69 fd = open(git_path("worktrees/%s/gitdir", id), O_RDONLY);
70 if (fd < 0) {
71 strbuf_addf(reason, _("Removing worktrees/%s: unable to read gitdir file (%s)"),
72 id, strerror(errno));
73 return 1;
75 len = xsize_t(st.st_size);
76 path = xmallocz(len);
78 read_result = read_in_full(fd, path, len);
79 if (read_result < 0) {
80 strbuf_addf(reason, _("Removing worktrees/%s: unable to read gitdir file (%s)"),
81 id, strerror(errno));
82 close(fd);
83 free(path);
84 return 1;
86 close(fd);
88 if (read_result != len) {
89 strbuf_addf(reason,
90 _("Removing worktrees/%s: short read (expected %"PRIuMAX" bytes, read %"PRIuMAX")"),
91 id, (uintmax_t)len, (uintmax_t)read_result);
92 free(path);
93 return 1;
95 while (len && (path[len - 1] == '\n' || path[len - 1] == '\r'))
96 len--;
97 if (!len) {
98 strbuf_addf(reason, _("Removing worktrees/%s: invalid gitdir file"), id);
99 free(path);
100 return 1;
102 path[len] = '\0';
103 if (!file_exists(path)) {
104 struct stat st_link;
105 free(path);
107 * the repo is moved manually and has not been
108 * accessed since?
110 if (!stat(git_path("worktrees/%s/link", id), &st_link) &&
111 st_link.st_nlink > 1)
112 return 0;
113 if (st.st_mtime <= expire) {
114 strbuf_addf(reason, _("Removing worktrees/%s: gitdir file points to non-existent location"), id);
115 return 1;
116 } else {
117 return 0;
120 free(path);
121 return 0;
124 static void prune_worktrees(void)
126 struct strbuf reason = STRBUF_INIT;
127 struct strbuf path = STRBUF_INIT;
128 DIR *dir = opendir(git_path("worktrees"));
129 struct dirent *d;
130 int ret;
131 if (!dir)
132 return;
133 while ((d = readdir(dir)) != NULL) {
134 if (is_dot_or_dotdot(d->d_name))
135 continue;
136 strbuf_reset(&reason);
137 if (!prune_worktree(d->d_name, &reason))
138 continue;
139 if (show_only || verbose)
140 printf("%s\n", reason.buf);
141 if (show_only)
142 continue;
143 git_path_buf(&path, "worktrees/%s", d->d_name);
144 ret = remove_dir_recursively(&path, 0);
145 if (ret < 0 && errno == ENOTDIR)
146 ret = unlink(path.buf);
147 if (ret)
148 error_errno(_("failed to remove '%s'"), path.buf);
150 closedir(dir);
151 if (!show_only)
152 rmdir(git_path("worktrees"));
153 strbuf_release(&reason);
154 strbuf_release(&path);
157 static int prune(int ac, const char **av, const char *prefix)
159 struct option options[] = {
160 OPT__DRY_RUN(&show_only, N_("do not remove, show only")),
161 OPT__VERBOSE(&verbose, N_("report pruned working trees")),
162 OPT_EXPIRY_DATE(0, "expire", &expire,
163 N_("expire working trees older than <time>")),
164 OPT_END()
167 expire = TIME_MAX;
168 ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
169 if (ac)
170 usage_with_options(worktree_usage, options);
171 prune_worktrees();
172 return 0;
175 static char *junk_work_tree;
176 static char *junk_git_dir;
177 static int is_junk;
178 static pid_t junk_pid;
180 static void remove_junk(void)
182 struct strbuf sb = STRBUF_INIT;
183 if (!is_junk || getpid() != junk_pid)
184 return;
185 if (junk_git_dir) {
186 strbuf_addstr(&sb, junk_git_dir);
187 remove_dir_recursively(&sb, 0);
188 strbuf_reset(&sb);
190 if (junk_work_tree) {
191 strbuf_addstr(&sb, junk_work_tree);
192 remove_dir_recursively(&sb, 0);
194 strbuf_release(&sb);
197 static void remove_junk_on_signal(int signo)
199 remove_junk();
200 sigchain_pop(signo);
201 raise(signo);
204 static const char *worktree_basename(const char *path, int *olen)
206 const char *name;
207 int len;
209 len = strlen(path);
210 while (len && is_dir_sep(path[len - 1]))
211 len--;
213 for (name = path + len - 1; name > path; name--)
214 if (is_dir_sep(*name)) {
215 name++;
216 break;
219 *olen = len;
220 return name;
223 static int add_worktree(const char *path, const char *refname,
224 const struct add_opts *opts)
226 struct strbuf sb_git = STRBUF_INIT, sb_repo = STRBUF_INIT;
227 struct strbuf sb = STRBUF_INIT;
228 const char *name;
229 struct stat st;
230 struct child_process cp = CHILD_PROCESS_INIT;
231 struct argv_array child_env = ARGV_ARRAY_INIT;
232 int counter = 0, len, ret;
233 struct strbuf symref = STRBUF_INIT;
234 struct commit *commit = NULL;
235 int is_branch = 0;
237 if (file_exists(path) && !is_empty_dir(path))
238 die(_("'%s' already exists"), path);
240 /* is 'refname' a branch or commit? */
241 if (!opts->detach && !strbuf_check_branch_ref(&symref, refname) &&
242 ref_exists(symref.buf)) {
243 is_branch = 1;
244 if (!opts->force)
245 die_if_checked_out(symref.buf, 0);
247 commit = lookup_commit_reference_by_name(refname);
248 if (!commit)
249 die(_("invalid reference: %s"), refname);
251 name = worktree_basename(path, &len);
252 git_path_buf(&sb_repo, "worktrees/%.*s", (int)(path + len - name), name);
253 len = sb_repo.len;
254 if (safe_create_leading_directories_const(sb_repo.buf))
255 die_errno(_("could not create leading directories of '%s'"),
256 sb_repo.buf);
257 while (!stat(sb_repo.buf, &st)) {
258 counter++;
259 strbuf_setlen(&sb_repo, len);
260 strbuf_addf(&sb_repo, "%d", counter);
262 name = strrchr(sb_repo.buf, '/') + 1;
264 junk_pid = getpid();
265 atexit(remove_junk);
266 sigchain_push_common(remove_junk_on_signal);
268 if (mkdir(sb_repo.buf, 0777))
269 die_errno(_("could not create directory of '%s'"), sb_repo.buf);
270 junk_git_dir = xstrdup(sb_repo.buf);
271 is_junk = 1;
274 * lock the incomplete repo so prune won't delete it, unlock
275 * after the preparation is over.
277 strbuf_addf(&sb, "%s/locked", sb_repo.buf);
278 if (!opts->keep_locked)
279 write_file(sb.buf, "initializing");
280 else
281 write_file(sb.buf, "added with --lock");
283 strbuf_addf(&sb_git, "%s/.git", path);
284 if (safe_create_leading_directories_const(sb_git.buf))
285 die_errno(_("could not create leading directories of '%s'"),
286 sb_git.buf);
287 junk_work_tree = xstrdup(path);
289 strbuf_reset(&sb);
290 strbuf_addf(&sb, "%s/gitdir", sb_repo.buf);
291 write_file(sb.buf, "%s", real_path(sb_git.buf));
292 write_file(sb_git.buf, "gitdir: %s/worktrees/%s",
293 real_path(get_git_common_dir()), name);
295 * This is to keep resolve_ref() happy. We need a valid HEAD
296 * or is_git_directory() will reject the directory. Any value which
297 * looks like an object ID will do since it will be immediately
298 * replaced by the symbolic-ref or update-ref invocation in the new
299 * worktree.
301 strbuf_reset(&sb);
302 strbuf_addf(&sb, "%s/HEAD", sb_repo.buf);
303 write_file(sb.buf, "%s", sha1_to_hex(null_sha1));
304 strbuf_reset(&sb);
305 strbuf_addf(&sb, "%s/commondir", sb_repo.buf);
306 write_file(sb.buf, "../..");
308 fprintf_ln(stderr, _("Preparing %s (identifier %s)"), path, name);
310 argv_array_pushf(&child_env, "%s=%s", GIT_DIR_ENVIRONMENT, sb_git.buf);
311 argv_array_pushf(&child_env, "%s=%s", GIT_WORK_TREE_ENVIRONMENT, path);
312 cp.git_cmd = 1;
314 if (!is_branch)
315 argv_array_pushl(&cp.args, "update-ref", "HEAD",
316 oid_to_hex(&commit->object.oid), NULL);
317 else
318 argv_array_pushl(&cp.args, "symbolic-ref", "HEAD",
319 symref.buf, NULL);
320 cp.env = child_env.argv;
321 ret = run_command(&cp);
322 if (ret)
323 goto done;
325 if (opts->checkout) {
326 cp.argv = NULL;
327 argv_array_clear(&cp.args);
328 argv_array_pushl(&cp.args, "reset", "--hard", NULL);
329 cp.env = child_env.argv;
330 ret = run_command(&cp);
331 if (ret)
332 goto done;
335 is_junk = 0;
336 FREE_AND_NULL(junk_work_tree);
337 FREE_AND_NULL(junk_git_dir);
339 done:
340 if (ret || !opts->keep_locked) {
341 strbuf_reset(&sb);
342 strbuf_addf(&sb, "%s/locked", sb_repo.buf);
343 unlink_or_warn(sb.buf);
347 * Hook failure does not warrant worktree deletion, so run hook after
348 * is_junk is cleared, but do return appropriate code when hook fails.
350 if (!ret && opts->checkout) {
351 const char *hook = find_hook("post-checkout");
352 if (hook) {
353 const char *env[] = { "GIT_DIR", "GIT_WORK_TREE", NULL };
354 cp.git_cmd = 0;
355 cp.no_stdin = 1;
356 cp.stdout_to_stderr = 1;
357 cp.dir = path;
358 cp.env = env;
359 cp.argv = NULL;
360 argv_array_pushl(&cp.args, absolute_path(hook),
361 oid_to_hex(&null_oid),
362 oid_to_hex(&commit->object.oid),
363 "1", NULL);
364 ret = run_command(&cp);
368 argv_array_clear(&child_env);
369 strbuf_release(&sb);
370 strbuf_release(&symref);
371 strbuf_release(&sb_repo);
372 strbuf_release(&sb_git);
373 return ret;
376 static int add(int ac, const char **av, const char *prefix)
378 struct add_opts opts;
379 const char *new_branch_force = NULL;
380 char *path;
381 const char *branch;
382 const char *opt_track = NULL;
383 struct option options[] = {
384 OPT__FORCE(&opts.force,
385 N_("checkout <branch> even if already checked out in other worktree"),
386 PARSE_OPT_NOCOMPLETE),
387 OPT_STRING('b', NULL, &opts.new_branch, N_("branch"),
388 N_("create a new branch")),
389 OPT_STRING('B', NULL, &new_branch_force, N_("branch"),
390 N_("create or reset a branch")),
391 OPT_BOOL(0, "detach", &opts.detach, N_("detach HEAD at named commit")),
392 OPT_BOOL(0, "checkout", &opts.checkout, N_("populate the new working tree")),
393 OPT_BOOL(0, "lock", &opts.keep_locked, N_("keep the new working tree locked")),
394 OPT_PASSTHRU(0, "track", &opt_track, NULL,
395 N_("set up tracking mode (see git-branch(1))"),
396 PARSE_OPT_NOARG | PARSE_OPT_OPTARG),
397 OPT_BOOL(0, "guess-remote", &guess_remote,
398 N_("try to match the new branch name with a remote-tracking branch")),
399 OPT_END()
402 memset(&opts, 0, sizeof(opts));
403 opts.checkout = 1;
404 ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
405 if (!!opts.detach + !!opts.new_branch + !!new_branch_force > 1)
406 die(_("-b, -B, and --detach are mutually exclusive"));
407 if (ac < 1 || ac > 2)
408 usage_with_options(worktree_usage, options);
410 path = prefix_filename(prefix, av[0]);
411 branch = ac < 2 ? "HEAD" : av[1];
413 if (!strcmp(branch, "-"))
414 branch = "@{-1}";
416 opts.force_new_branch = !!new_branch_force;
417 if (opts.force_new_branch) {
418 struct strbuf symref = STRBUF_INIT;
420 opts.new_branch = new_branch_force;
422 if (!opts.force &&
423 !strbuf_check_branch_ref(&symref, opts.new_branch) &&
424 ref_exists(symref.buf))
425 die_if_checked_out(symref.buf, 0);
426 strbuf_release(&symref);
429 if (ac < 2 && !opts.new_branch && !opts.detach) {
430 int n;
431 const char *s = worktree_basename(path, &n);
432 opts.new_branch = xstrndup(s, n);
433 if (guess_remote) {
434 struct object_id oid;
435 const char *remote =
436 unique_tracking_name(opts.new_branch, &oid);
437 if (remote)
438 branch = remote;
442 if (ac == 2 && !opts.new_branch && !opts.detach) {
443 struct object_id oid;
444 struct commit *commit;
445 const char *remote;
447 commit = lookup_commit_reference_by_name(branch);
448 if (!commit) {
449 remote = unique_tracking_name(branch, &oid);
450 if (remote) {
451 opts.new_branch = branch;
452 branch = remote;
457 if (opts.new_branch) {
458 struct child_process cp = CHILD_PROCESS_INIT;
459 cp.git_cmd = 1;
460 argv_array_push(&cp.args, "branch");
461 if (opts.force_new_branch)
462 argv_array_push(&cp.args, "--force");
463 argv_array_push(&cp.args, opts.new_branch);
464 argv_array_push(&cp.args, branch);
465 if (opt_track)
466 argv_array_push(&cp.args, opt_track);
467 if (run_command(&cp))
468 return -1;
469 branch = opts.new_branch;
470 } else if (opt_track) {
471 die(_("--[no-]track can only be used if a new branch is created"));
474 UNLEAK(path);
475 UNLEAK(opts);
476 return add_worktree(path, branch, &opts);
479 static void show_worktree_porcelain(struct worktree *wt)
481 printf("worktree %s\n", wt->path);
482 if (wt->is_bare)
483 printf("bare\n");
484 else {
485 printf("HEAD %s\n", oid_to_hex(&wt->head_oid));
486 if (wt->is_detached)
487 printf("detached\n");
488 else if (wt->head_ref)
489 printf("branch %s\n", wt->head_ref);
491 printf("\n");
494 static void show_worktree(struct worktree *wt, int path_maxlen, int abbrev_len)
496 struct strbuf sb = STRBUF_INIT;
497 int cur_path_len = strlen(wt->path);
498 int path_adj = cur_path_len - utf8_strwidth(wt->path);
500 strbuf_addf(&sb, "%-*s ", 1 + path_maxlen + path_adj, wt->path);
501 if (wt->is_bare)
502 strbuf_addstr(&sb, "(bare)");
503 else {
504 strbuf_addf(&sb, "%-*s ", abbrev_len,
505 find_unique_abbrev(wt->head_oid.hash, DEFAULT_ABBREV));
506 if (wt->is_detached)
507 strbuf_addstr(&sb, "(detached HEAD)");
508 else if (wt->head_ref) {
509 char *ref = shorten_unambiguous_ref(wt->head_ref, 0);
510 strbuf_addf(&sb, "[%s]", ref);
511 free(ref);
512 } else
513 strbuf_addstr(&sb, "(error)");
515 printf("%s\n", sb.buf);
517 strbuf_release(&sb);
520 static void measure_widths(struct worktree **wt, int *abbrev, int *maxlen)
522 int i;
524 for (i = 0; wt[i]; i++) {
525 int sha1_len;
526 int path_len = strlen(wt[i]->path);
528 if (path_len > *maxlen)
529 *maxlen = path_len;
530 sha1_len = strlen(find_unique_abbrev(wt[i]->head_oid.hash, *abbrev));
531 if (sha1_len > *abbrev)
532 *abbrev = sha1_len;
536 static int list(int ac, const char **av, const char *prefix)
538 int porcelain = 0;
540 struct option options[] = {
541 OPT_BOOL(0, "porcelain", &porcelain, N_("machine-readable output")),
542 OPT_END()
545 ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
546 if (ac)
547 usage_with_options(worktree_usage, options);
548 else {
549 struct worktree **worktrees = get_worktrees(GWT_SORT_LINKED);
550 int path_maxlen = 0, abbrev = DEFAULT_ABBREV, i;
552 if (!porcelain)
553 measure_widths(worktrees, &abbrev, &path_maxlen);
555 for (i = 0; worktrees[i]; i++) {
556 if (porcelain)
557 show_worktree_porcelain(worktrees[i]);
558 else
559 show_worktree(worktrees[i], path_maxlen, abbrev);
561 free_worktrees(worktrees);
563 return 0;
566 static int lock_worktree(int ac, const char **av, const char *prefix)
568 const char *reason = "", *old_reason;
569 struct option options[] = {
570 OPT_STRING(0, "reason", &reason, N_("string"),
571 N_("reason for locking")),
572 OPT_END()
574 struct worktree **worktrees, *wt;
576 ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
577 if (ac != 1)
578 usage_with_options(worktree_usage, options);
580 worktrees = get_worktrees(0);
581 wt = find_worktree(worktrees, prefix, av[0]);
582 if (!wt)
583 die(_("'%s' is not a working tree"), av[0]);
584 if (is_main_worktree(wt))
585 die(_("The main working tree cannot be locked or unlocked"));
587 old_reason = is_worktree_locked(wt);
588 if (old_reason) {
589 if (*old_reason)
590 die(_("'%s' is already locked, reason: %s"),
591 av[0], old_reason);
592 die(_("'%s' is already locked"), av[0]);
595 write_file(git_common_path("worktrees/%s/locked", wt->id),
596 "%s", reason);
597 free_worktrees(worktrees);
598 return 0;
601 static int unlock_worktree(int ac, const char **av, const char *prefix)
603 struct option options[] = {
604 OPT_END()
606 struct worktree **worktrees, *wt;
607 int ret;
609 ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
610 if (ac != 1)
611 usage_with_options(worktree_usage, options);
613 worktrees = get_worktrees(0);
614 wt = find_worktree(worktrees, prefix, av[0]);
615 if (!wt)
616 die(_("'%s' is not a working tree"), av[0]);
617 if (is_main_worktree(wt))
618 die(_("The main working tree cannot be locked or unlocked"));
619 if (!is_worktree_locked(wt))
620 die(_("'%s' is not locked"), av[0]);
621 ret = unlink_or_warn(git_common_path("worktrees/%s/locked", wt->id));
622 free_worktrees(worktrees);
623 return ret;
626 static void validate_no_submodules(const struct worktree *wt)
628 struct index_state istate = { NULL };
629 int i, found_submodules = 0;
631 if (read_index_from(&istate, worktree_git_path(wt, "index"),
632 get_worktree_git_dir(wt)) > 0) {
633 for (i = 0; i < istate.cache_nr; i++) {
634 struct cache_entry *ce = istate.cache[i];
636 if (S_ISGITLINK(ce->ce_mode)) {
637 found_submodules = 1;
638 break;
642 discard_index(&istate);
644 if (found_submodules)
645 die(_("working trees containing submodules cannot be moved or removed"));
648 static int move_worktree(int ac, const char **av, const char *prefix)
650 struct option options[] = {
651 OPT_END()
653 struct worktree **worktrees, *wt;
654 struct strbuf dst = STRBUF_INIT;
655 struct strbuf errmsg = STRBUF_INIT;
656 const char *reason;
657 char *path;
659 ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
660 if (ac != 2)
661 usage_with_options(worktree_usage, options);
663 path = prefix_filename(prefix, av[1]);
664 strbuf_addstr(&dst, path);
665 free(path);
667 worktrees = get_worktrees(0);
668 wt = find_worktree(worktrees, prefix, av[0]);
669 if (!wt)
670 die(_("'%s' is not a working tree"), av[0]);
671 if (is_main_worktree(wt))
672 die(_("'%s' is a main working tree"), av[0]);
673 if (is_directory(dst.buf)) {
674 const char *sep = find_last_dir_sep(wt->path);
676 if (!sep)
677 die(_("could not figure out destination name from '%s'"),
678 wt->path);
679 strbuf_trim_trailing_dir_sep(&dst);
680 strbuf_addstr(&dst, sep);
682 if (file_exists(dst.buf))
683 die(_("target '%s' already exists"), dst.buf);
685 validate_no_submodules(wt);
687 reason = is_worktree_locked(wt);
688 if (reason) {
689 if (*reason)
690 die(_("cannot move a locked working tree, lock reason: %s"),
691 reason);
692 die(_("cannot move a locked working tree"));
694 if (validate_worktree(wt, &errmsg, 0))
695 die(_("validation failed, cannot move working tree: %s"),
696 errmsg.buf);
697 strbuf_release(&errmsg);
699 if (rename(wt->path, dst.buf) == -1)
700 die_errno(_("failed to move '%s' to '%s'"), wt->path, dst.buf);
702 update_worktree_location(wt, dst.buf);
704 strbuf_release(&dst);
705 free_worktrees(worktrees);
706 return 0;
710 * Note, "git status --porcelain" is used to determine if it's safe to
711 * delete a whole worktree. "git status" does not ignore user
712 * configuration, so if a normal "git status" shows "clean" for the
713 * user, then it's ok to remove it.
715 * This assumption may be a bad one. We may want to ignore
716 * (potentially bad) user settings and only delete a worktree when
717 * it's absolutely safe to do so from _our_ point of view because we
718 * know better.
720 static void check_clean_worktree(struct worktree *wt,
721 const char *original_path)
723 struct argv_array child_env = ARGV_ARRAY_INIT;
724 struct child_process cp;
725 char buf[1];
726 int ret;
729 * Until we sort this out, all submodules are "dirty" and
730 * will abort this function.
732 validate_no_submodules(wt);
734 argv_array_pushf(&child_env, "%s=%s/.git",
735 GIT_DIR_ENVIRONMENT, wt->path);
736 argv_array_pushf(&child_env, "%s=%s",
737 GIT_WORK_TREE_ENVIRONMENT, wt->path);
738 memset(&cp, 0, sizeof(cp));
739 argv_array_pushl(&cp.args, "status",
740 "--porcelain", "--ignore-submodules=none",
741 NULL);
742 cp.env = child_env.argv;
743 cp.git_cmd = 1;
744 cp.dir = wt->path;
745 cp.out = -1;
746 ret = start_command(&cp);
747 if (ret)
748 die_errno(_("failed to run 'git status' on '%s'"),
749 original_path);
750 ret = xread(cp.out, buf, sizeof(buf));
751 if (ret)
752 die(_("'%s' is dirty, use --force to delete it"),
753 original_path);
754 close(cp.out);
755 ret = finish_command(&cp);
756 if (ret)
757 die_errno(_("failed to run 'git status' on '%s', code %d"),
758 original_path, ret);
761 static int delete_git_work_tree(struct worktree *wt)
763 struct strbuf sb = STRBUF_INIT;
764 int ret = 0;
766 strbuf_addstr(&sb, wt->path);
767 if (remove_dir_recursively(&sb, 0)) {
768 error_errno(_("failed to delete '%s'"), sb.buf);
769 ret = -1;
771 strbuf_release(&sb);
772 return ret;
775 static int delete_git_dir(struct worktree *wt)
777 struct strbuf sb = STRBUF_INIT;
778 int ret = 0;
780 strbuf_addstr(&sb, git_common_path("worktrees/%s", wt->id));
781 if (remove_dir_recursively(&sb, 0)) {
782 error_errno(_("failed to delete '%s'"), sb.buf);
783 ret = -1;
785 strbuf_release(&sb);
786 return ret;
789 static int remove_worktree(int ac, const char **av, const char *prefix)
791 int force = 0;
792 struct option options[] = {
793 OPT_BOOL(0, "force", &force,
794 N_("force removing even if the worktree is dirty")),
795 OPT_END()
797 struct worktree **worktrees, *wt;
798 struct strbuf errmsg = STRBUF_INIT;
799 const char *reason;
800 int ret = 0;
802 ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
803 if (ac != 1)
804 usage_with_options(worktree_usage, options);
806 worktrees = get_worktrees(0);
807 wt = find_worktree(worktrees, prefix, av[0]);
808 if (!wt)
809 die(_("'%s' is not a working tree"), av[0]);
810 if (is_main_worktree(wt))
811 die(_("'%s' is a main working tree"), av[0]);
812 reason = is_worktree_locked(wt);
813 if (reason) {
814 if (*reason)
815 die(_("cannot remove a locked working tree, lock reason: %s"),
816 reason);
817 die(_("cannot remove a locked working tree"));
819 if (validate_worktree(wt, &errmsg, WT_VALIDATE_WORKTREE_MISSING_OK))
820 die(_("validation failed, cannot remove working tree: %s"),
821 errmsg.buf);
822 strbuf_release(&errmsg);
824 if (file_exists(wt->path)) {
825 if (!force)
826 check_clean_worktree(wt, av[0]);
828 ret |= delete_git_work_tree(wt);
831 * continue on even if ret is non-zero, there's no going back
832 * from here.
834 ret |= delete_git_dir(wt);
836 free_worktrees(worktrees);
837 return ret;
840 int cmd_worktree(int ac, const char **av, const char *prefix)
842 struct option options[] = {
843 OPT_END()
846 git_config(git_worktree_config, NULL);
848 if (ac < 2)
849 usage_with_options(worktree_usage, options);
850 if (!prefix)
851 prefix = "";
852 if (!strcmp(av[1], "add"))
853 return add(ac - 1, av + 1, prefix);
854 if (!strcmp(av[1], "prune"))
855 return prune(ac - 1, av + 1, prefix);
856 if (!strcmp(av[1], "list"))
857 return list(ac - 1, av + 1, prefix);
858 if (!strcmp(av[1], "lock"))
859 return lock_worktree(ac - 1, av + 1, prefix);
860 if (!strcmp(av[1], "unlock"))
861 return unlock_worktree(ac - 1, av + 1, prefix);
862 if (!strcmp(av[1], "move"))
863 return move_worktree(ac - 1, av + 1, prefix);
864 if (!strcmp(av[1], "remove"))
865 return remove_worktree(ac - 1, av + 1, prefix);
866 usage_with_options(worktree_usage, options);