From ac6c561b598ae74d8e752e22607194536000e4db Mon Sep 17 00:00:00 2001 From: Michael Rappazzo Date: Fri, 2 Oct 2015 07:55:31 -0400 Subject: worktree: add top-level worktree.c worktree.c contains functions to work with and get information from worktrees. This introduction moves functions related to worktrees from branch.c into worktree.c Signed-off-by: Michael Rappazzo Signed-off-by: Junio C Hamano --- worktree.c | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 worktree.c (limited to 'worktree.c') diff --git a/worktree.c b/worktree.c new file mode 100644 index 0000000000..10e14960b2 --- /dev/null +++ b/worktree.c @@ -0,0 +1,82 @@ +#include "cache.h" +#include "refs.h" +#include "strbuf.h" +#include "worktree.h" + +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/$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/%s", get_git_common_dir(), id, symref); + else + strbuf_addf(&path, "%s/%s", get_git_common_dir(), symref); + + if (!strbuf_readlink(&sb, path.buf, 0)) { + if (!starts_with(sb.buf, "refs/") || + check_refname_format(sb.buf, 0)) + goto done; + } else if (strbuf_read_file(&sb, path.buf, 0) >= 0 && + starts_with(sb.buf, "ref:")) { + strbuf_remove(&sb, 0, strlen("ref:")); + strbuf_trim(&sb); + } else + goto done; + if (strcmp(sb.buf, branch)) + goto done; + if (id) { + strbuf_reset(&path); + strbuf_addf(&path, "%s/worktrees/%s/gitdir", get_git_common_dir(), id); + if (strbuf_read_file(&gitdir, path.buf, 0) <= 0) + goto done; + strbuf_rtrim(&gitdir); + } else + strbuf_addstr(&gitdir, get_git_common_dir()); + strbuf_strip_suffix(&gitdir, ".git"); + + existing = strbuf_detach(&gitdir, NULL); +done: + strbuf_release(&path); + strbuf_release(&sb); + strbuf_release(&gitdir); + + return existing; +} + +char *find_shared_symref(const char *symref, const char *target) +{ + struct strbuf path = STRBUF_INIT; + DIR *dir; + struct dirent *d; + char *existing; + + 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 NULL; + + while ((d = readdir(dir)) != NULL) { + if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) + continue; + existing = find_linked_symref(symref, target, d->d_name); + if (existing) + goto done; + } +done: + closedir(dir); + + return existing; +} -- cgit v1.3 From 1ceb7f90674897a24a9f2a56abf7d26297761f18 Mon Sep 17 00:00:00 2001 From: Michael Rappazzo Date: Thu, 8 Oct 2015 13:01:02 -0400 Subject: worktree: refactor find_linked_symref function Refactoring will help transition this code to provide additional useful worktree functions. Signed-off-by: Michael Rappazzo Signed-off-by: Junio C Hamano --- worktree.c | 96 ++++++++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 69 insertions(+), 27 deletions(-) (limited to 'worktree.c') diff --git a/worktree.c b/worktree.c index 10e14960b2..3c2498ae1c 100644 --- a/worktree.c +++ b/worktree.c @@ -3,6 +3,64 @@ #include "strbuf.h" #include "worktree.h" +/* + * read 'path_to_ref' into 'ref'. Also if is_detached is not NULL, + * set is_detached to 1 (0) if the ref is detatched (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; +} + +static char *find_main_symref(const char *symref, const char *branch) +{ + struct strbuf sb = STRBUF_INIT; + struct strbuf path = STRBUF_INIT; + struct strbuf gitdir = STRBUF_INIT; + char *existing = NULL; + + strbuf_addf(&path, "%s/%s", get_git_common_dir(), symref); + if (parse_ref(path.buf, &sb, NULL) < 0) + goto done; + if (strcmp(sb.buf, branch)) + goto done; + strbuf_addstr(&gitdir, get_git_common_dir()); + strbuf_strip_suffix(&gitdir, ".git"); + existing = strbuf_detach(&gitdir, NULL); +done: + strbuf_release(&path); + strbuf_release(&sb); + strbuf_release(&gitdir); + + return existing; +} + static char *find_linked_symref(const char *symref, const char *branch, const char *id) { @@ -11,36 +69,20 @@ static char *find_linked_symref(const char *symref, const char *branch, struct strbuf gitdir = STRBUF_INIT; char *existing = NULL; - /* - * $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/%s", get_git_common_dir(), id, symref); - else - strbuf_addf(&path, "%s/%s", get_git_common_dir(), symref); + if (!id) + die("Missing linked worktree name"); - if (!strbuf_readlink(&sb, path.buf, 0)) { - if (!starts_with(sb.buf, "refs/") || - check_refname_format(sb.buf, 0)) - goto done; - } else if (strbuf_read_file(&sb, path.buf, 0) >= 0 && - starts_with(sb.buf, "ref:")) { - strbuf_remove(&sb, 0, strlen("ref:")); - strbuf_trim(&sb); - } else + strbuf_addf(&path, "%s/worktrees/%s/%s", get_git_common_dir(), id, symref); + + if (parse_ref(path.buf, &sb, NULL) < 0) goto done; if (strcmp(sb.buf, branch)) goto done; - if (id) { - strbuf_reset(&path); - strbuf_addf(&path, "%s/worktrees/%s/gitdir", get_git_common_dir(), id); - if (strbuf_read_file(&gitdir, path.buf, 0) <= 0) - goto done; - strbuf_rtrim(&gitdir); - } else - strbuf_addstr(&gitdir, get_git_common_dir()); + strbuf_reset(&path); + strbuf_addf(&path, "%s/worktrees/%s/gitdir", get_git_common_dir(), id); + if (strbuf_read_file(&gitdir, path.buf, 0) <= 0) + goto done; + strbuf_rtrim(&gitdir); strbuf_strip_suffix(&gitdir, ".git"); existing = strbuf_detach(&gitdir, NULL); @@ -59,7 +101,7 @@ char *find_shared_symref(const char *symref, const char *target) struct dirent *d; char *existing; - if ((existing = find_linked_symref(symref, target, NULL))) + if ((existing = find_main_symref(symref, target))) return existing; strbuf_addf(&path, "%s/worktrees", get_git_common_dir()); -- cgit v1.3 From 51934904425e55a190b05f0a7a3de40ea486f0e5 Mon Sep 17 00:00:00 2001 From: Michael Rappazzo Date: Thu, 8 Oct 2015 13:01:03 -0400 Subject: worktree: add a function to get worktree details The worktree structure provided for an individual worktree includes the absolute path of the worktree. The fuction to get the worktree details is a refactor of the find main/linked symref functions. Signed-off-by: Michael Rappazzo Signed-off-by: Junio C Hamano --- worktree.c | 154 +++++++++++++++++++++++++++++++++++++++++++------------------ worktree.h | 22 +++++++++ 2 files changed, 130 insertions(+), 46 deletions(-) (limited to 'worktree.c') diff --git a/worktree.c b/worktree.c index 3c2498ae1c..c2e6db0a2c 100644 --- a/worktree.c +++ b/worktree.c @@ -3,6 +3,17 @@ #include "strbuf.h" #include "worktree.h" +void free_worktrees(struct worktree **worktrees) +{ + int i = 0; + + for (i = 0; worktrees[i]; i++) { + free(worktrees[i]->path); + free(worktrees[i]); + } + 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 detatched (is not detached). @@ -38,87 +49,138 @@ static int parse_ref(char *path_to_ref, struct strbuf *ref, int *is_detached) return 0; } -static char *find_main_symref(const char *symref, const char *branch) +/** + * get the main worktree + */ +static struct worktree *get_main_worktree(void) { - struct strbuf sb = STRBUF_INIT; + struct worktree *worktree = NULL; struct strbuf path = STRBUF_INIT; + struct strbuf worktree_path = STRBUF_INIT; struct strbuf gitdir = STRBUF_INIT; - char *existing = NULL; + struct strbuf head_ref = STRBUF_INIT; - strbuf_addf(&path, "%s/%s", get_git_common_dir(), symref); - if (parse_ref(path.buf, &sb, NULL) < 0) - goto done; - if (strcmp(sb.buf, branch)) - goto done; - strbuf_addstr(&gitdir, get_git_common_dir()); - strbuf_strip_suffix(&gitdir, ".git"); - existing = strbuf_detach(&gitdir, NULL); -done: + strbuf_addf(&gitdir, "%s", absolute_path(get_git_common_dir())); + strbuf_addbuf(&worktree_path, &gitdir); + if (!strbuf_strip_suffix(&worktree_path, "/.git")) + strbuf_strip_suffix(&worktree_path, "/."); + + strbuf_addf(&path, "%s/HEAD", get_git_common_dir()); + + if (parse_ref(path.buf, &head_ref, NULL) >= 0) { + worktree = xmalloc(sizeof(struct worktree)); + worktree->path = strbuf_detach(&worktree_path, NULL); + worktree->git_dir = strbuf_detach(&gitdir, NULL); + } strbuf_release(&path); - strbuf_release(&sb); strbuf_release(&gitdir); - - return existing; + strbuf_release(&worktree_path); + strbuf_release(&head_ref); + return worktree; } -static char *find_linked_symref(const char *symref, const char *branch, - const char *id) +static struct worktree *get_linked_worktree(const char *id) { - struct strbuf sb = STRBUF_INIT; + struct worktree *worktree = NULL; struct strbuf path = STRBUF_INIT; + struct strbuf worktree_path = STRBUF_INIT; struct strbuf gitdir = STRBUF_INIT; - char *existing = NULL; + struct strbuf head_ref = STRBUF_INIT; if (!id) die("Missing linked worktree name"); - strbuf_addf(&path, "%s/worktrees/%s/%s", get_git_common_dir(), id, symref); - - if (parse_ref(path.buf, &sb, NULL) < 0) - goto done; - if (strcmp(sb.buf, branch)) + strbuf_addf(&gitdir, "%s/worktrees/%s", + absolute_path(get_git_common_dir()), id); + strbuf_addf(&path, "%s/gitdir", gitdir.buf); + if (strbuf_read_file(&worktree_path, path.buf, 0) <= 0) + /* invalid gitdir file */ goto done; + + strbuf_rtrim(&worktree_path); + if (!strbuf_strip_suffix(&worktree_path, "/.git")) { + strbuf_reset(&worktree_path); + strbuf_addstr(&worktree_path, absolute_path(".")); + strbuf_strip_suffix(&worktree_path, "/."); + } + strbuf_reset(&path); - strbuf_addf(&path, "%s/worktrees/%s/gitdir", get_git_common_dir(), id); - if (strbuf_read_file(&gitdir, path.buf, 0) <= 0) - goto done; - strbuf_rtrim(&gitdir); - strbuf_strip_suffix(&gitdir, ".git"); + strbuf_addf(&path, "%s/worktrees/%s/HEAD", get_git_common_dir(), id); + + if (parse_ref(path.buf, &head_ref, NULL) >= 0) { + worktree = xmalloc(sizeof(struct worktree)); + worktree->path = strbuf_detach(&worktree_path, NULL); + worktree->git_dir = strbuf_detach(&gitdir, NULL); + } - existing = strbuf_detach(&gitdir, NULL); done: strbuf_release(&path); - strbuf_release(&sb); strbuf_release(&gitdir); - - return existing; + strbuf_release(&worktree_path); + strbuf_release(&head_ref); + return worktree; } -char *find_shared_symref(const char *symref, const char *target) +struct worktree **get_worktrees(void) { + struct worktree **list = NULL; struct strbuf path = STRBUF_INIT; DIR *dir; struct dirent *d; - char *existing; + int counter = 0, alloc = 2; + + list = xmalloc(alloc * sizeof(struct worktree *)); - if ((existing = find_main_symref(symref, target))) - return existing; + if ((list[counter] = get_main_worktree())) + counter++; strbuf_addf(&path, "%s/worktrees", get_git_common_dir()); dir = opendir(path.buf); strbuf_release(&path); - if (!dir) - return NULL; + if (dir) { + while ((d = readdir(dir)) != NULL) { + struct worktree *linked = NULL; + if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) + continue; - while ((d = readdir(dir)) != NULL) { - if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) + if ((linked = get_linked_worktree(d->d_name))) { + ALLOC_GROW(list, counter + 1, alloc); + list[counter++] = linked; + } + } + closedir(dir); + } + ALLOC_GROW(list, counter + 1, alloc); + list[counter] = NULL; + return list; +} + +char *find_shared_symref(const char *symref, const char *target) +{ + char *existing = NULL; + struct strbuf path = STRBUF_INIT; + struct strbuf sb = STRBUF_INIT; + struct worktree **worktrees = get_worktrees(); + int i = 0; + + for (i = 0; worktrees[i]; i++) { + strbuf_reset(&path); + strbuf_reset(&sb); + strbuf_addf(&path, "%s/%s", worktrees[i]->git_dir, symref); + + if (parse_ref(path.buf, &sb, NULL)) { continue; - existing = find_linked_symref(symref, target, d->d_name); - if (existing) - goto done; + } + + if (!strcmp(sb.buf, target)) { + existing = xstrdup(worktrees[i]->path); + break; + } } -done: - closedir(dir); + + strbuf_release(&path); + strbuf_release(&sb); + free_worktrees(worktrees); return existing; } diff --git a/worktree.h b/worktree.h index 71b14092c4..7022029db5 100644 --- a/worktree.h +++ b/worktree.h @@ -1,6 +1,28 @@ #ifndef WORKTREE_H #define WORKTREE_H +struct worktree { + char *path; + char *git_dir; +}; + +/* Functions for acting on the information about worktrees. */ + +/* + * Get the worktrees. The primary worktree will always be the first returned, + * and linked worktrees will be pointed to by 'next' in each subsequent + * worktree. No specific ordering is done on the linked worktrees. + * + * The caller is responsible for freeing the memory from the returned + * worktree(s). + */ +extern struct worktree **get_worktrees(void); + +/* + * Free up the memory for worktree(s) + */ +extern void free_worktrees(struct worktree **); + /* * 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 -- cgit v1.3 From 92718b7438799f4654304e2fa3b5b7e5a9fda882 Mon Sep 17 00:00:00 2001 From: Michael Rappazzo Date: Thu, 8 Oct 2015 13:01:04 -0400 Subject: worktree: add details to the worktree struct In addition to the absolute path in the worktree struct, add the location of the git dir, the head ref (if not detached), the head revision sha1, whether or not head is detached, and whether or not the worktree is a bare repo. Signed-off-by: Michael Rappazzo Signed-off-by: Junio C Hamano --- worktree.c | 55 ++++++++++++++++++++++++++++++++++++++++++++----------- worktree.h | 4 ++++ 2 files changed, 48 insertions(+), 11 deletions(-) (limited to 'worktree.c') diff --git a/worktree.c b/worktree.c index c2e6db0a2c..981f810e80 100644 --- a/worktree.c +++ b/worktree.c @@ -9,6 +9,8 @@ void free_worktrees(struct worktree **worktrees) for (i = 0; worktrees[i]; i++) { free(worktrees[i]->path); + free(worktrees[i]->git_dir); + free(worktrees[i]->head_ref); free(worktrees[i]); } free (worktrees); @@ -49,6 +51,21 @@ static int parse_ref(char *path_to_ref, struct strbuf *ref, int *is_detached) return 0; } +/** + * Add the head_sha1 and head_ref (if not detached) to the given worktree + */ +static void add_head_info(struct strbuf *head_ref, struct worktree *worktree) +{ + 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); + } + } +} + /** * get the main worktree */ @@ -59,19 +76,29 @@ static struct worktree *get_main_worktree(void) struct strbuf worktree_path = STRBUF_INIT; struct strbuf gitdir = STRBUF_INIT; struct strbuf head_ref = STRBUF_INIT; + int is_bare = 0; + int is_detached = 0; strbuf_addf(&gitdir, "%s", absolute_path(get_git_common_dir())); strbuf_addbuf(&worktree_path, &gitdir); - if (!strbuf_strip_suffix(&worktree_path, "/.git")) + is_bare = !strbuf_strip_suffix(&worktree_path, "/.git"); + if (is_bare) strbuf_strip_suffix(&worktree_path, "/."); strbuf_addf(&path, "%s/HEAD", get_git_common_dir()); - if (parse_ref(path.buf, &head_ref, NULL) >= 0) { - worktree = xmalloc(sizeof(struct worktree)); - worktree->path = strbuf_detach(&worktree_path, NULL); - worktree->git_dir = strbuf_detach(&gitdir, NULL); - } + if (parse_ref(path.buf, &head_ref, &is_detached) < 0) + goto done; + + worktree = xmalloc(sizeof(struct worktree)); + worktree->path = strbuf_detach(&worktree_path, NULL); + worktree->git_dir = strbuf_detach(&gitdir, NULL); + worktree->is_bare = is_bare; + worktree->head_ref = NULL; + worktree->is_detached = is_detached; + add_head_info(&head_ref, worktree); + +done: strbuf_release(&path); strbuf_release(&gitdir); strbuf_release(&worktree_path); @@ -86,6 +113,7 @@ static struct worktree *get_linked_worktree(const char *id) struct strbuf worktree_path = STRBUF_INIT; struct strbuf gitdir = STRBUF_INIT; struct strbuf head_ref = STRBUF_INIT; + int is_detached = 0; if (!id) die("Missing linked worktree name"); @@ -107,11 +135,16 @@ static struct worktree *get_linked_worktree(const char *id) strbuf_reset(&path); strbuf_addf(&path, "%s/worktrees/%s/HEAD", get_git_common_dir(), id); - if (parse_ref(path.buf, &head_ref, NULL) >= 0) { - worktree = xmalloc(sizeof(struct worktree)); - worktree->path = strbuf_detach(&worktree_path, NULL); - worktree->git_dir = strbuf_detach(&gitdir, NULL); - } + if (parse_ref(path.buf, &head_ref, &is_detached) < 0) + goto done; + + worktree = xmalloc(sizeof(struct worktree)); + worktree->path = strbuf_detach(&worktree_path, NULL); + worktree->git_dir = strbuf_detach(&gitdir, NULL); + worktree->is_bare = 0; + worktree->head_ref = NULL; + worktree->is_detached = is_detached; + add_head_info(&head_ref, worktree); done: strbuf_release(&path); diff --git a/worktree.h b/worktree.h index 7022029db5..b4b3dda792 100644 --- a/worktree.h +++ b/worktree.h @@ -4,6 +4,10 @@ struct worktree { char *path; char *git_dir; + char *head_ref; + unsigned char head_sha1[20]; + int is_detached; + int is_bare; }; /* Functions for acting on the information about worktrees. */ -- cgit v1.3