nbelakovski@xxxxxxxxx writes:
> +static struct hashmap ref_to_worktree_map;
> +static struct worktree **worktrees = NULL;
> +
> /*
> * An atom is a valid field atom listed below, possibly prefixed with
> * a "*" to denote deref_tag().
> @@ -420,6 +438,34 @@ static int head_atom_parser(const struct ref_format *format, struct used_atom *a
> return 0;
> }
>
> +static int worktree_atom_parser(const struct ref_format *format,
> + struct used_atom *atom,
> + const char *arg,
> + struct strbuf *unused_err)
> +{
> + int i;
> +
> + if (worktrees)
> + return 0;
OK, so verify_ref_format() etc. will trigger this to be called via
valid_atom[].parser when "%(worktreepath)" is seen in the user
format, and then this grabs all the worktrees and record their paths
in the hashmap. This if() statement makes sure that it happens only
once.
> + worktrees = get_worktrees(0);
> +
> + hashmap_init(&ref_to_worktree_map, ref_to_worktree_map_cmpfnc, NULL, 0);
> +
> + for (i = 0; worktrees[i]; i++) {
> + if (worktrees[i]->head_ref) {
> + struct ref_to_worktree_entry *entry;
> + entry = xmalloc(sizeof(*entry));
> + entry->wt = worktrees[i];
> + hashmap_entry_init(entry, strhash(worktrees[i]->head_ref));
> +
> + hashmap_add(&ref_to_worktree_map, entry);
> + }
> + }
> +
> + return 0;
> +}
> +
> static struct {
> const char *name;
> info_source source;
> @@ -461,6 +507,7 @@ static struct {
> { "flag", SOURCE_NONE },
> { "HEAD", SOURCE_NONE, FIELD_STR, head_atom_parser },
> { "color", SOURCE_NONE, FIELD_STR, color_atom_parser },
> + { "worktreepath", SOURCE_NONE, FIELD_STR, worktree_atom_parser },
> { "align", SOURCE_NONE, FIELD_STR, align_atom_parser },
> { "end", SOURCE_NONE },
> { "if", SOURCE_NONE, FIELD_STR, if_atom_parser },
> @@ -1500,6 +1547,21 @@ static int get_object(struct ref_array_item *ref, int deref, struct object **obj
> return 0;
> }
>
> +static char *get_worktree_path(const struct used_atom *atom, const struct ref_array_item *ref)
> +{
> + struct strbuf val = STRBUF_INIT;
> + struct hashmap_entry entry;
> + struct ref_to_worktree_entry *lookup_result;
And then this will be called from populate_value() for each of the
ref. It looks up the worktree that has checked out this branch, if
any, from the hashmap, and yields the path to it.
When seeing a tag or note ref, by definition that's not something we
can have checked out in any worktree. I wonder if it is worth to
optimize further by omitting this lookup when ref is not a local
branch?
IOW, with a typical number of worktrees and refs, how costly would ...
> + hashmap_entry_init(&entry, strhash(ref->refname));
> + lookup_result = hashmap_get(&ref_to_worktree_map, &entry, ref->refname);
... this sequence of calls be.
> +
> + if (lookup_result)
> + strbuf_addstr(&val, lookup_result->wt->path);
> +
> + return strbuf_detach(&val, NULL);
> +}
> +
> /*
> * Parse the object referred by ref, and grab needed value.
> */
> @@ -1537,6 +1599,10 @@ static int populate_value(struct ref_array_item *ref, struct strbuf *err)
>
> if (starts_with(name, "refname"))
> refname = get_refname(atom, ref);
> + else if (starts_with(name, "worktreepath")) {
> + v->s = get_worktree_path(atom, ref);
> + continue;
> + }
> else if (starts_with(name, "symref"))
> refname = get_symref(atom, ref);
> else if (starts_with(name, "upstream")) {
> @@ -2020,6 +2086,11 @@ void ref_array_clear(struct ref_array *array)
> free_array_item(array->items[i]);
> FREE_AND_NULL(array->items);
> array->nr = array->alloc = 0;
> + if (worktrees)
> + {
Have this opening brace at the end of the previous line, i.e.
if (worktrees) {
> + hashmap_free(&ref_to_worktree_map, 1);
> + free_worktrees(worktrees);
> + }
> }
What's the point of ref_array_clear()? What does the caller of this
function really want? Is it merely to release the resources
consumed? If so, then this is good enough, but then the existing
calls to FREE_AND_NULL() for releasing resources in the function is
overkill.
Or is it envisioned that we are preparing a clean slate so that
another call, possibly after the external environment changed, can
be made into this machinery (i.e. imagine we lift ref-filter.c code
and link it to a long running service process; after serving one
for-each-ref request, a new worktree or a new branch may get
created, and then we may get another for-each-ref request)? If that
is the case, then the added code breaks that hope, as it leaves a
dangling pointer in the worktrees variable.
> static void do_merge_filter(struct ref_filter_cbdata *ref_cbdata)
> diff --git a/t/t6302-for-each-ref-filter.sh b/t/t6302-for-each-ref-filter.sh
> index fc067ed672..87e0222ea1 100755
> --- a/t/t6302-for-each-ref-filter.sh
> +++ b/t/t6302-for-each-ref-filter.sh
> @@ -441,4 +441,19 @@ test_expect_success '--merged is incompatible with --no-merged' '
> test_must_fail git for-each-ref --merged HEAD --no-merged HEAD
> '
>
> +test_expect_success '"add" a worktree' '
> + mkdir worktree_dir &&
> + git worktree add -b master_worktree worktree_dir master
> +'
> +
> +test_expect_success 'validate worktree atom' '
> + cat >expect <<-EOF &&
> + master: $(pwd)
> + master_worktree: $(pwd)/worktree_dir
> + side: not checked out
> + EOF
> + git for-each-ref --format="%(refname:short): %(if)%(worktreepath)%(then)%(worktreepath)%(else)not checked out%(end)" refs/heads/ >actual &&
> + test_cmp expect actual
> +'
> +
> test_done
