worktrees: add find_shared_symref

Add a new function, find_shared_symref, which contains the heart of
die_if_checked_out, but works for any symref, not just HEAD.  Refactor
die_if_checked_out to use the same infrastructure as
find_shared_symref.

Soon, we will use find_shared_symref to protect notes merges in
worktrees.

Signed-off-by: David Turner <dturner@twopensource.com>
Reviewed-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/branch.c b/branch.c
index af9480f25a54bf5706632b72b46c3cc6d8ae87d2..483c52740f75b1b47a80df67f167d039c7ef9d1b 100644 (file)
--- a/branch.c
+++ b/branch.c
@@ -310,21 +310,23 @@ void remove_branch_state(void)
        unlink(git_path("SQUASH_MSG"));
 }
 
-static void check_linked_checkout(const char *branch, const char *id)
+static char *find_linked_symref(const char *symref, const char *branch,
+                               const char *id)
 {
        struct strbuf sb = STRBUF_INIT;
        struct strbuf path = STRBUF_INIT;
        struct strbuf gitdir = STRBUF_INIT;
+       char *existing = NULL;
 
        /*
-        * $GIT_COMMON_DIR/HEAD is practically outside
-        * $GIT_DIR so resolve_ref_unsafe() won't work (it
-        * uses git_path). Parse the ref ourselves.
+        * $GIT_COMMON_DIR/$symref (e.g. HEAD) is practically outside
+        * $GIT_DIR so resolve_ref_unsafe() won't work (it uses
+        * git_path). Parse the ref ourselves.
         */
        if (id)
-               strbuf_addf(&path, "%s/worktrees/%s/HEAD", get_git_common_dir(), id);
+               strbuf_addf(&path, "%s/worktrees/%s/%s", get_git_common_dir(), id, symref);
        else
-               strbuf_addf(&path, "%s/HEAD", get_git_common_dir());
+               strbuf_addf(&path, "%s/%s", get_git_common_dir(), symref);
 
        if (!strbuf_readlink(&sb, path.buf, 0)) {
                if (!starts_with(sb.buf, "refs/") ||
@@ -346,33 +348,53 @@ static void check_linked_checkout(const char *branch, const char *id)
                strbuf_rtrim(&gitdir);
        } else
                strbuf_addstr(&gitdir, get_git_common_dir());
-       skip_prefix(branch, "refs/heads/", &branch);
        strbuf_strip_suffix(&gitdir, ".git");
-       die(_("'%s' is already checked out at '%s'"), branch, gitdir.buf);
+
+       existing = strbuf_detach(&gitdir, NULL);
 done:
        strbuf_release(&path);
        strbuf_release(&sb);
        strbuf_release(&gitdir);
+
+       return existing;
 }
 
-void die_if_checked_out(const char *branch)
+char *find_shared_symref(const char *symref, const char *target)
 {
        struct strbuf path = STRBUF_INIT;
        DIR *dir;
        struct dirent *d;
+       char *existing;
 
-       check_linked_checkout(branch, NULL);
+       if ((existing = find_linked_symref(symref, target, NULL)))
+               return existing;
 
        strbuf_addf(&path, "%s/worktrees", get_git_common_dir());
        dir = opendir(path.buf);
        strbuf_release(&path);
        if (!dir)
-               return;
+               return NULL;
 
        while ((d = readdir(dir)) != NULL) {
                if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
                        continue;
-               check_linked_checkout(branch, d->d_name);
+               existing = find_linked_symref(symref, target, d->d_name);
+               if (existing)
+                       goto done;
        }
+done:
        closedir(dir);
+
+       return existing;
+}
+
+void die_if_checked_out(const char *branch)
+{
+       char *existing;
+
+       existing = find_shared_symref("HEAD", branch);
+       if (existing) {
+               skip_prefix(branch, "refs/heads/", &branch);
+               die(_("'%s' is already checked out at '%s'"), branch, existing);
+       }
 }

diff --git a/branch.h b/branch.h
index 58aa45fe72ca356a8bd3648782b36e63e207ee36..d3446ed73c0c209f0d6b3dc2a7412a643031ea08 100644 (file)
--- a/branch.h
+++ b/branch.h
@@ -59,4 +59,12 @@ extern int read_branch_desc(struct strbuf *, const char *branch_name);
  */
 extern void die_if_checked_out(const char *branch);
 
+/*
+ * Check if a per-worktree symref points to a ref in the main worktree
+ * or any linked worktree, and return the path to the exising worktree
+ * if it is.  Returns NULL if there is no existing ref.  The caller is
+ * responsible for freeing the returned path.
+ */
+extern char *find_shared_symref(const char *symref, const char *target);
+
 #endif