Merge branch 'nd/ignore-glob-doc-update' into maint
[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 prune [<options>]"),
21         N_("git worktree unlock <path>"),
22         NULL
23 };
24
25 struct add_opts {
26         int force;
27         int detach;
28         int checkout;
29         int keep_locked;
30         const char *new_branch;
31         int force_new_branch;
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                 struct stat st_link;
103                 free(path);
104                 /*
105                  * the repo is moved manually and has not been
106                  * accessed since?
107                  */
108                 if (!stat(git_path("worktrees/%s/link", id), &st_link) &&
109                     st_link.st_nlink > 1)
110                         return 0;
111                 if (st.st_mtime <= expire) {
112                         strbuf_addf(reason, _("Removing worktrees/%s: gitdir file points to non-existent location"), id);
113                         return 1;
114                 } else {
115                         return 0;
116                 }
117         }
118         free(path);
119         return 0;
120 }
121
122 static void prune_worktrees(void)
123 {
124         struct strbuf reason = STRBUF_INIT;
125         struct strbuf path = STRBUF_INIT;
126         DIR *dir = opendir(git_path("worktrees"));
127         struct dirent *d;
128         int ret;
129         if (!dir)
130                 return;
131         while ((d = readdir(dir)) != NULL) {
132                 if (is_dot_or_dotdot(d->d_name))
133                         continue;
134                 strbuf_reset(&reason);
135                 if (!prune_worktree(d->d_name, &reason))
136                         continue;
137                 if (show_only || verbose)
138                         printf("%s\n", reason.buf);
139                 if (show_only)
140                         continue;
141                 git_path_buf(&path, "worktrees/%s", d->d_name);
142                 ret = remove_dir_recursively(&path, 0);
143                 if (ret < 0 && errno == ENOTDIR)
144                         ret = unlink(path.buf);
145                 if (ret)
146                         error_errno(_("failed to remove '%s'"), path.buf);
147         }
148         closedir(dir);
149         if (!show_only)
150                 rmdir(git_path("worktrees"));
151         strbuf_release(&reason);
152         strbuf_release(&path);
153 }
154
155 static int prune(int ac, const char **av, const char *prefix)
156 {
157         struct option options[] = {
158                 OPT__DRY_RUN(&show_only, N_("do not remove, show only")),
159                 OPT__VERBOSE(&verbose, N_("report pruned working trees")),
160                 OPT_EXPIRY_DATE(0, "expire", &expire,
161                                 N_("expire working trees older than <time>")),
162                 OPT_END()
163         };
164
165         expire = TIME_MAX;
166         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
167         if (ac)
168                 usage_with_options(worktree_usage, options);
169         prune_worktrees();
170         return 0;
171 }
172
173 static char *junk_work_tree;
174 static char *junk_git_dir;
175 static int is_junk;
176 static pid_t junk_pid;
177
178 static void remove_junk(void)
179 {
180         struct strbuf sb = STRBUF_INIT;
181         if (!is_junk || getpid() != junk_pid)
182                 return;
183         if (junk_git_dir) {
184                 strbuf_addstr(&sb, junk_git_dir);
185                 remove_dir_recursively(&sb, 0);
186                 strbuf_reset(&sb);
187         }
188         if (junk_work_tree) {
189                 strbuf_addstr(&sb, junk_work_tree);
190                 remove_dir_recursively(&sb, 0);
191         }
192         strbuf_release(&sb);
193 }
194
195 static void remove_junk_on_signal(int signo)
196 {
197         remove_junk();
198         sigchain_pop(signo);
199         raise(signo);
200 }
201
202 static const char *worktree_basename(const char *path, int *olen)
203 {
204         const char *name;
205         int len;
206
207         len = strlen(path);
208         while (len && is_dir_sep(path[len - 1]))
209                 len--;
210
211         for (name = path + len - 1; name > path; name--)
212                 if (is_dir_sep(*name)) {
213                         name++;
214                         break;
215                 }
216
217         *olen = len;
218         return name;
219 }
220
221 static int add_worktree(const char *path, const char *refname,
222                         const struct add_opts *opts)
223 {
224         struct strbuf sb_git = STRBUF_INIT, sb_repo = STRBUF_INIT;
225         struct strbuf sb = STRBUF_INIT;
226         const char *name;
227         struct stat st;
228         struct child_process cp = CHILD_PROCESS_INIT;
229         struct argv_array child_env = ARGV_ARRAY_INIT;
230         int counter = 0, len, ret;
231         struct strbuf symref = STRBUF_INIT;
232         struct commit *commit = NULL;
233         int is_branch = 0;
234
235         if (file_exists(path) && !is_empty_dir(path))
236                 die(_("'%s' already exists"), path);
237
238         /* is 'refname' a branch or commit? */
239         if (!opts->detach && !strbuf_check_branch_ref(&symref, refname) &&
240             ref_exists(symref.buf)) {
241                 is_branch = 1;
242                 if (!opts->force)
243                         die_if_checked_out(symref.buf, 0);
244         }
245         commit = lookup_commit_reference_by_name(refname);
246         if (!commit)
247                 die(_("invalid reference: %s"), refname);
248
249         name = worktree_basename(path, &len);
250         git_path_buf(&sb_repo, "worktrees/%.*s", (int)(path + len - name), name);
251         len = sb_repo.len;
252         if (safe_create_leading_directories_const(sb_repo.buf))
253                 die_errno(_("could not create leading directories of '%s'"),
254                           sb_repo.buf);
255         while (!stat(sb_repo.buf, &st)) {
256                 counter++;
257                 strbuf_setlen(&sb_repo, len);
258                 strbuf_addf(&sb_repo, "%d", counter);
259         }
260         name = strrchr(sb_repo.buf, '/') + 1;
261
262         junk_pid = getpid();
263         atexit(remove_junk);
264         sigchain_push_common(remove_junk_on_signal);
265
266         if (mkdir(sb_repo.buf, 0777))
267                 die_errno(_("could not create directory of '%s'"), sb_repo.buf);
268         junk_git_dir = xstrdup(sb_repo.buf);
269         is_junk = 1;
270
271         /*
272          * lock the incomplete repo so prune won't delete it, unlock
273          * after the preparation is over.
274          */
275         strbuf_addf(&sb, "%s/locked", sb_repo.buf);
276         if (!opts->keep_locked)
277                 write_file(sb.buf, "initializing");
278         else
279                 write_file(sb.buf, "added with --lock");
280
281         strbuf_addf(&sb_git, "%s/.git", path);
282         if (safe_create_leading_directories_const(sb_git.buf))
283                 die_errno(_("could not create leading directories of '%s'"),
284                           sb_git.buf);
285         junk_work_tree = xstrdup(path);
286
287         strbuf_reset(&sb);
288         strbuf_addf(&sb, "%s/gitdir", sb_repo.buf);
289         write_file(sb.buf, "%s", real_path(sb_git.buf));
290         write_file(sb_git.buf, "gitdir: %s/worktrees/%s",
291                    real_path(get_git_common_dir()), name);
292         /*
293          * This is to keep resolve_ref() happy. We need a valid HEAD
294          * or is_git_directory() will reject the directory. Any value which
295          * looks like an object ID will do since it will be immediately
296          * replaced by the symbolic-ref or update-ref invocation in the new
297          * worktree.
298          */
299         strbuf_reset(&sb);
300         strbuf_addf(&sb, "%s/HEAD", sb_repo.buf);
301         write_file(sb.buf, "%s", sha1_to_hex(null_sha1));
302         strbuf_reset(&sb);
303         strbuf_addf(&sb, "%s/commondir", sb_repo.buf);
304         write_file(sb.buf, "../..");
305
306         fprintf_ln(stderr, _("Preparing %s (identifier %s)"), path, name);
307
308         argv_array_pushf(&child_env, "%s=%s", GIT_DIR_ENVIRONMENT, sb_git.buf);
309         argv_array_pushf(&child_env, "%s=%s", GIT_WORK_TREE_ENVIRONMENT, path);
310         cp.git_cmd = 1;
311
312         if (!is_branch)
313                 argv_array_pushl(&cp.args, "update-ref", "HEAD",
314                                  oid_to_hex(&commit->object.oid), NULL);
315         else
316                 argv_array_pushl(&cp.args, "symbolic-ref", "HEAD",
317                                  symref.buf, NULL);
318         cp.env = child_env.argv;
319         ret = run_command(&cp);
320         if (ret)
321                 goto done;
322
323         if (opts->checkout) {
324                 cp.argv = NULL;
325                 argv_array_clear(&cp.args);
326                 argv_array_pushl(&cp.args, "reset", "--hard", NULL);
327                 cp.env = child_env.argv;
328                 ret = run_command(&cp);
329                 if (ret)
330                         goto done;
331         }
332
333         is_junk = 0;
334         FREE_AND_NULL(junk_work_tree);
335         FREE_AND_NULL(junk_git_dir);
336
337 done:
338         if (ret || !opts->keep_locked) {
339                 strbuf_reset(&sb);
340                 strbuf_addf(&sb, "%s/locked", sb_repo.buf);
341                 unlink_or_warn(sb.buf);
342         }
343
344         /*
345          * Hook failure does not warrant worktree deletion, so run hook after
346          * is_junk is cleared, but do return appropriate code when hook fails.
347          */
348         if (!ret && opts->checkout)
349                 ret = run_hook_le(NULL, "post-checkout", oid_to_hex(&null_oid),
350                                   oid_to_hex(&commit->object.oid), "1", NULL);
351
352         argv_array_clear(&child_env);
353         strbuf_release(&sb);
354         strbuf_release(&symref);
355         strbuf_release(&sb_repo);
356         strbuf_release(&sb_git);
357         return ret;
358 }
359
360 static int add(int ac, const char **av, const char *prefix)
361 {
362         struct add_opts opts;
363         const char *new_branch_force = NULL;
364         char *path;
365         const char *branch;
366         const char *opt_track = NULL;
367         struct option options[] = {
368                 OPT__FORCE(&opts.force, N_("checkout <branch> even if already checked out in other worktree")),
369                 OPT_STRING('b', NULL, &opts.new_branch, N_("branch"),
370                            N_("create a new branch")),
371                 OPT_STRING('B', NULL, &new_branch_force, N_("branch"),
372                            N_("create or reset a branch")),
373                 OPT_BOOL(0, "detach", &opts.detach, N_("detach HEAD at named commit")),
374                 OPT_BOOL(0, "checkout", &opts.checkout, N_("populate the new working tree")),
375                 OPT_BOOL(0, "lock", &opts.keep_locked, N_("keep the new working tree locked")),
376                 OPT_PASSTHRU(0, "track", &opt_track, NULL,
377                              N_("set up tracking mode (see git-branch(1))"),
378                              PARSE_OPT_NOARG | PARSE_OPT_OPTARG),
379                 OPT_BOOL(0, "guess-remote", &guess_remote,
380                          N_("try to match the new branch name with a remote-tracking branch")),
381                 OPT_END()
382         };
383
384         memset(&opts, 0, sizeof(opts));
385         opts.checkout = 1;
386         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
387         if (!!opts.detach + !!opts.new_branch + !!new_branch_force > 1)
388                 die(_("-b, -B, and --detach are mutually exclusive"));
389         if (ac < 1 || ac > 2)
390                 usage_with_options(worktree_usage, options);
391
392         path = prefix_filename(prefix, av[0]);
393         branch = ac < 2 ? "HEAD" : av[1];
394
395         if (!strcmp(branch, "-"))
396                 branch = "@{-1}";
397
398         opts.force_new_branch = !!new_branch_force;
399         if (opts.force_new_branch) {
400                 struct strbuf symref = STRBUF_INIT;
401
402                 opts.new_branch = new_branch_force;
403
404                 if (!opts.force &&
405                     !strbuf_check_branch_ref(&symref, opts.new_branch) &&
406                     ref_exists(symref.buf))
407                         die_if_checked_out(symref.buf, 0);
408                 strbuf_release(&symref);
409         }
410
411         if (ac < 2 && !opts.new_branch && !opts.detach) {
412                 int n;
413                 const char *s = worktree_basename(path, &n);
414                 opts.new_branch = xstrndup(s, n);
415                 if (guess_remote) {
416                         struct object_id oid;
417                         const char *remote =
418                                 unique_tracking_name(opts.new_branch, &oid);
419                         if (remote)
420                                 branch = remote;
421                 }
422         }
423
424         if (ac == 2 && !opts.new_branch && !opts.detach) {
425                 struct object_id oid;
426                 struct commit *commit;
427                 const char *remote;
428
429                 commit = lookup_commit_reference_by_name(branch);
430                 if (!commit) {
431                         remote = unique_tracking_name(branch, &oid);
432                         if (remote) {
433                                 opts.new_branch = branch;
434                                 branch = remote;
435                         }
436                 }
437         }
438
439         if (opts.new_branch) {
440                 struct child_process cp = CHILD_PROCESS_INIT;
441                 cp.git_cmd = 1;
442                 argv_array_push(&cp.args, "branch");
443                 if (opts.force_new_branch)
444                         argv_array_push(&cp.args, "--force");
445                 argv_array_push(&cp.args, opts.new_branch);
446                 argv_array_push(&cp.args, branch);
447                 if (opt_track)
448                         argv_array_push(&cp.args, opt_track);
449                 if (run_command(&cp))
450                         return -1;
451                 branch = opts.new_branch;
452         } else if (opt_track) {
453                 die(_("--[no-]track can only be used if a new branch is created"));
454         }
455
456         UNLEAK(path);
457         UNLEAK(opts);
458         return add_worktree(path, branch, &opts);
459 }
460
461 static void show_worktree_porcelain(struct worktree *wt)
462 {
463         printf("worktree %s\n", wt->path);
464         if (wt->is_bare)
465                 printf("bare\n");
466         else {
467                 printf("HEAD %s\n", oid_to_hex(&wt->head_oid));
468                 if (wt->is_detached)
469                         printf("detached\n");
470                 else if (wt->head_ref)
471                         printf("branch %s\n", wt->head_ref);
472         }
473         printf("\n");
474 }
475
476 static void show_worktree(struct worktree *wt, int path_maxlen, int abbrev_len)
477 {
478         struct strbuf sb = STRBUF_INIT;
479         int cur_path_len = strlen(wt->path);
480         int path_adj = cur_path_len - utf8_strwidth(wt->path);
481
482         strbuf_addf(&sb, "%-*s ", 1 + path_maxlen + path_adj, wt->path);
483         if (wt->is_bare)
484                 strbuf_addstr(&sb, "(bare)");
485         else {
486                 strbuf_addf(&sb, "%-*s ", abbrev_len,
487                                 find_unique_abbrev(wt->head_oid.hash, DEFAULT_ABBREV));
488                 if (wt->is_detached)
489                         strbuf_addstr(&sb, "(detached HEAD)");
490                 else if (wt->head_ref) {
491                         char *ref = shorten_unambiguous_ref(wt->head_ref, 0);
492                         strbuf_addf(&sb, "[%s]", ref);
493                         free(ref);
494                 } else
495                         strbuf_addstr(&sb, "(error)");
496         }
497         printf("%s\n", sb.buf);
498
499         strbuf_release(&sb);
500 }
501
502 static void measure_widths(struct worktree **wt, int *abbrev, int *maxlen)
503 {
504         int i;
505
506         for (i = 0; wt[i]; i++) {
507                 int sha1_len;
508                 int path_len = strlen(wt[i]->path);
509
510                 if (path_len > *maxlen)
511                         *maxlen = path_len;
512                 sha1_len = strlen(find_unique_abbrev(wt[i]->head_oid.hash, *abbrev));
513                 if (sha1_len > *abbrev)
514                         *abbrev = sha1_len;
515         }
516 }
517
518 static int list(int ac, const char **av, const char *prefix)
519 {
520         int porcelain = 0;
521
522         struct option options[] = {
523                 OPT_BOOL(0, "porcelain", &porcelain, N_("machine-readable output")),
524                 OPT_END()
525         };
526
527         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
528         if (ac)
529                 usage_with_options(worktree_usage, options);
530         else {
531                 struct worktree **worktrees = get_worktrees(GWT_SORT_LINKED);
532                 int path_maxlen = 0, abbrev = DEFAULT_ABBREV, i;
533
534                 if (!porcelain)
535                         measure_widths(worktrees, &abbrev, &path_maxlen);
536
537                 for (i = 0; worktrees[i]; i++) {
538                         if (porcelain)
539                                 show_worktree_porcelain(worktrees[i]);
540                         else
541                                 show_worktree(worktrees[i], path_maxlen, abbrev);
542                 }
543                 free_worktrees(worktrees);
544         }
545         return 0;
546 }
547
548 static int lock_worktree(int ac, const char **av, const char *prefix)
549 {
550         const char *reason = "", *old_reason;
551         struct option options[] = {
552                 OPT_STRING(0, "reason", &reason, N_("string"),
553                            N_("reason for locking")),
554                 OPT_END()
555         };
556         struct worktree **worktrees, *wt;
557
558         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
559         if (ac != 1)
560                 usage_with_options(worktree_usage, options);
561
562         worktrees = get_worktrees(0);
563         wt = find_worktree(worktrees, prefix, av[0]);
564         if (!wt)
565                 die(_("'%s' is not a working tree"), av[0]);
566         if (is_main_worktree(wt))
567                 die(_("The main working tree cannot be locked or unlocked"));
568
569         old_reason = is_worktree_locked(wt);
570         if (old_reason) {
571                 if (*old_reason)
572                         die(_("'%s' is already locked, reason: %s"),
573                             av[0], old_reason);
574                 die(_("'%s' is already locked"), av[0]);
575         }
576
577         write_file(git_common_path("worktrees/%s/locked", wt->id),
578                    "%s", reason);
579         free_worktrees(worktrees);
580         return 0;
581 }
582
583 static int unlock_worktree(int ac, const char **av, const char *prefix)
584 {
585         struct option options[] = {
586                 OPT_END()
587         };
588         struct worktree **worktrees, *wt;
589         int ret;
590
591         ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
592         if (ac != 1)
593                 usage_with_options(worktree_usage, options);
594
595         worktrees = get_worktrees(0);
596         wt = find_worktree(worktrees, prefix, av[0]);
597         if (!wt)
598                 die(_("'%s' is not a working tree"), av[0]);
599         if (is_main_worktree(wt))
600                 die(_("The main working tree cannot be locked or unlocked"));
601         if (!is_worktree_locked(wt))
602                 die(_("'%s' is not locked"), av[0]);
603         ret = unlink_or_warn(git_common_path("worktrees/%s/locked", wt->id));
604         free_worktrees(worktrees);
605         return ret;
606 }
607
608 int cmd_worktree(int ac, const char **av, const char *prefix)
609 {
610         struct option options[] = {
611                 OPT_END()
612         };
613
614         git_config(git_worktree_config, NULL);
615
616         if (ac < 2)
617                 usage_with_options(worktree_usage, options);
618         if (!prefix)
619                 prefix = "";
620         if (!strcmp(av[1], "add"))
621                 return add(ac - 1, av + 1, prefix);
622         if (!strcmp(av[1], "prune"))
623                 return prune(ac - 1, av + 1, prefix);
624         if (!strcmp(av[1], "list"))
625                 return list(ac - 1, av + 1, prefix);
626         if (!strcmp(av[1], "lock"))
627                 return lock_worktree(ac - 1, av + 1, prefix);
628         if (!strcmp(av[1], "unlock"))
629                 return unlock_worktree(ac - 1, av + 1, prefix);
630         usage_with_options(worktree_usage, options);
631 }