[GSoC Patch v6 0/4] teach git repo info to handle path keys

Hi!

This series teaches `git repo info` to handle `path.*` keys, allowing scripts to reliably discover core repository paths without resorting to `git rev-parse`.

The patches are structured as follows:

1. path: Extract the localized path-formatting logic
   out of `rev-parse` and expose it globally via
   `path.h` using clear append semantics.

2. rev-parse: Delegate the command's path-printing
   helper to the newly shared path engine, while
   leaving its existing option-parsing untouched.

3. repo: Introduce `path.commondir.absolute` and
   `path.commondir.relative` alongside a robust,
   isolated test helper.

4. repo: Introduce `path.gitdir.absolute` and
   `path.gitdir.relative` using the same standardized
   formatting rules.

Changes since v5:

* Dropped `PATH_FORMAT_DEFAULT` from the shared
  `path_format` enum in path.h. It only existed to let
  rev-parse track "no format was requested", which is a
  rev-parse-specific concern that other callers of
  `append_formatted_path()` shouldn't need to reason
  about (Phillip).

* Reverted `print_path()` in builtin/rev-parse.c to keep
  its original `format_type` and `default_type` local
  enums completely untouched (Phillip).

* As a result, patch 2 is now much smaller: it only
  touches the body of `print_path()`.

Tagging Justin Tobler, Lucas Seiki Oshiro, Junio, Phillip Wood, brian m. carlson, and Ayush Jha.

Thanks again for the careful review!

K Jayatheerth (4):
  path: introduce append_formatted_path() for shared path formatting
  rev-parse: use append_formatted_path() for path formatting
  repo: add path.commondir with absolute and relative suffix formatting
  repo: add path.gitdir with absolute and relative suffix formatting

 Documentation/git-repo.adoc | 15 ++++++++
 builtin/repo.c              | 50 +++++++++++++++++++++++++
 builtin/rev-parse.c         | 73 +++++++++++++++----------------------
 path.c                      | 69 +++++++++++++++++++++++++++++++++++
 path.h                      | 30 +++++++++++++++
 t/t1900-repo-info.sh        | 58 +++++++++++++++++++++++++++++
 6 files changed, 251 insertions(+), 44 deletions(-)

