mirror of
https://github.com/git/git
synced 2024-09-29 21:27:13 +00:00
Merge branch 'kn/for-all-refs'
"git for-each-ref" learned "--include-root-refs" option to show even the stuff outside the 'refs/' hierarchy. * kn/for-all-refs: for-each-ref: add new option to include root refs ref-filter: rename 'FILTER_REFS_ALL' to 'FILTER_REFS_REGULAR' refs: introduce `refs_for_each_include_root_refs()` refs: extract out `loose_fill_ref_dir_regular_file()` refs: introduce `is_pseudoref()` and `is_headref()`
This commit is contained in:
commit
d037212d97
|
@ -10,7 +10,7 @@ SYNOPSIS
|
|||
[verse]
|
||||
'git for-each-ref' [--count=<count>] [--shell|--perl|--python|--tcl]
|
||||
[(--sort=<key>)...] [--format=<format>]
|
||||
[ --stdin | <pattern>... ]
|
||||
[--include-root-refs] [ --stdin | <pattern>... ]
|
||||
[--points-at=<object>]
|
||||
[--merged[=<object>]] [--no-merged[=<object>]]
|
||||
[--contains[=<object>]] [--no-contains[=<object>]]
|
||||
|
@ -105,6 +105,9 @@ TAB %(refname)`.
|
|||
any excluded pattern(s) are shown. Matching is done using the
|
||||
same rules as `<pattern>` above.
|
||||
|
||||
--include-root-refs::
|
||||
List root refs (HEAD and pseudorefs) apart from regular refs.
|
||||
|
||||
FIELD NAMES
|
||||
-----------
|
||||
|
||||
|
|
|
@ -20,10 +20,10 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
|
|||
{
|
||||
struct ref_sorting *sorting;
|
||||
struct string_list sorting_options = STRING_LIST_INIT_DUP;
|
||||
int icase = 0;
|
||||
int icase = 0, include_root_refs = 0, from_stdin = 0;
|
||||
struct ref_filter filter = REF_FILTER_INIT;
|
||||
struct ref_format format = REF_FORMAT_INIT;
|
||||
int from_stdin = 0;
|
||||
unsigned int flags = FILTER_REFS_REGULAR;
|
||||
struct strvec vec = STRVEC_INIT;
|
||||
|
||||
struct option opts[] = {
|
||||
|
@ -53,6 +53,7 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
|
|||
OPT_NO_CONTAINS(&filter.no_commit, N_("print only refs which don't contain the commit")),
|
||||
OPT_BOOL(0, "ignore-case", &icase, N_("sorting and filtering are case insensitive")),
|
||||
OPT_BOOL(0, "stdin", &from_stdin, N_("read reference patterns from stdin")),
|
||||
OPT_BOOL(0, "include-root-refs", &include_root_refs, N_("also include HEAD ref and pseudorefs")),
|
||||
OPT_END(),
|
||||
};
|
||||
|
||||
|
@ -96,8 +97,11 @@ int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
|
|||
filter.name_patterns = argv;
|
||||
}
|
||||
|
||||
if (include_root_refs)
|
||||
flags |= FILTER_REFS_ROOT_REFS;
|
||||
|
||||
filter.match_as_path = 1;
|
||||
filter_and_format_refs(&filter, FILTER_REFS_ALL, sorting, &format);
|
||||
filter_and_format_refs(&filter, flags, sorting, &format);
|
||||
|
||||
ref_filter_clear(&filter);
|
||||
ref_sorting_release(sorting);
|
||||
|
|
30
ref-filter.c
30
ref-filter.c
|
@ -2628,6 +2628,12 @@ static int for_each_fullref_in_pattern(struct ref_filter *filter,
|
|||
each_ref_fn cb,
|
||||
void *cb_data)
|
||||
{
|
||||
if (filter->kind == FILTER_REFS_KIND_MASK) {
|
||||
/* In this case, we want to print all refs including root refs. */
|
||||
return refs_for_each_include_root_refs(get_main_ref_store(the_repository),
|
||||
cb, cb_data);
|
||||
}
|
||||
|
||||
if (!filter->match_as_path) {
|
||||
/*
|
||||
* in this case, the patterns are applied after
|
||||
|
@ -2750,6 +2756,9 @@ static int ref_kind_from_refname(const char *refname)
|
|||
return ref_kind[i].kind;
|
||||
}
|
||||
|
||||
if (is_pseudoref(get_main_ref_store(the_repository), refname))
|
||||
return FILTER_REFS_PSEUDOREFS;
|
||||
|
||||
return FILTER_REFS_OTHERS;
|
||||
}
|
||||
|
||||
|
@ -2781,7 +2790,16 @@ static struct ref_array_item *apply_ref_filter(const char *refname, const struct
|
|||
|
||||
/* Obtain the current ref kind from filter_ref_kind() and ignore unwanted refs. */
|
||||
kind = filter_ref_kind(filter, refname);
|
||||
if (!(kind & filter->kind))
|
||||
|
||||
/*
|
||||
* Generally HEAD refs are printed with special description denoting a rebase,
|
||||
* detached state and so forth. This is useful when only printing the HEAD ref
|
||||
* But when it is being printed along with other pseudorefs, it makes sense to
|
||||
* keep the formatting consistent. So we mask the type to act like a pseudoref.
|
||||
*/
|
||||
if (filter->kind == FILTER_REFS_KIND_MASK && kind == FILTER_REFS_DETACHED_HEAD)
|
||||
kind = FILTER_REFS_PSEUDOREFS;
|
||||
else if (!(kind & filter->kind))
|
||||
return NULL;
|
||||
|
||||
if (!filter_pattern_match(filter, refname))
|
||||
|
@ -3047,9 +3065,15 @@ static int do_filter_refs(struct ref_filter *filter, unsigned int type, each_ref
|
|||
ret = for_each_fullref_in("refs/remotes/", fn, cb_data);
|
||||
else if (filter->kind == FILTER_REFS_TAGS)
|
||||
ret = for_each_fullref_in("refs/tags/", fn, cb_data);
|
||||
else if (filter->kind & FILTER_REFS_ALL)
|
||||
else if (filter->kind & FILTER_REFS_REGULAR)
|
||||
ret = for_each_fullref_in_pattern(filter, fn, cb_data);
|
||||
if (!ret && (filter->kind & FILTER_REFS_DETACHED_HEAD))
|
||||
|
||||
/*
|
||||
* When printing all ref types, HEAD is already included,
|
||||
* so we don't want to print HEAD again.
|
||||
*/
|
||||
if (!ret && (filter->kind != FILTER_REFS_KIND_MASK) &&
|
||||
(filter->kind & FILTER_REFS_DETACHED_HEAD))
|
||||
head_ref(fn, cb_data);
|
||||
}
|
||||
|
||||
|
|
|
@ -19,10 +19,13 @@
|
|||
#define FILTER_REFS_BRANCHES 0x0004
|
||||
#define FILTER_REFS_REMOTES 0x0008
|
||||
#define FILTER_REFS_OTHERS 0x0010
|
||||
#define FILTER_REFS_ALL (FILTER_REFS_TAGS | FILTER_REFS_BRANCHES | \
|
||||
#define FILTER_REFS_REGULAR (FILTER_REFS_TAGS | FILTER_REFS_BRANCHES | \
|
||||
FILTER_REFS_REMOTES | FILTER_REFS_OTHERS)
|
||||
#define FILTER_REFS_DETACHED_HEAD 0x0020
|
||||
#define FILTER_REFS_KIND_MASK (FILTER_REFS_ALL | FILTER_REFS_DETACHED_HEAD)
|
||||
#define FILTER_REFS_PSEUDOREFS 0x0040
|
||||
#define FILTER_REFS_ROOT_REFS (FILTER_REFS_DETACHED_HEAD | FILTER_REFS_PSEUDOREFS)
|
||||
#define FILTER_REFS_KIND_MASK (FILTER_REFS_REGULAR | FILTER_REFS_DETACHED_HEAD | \
|
||||
FILTER_REFS_PSEUDOREFS)
|
||||
|
||||
struct atom_value;
|
||||
struct ref_sorting;
|
||||
|
|
48
refs.c
48
refs.c
|
@ -860,6 +860,47 @@ static int is_pseudoref_syntax(const char *refname)
|
|||
return 1;
|
||||
}
|
||||
|
||||
int is_pseudoref(struct ref_store *refs, const char *refname)
|
||||
{
|
||||
static const char *const irregular_pseudorefs[] = {
|
||||
"AUTO_MERGE",
|
||||
"BISECT_EXPECTED_REV",
|
||||
"NOTES_MERGE_PARTIAL",
|
||||
"NOTES_MERGE_REF",
|
||||
"MERGE_AUTOSTASH",
|
||||
};
|
||||
struct object_id oid;
|
||||
size_t i;
|
||||
|
||||
if (!is_pseudoref_syntax(refname))
|
||||
return 0;
|
||||
|
||||
if (ends_with(refname, "_HEAD")) {
|
||||
refs_resolve_ref_unsafe(refs, refname,
|
||||
RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,
|
||||
&oid, NULL);
|
||||
return !is_null_oid(&oid);
|
||||
}
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(irregular_pseudorefs); i++)
|
||||
if (!strcmp(refname, irregular_pseudorefs[i])) {
|
||||
refs_resolve_ref_unsafe(refs, refname,
|
||||
RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,
|
||||
&oid, NULL);
|
||||
return !is_null_oid(&oid);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int is_headref(struct ref_store *refs, const char *refname)
|
||||
{
|
||||
if (!strcmp(refname, "HEAD"))
|
||||
return refs_ref_exists(refs, refname);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int is_current_worktree_ref(const char *ref) {
|
||||
return is_pseudoref_syntax(ref) || is_per_worktree_ref(ref);
|
||||
}
|
||||
|
@ -1715,6 +1756,13 @@ int for_each_rawref(each_ref_fn fn, void *cb_data)
|
|||
return refs_for_each_rawref(get_main_ref_store(the_repository), fn, cb_data);
|
||||
}
|
||||
|
||||
int refs_for_each_include_root_refs(struct ref_store *refs, each_ref_fn fn,
|
||||
void *cb_data)
|
||||
{
|
||||
return do_for_each_ref(refs, "", NULL, fn, 0,
|
||||
DO_FOR_EACH_INCLUDE_ROOT_REFS, cb_data);
|
||||
}
|
||||
|
||||
static int qsort_strcmp(const void *va, const void *vb)
|
||||
{
|
||||
const char *a = *(const char **)va;
|
||||
|
|
9
refs.h
9
refs.h
|
@ -398,6 +398,12 @@ int for_each_namespaced_ref(const char **exclude_patterns,
|
|||
int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data);
|
||||
int for_each_rawref(each_ref_fn fn, void *cb_data);
|
||||
|
||||
/*
|
||||
* Iterates over all refs including root refs, i.e. pseudorefs and HEAD.
|
||||
*/
|
||||
int refs_for_each_include_root_refs(struct ref_store *refs, each_ref_fn fn,
|
||||
void *cb_data);
|
||||
|
||||
/*
|
||||
* Normalizes partial refs to their fully qualified form.
|
||||
* Will prepend <prefix> to the <pattern> if it doesn't start with 'refs/'.
|
||||
|
@ -1043,4 +1049,7 @@ extern struct ref_namespace_info ref_namespace[NAMESPACE__COUNT];
|
|||
*/
|
||||
void update_ref_namespace(enum ref_namespace namespace, char *ref);
|
||||
|
||||
int is_pseudoref(struct ref_store *refs, const char *refname);
|
||||
int is_headref(struct ref_store *refs, const char *refname);
|
||||
|
||||
#endif /* REFS_H */
|
||||
|
|
|
@ -229,6 +229,38 @@ static void add_per_worktree_entries_to_dir(struct ref_dir *dir, const char *dir
|
|||
}
|
||||
}
|
||||
|
||||
static void loose_fill_ref_dir_regular_file(struct files_ref_store *refs,
|
||||
const char *refname,
|
||||
struct ref_dir *dir)
|
||||
{
|
||||
struct object_id oid;
|
||||
int flag;
|
||||
|
||||
if (!refs_resolve_ref_unsafe(&refs->base, refname, RESOLVE_REF_READING,
|
||||
&oid, &flag)) {
|
||||
oidclr(&oid);
|
||||
flag |= REF_ISBROKEN;
|
||||
} else if (is_null_oid(&oid)) {
|
||||
/*
|
||||
* It is so astronomically unlikely
|
||||
* that null_oid is the OID of an
|
||||
* actual object that we consider its
|
||||
* appearance in a loose reference
|
||||
* file to be repo corruption
|
||||
* (probably due to a software bug).
|
||||
*/
|
||||
flag |= REF_ISBROKEN;
|
||||
}
|
||||
|
||||
if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
|
||||
if (!refname_is_safe(refname))
|
||||
die("loose refname is dangerous: %s", refname);
|
||||
oidclr(&oid);
|
||||
flag |= REF_BAD_NAME | REF_ISBROKEN;
|
||||
}
|
||||
add_entry_to_dir(dir, create_ref_entry(refname, &oid, flag));
|
||||
}
|
||||
|
||||
/*
|
||||
* Read the loose references from the namespace dirname into dir
|
||||
* (without recursing). dirname must end with '/'. dir must be the
|
||||
|
@ -257,8 +289,6 @@ static void loose_fill_ref_dir(struct ref_store *ref_store,
|
|||
strbuf_add(&refname, dirname, dirnamelen);
|
||||
|
||||
while ((de = readdir(d)) != NULL) {
|
||||
struct object_id oid;
|
||||
int flag;
|
||||
unsigned char dtype;
|
||||
|
||||
if (de->d_name[0] == '.')
|
||||
|
@ -274,33 +304,7 @@ static void loose_fill_ref_dir(struct ref_store *ref_store,
|
|||
create_dir_entry(dir->cache, refname.buf,
|
||||
refname.len));
|
||||
} else if (dtype == DT_REG) {
|
||||
if (!refs_resolve_ref_unsafe(&refs->base,
|
||||
refname.buf,
|
||||
RESOLVE_REF_READING,
|
||||
&oid, &flag)) {
|
||||
oidclr(&oid);
|
||||
flag |= REF_ISBROKEN;
|
||||
} else if (is_null_oid(&oid)) {
|
||||
/*
|
||||
* It is so astronomically unlikely
|
||||
* that null_oid is the OID of an
|
||||
* actual object that we consider its
|
||||
* appearance in a loose reference
|
||||
* file to be repo corruption
|
||||
* (probably due to a software bug).
|
||||
*/
|
||||
flag |= REF_ISBROKEN;
|
||||
}
|
||||
|
||||
if (check_refname_format(refname.buf,
|
||||
REFNAME_ALLOW_ONELEVEL)) {
|
||||
if (!refname_is_safe(refname.buf))
|
||||
die("loose refname is dangerous: %s", refname.buf);
|
||||
oidclr(&oid);
|
||||
flag |= REF_BAD_NAME | REF_ISBROKEN;
|
||||
}
|
||||
add_entry_to_dir(dir,
|
||||
create_ref_entry(refname.buf, &oid, flag));
|
||||
loose_fill_ref_dir_regular_file(refs, refname.buf, dir);
|
||||
}
|
||||
strbuf_setlen(&refname, dirnamelen);
|
||||
}
|
||||
|
@ -311,9 +315,59 @@ static void loose_fill_ref_dir(struct ref_store *ref_store,
|
|||
add_per_worktree_entries_to_dir(dir, dirname);
|
||||
}
|
||||
|
||||
static struct ref_cache *get_loose_ref_cache(struct files_ref_store *refs)
|
||||
/*
|
||||
* Add pseudorefs to the ref dir by parsing the directory for any files
|
||||
* which follow the pseudoref syntax.
|
||||
*/
|
||||
static void add_pseudoref_and_head_entries(struct ref_store *ref_store,
|
||||
struct ref_dir *dir,
|
||||
const char *dirname)
|
||||
{
|
||||
struct files_ref_store *refs =
|
||||
files_downcast(ref_store, REF_STORE_READ, "fill_ref_dir");
|
||||
struct strbuf path = STRBUF_INIT, refname = STRBUF_INIT;
|
||||
struct dirent *de;
|
||||
size_t dirnamelen;
|
||||
DIR *d;
|
||||
|
||||
files_ref_path(refs, &path, dirname);
|
||||
|
||||
d = opendir(path.buf);
|
||||
if (!d) {
|
||||
strbuf_release(&path);
|
||||
return;
|
||||
}
|
||||
|
||||
strbuf_addstr(&refname, dirname);
|
||||
dirnamelen = refname.len;
|
||||
|
||||
while ((de = readdir(d)) != NULL) {
|
||||
unsigned char dtype;
|
||||
|
||||
if (de->d_name[0] == '.')
|
||||
continue;
|
||||
if (ends_with(de->d_name, ".lock"))
|
||||
continue;
|
||||
strbuf_addstr(&refname, de->d_name);
|
||||
|
||||
dtype = get_dtype(de, &path, 1);
|
||||
if (dtype == DT_REG && (is_pseudoref(ref_store, de->d_name) ||
|
||||
is_headref(ref_store, de->d_name)))
|
||||
loose_fill_ref_dir_regular_file(refs, refname.buf, dir);
|
||||
|
||||
strbuf_setlen(&refname, dirnamelen);
|
||||
}
|
||||
strbuf_release(&refname);
|
||||
strbuf_release(&path);
|
||||
closedir(d);
|
||||
}
|
||||
|
||||
static struct ref_cache *get_loose_ref_cache(struct files_ref_store *refs,
|
||||
unsigned int flags)
|
||||
{
|
||||
if (!refs->loose) {
|
||||
struct ref_dir *dir;
|
||||
|
||||
/*
|
||||
* Mark the top-level directory complete because we
|
||||
* are about to read the only subdirectory that can
|
||||
|
@ -324,12 +378,17 @@ static struct ref_cache *get_loose_ref_cache(struct files_ref_store *refs)
|
|||
/* We're going to fill the top level ourselves: */
|
||||
refs->loose->root->flag &= ~REF_INCOMPLETE;
|
||||
|
||||
dir = get_ref_dir(refs->loose->root);
|
||||
|
||||
if (flags & DO_FOR_EACH_INCLUDE_ROOT_REFS)
|
||||
add_pseudoref_and_head_entries(dir->cache->ref_store, dir,
|
||||
refs->loose->root->name);
|
||||
|
||||
/*
|
||||
* Add an incomplete entry for "refs/" (to be filled
|
||||
* lazily):
|
||||
*/
|
||||
add_entry_to_dir(get_ref_dir(refs->loose->root),
|
||||
create_dir_entry(refs->loose, "refs/", 5));
|
||||
add_entry_to_dir(dir, create_dir_entry(refs->loose, "refs/", 5));
|
||||
}
|
||||
return refs->loose;
|
||||
}
|
||||
|
@ -857,7 +916,7 @@ static struct ref_iterator *files_ref_iterator_begin(
|
|||
* disk, and re-reads it if not.
|
||||
*/
|
||||
|
||||
loose_iter = cache_ref_iterator_begin(get_loose_ref_cache(refs),
|
||||
loose_iter = cache_ref_iterator_begin(get_loose_ref_cache(refs, flags),
|
||||
prefix, ref_store->repo, 1);
|
||||
|
||||
/*
|
||||
|
@ -1217,7 +1276,7 @@ static int files_pack_refs(struct ref_store *ref_store,
|
|||
|
||||
packed_refs_lock(refs->packed_ref_store, LOCK_DIE_ON_ERROR, &err);
|
||||
|
||||
iter = cache_ref_iterator_begin(get_loose_ref_cache(refs), NULL,
|
||||
iter = cache_ref_iterator_begin(get_loose_ref_cache(refs, 0), NULL,
|
||||
the_repository, 0);
|
||||
while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
|
||||
/*
|
||||
|
|
|
@ -260,6 +260,12 @@ enum do_for_each_ref_flags {
|
|||
* INCLUDE_BROKEN, since they are otherwise not included at all.
|
||||
*/
|
||||
DO_FOR_EACH_OMIT_DANGLING_SYMREFS = (1 << 2),
|
||||
|
||||
/*
|
||||
* Include root refs i.e. HEAD and pseudorefs along with the regular
|
||||
* refs.
|
||||
*/
|
||||
DO_FOR_EACH_INCLUDE_ROOT_REFS = (1 << 3),
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
|
@ -364,12 +364,15 @@ static int reftable_ref_iterator_advance(struct ref_iterator *ref_iterator)
|
|||
break;
|
||||
|
||||
/*
|
||||
* The files backend only lists references contained in
|
||||
* "refs/". We emulate the same behaviour here and thus skip
|
||||
* all references that don't start with this prefix.
|
||||
* The files backend only lists references contained in "refs/" unless
|
||||
* the root refs are to be included. We emulate the same behaviour here.
|
||||
*/
|
||||
if (!starts_with(iter->ref.refname, "refs/"))
|
||||
if (!starts_with(iter->ref.refname, "refs/") &&
|
||||
!(iter->flags & DO_FOR_EACH_INCLUDE_ROOT_REFS &&
|
||||
(is_pseudoref(&iter->refs->base, iter->ref.refname) ||
|
||||
is_headref(&iter->refs->base, iter->ref.refname)))) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (iter->prefix &&
|
||||
strncmp(iter->prefix, iter->ref.refname, strlen(iter->prefix))) {
|
||||
|
|
|
@ -279,18 +279,18 @@ test_expect_success 'setup worktree' '
|
|||
# direct FS access for creating the reflogs. 3) PSEUDO-WT and refs/bisect/random
|
||||
# do not create reflogs by default, so it is not testing a realistic scenario.
|
||||
test_expect_success 'for_each_reflog()' '
|
||||
echo $ZERO_OID > .git/logs/PSEUDO-MAIN &&
|
||||
echo $ZERO_OID >.git/logs/PSEUDO_MAIN_HEAD &&
|
||||
mkdir -p .git/logs/refs/bisect &&
|
||||
echo $ZERO_OID > .git/logs/refs/bisect/random &&
|
||||
echo $ZERO_OID >.git/logs/refs/bisect/random &&
|
||||
|
||||
echo $ZERO_OID > .git/worktrees/wt/logs/PSEUDO-WT &&
|
||||
echo $ZERO_OID >.git/worktrees/wt/logs/PSEUDO_WT_HEAD &&
|
||||
mkdir -p .git/worktrees/wt/logs/refs/bisect &&
|
||||
echo $ZERO_OID > .git/worktrees/wt/logs/refs/bisect/wt-random &&
|
||||
echo $ZERO_OID >.git/worktrees/wt/logs/refs/bisect/wt-random &&
|
||||
|
||||
$RWT for-each-reflog >actual &&
|
||||
cat >expected <<-\EOF &&
|
||||
HEAD
|
||||
PSEUDO-WT
|
||||
PSEUDO_WT_HEAD
|
||||
refs/bisect/wt-random
|
||||
refs/heads/main
|
||||
refs/heads/wt-main
|
||||
|
@ -300,7 +300,7 @@ test_expect_success 'for_each_reflog()' '
|
|||
$RMAIN for-each-reflog >actual &&
|
||||
cat >expected <<-\EOF &&
|
||||
HEAD
|
||||
PSEUDO-MAIN
|
||||
PSEUDO_MAIN_HEAD
|
||||
refs/bisect/random
|
||||
refs/heads/main
|
||||
refs/heads/wt-main
|
||||
|
|
|
@ -31,6 +31,37 @@ test_expect_success 'setup some history and refs' '
|
|||
git update-ref refs/odd/spot main
|
||||
'
|
||||
|
||||
test_expect_success '--include-root-refs pattern prints pseudorefs' '
|
||||
cat >expect <<-\EOF &&
|
||||
HEAD
|
||||
ORIG_HEAD
|
||||
refs/heads/main
|
||||
refs/heads/side
|
||||
refs/odd/spot
|
||||
refs/tags/annotated-tag
|
||||
refs/tags/doubly-annotated-tag
|
||||
refs/tags/doubly-signed-tag
|
||||
refs/tags/four
|
||||
refs/tags/one
|
||||
refs/tags/signed-tag
|
||||
refs/tags/three
|
||||
refs/tags/two
|
||||
EOF
|
||||
git update-ref ORIG_HEAD main &&
|
||||
git for-each-ref --format="%(refname)" --include-root-refs >actual &&
|
||||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_expect_success '--include-root-refs with other patterns' '
|
||||
cat >expect <<-\EOF &&
|
||||
HEAD
|
||||
ORIG_HEAD
|
||||
EOF
|
||||
git update-ref ORIG_HEAD main &&
|
||||
git for-each-ref --format="%(refname)" --include-root-refs "*HEAD" >actual &&
|
||||
test_cmp expect actual
|
||||
'
|
||||
|
||||
test_expect_success 'filtering with --points-at' '
|
||||
cat >expect <<-\EOF &&
|
||||
refs/heads/main
|
||||
|
|
Loading…
Reference in a new issue