worktree.c: kill parse_ref() in favor of refs_resolve_ref_unsafe()

The manual parsing code is replaced with a call to refs_resolve_ref_unsafe().
The manual parsing code must die because only refs/files-backend.c
should do that.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/branch.c b/branch.c
index 5c12036b0206fe250f50bea30578785b090f9ee4..0b949b7fb215640cffad654f7c50d8120a31b801 100644 (file)
--- a/branch.c
+++ b/branch.c
@@ -355,7 +355,8 @@ int replace_each_worktree_head_symref(const char *oldref, const char *newref,
        for (i = 0; worktrees[i]; i++) {
                if (worktrees[i]->is_detached)
                        continue;
        for (i = 0; worktrees[i]; i++) {
                if (worktrees[i]->is_detached)
                        continue;

-               if (strcmp(oldref, worktrees[i]->head_ref))
+               if (worktrees[i]->head_ref &&
+                   strcmp(oldref, worktrees[i]->head_ref))

                        continue;
 
                if (set_worktree_head_symref(get_worktree_git_dir(worktrees[i]),
                        continue;
 
                if (set_worktree_head_symref(get_worktree_git_dir(worktrees[i]),

diff --git a/t/helper/test-ref-store.c b/t/helper/test-ref-store.c
index 2d84c45ffe99d1d5430345a32d1386804c3c495d..4a487c014e08794a818704735101e85a6781c14a 100644 (file)
--- a/t/helper/test-ref-store.c
+++ b/t/helper/test-ref-store.c
@@ -1,5 +1,6 @@
 #include "cache.h"
 #include "refs.h"
 #include "cache.h"
 #include "refs.h"

+#include "worktree.h"

 
 static const char *notnull(const char *arg, const char *name)
 {
 
 static const char *notnull(const char *arg, const char *name)
 {


@@ -32,6 +33,23 @@ static const char **get_store(const char **argv, struct ref_store **refs)
                strbuf_release(&sb);
 
                *refs = get_submodule_ref_store(gitdir);
                strbuf_release(&sb);
 
                *refs = get_submodule_ref_store(gitdir);

+       } else if (skip_prefix(argv[0], "worktree:", &gitdir)) {
+               struct worktree **p, **worktrees = get_worktrees(0);
+
+               for (p = worktrees; *p; p++) {
+                       struct worktree *wt = *p;
+
+                       if (!wt->id) {
+                               /* special case for main worktree */
+                               if (!strcmp(gitdir, "main"))
+                                       break;
+                       } else if (!strcmp(gitdir, wt->id))
+                               break;
+               }
+               if (!*p)
+                       die("no such worktree: %s", gitdir);
+
+               *refs = get_worktree_ref_store(*p);

        } else
                die("unknown backend %s", argv[0]);
 
        } else
                die("unknown backend %s", argv[0]);
 

diff --git a/t/t1407-worktree-ref-store.sh b/t/t1407-worktree-ref-store.sh
new file mode 100755 (executable)
index 0000000..04d1e9d
--- /dev/null
+++ b/t/t1407-worktree-ref-store.sh
@@ -0,0 +1,40 @@
+#!/bin/sh
+
+test_description='test worktree ref store api'
+
+. ./test-lib.sh
+
+RWT="test-ref-store worktree:wt"
+RMAIN="test-ref-store worktree:main"
+
+test_expect_success 'setup' '
+       test_commit first &&
+       git worktree add -b wt-master wt &&
+       (
+               cd wt &&
+               test_commit second
+       )
+'
+
+test_expect_success 'resolve_ref(<shared-ref>)' '
+       SHA1=`git rev-parse master` &&
+       echo "$SHA1 refs/heads/master 0x0" >expected &&
+       $RWT resolve-ref refs/heads/master 0 >actual &&
+       test_cmp expected actual &&
+       $RMAIN resolve-ref refs/heads/master 0 >actual &&
+       test_cmp expected actual
+'
+
+test_expect_success 'resolve_ref(<per-worktree-ref>)' '
+       SHA1=`git -C wt rev-parse HEAD` &&
+       echo "$SHA1 refs/heads/wt-master 0x1" >expected &&
+       $RWT resolve-ref HEAD 0 >actual &&
+       test_cmp expected actual &&
+
+       SHA1=`git rev-parse HEAD` &&
+       echo "$SHA1 refs/heads/master 0x1" >expected &&
+       $RMAIN resolve-ref HEAD 0 >actual &&
+       test_cmp expected actual
+'
+
+test_done

diff --git a/worktree.c b/worktree.c
index fa7bc67a50a6d52116b0ca994b473668998f1c3f..c1ec334b06f8b8d55b4087d1208d85731fd46543 100644 (file)
--- a/worktree.c
+++ b/worktree.c
@@ -19,54 +19,25 @@ void free_worktrees(struct worktree **worktrees)
        free (worktrees);
 }
 
        free (worktrees);
 }
 

-/*
- * read 'path_to_ref' into 'ref'.  Also if is_detached is not NULL,
- * set is_detached to 1 (0) if the ref is detached (is not detached).
- *
- * $GIT_COMMON_DIR/$symref (e.g. HEAD) is practically outside $GIT_DIR so
- * for linked worktrees, `resolve_ref_unsafe()` won't work (it uses
- * git_path). Parse the ref ourselves.
- *
- * return -1 if the ref is not a proper ref, 0 otherwise (success)
- */
-static int parse_ref(char *path_to_ref, struct strbuf *ref, int *is_detached)
-{
-       if (is_detached)
-               *is_detached = 0;
-       if (!strbuf_readlink(ref, path_to_ref, 0)) {
-               /* HEAD is symbolic link */
-               if (!starts_with(ref->buf, "refs/") ||
-                               check_refname_format(ref->buf, 0))
-                       return -1;
-       } else if (strbuf_read_file(ref, path_to_ref, 0) >= 0) {
-               /* textual symref or detached */
-               if (!starts_with(ref->buf, "ref:")) {
-                       if (is_detached)
-                               *is_detached = 1;
-               } else {
-                       strbuf_remove(ref, 0, strlen("ref:"));
-                       strbuf_trim(ref);
-                       if (check_refname_format(ref->buf, 0))
-                               return -1;
-               }
-       } else
-               return -1;
-       return 0;
-}
-

 /**
 /**

- * Add the head_sha1 and head_ref (if not detached) to the given worktree
+ * Update head_sha1, head_ref and is_detached of the given worktree

  */
  */

-static void add_head_info(struct strbuf *head_ref, struct worktree *worktree)
+static void add_head_info(struct worktree *wt)

 {
 {

-       if (head_ref->len) {
-               if (worktree->is_detached) {
-                       get_sha1_hex(head_ref->buf, worktree->head_sha1);
-               } else {
-                       resolve_ref_unsafe(head_ref->buf, 0, worktree->head_sha1, NULL);
-                       worktree->head_ref = strbuf_detach(head_ref, NULL);
-               }
-       }
+       int flags;
+       const char *target;
+
+       target = refs_resolve_ref_unsafe(get_worktree_ref_store(wt),
+                                        "HEAD",
+                                        RESOLVE_REF_READING,
+                                        wt->head_sha1, &flags);
+       if (!target)
+               return;
+
+       if (flags & REF_ISSYMREF)
+               wt->head_ref = xstrdup(target);
+       else
+               wt->is_detached = 1;

 }
 
 /**
 }
 
 /**


@@ -77,9 +48,7 @@ static struct worktree *get_main_worktree(void)
        struct worktree *worktree = NULL;
        struct strbuf path = STRBUF_INIT;
        struct strbuf worktree_path = STRBUF_INIT;
        struct worktree *worktree = NULL;
        struct strbuf path = STRBUF_INIT;
        struct strbuf worktree_path = STRBUF_INIT;

-       struct strbuf head_ref = STRBUF_INIT;

        int is_bare = 0;
        int is_bare = 0;

-       int is_detached = 0;

 
        strbuf_add_absolute_path(&worktree_path, get_git_common_dir());
        is_bare = !strbuf_strip_suffix(&worktree_path, "/.git");
 
        strbuf_add_absolute_path(&worktree_path, get_git_common_dir());
        is_bare = !strbuf_strip_suffix(&worktree_path, "/.git");


@@ -91,13 +60,10 @@ static struct worktree *get_main_worktree(void)
        worktree = xcalloc(1, sizeof(*worktree));
        worktree->path = strbuf_detach(&worktree_path, NULL);
        worktree->is_bare = is_bare;
        worktree = xcalloc(1, sizeof(*worktree));
        worktree->path = strbuf_detach(&worktree_path, NULL);
        worktree->is_bare = is_bare;

-       worktree->is_detached = is_detached;
-       if (!parse_ref(path.buf, &head_ref, &is_detached))
-               add_head_info(&head_ref, worktree);
+       add_head_info(worktree);

 
        strbuf_release(&path);
        strbuf_release(&worktree_path);
 
        strbuf_release(&path);
        strbuf_release(&worktree_path);

-       strbuf_release(&head_ref);

        return worktree;
 }
 
        return worktree;
 }
 


@@ -106,8 +72,6 @@ static struct worktree *get_linked_worktree(const char *id)
        struct worktree *worktree = NULL;
        struct strbuf path = STRBUF_INIT;
        struct strbuf worktree_path = STRBUF_INIT;
        struct worktree *worktree = NULL;
        struct strbuf path = STRBUF_INIT;
        struct strbuf worktree_path = STRBUF_INIT;

-       struct strbuf head_ref = STRBUF_INIT;
-       int is_detached = 0;

 
        if (!id)
                die("Missing linked worktree name");
 
        if (!id)
                die("Missing linked worktree name");


@@ -127,19 +91,14 @@ static struct worktree *get_linked_worktree(const char *id)
        strbuf_reset(&path);
        strbuf_addf(&path, "%s/worktrees/%s/HEAD", get_git_common_dir(), id);
 
        strbuf_reset(&path);
        strbuf_addf(&path, "%s/worktrees/%s/HEAD", get_git_common_dir(), id);
 

-       if (parse_ref(path.buf, &head_ref, &is_detached) < 0)
-               goto done;
-

        worktree = xcalloc(1, sizeof(*worktree));
        worktree->path = strbuf_detach(&worktree_path, NULL);
        worktree->id = xstrdup(id);
        worktree = xcalloc(1, sizeof(*worktree));
        worktree->path = strbuf_detach(&worktree_path, NULL);
        worktree->id = xstrdup(id);

-       worktree->is_detached = is_detached;
-       add_head_info(&head_ref, worktree);
+       add_head_info(worktree);

 
 done:
        strbuf_release(&path);
        strbuf_release(&worktree_path);
 
 done:
        strbuf_release(&path);
        strbuf_release(&worktree_path);

-       strbuf_release(&head_ref);

        return worktree;
 }
 
        return worktree;
 }
 


@@ -334,8 +293,6 @@ const struct worktree *find_shared_symref(const char *symref,
                                          const char *target)
 {
        const struct worktree *existing = NULL;
                                          const char *target)
 {
        const struct worktree *existing = NULL;

-       struct strbuf path = STRBUF_INIT;
-       struct strbuf sb = STRBUF_INIT;

        static struct worktree **worktrees;
        int i = 0;
 
        static struct worktree **worktrees;
        int i = 0;
 


@@ -345,6 +302,11 @@ const struct worktree *find_shared_symref(const char *symref,
 
        for (i = 0; worktrees[i]; i++) {
                struct worktree *wt = worktrees[i];
 
        for (i = 0; worktrees[i]; i++) {
                struct worktree *wt = worktrees[i];

+               const char *symref_target;
+               unsigned char sha1[20];
+               struct ref_store *refs;
+               int flags;
+

                if (wt->is_bare)
                        continue;
 
                if (wt->is_bare)
                        continue;
 


@@ -359,25 +321,15 @@ const struct worktree *find_shared_symref(const char *symref,
                        }
                }
 
                        }
                }
 

-               strbuf_reset(&path);
-               strbuf_reset(&sb);
-               strbuf_addf(&path, "%s/%s",
-                           get_worktree_git_dir(wt),
-                           symref);
-
-               if (parse_ref(path.buf, &sb, NULL)) {
-                       continue;
-               }
-
-               if (!strcmp(sb.buf, target)) {
+               refs = get_worktree_ref_store(wt);
+               symref_target = refs_resolve_ref_unsafe(refs, symref, 0,
+                                                       sha1, &flags);
+               if ((flags & REF_ISSYMREF) && !strcmp(symref_target, target)) {

                        existing = wt;
                        break;
                }
        }
 
                        existing = wt;
                        break;
                }
        }
 

-       strbuf_release(&path);
-       strbuf_release(&sb);
-

        return existing;
 }
 
        return existing;
 }
 

diff --git a/worktree.h b/worktree.h
index 6bfb985203070e3051f82348568840f5577bf0dc..5ea5e503fbe491a76d3c8ce279b7e281a5d07d3e 100644 (file)
--- a/worktree.h
+++ b/worktree.h
@@ -4,7 +4,7 @@
 struct worktree {
        char *path;
        char *id;
 struct worktree {
        char *path;
        char *id;

-       char *head_ref;
+       char *head_ref;         /* NULL if HEAD is broken or detached */

        char *lock_reason;      /* internal use */
        unsigned char head_sha1[20];
        int is_detached;
        char *lock_reason;      /* internal use */
        unsigned char head_sha1[20];
        int is_detached;