Range-diff against v5:
1:  31bc2c96e9 ! 1:  bb8bb40030 path: introduce append_formatted_path() for shared path formatting
    @@ path.c: char *xdg_cache_home(const char *filename)
     +			   const char *prefix, enum path_format format)
     +{
     +	switch (format) {
    -+	case PATH_FORMAT_DEFAULT:
     +	case PATH_FORMAT_UNMODIFIED:
     +		strbuf_addstr(dest, path);
     +		break;
    @@ path.h: enum scld_error safe_create_leading_directories_no_share(char *path);
     + * The formatting strategy to apply when writing a path into a buffer.
     + */
     +enum path_format {
    -+	/*
    -+	 * Represents the default formatting behavior. Treated as
    -+	 * PATH_FORMAT_UNMODIFIED by append_formatted_path().
    -+	 */
    -+	PATH_FORMAT_DEFAULT,
    -+
     +	/* Output the path exactly as-is without any modifications. */
     +	PATH_FORMAT_UNMODIFIED,
     +
2:  12af24ffc3 ! 2:  0ab0e4bde3 rev-parse: use append_formatted_path() for path formatting
    @@ Metadata
      ## Commit message ##
         rev-parse: use append_formatted_path() for path formatting
     
    -    Now that path formatting logic lives in a shared helper, keeping a
    -    duplicate implementation in rev-parse is unnecessary and risks the
    -    two diverging over time.
    +    Now that the core path-formatting algorithm lives in
    +    append_formatted_path(), print_path() doesn't need to duplicate it.
     
    -    Replace the local format_type and default_type enums and the
    -    hand-rolled formatting logic with a call to append_formatted_path().
    -    Introduce PATH_FORMAT_DEFAULT as the initial value of arg_path_format
    -    so that per-path fallback behavior is resolved in print_path() rather
    -    than leaked into the shared helper.
    +    Replace the body of print_path() with a small mapping from rev-parse's
    +    existing format_type/default_type pair to the shared path_format enum,
    +    then delegate to append_formatted_path(). The two local enums, and
    +    every call site that uses them throughout cmd_rev_parse(), are left
    +    untouched.
     
         Mentored-by: Justin Tobler <jltobler@gmail.com>
         Mentored-by: Lucas Seiki Oshiro <lucasseikioshiro@gmail.com>
         Signed-off-by: K Jayatheerth <jayatheerthkulkarni2005@gmail.com>
     
      ## builtin/rev-parse.c ##
    -@@ builtin/rev-parse.c: static void handle_ref_opt(const char *pattern, const char *prefix)
    - 	clear_ref_exclusions(&ref_excludes);
    - }
    +@@ builtin/rev-parse.c: enum default_type {
    + 	DEFAULT_UNMODIFIED,
    + };
      
    --enum format_type {
    --	/* We would like a relative path. */
    --	FORMAT_RELATIVE,
    --	/* We would like a canonical absolute path. */
    --	FORMAT_CANONICAL,
    --	/* We would like the default behavior. */
    --	FORMAT_DEFAULT,
    --};
    --
    --enum default_type {
    --	/* Our default is a relative path. */
    --	DEFAULT_RELATIVE,
    --	/* Our default is a relative path if there's a shared root. */
    --	DEFAULT_RELATIVE_IF_SHARED,
    --	/* Our default is a canonical absolute path. */
    --	DEFAULT_CANONICAL,
    --	/* Our default is not to modify the item. */
    --	DEFAULT_UNMODIFIED,
    --};
    --
     -static void print_path(const char *path, const char *prefix, enum format_type format, enum default_type def)
     +static void print_path(const char *path, const char *prefix,
    -+		       enum path_format arg_path_format, enum path_format def_format)
    ++		       enum format_type format, enum default_type def)
      {
     -	char *cwd = NULL;
     -	/*
    @@ builtin/rev-parse.c: static void handle_ref_opt(const char *pattern, const char
     -		if (!is_absolute_path(prefix)) {
     -			strbuf_realpath_forgiving(&prefixbuf, prefix, 1);
     -			prefix = prefixbuf.buf;
    --		}
    ++	struct strbuf sb = STRBUF_INIT;
    ++	enum path_format fmt;
    ++
    ++	if (format == FORMAT_RELATIVE) {
    ++		fmt = PATH_FORMAT_RELATIVE;
    ++	} else if (format == FORMAT_CANONICAL) {
    ++		fmt = PATH_FORMAT_CANONICAL;
    ++	} else /* FORMAT_DEFAULT */ {
    ++		switch (def) {
    ++		case DEFAULT_RELATIVE:
    ++			fmt = PATH_FORMAT_RELATIVE;
    ++			break;
    ++		case DEFAULT_RELATIVE_IF_SHARED:
    ++			fmt = PATH_FORMAT_RELATIVE_IF_SHARED;
    ++			break;
    ++		case DEFAULT_CANONICAL:
    ++			fmt = PATH_FORMAT_CANONICAL;
    ++			break;
    ++		case DEFAULT_UNMODIFIED:
    ++		default:
    ++			fmt = PATH_FORMAT_UNMODIFIED;
    ++			break;
    + 		}
     -		puts(relative_path(path, prefix, &buf));
     -		strbuf_release(&buf);
     -		strbuf_release(&realbuf);
    @@ builtin/rev-parse.c: static void handle_ref_opt(const char *pattern, const char
     -		strbuf_realpath_forgiving(&buf, path, 1);
     -		puts(buf.buf);
     -		strbuf_release(&buf);
    --	}
    + 	}
     -	free(cwd);
    -+	struct strbuf sb = STRBUF_INIT;
    -+	/* If the user didn't explicitly specify a format, fallback to the path-specific default. */
    -+	enum path_format fmt = (arg_path_format != PATH_FORMAT_DEFAULT) ? arg_path_format : def_format;
     +
     +	append_formatted_path(&sb, path, prefix, fmt);
     +	puts(sb.buf);
    @@ builtin/rev-parse.c: static void handle_ref_opt(const char *pattern, const char
      }
      
      int cmd_rev_parse(int argc,
    -@@ builtin/rev-parse.c: int cmd_rev_parse(int argc,
    - 	const char *name = NULL;
    - 	struct strbuf buf = STRBUF_INIT;
    - 	int seen_end_of_options = 0;
    --	enum format_type format = FORMAT_DEFAULT;
    -+	enum path_format arg_path_format = PATH_FORMAT_DEFAULT;
    - 
    - 	show_usage_if_asked(argc, argv, builtin_rev_parse_usage);
    - 
    -@@ builtin/rev-parse.c: int cmd_rev_parse(int argc,
    - 					die(_("--git-path requires an argument"));
    - 				print_path(repo_git_path_replace(the_repository, &buf,
    - 								 "%s", argv[i + 1]), prefix,
    --						format,
    --						DEFAULT_RELATIVE_IF_SHARED);
    -+						arg_path_format,
    -+						PATH_FORMAT_RELATIVE_IF_SHARED);
    - 				i++;
    - 				continue;
    - 			}
    -@@ builtin/rev-parse.c: int cmd_rev_parse(int argc,
    - 				if (!arg)
    - 					die(_("--path-format requires an argument"));
    - 				if (!strcmp(arg, "absolute")) {
    --					format = FORMAT_CANONICAL;
    -+					arg_path_format = PATH_FORMAT_CANONICAL;
    - 				} else if (!strcmp(arg, "relative")) {
    --					format = FORMAT_RELATIVE;
    -+					arg_path_format = PATH_FORMAT_RELATIVE;
    - 				} else {
    - 					die(_("unknown argument to --path-format: %s"), arg);
    - 				}
    -@@ builtin/rev-parse.c: int cmd_rev_parse(int argc,
    - 			if (!strcmp(arg, "--show-toplevel")) {
    - 				const char *work_tree = repo_get_work_tree(the_repository);
    - 				if (work_tree)
    --					print_path(work_tree, prefix, format, DEFAULT_UNMODIFIED);
    -+					print_path(work_tree, prefix, arg_path_format, PATH_FORMAT_UNMODIFIED);
    - 				else
    - 					die(_("this operation must be run in a work tree"));
    - 				continue;
    -@@ builtin/rev-parse.c: int cmd_rev_parse(int argc,
    - 			if (!strcmp(arg, "--show-superproject-working-tree")) {
    - 				struct strbuf superproject = STRBUF_INIT;
    - 				if (get_superproject_working_tree(&superproject))
    --					print_path(superproject.buf, prefix, format, DEFAULT_UNMODIFIED);
    -+					print_path(superproject.buf, prefix, arg_path_format, PATH_FORMAT_UNMODIFIED);
    - 				strbuf_release(&superproject);
    - 				continue;
    - 			}
    -@@ builtin/rev-parse.c: int cmd_rev_parse(int argc,
    - 				const char *gitdir = getenv(GIT_DIR_ENVIRONMENT);
    - 				char *cwd;
    - 				int len;
    --				enum format_type wanted = format;
    -+				enum path_format wanted = arg_path_format;
    - 				if (arg[2] == 'g') {	/* --git-dir */
    - 					if (gitdir) {
    --						print_path(gitdir, prefix, format, DEFAULT_UNMODIFIED);
    -+						print_path(gitdir, prefix, arg_path_format, PATH_FORMAT_UNMODIFIED);
    - 						continue;
    - 					}
    - 					if (!prefix) {
    --						print_path(".git", prefix, format, DEFAULT_UNMODIFIED);
    -+						print_path(".git", prefix, arg_path_format, PATH_FORMAT_UNMODIFIED);
    - 						continue;
    - 					}
    - 				} else {		/* --absolute-git-dir */
    --					wanted = FORMAT_CANONICAL;
    -+					wanted = PATH_FORMAT_CANONICAL;
    - 					if (!gitdir && !prefix)
    - 						gitdir = ".git";
    - 					if (gitdir) {
    -@@ builtin/rev-parse.c: int cmd_rev_parse(int argc,
    - 				strbuf_reset(&buf);
    - 				strbuf_addf(&buf, "%s%s.git", cwd, len && cwd[len-1] != '/' ? "/" : "");
    - 				free(cwd);
    --				print_path(buf.buf, prefix, wanted, DEFAULT_CANONICAL);
    -+				print_path(buf.buf, prefix, wanted, PATH_FORMAT_CANONICAL);
    - 				continue;
    - 			}
    - 			if (!strcmp(arg, "--git-common-dir")) {
    --				print_path(repo_get_common_dir(the_repository), prefix, format, DEFAULT_RELATIVE_IF_SHARED);
    -+				print_path(repo_get_common_dir(the_repository), prefix, arg_path_format, PATH_FORMAT_RELATIVE_IF_SHARED);
    - 				continue;
    - 			}
    - 			if (!strcmp(arg, "--is-inside-git-dir")) {
    -@@ builtin/rev-parse.c: int cmd_rev_parse(int argc,
    - 				if (the_repository->index->split_index) {
    - 					const struct object_id *oid = &the_repository->index->split_index->base_oid;
    - 					const char *path = repo_git_path_replace(the_repository, &buf, "sharedindex.%s", oid_to_hex(oid));
    --					print_path(path, prefix, format, DEFAULT_RELATIVE);
    -+					print_path(path, prefix, arg_path_format, PATH_FORMAT_RELATIVE);
    - 				}
    - 				continue;
    - 			}
3:  7aecf1e806 = 3:  a50c75a55b repo: add path.commondir with absolute and relative suffix formatting
4:  f30010b76c = 4:  1dd22e5cd4 repo: add path.gitdir with absolute and relative suffix formatting