nd/worktree-move update

This function is later used by "worktree move" and "worktree remove" to ensure that we have a good connection between the repository and the worktree. For example, if a worktree is moved manually, the worktree location recorded in $GIT_DIR/worktrees/.../gitdir is incorrect and we should not move that one.

Signed-off-by Nguyễn Thái Ngọc Duy <[email protected]>

---
 worktree.c | 66 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 worktree.h |  5 +++++
 2 files changed, 71 insertions(+)

worktree.c +22 -0

index bae787cf8d..40cc031ac9 100644
@@ -294,6 +294,72 @@ const char *is_worktree_locked(struct worktree *wt)
 	return wt->lock_reason;
 }
 
+static int report(int quiet, const char *fmt, ...)
+{
+	va_list params;
+
+	if (quiet)
+		return -1;
+
+	va_start(params, fmt);
+	vfprintf(stderr, fmt, params);
+	fputc('\n', stderr);
+	va_end(params);
+	return -1;
+}
+
+int validate_worktree(const struct worktree *wt, int quiet)
+{
+	struct strbuf sb = STRBUF_INIT;
+	char *path;
+	int err, ret;
+
+	if (is_main_worktree(wt)) {
+		/*

worktree.c +10 -0

+	ret = fspathcmp(path, real_path(git_common_path("worktrees/%s", wt->id)));
+	free(path);
+
+	if (ret)
+		return report(quiet, _("'%s' does not point back to '%s'"),
+			      wt->path, git_common_path("worktrees/%s", wt->id));
+
+	return 0;
+}
+
 int is_worktree_being_rebased(const struct worktree *wt,
 			      const char *target)
 {

worktree.h +5 -0

index 6bfb985203..33f7405e33 100644
@@ -58,6 +58,11 @@ extern int is_main_worktree(const struct worktree *wt);
 extern const char *is_worktree_locked(struct worktree *wt);
 
 /*
+ * Return zero if the worktree is in good condition.
+ */
+extern int validate_worktree(const struct worktree *wt, int quiet);
+
+/*
  * Free up the memory for worktree(s)
  */
 extern void free_worktrees(struct worktree **);

Signed-off-by Nguyễn Thái Ngọc Duy <[email protected]>

---
 worktree.c | 21 +++++++++++++++++++++
 worktree.h |  6 ++++++
 2 files changed, 27 insertions(+)

worktree.c +0 -0

index 40cc031ac9..c695dcf982 100644

worktree.c +0 -0

 int is_worktree_being_rebased(const struct worktree *wt,
 			      const char *target)
 {

worktree.h +6 -0

index 33f7405e33..b896bdec55 100644
@@ -63,6 +63,12 @@ extern const char *is_worktree_locked(struct worktree *wt);
 extern int validate_worktree(const struct worktree *wt, int quiet);
 
 /*
+ * Update worktrees/xxx/gitdir with the new path.
+ */
+extern int update_worktree_location(struct worktree *wt,
+				    const char *path_);
+
+/*
  * Free up the memory for worktree(s)
  */
 extern void free_worktrees(struct worktree **);

There are two options to move the main worktree, but both have complications, so it's not implemented yet. Anyway the options are:

- convert the main worktree to a linked one and move it away, leave the git repository where it is. The repo essentially becomes bare after this move.

- move the repository with the main worktree. The tricky part is make sure all file descriptors to the repository are closed, or it may fail on Windows.

Signed-off-by Nguyễn Thái Ngọc Duy <[email protected]>

---
 Documentation/git-worktree.txt         |  7 +++++-
 builtin/worktree.c                     | 41 ++++++++++++++++++++++++++++++++++
 contrib/completion/git-completion.bash |  2 +-
 t/t2028-worktree-move.sh               | 31 +++++++++++++++++++++++++
 4 files changed, 79 insertions(+), 2 deletions(-)

Documentation/git-worktree.txt +1 -0

index 553cf8413f..b47a3247bb 100644
@@ -12,6 +12,7 @@ SYNOPSIS
 'git worktree add' [-f] [--detach] [--checkout] [-b <new-branch>] <path> [<branch>]
 'git worktree list' [--porcelain]
 'git worktree lock' [--reason <string>] <worktree>
+'git worktree move' <worktree> <new-path>
 'git worktree prune' [-n] [-v] [--expire <expire>]
 'git worktree unlock' <worktree>
 

Documentation/git-worktree.txt +13 -0

+static int move_worktree(int ac, const char **av, const char *prefix)
+{
+	struct option options[] = {
+		OPT_END()
+	};
+	struct worktree **worktrees, *wt;
+	struct strbuf dst = STRBUF_INIT;
+	const char *reason;
+
+	ac = parse_options(ac, av, prefix, options, worktree_usage, 0);
+	if (ac != 2)
+		usage_with_options(worktree_usage, options);
+

Similar to "mv a b/", which is actually "mv a b/a", we extract basename of source worktree and create a directory of the same name at destination if dst path is a directory.

Signed-off-by Nguyễn Thái Ngọc Duy <[email protected]>

---
 builtin/worktree.c | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

builtin/worktree.c +0 -0

index e3fbfe2a71..116507e47e 100644

builtin/worktree.c +12 -0

+	else if (file_exists(dst.buf))
 		die(_("target '%s' already exists"), av[1]);
 
 	worktrees = get_worktrees(0);

@@ -558,6 +564,17 @@ static int move_worktree(int ac, const char **av, const char *prefix)
 	if (validate_worktree(wt, 0))
 		return -1;
 
+	if (is_directory(dst.buf)) {
+		const char *sep = find_last_dir_sep(wt->path);
+
+		if (!sep)
+			die(_("could not figure out destination name from '%s'"),
+			    wt->path);
+		strbuf_addstr(&dst, sep);
+		if (file_exists(dst.buf))
+			die(_("target '%s' already exists"), dst.buf);
+	}
+
 	if (rename(wt->path, dst.buf) == -1)
 		die_errno(_("failed to move '%s' to '%s'"), wt->path, dst.buf);

Submodules contains .git files with relative paths. After a worktree move, these files need to be updated or they may point to nowhere.

This is a bandage patch to make sure "worktree move" don't break people's worktrees by accident. When .git file update code is in place, this validate_no_submodules() could be removed.

builtin/worktree.c +12 -0

+	if (validate_worktree(wt, 0))
+		return -1;
+
+	if (!force) {
+		struct argv_array child_env = ARGV_ARRAY_INIT;
+		struct child_process cp;
+		char buf[1];
+
+		argv_array_pushf(&child_env, "%s=%s/.git",
+				 GIT_DIR_ENVIRONMENT, wt->path);
+		argv_array_pushf(&child_env, "%s=%s",
+				 GIT_WORK_TREE_ENVIRONMENT, wt->path);

builtin/worktree.c +9 -0

+		error_errno(_("failed to delete '%s'"), sb.buf);
+		ret = -1;
+	}
+	strbuf_reset(&sb);
+	strbuf_addstr(&sb, git_common_path("worktrees/%s", wt->id));
+	if (remove_dir_recursively(&sb, 0)) {
+		error_errno(_("failed to delete '%s'"), sb.buf);
+		ret = -1;
+	}

- fixes the compile problem on latest master (because prefix_filename takes one argument less)

Quoted 15 lines

worktree.c +15 -0

+int validate_worktree(const struct worktree *wt, int quiet)
+{
+     struct strbuf sb = STRBUF_INIT;
+     char *path;
+     int err, ret;
+
+     if (is_main_worktree(wt)) {
+             /*
+              * Main worktree using .git file to point to the
+              * repository would make it impossible to know where
+              * the actual worktree is if this function is executed
+              * from another worktree. No .git file support for now.
+              */
+             strbuf_addf(&sb, "%s/.git", wt->path);
+             if (!is_directory(sb.buf)) {

worktree.c const char *is_worktree_locked(struct worktree *wt) · line 328

Quoted 3 lines

worktree.c +3 -0

+                     strbuf_release(&sb);
+                     return report(quiet, _("'%s/.git' at main worktree is not the repository directory"),
+                                   wt->path);

These messages come without telling what they are. Should they say that these are errors? Or does the severity depend on the caller, i.e. why they want to know if a particular worktree is valid, and sometimes these are errors and other times they are mere warnings?

worktree.c const char *is_worktree_locked(struct worktree *wt) · line 339

Quoted 11 lines

worktree.c +11 -0

+             }
+             return 0;
+     }
+
+     /*
+      * Make sure "gitdir" file points to a real .git file and that
+      * file points back here.
+      */
+     if (!is_absolute_path(wt->path))
+             return report(quiet, _("'%s' file does not contain absolute path to the worktree location"),
+                           git_common_path("worktrees/%s/gitdir", wt->id));

It makes me wonder if this kind of error reporting belongs to the place where these are read (and a new wt is written out to the filesystem, perhaps). The programmer who wrote this code may have known that wt->path is prepared by reading "worktrees/%s/gitdir" and without doing real_path() or absolute_path() on the result when this code was written, but nothing guarantees that to stay true over time as the code evolves.