From: Yoichi NAKAYAMA <yoichi.nakayama@gmail.com>
Remove the file reading and trimming logic from `infer_backlink()`, and instead read the .git file once in its caller, `repair_worktree_at_path()`, using `read_gitfile_raw()`. Since `read_gitfile_gently()` is replaced with `read_gitfile_raw()`, restore the logic for constructing the absolute path and replace the READ_GITFILE_ERR_NOT_A_REPO handling with a check using `is_git_directory()`. Simplify the logic for prioritizing 'inferred_backlink' over 'backlink'.
Extract `get_worktree_id()` to get the worktree ID from the contents of the .git file. We are going to modify and use this function in subsequent commits.
Signed-off-by: Yoichi NAKAYAMA <yoichi.nakayama@gmail.com>
---
worktree.c | 89 ++++++++++++++++++++++++++----------------------------
1 file changed, 43 insertions(+), 46 deletions(-)
Show changes to worktree.c +43 −46
diff --git a/worktree.c b/worktree.c
index 8cb8637b18..7af13898d0 100644
--- a/worktree.c
+++ b/worktree.c
@@ -637,6 +637,14 @@ int other_head_refs(struct repository *repo,
return ret;
}
+static const char *get_worktree_id(const char *dotgit_contents)
+{
+ const char *slash = find_last_dir_sep(dotgit_contents);
+ if (!slash)
+ return "";
+ return slash + 1;
+}
+
/*
* Repair worktree's /path/to/worktree/.git file if missing, corrupt, or not
* pointing at <repo>/worktrees/<id>.
@@ -798,30 +806,20 @@ static int is_main_worktree_path(struct repository *repo, const char *path)
* Returns -1 on failure and strbuf.len on success.
*/
static ssize_t infer_backlink(struct repository *repo,
- const char *gitfile,
+ const char *dotgit_contents,
struct strbuf *inferred)
{
- struct strbuf actual = STRBUF_INIT;
const char *id;
- if (strbuf_read_file(&actual, gitfile, 0) < 0)
- goto error;
- if (!starts_with(actual.buf, "gitdir:"))
- goto error;
- if (!(id = find_last_dir_sep(actual.buf)))
- goto error;
- strbuf_trim(&actual);
- id++; /* advance past '/' to point at <id> */
+ id = get_worktree_id(dotgit_contents);
if (!*id)
goto error;
repo_common_path_replace(repo, inferred, "worktrees/%s", id);
if (!is_directory(inferred->buf))
goto error;
- strbuf_release(&actual);
return inferred->len;
error:
- strbuf_release(&actual);
strbuf_reset(inferred); /* clear invalid path */
return -1;
}
@@ -840,7 +838,8 @@ void repair_worktree_at_path(struct repository *repo,
struct strbuf inferred_backlink = STRBUF_INIT;
struct strbuf gitdir = STRBUF_INIT;
struct strbuf olddotgit = STRBUF_INIT;
- char *dotgit_contents = NULL;
+ struct strbuf contents = STRBUF_INIT;
+ const char *dotgit_contents = NULL;
const char *repair = NULL;
int err;
@@ -856,51 +855,49 @@ void repair_worktree_at_path(struct repository *repo,
goto done;
}
- infer_backlink(repo, dotgit.buf, &inferred_backlink);
- strbuf_realpath_forgiving(&inferred_backlink, inferred_backlink.buf, 0);
- dotgit_contents = xstrdup_or_null(read_gitfile_gently(dotgit.buf, &err));
- if (dotgit_contents) {
- strbuf_addstr(&backlink, dotgit_contents);
- } else if (err == READ_GITFILE_ERR_NOT_A_FILE ||
- err == READ_GITFILE_ERR_IS_A_DIR) {
+ err = read_gitfile_raw(&contents, dotgit.buf);
+ if (err == READ_GITFILE_ERR_NOT_A_FILE ||
+ err == READ_GITFILE_ERR_IS_A_DIR) {
fn(1, dotgit.buf, _("unable to locate repository; .git is not a file"), cb_data);
goto done;
- } else if (err == READ_GITFILE_ERR_NOT_A_REPO) {
- if (inferred_backlink.len) {
- /*
- * Worktree's .git file does not point at a repository
- * but we found a .git/worktrees/<id> in this
- * repository with the same <id> as recorded in the
- * worktree's .git file so make the worktree point at
- * the discovered .git/worktrees/<id>.
- */
- strbuf_swap(&backlink, &inferred_backlink);
- } else {
- fn(1, dotgit.buf, _("unable to locate repository; .git file does not reference a repository"), cb_data);
- goto done;
- }
- } else {
+ } else if (err) {
fn(1, dotgit.buf, _("unable to locate repository; .git file broken"), cb_data);
goto done;
}
+ dotgit_contents = contents.buf;
+ infer_backlink(repo, dotgit_contents, &inferred_backlink);
+ strbuf_realpath_forgiving(&inferred_backlink, inferred_backlink.buf, 0);
+
+ if (is_absolute_path(dotgit_contents)) {
+ strbuf_addstr(&backlink, dotgit_contents);
+ } else {
+ strbuf_addbuf(&backlink, &dotgit);
+ strbuf_strip_suffix(&backlink, ".git");
+ strbuf_addstr(&backlink, dotgit_contents);
+ strbuf_realpath_forgiving(&backlink, backlink.buf, 0);
+ }
+
+ if (!is_git_directory(backlink.buf) && !inferred_backlink.len) {
+ fn(1, dotgit.buf, _("unable to locate repository; .git file does not reference a repository"), cb_data);
+ goto done;
+ }
+
/*
* If we got this far, either the worktree's .git file pointed at a
- * valid repository (i.e. read_gitfile_gently() returned success) or
+ * valid repository (i.e. is_git_directory() returned true) or
* the .git file did not point at a repository but we were able to
* infer a suitable new value for the .git file by locating a
* .git/worktrees/<id> in *this* repository corresponding to the <id>
* recorded in the worktree's .git file.
*
- * However, if, at this point, inferred_backlink is non-NULL (i.e. we
- * found a suitable .git/worktrees/<id> in *this* repository) *and* the
- * worktree's .git file points at a valid repository *and* those two
- * paths differ, then that indicates that the user probably *copied*
- * the main and linked worktrees to a new location as a unit rather
- * than *moving* them. Thus, the copied worktree's .git file actually
- * points at the .git/worktrees/<id> in the *original* repository, not
- * in the "copy" repository. In this case, point the "copy" worktree's
- * .git file at the "copy" repository.
+ * Even if the worktree's .git file pointed at a valid repository,
+ * it doesn't always mean that the backlink is correct. For example,
+ * the user might have *copied* the main and linked worktrees to a
+ * new location as a unit rather than *moving* them (the copied
+ * worktree's .git file actually points at the .git/worktrees/<id>
+ * in the *original* repository, not in the "copy" repository).
+ * Therefore, we prioritize inferred_backlink over backlink.
*/
if (inferred_backlink.len && fspathcmp(backlink.buf, inferred_backlink.buf))
strbuf_swap(&backlink, &inferred_backlink);
@@ -926,12 +923,12 @@ void repair_worktree_at_path(struct repository *repo,
gitdir.buf, use_relative_paths);
}
done:
- free(dotgit_contents);
strbuf_release(&olddotgit);
strbuf_release(&backlink);
strbuf_release(&inferred_backlink);
strbuf_release(&gitdir);
strbuf_release(&dotgit);
+ strbuf_release(&contents);
}
int should_prune_worktree(struct repository *repo,