From d6fc343749b496866e68acb3f347d5db6e3f2417 Mon Sep 17 00:00:00 2001 From: Johannes Schindelin Date: Fri, 1 Sep 2017 16:35:17 +0200 Subject: [PATCH 1/4] for-each-ref: let upstream/push optionally report the remote name There are times when e.g. scripts want to know not only the name of the upstream branch on the remote repository, but also the name of the remote. This patch offers the new suffix :remotename for the upstream and for the push atoms, allowing to show exactly that. Example: $ cat .git/config ... [remote "origin"] url = https://where.do.we.come/from fetch = refs/heads/*:refs/remote/origin/* [remote "hello-world"] url = https://hello.world/git fetch = refs/heads/*:refs/remote/origin/* pushURL = hello.world:git push = refs/heads/*:refs/heads/* [branch "master"] remote = origin pushRemote = hello-world ... $ git for-each-ref \ --format='%(upstream) %(upstream:remote) %(push:remote)' \ refs/heads/master refs/remotes/origin/master origin hello-world The implementation chooses *not* to DWIM the push remote if no explicit push remote was configured; The reason is that it is possible to DWIM this by using %(if)%(push:remotename)%(then) %(push:remotename) %(else) %(upstream:remotename) %(end) while it would be impossible to "un-DWIM" the information in case the caller is really only interested in explicit push remotes. While `:remote` would be shorter, it would also be a bit more ambiguous, and it would also shut the door e.g. for `:remoteref` (which would obviously refer to the corresponding ref in the remote repository). Note: the dashless, non-CamelCased form `:remotename` follows the example of the `:trackshort` example. Signed-off-by: Johannes Schindelin --- Documentation/git-for-each-ref.txt | 17 +++++++++------ ref-filter.c | 35 ++++++++++++++++++++++++------ 2 files changed, 38 insertions(+), 14 deletions(-) diff --git a/Documentation/git-for-each-ref.txt b/Documentation/git-for-each-ref.txt index bb370c9c7b9142..779ad469a2831f 100644 --- a/Documentation/git-for-each-ref.txt +++ b/Documentation/git-for-each-ref.txt @@ -139,17 +139,20 @@ upstream:: (behind), "<>" (ahead and behind), or "=" (in sync). `:track` also prints "[gone]" whenever unknown upstream ref is encountered. Append `:track,nobracket` to show tracking - information without brackets (i.e "ahead N, behind M"). Has - no effect if the ref does not have tracking information - associated with it. All the options apart from `nobracket` - are mutually exclusive, but if used together the last option - is selected. + information without brackets (i.e "ahead N, behind M"). ++ +Also respects `:remotename` to state the name of the *remote* instead of +the ref. ++ +Has no effect if the ref does not have tracking information associated +with it. All the options apart from `nobracket` are mutually exclusive, +but if used together the last option is selected. push:: The name of a local ref which represents the `@{push}` location for the displayed ref. Respects `:short`, `:lstrip`, - `:rstrip`, `:track`, and `:trackshort` options as `upstream` - does. Produces an empty string if no `@{push}` ref is + `:rstrip`, `:track`, `:trackshort` and `:remotename` options as + `upstream` does. Produces an empty string if no `@{push}` ref is configured. HEAD:: diff --git a/ref-filter.c b/ref-filter.c index bc591f4f3de0c0..a7f2a901445195 100644 --- a/ref-filter.c +++ b/ref-filter.c @@ -76,9 +76,11 @@ static struct used_atom { char color[COLOR_MAXLEN]; struct align align; struct { - enum { RR_REF, RR_TRACK, RR_TRACKSHORT } option; + enum { + RR_REF, RR_TRACK, RR_TRACKSHORT, RR_REMOTE_NAME + } option; struct refname_atom refname; - unsigned int nobracket : 1; + unsigned int nobracket : 1, push : 1, push_remote : 1; } remote_ref; struct { enum { C_BARE, C_BODY, C_BODY_DEP, C_LINES, C_SIG, C_SUB, C_TRAILERS } option; @@ -137,6 +139,9 @@ static void remote_ref_atom_parser(const struct ref_format *format, struct used_ struct string_list params = STRING_LIST_INIT_DUP; int i; + if (!strcmp(atom->name, "push") || starts_with(atom->name, "push:")) + atom->u.remote_ref.push = 1; + if (!arg) { atom->u.remote_ref.option = RR_REF; refname_atom_parser_internal(&atom->u.remote_ref.refname, @@ -156,7 +161,10 @@ static void remote_ref_atom_parser(const struct ref_format *format, struct used_ atom->u.remote_ref.option = RR_TRACKSHORT; else if (!strcmp(s, "nobracket")) atom->u.remote_ref.nobracket = 1; - else { + else if (!strcmp(s, "remotename")) { + atom->u.remote_ref.option = RR_REMOTE_NAME; + atom->u.remote_ref.push_remote = 1; + } else { atom->u.remote_ref.option = RR_REF; refname_atom_parser_internal(&atom->u.remote_ref.refname, arg, atom->name); @@ -1247,6 +1255,15 @@ static void fill_remote_ref_details(struct used_atom *atom, const char *refname, *s = ">"; else *s = "<>"; + } else if (atom->u.remote_ref.option == RR_REMOTE_NAME) { + int explicit; + const char *remote = atom->u.remote_ref.push ? + pushremote_for_branch(branch, &explicit) : + remote_for_branch(branch, &explicit); + if (explicit) + *s = xstrdup(remote); + else + *s = ""; } else die("BUG: unhandled RR_* enum"); } @@ -1357,16 +1374,20 @@ static void populate_value(struct ref_array_item *ref) if (refname) fill_remote_ref_details(atom, refname, branch, &v->s); continue; - } else if (starts_with(name, "push")) { + } else if (atom->u.remote_ref.push) { const char *branch_name; if (!skip_prefix(ref->refname, "refs/heads/", &branch_name)) continue; branch = branch_get(branch_name); - refname = branch_get_push(branch, NULL); - if (!refname) - continue; + if (atom->u.remote_ref.push_remote) + refname = NULL; + else { + refname = branch_get_push(branch, NULL); + if (!refname) + continue; + } fill_remote_ref_details(atom, refname, branch, &v->s); continue; } else if (starts_with(name, "color:")) { From a230e60785b4043d73b9b2e67801a75419ee9cac Mon Sep 17 00:00:00 2001 From: J Wyman Date: Thu, 5 Oct 2017 13:00:41 +0200 Subject: [PATCH 2/4] for-each-ref: let upstream/push optionally remote ref name There are times when scripts want to know not only the name of the push branch on the remote, but also the name of the branch as known by the remote repository. An example of this is when a tool wants to push to the very same branch from which it would pull automatically, i.e. the `` and the `` in `git push :` would be provided by `%(upstream:remotename)` and `%(upstream:remoteref)`, respectively. This patch offers the new suffix :remoteref for the `upstream` and `push` atoms, allowing to show exactly that. Example: $ cat .git/config ... [remote "origin"] url = https://where.do.we.come/from fetch = refs/heads/*:refs/remote/origin/* [branch "master"] remote = origin merge = refs/heads/master [branch "develop/with/topics"] remote = origin merge = refs/heads/develop/with/topics ... $ git for-each-ref \ --format='%(push) %(push:remoteref)' \ refs/heads refs/remotes/origin/master refs/heads/master refs/remotes/origin/develop/with/topics refs/heads/develop/with/topics Signed-off-by: J Wyman Signed-off-by: Johannes Schindelin --- Documentation/git-for-each-ref.txt | 11 ++++++----- ref-filter.c | 13 ++++++++++++- remote.c | 30 ++++++++++++++++++++++++++++++ remote.h | 2 ++ 4 files changed, 50 insertions(+), 6 deletions(-) diff --git a/Documentation/git-for-each-ref.txt b/Documentation/git-for-each-ref.txt index 779ad469a2831f..60bcda77b66209 100644 --- a/Documentation/git-for-each-ref.txt +++ b/Documentation/git-for-each-ref.txt @@ -141,8 +141,9 @@ upstream:: encountered. Append `:track,nobracket` to show tracking information without brackets (i.e "ahead N, behind M"). + -Also respects `:remotename` to state the name of the *remote* instead of -the ref. +Also respects `:remotename` to state the name of the *remote* instead +of the ref, and `:remoteref` to state the name of the *reference* as +locally known by the remote. + Has no effect if the ref does not have tracking information associated with it. All the options apart from `nobracket` are mutually exclusive, @@ -151,9 +152,9 @@ but if used together the last option is selected. push:: The name of a local ref which represents the `@{push}` location for the displayed ref. Respects `:short`, `:lstrip`, - `:rstrip`, `:track`, `:trackshort` and `:remotename` options as - `upstream` does. Produces an empty string if no `@{push}` ref is - configured. + `:rstrip`, `:track`, `:trackshort`, `:remotename`, and `:remoteref` + options as `upstream` does. Produces an empty string if no `@{push}` + ref is configured. HEAD:: '*' if HEAD matches current ref (the checked out branch), ' ' diff --git a/ref-filter.c b/ref-filter.c index a7f2a901445195..2556c7885de670 100644 --- a/ref-filter.c +++ b/ref-filter.c @@ -77,7 +77,7 @@ static struct used_atom { struct align align; struct { enum { - RR_REF, RR_TRACK, RR_TRACKSHORT, RR_REMOTE_NAME + RR_REF, RR_TRACK, RR_TRACKSHORT, RR_REMOTE_NAME, RR_REMOTE_REF } option; struct refname_atom refname; unsigned int nobracket : 1, push : 1, push_remote : 1; @@ -164,6 +164,9 @@ static void remote_ref_atom_parser(const struct ref_format *format, struct used_ else if (!strcmp(s, "remotename")) { atom->u.remote_ref.option = RR_REMOTE_NAME; atom->u.remote_ref.push_remote = 1; + } else if (!strcmp(s, "remoteref")) { + atom->u.remote_ref.option = RR_REMOTE_REF; + atom->u.remote_ref.push_remote = 1; } else { atom->u.remote_ref.option = RR_REF; refname_atom_parser_internal(&atom->u.remote_ref.refname, @@ -1264,6 +1267,14 @@ static void fill_remote_ref_details(struct used_atom *atom, const char *refname, *s = xstrdup(remote); else *s = ""; + } else if (atom->u.remote_ref.option == RR_REMOTE_REF) { + int explicit, for_push = starts_with(atom->name, "push"); + const char *merge = remote_ref_for_branch(branch, for_push, + &explicit); + if (explicit) + *s = xstrdup(merge); + else + *s = ""; } else die("BUG: unhandled RR_* enum"); } diff --git a/remote.c b/remote.c index 60d004392109f1..696f91590486e8 100644 --- a/remote.c +++ b/remote.c @@ -672,6 +672,36 @@ const char *pushremote_for_branch(struct branch *branch, int *explicit) return remote_for_branch(branch, explicit); } +const char *remote_ref_for_branch(struct branch *branch, int for_push, + int *explicit) +{ + if (branch) { + if (!for_push) { + if (branch->merge_nr) { + if (explicit) + *explicit = 1; + return branch->merge_name[0]; + } + } else { + const char *dst, *remote_name = + pushremote_for_branch(branch, NULL); + struct remote *remote = remote_get(remote_name); + + if (remote && remote->push_refspec_nr && + (dst = apply_refspecs(remote->push, + remote->push_refspec_nr, + branch->refname))) { + if (explicit) + *explicit = 1; + return dst; + } + } + } + if (explicit) + *explicit = 0; + return ""; +} + static struct remote *remote_get_1(const char *name, const char *(*get_default)(struct branch *, int *)) { diff --git a/remote.h b/remote.h index 6c28cd3e4bfe2e..8e26d253d9cbd5 100644 --- a/remote.h +++ b/remote.h @@ -223,6 +223,8 @@ struct branch { struct branch *branch_get(const char *name); const char *remote_for_branch(struct branch *branch, int *explicit); const char *pushremote_for_branch(struct branch *branch, int *explicit); +const char *remote_ref_for_branch(struct branch *branch, int for_push, + int *explicit); int branch_has_merge_config(struct branch *branch); int branch_merge_matches(struct branch *, int n, const char *); From 344ce56e1efc204e0c42e8596c084045601dd9bd Mon Sep 17 00:00:00 2001 From: Johannes Schindelin Date: Mon, 4 Sep 2017 18:32:26 +0200 Subject: [PATCH 3/4] for-each-ref: test :remotename and :remoteref This not only prevents regressions, but also serves as documentation what this new feature is expected to do. Signed-off-by: Johannes Schindelin --- t/t6300-for-each-ref.sh | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/t/t6300-for-each-ref.sh b/t/t6300-for-each-ref.sh index 2274a4b73310bf..d9eb2be0256e39 100755 --- a/t/t6300-for-each-ref.sh +++ b/t/t6300-for-each-ref.sh @@ -675,4 +675,36 @@ test_expect_success 'Verify usage of %(symref:rstrip) atom' ' test_cmp expected actual ' +test_expect_success ':remotename and :remoteref' ' + git init remote-tests && + ( + cd remote-tests && + test_commit initial && + git remote add from fifth.coffee:blub && + git config branch.master.remote from && + git config branch.master.merge refs/heads/stable && + git remote add to southridge.audio:repo && + git config remote.to.push "refs/heads/*:refs/heads/pushed/*" && + git config branch.master.pushRemote to && + for pair in "%(upstream)=refs/remotes/from/stable" \ + "%(upstream:remotename)=from" \ + "%(upstream:remoteref)=refs/heads/stable" \ + "%(push)=refs/remotes/to/pushed/master" \ + "%(push:remotename)=to" \ + "%(push:remoteref)=refs/heads/pushed/master" + do + echo "${pair#*=}" >expect && + git for-each-ref --format="${pair%=*}" \ + refs/heads/master >actual && + test_cmp expect actual + done && + git branch push-simple && + git config branch.push-simple.pushRemote from && + actual="$(git for-each-ref \ + --format="%(push:remotename),%(push:remoteref)" \ + refs/heads/push-simple)" && + test from, = "$actual" + ) +' + test_done From 3e0bdee1baf14b806d7e88ef36b03b68402dcee3 Mon Sep 17 00:00:00 2001 From: Johannes Schindelin Date: Tue, 5 Sep 2017 10:59:32 +0200 Subject: [PATCH 4/4] for-each-ref: mark :remote-name and :remote-ref as experimental These expansions will most likely be introduced into Git for Windows as a test balloon first, and if they work out as expected, we'll try to get the patches into upstream Git. Signed-off-by: Johannes Schindelin --- Documentation/git-for-each-ref.txt | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Documentation/git-for-each-ref.txt b/Documentation/git-for-each-ref.txt index 60bcda77b66209..4977573ea40e1e 100644 --- a/Documentation/git-for-each-ref.txt +++ b/Documentation/git-for-each-ref.txt @@ -141,9 +141,9 @@ upstream:: encountered. Append `:track,nobracket` to show tracking information without brackets (i.e "ahead N, behind M"). + -Also respects `:remotename` to state the name of the *remote* instead -of the ref, and `:remoteref` to state the name of the *reference* as -locally known by the remote. +(EXPERIMENTAL) Also respects `:remotename` to state the name of the +*remote* instead of the ref, and `:remoteref` to state the name of +the *reference* as locally known by the remote. + Has no effect if the ref does not have tracking information associated with it. All the options apart from `nobracket` are mutually exclusive, @@ -152,9 +152,9 @@ but if used together the last option is selected. push:: The name of a local ref which represents the `@{push}` location for the displayed ref. Respects `:short`, `:lstrip`, - `:rstrip`, `:track`, `:trackshort`, `:remotename`, and `:remoteref` - options as `upstream` does. Produces an empty string if no `@{push}` - ref is configured. + `:rstrip`, `:track`, `:trackshort`, (EXPERIMENTAL) `:remotename`, + and (EXPERIMENTAL) `:remoteref` options as `upstream` does. + Produces an empty string if no `@{push}` ref is configured. HEAD:: '*' if HEAD matches current ref (the checked out branch), ' '