Merge branch 'pm/build-persistent-https-with-recent-go'

diff --git a/worktree.c b/worktree.c
index 12a766a38d301e2ab7d6cfc3efadf83d5b8c8953..5acfe4cd64967d86462f3958433f3d2f844ead51 100644 (file)
--- a/worktree.c
+++ b/worktree.c
@@ -13,6 +13,7 @@ void free_worktrees(struct worktree **worktrees)
                free(worktrees[i]->path);
                free(worktrees[i]->id);
                free(worktrees[i]->head_ref);
+               free(worktrees[i]->lock_reason);
                free(worktrees[i]);
        }
        free (worktrees);
@@ -20,7 +21,7 @@ void free_worktrees(struct worktree **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).
+ * 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
@@ -80,7 +81,7 @@ static struct worktree *get_main_worktree(void)
        int is_bare = 0;
        int is_detached = 0;
 
-       strbuf_addstr(&worktree_path, absolute_path(get_git_common_dir()));
+       strbuf_add_absolute_path(&worktree_path, get_git_common_dir());
        is_bare = !strbuf_strip_suffix(&worktree_path, "/.git");
        if (is_bare)
                strbuf_strip_suffix(&worktree_path, "/.");
@@ -98,6 +99,8 @@ static struct worktree *get_main_worktree(void)
        worktree->is_detached = is_detached;
        worktree->is_current = 0;
        add_head_info(&head_ref, worktree);
+       worktree->lock_reason = NULL;
+       worktree->lock_reason_valid = 0;
 
 done:
        strbuf_release(&path);
@@ -125,7 +128,7 @@ static struct worktree *get_linked_worktree(const char *id)
        strbuf_rtrim(&worktree_path);
        if (!strbuf_strip_suffix(&worktree_path, "/.git")) {
                strbuf_reset(&worktree_path);
-               strbuf_addstr(&worktree_path, absolute_path("."));
+               strbuf_add_absolute_path(&worktree_path, ".");
                strbuf_strip_suffix(&worktree_path, "/.");
        }
 
@@ -143,6 +146,8 @@ static struct worktree *get_linked_worktree(const char *id)
        worktree->is_detached = is_detached;
        worktree->is_current = 0;
        add_head_info(&head_ref, worktree);
+       worktree->lock_reason = NULL;
+       worktree->lock_reason_valid = 0;
 
 done:
        strbuf_release(&path);
@@ -214,12 +219,41 @@ const char *get_worktree_git_dir(const struct worktree *wt)
                return git_common_path("worktrees/%s", wt->id);
 }
 
+static struct worktree *find_worktree_by_suffix(struct worktree **list,
+                                               const char *suffix)
+{
+       struct worktree *found = NULL;
+       int nr_found = 0, suffixlen;
+
+       suffixlen = strlen(suffix);
+       if (!suffixlen)
+               return NULL;
+
+       for (; *list && nr_found < 2; list++) {
+               const char      *path    = (*list)->path;
+               int              pathlen = strlen(path);
+               int              start   = pathlen - suffixlen;
+
+               /* suffix must start at directory boundary */
+               if ((!start || (start > 0 && is_dir_sep(path[start - 1]))) &&
+                   !fspathcmp(suffix, path + start)) {
+                       found = *list;
+                       nr_found++;
+               }
+       }
+       return nr_found == 1 ? found : NULL;
+}
+
 struct worktree *find_worktree(struct worktree **list,
                               const char *prefix,
                               const char *arg)
 {
+       struct worktree *wt;
        char *path;
 
+       if ((wt = find_worktree_by_suffix(list, arg)))
+               return wt;
+
        arg = prefix_filename(prefix, strlen(prefix), arg);
        path = xstrdup(real_path(arg));
        for (; *list; list++)
@@ -234,6 +268,29 @@ int is_main_worktree(const struct worktree *wt)
        return !wt->id;
 }
 
+const char *is_worktree_locked(struct worktree *wt)
+{
+       assert(!is_main_worktree(wt));
+
+       if (!wt->lock_reason_valid) {
+               struct strbuf path = STRBUF_INIT;
+
+               strbuf_addstr(&path, worktree_git_path(wt, "locked"));
+               if (file_exists(path.buf)) {
+                       struct strbuf lock_reason = STRBUF_INIT;
+                       if (strbuf_read_file(&lock_reason, path.buf, 0) < 0)
+                               die_errno(_("failed to read '%s'"), path.buf);
+                       strbuf_trim(&lock_reason);
+                       wt->lock_reason = strbuf_detach(&lock_reason, NULL);
+               } else
+                       wt->lock_reason = NULL;
+               wt->lock_reason_valid = 1;
+               strbuf_release(&path);
+       }
+
+       return wt->lock_reason;
+}
+
 int is_worktree_being_rebased(const struct worktree *wt,
                              const char *target)
 {