status: show default branch comparison when tracking non-default branch

From: Harald Nordgren <[email protected]>

"git status" on a branch that follows a remote branch compares commits on the current branch and the remote-tracking branch it builds upon, to show "ahead", "behind", or "diverged" status.

When working on a feature branch that tracks a remote feature branch, but you also want to track progress relative to the push destination tracking branch (which may differ from the upstream branch), git status now shows an additional comparison.

When the upstream tracking branch differs from the push destination tracking branch, git status shows both the comparison with the upstream tracking branch (as before) and an additional comparison with the push destination tracking branch. The push branch comparison appears on a separate line after the upstream branch status, using the same format.

Example output when tracking origin/main but push destination is origin/feature:
On branch feature
Your branch and 'origin/main' have diverged,
and have 3 and 1 different commits each, respectively.
(use "git pull" if you want to integrate the remote branch with yours)

Your branch is ahead of 'origin/feature' by 1 commit.
(use "git push" to publish your local commits)

The comparison is only shown when the push destination tracking branch differs from the upstream tracking branch, even if they are on the same remote.

---
 remote.c                 | 102 ++++++++++++++-
 t/t6040-tracking-info.sh | 262 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 358 insertions(+), 6 deletions(-)

index b053d4e443..dd8f94fa23 100644
@@ -29,6 +29,11 @@
 
 enum map_direction { FROM_SRC, FROM_DST };
 
+enum {
+	BRANCH_MODE_PULL = (1 << 0),
+	BRANCH_MODE_PUSH = (1 << 1),
+};
+
 struct counted_string {
 	size_t len;
 	const char *s;

@@ -2237,13 +2242,75 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
+static char *get_remote_push_branch(struct branch *branch, char **full_ref_out)
+{
+	struct remote *remote;
+	const char *push_remote;
+	char *push_dst = NULL;
+	char *tracking_ref;
+	const char *resolved;
+	char *ret;
+
+	if (!branch)
+		return NULL;
+
+	push_remote = pushremote_for_branch(branch, NULL);
+	if (!push_remote)
+		return NULL;
+
+	remote = remotes_remote_get(the_repository, push_remote);
+	if (!remote)
+		return NULL;
+
+	push_dst = remote_ref_for_branch(branch, 1);
+	if (!push_dst) {
+		if (remote->push.nr)
+			return NULL;
+		push_dst = xstrdup(branch->refname);
+	}
+
+	tracking_ref = (char *)tracking_for_push_dest(remote, push_dst, NULL);
+	free(push_dst);
+
+	if (!tracking_ref)
+		return NULL;
+
+	resolved = refs_resolve_ref_unsafe(
+		get_main_ref_store(the_repository),
+		tracking_ref,
+		RESOLVE_REF_READING,
+		NULL, NULL);
+
+	if (!resolved) {
+		free(tracking_ref);
+		return NULL;
+	}
+
+	if (full_ref_out)
+		*full_ref_out = xstrdup(resolved);
+
+	ret = refs_shorten_unambiguous_ref(
+		get_main_ref_store(the_repository), resolved, 0);
+	free(tracking_ref);
+	return ret;
+}
+
 static void format_branch_comparison(struct strbuf *sb,
 				     bool up_to_date,
 				     int ours, int theirs,
 				     const char *branch_name,
 				     enum ahead_behind_flags abf,
+				     unsigned flags,
 				     bool show_divergence_advice)
 {
+	bool want_push_advice = (flags & BRANCH_MODE_PUSH) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool want_pull_advice = (flags & BRANCH_MODE_PULL) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool want_divergence_advice = (flags & BRANCH_MODE_PULL) &&
+		show_divergence_advice &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+
 	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),

@@ -2252,7 +2319,7 @@ static void format_branch_comparison(struct strbuf *sb,
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
 			    branch_name);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_push_advice)
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");
 	} else if (!theirs) {

@@ -2261,7 +2328,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
 			branch_name, ours);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_push_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));
 	} else if (!ours) {

@@ -2272,7 +2339,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			       "and can be fast-forwarded.\n",
 			   theirs),
 			branch_name, theirs);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_pull_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));
 	} else {

@@ -2280,8 +2347,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			"Your branch and '%s' have diverged,\n"
 			       "and have %d and %d different commits each, respectively.\n",
 			branch_name, ours, theirs);
-		if (show_divergence_advice &&
-		    advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_divergence_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}

@@ -2298,6 +2364,11 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	const char *full_base;
 	char *base;
 	int upstream_is_gone = 0;
+	unsigned base_branch_modes = BRANCH_MODE_PULL | BRANCH_MODE_PUSH;
+	int push_ours, push_theirs, push_sti;
+	char *full_push = NULL;
+	char *push = NULL;
+	unsigned push_branch_modes = 0;
 
 	sti = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
 	if (sti < 0) {

@@ -2309,6 +2380,16 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
 					    full_base, 0);
 
+	push = get_remote_push_branch(branch, &full_push);
+	if (push && strcmp(base, push)) {
+		push_sti = stat_branch_pair(branch->refname, full_push,
+					   &push_ours, &push_theirs, abf);
+		if (push_sti >= 0) {
+			base_branch_modes = BRANCH_MODE_PULL;
+			push_branch_modes = BRANCH_MODE_PUSH;
+		}
+	}
+
 	if (upstream_is_gone) {
 		strbuf_addf(sb,
 			_("Your branch is based on '%s', but the upstream is gone.\n"),

@@ -2317,10 +2398,19 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			strbuf_addstr(sb,
 				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
 	} else {
-		format_branch_comparison(sb, !sti, ours, theirs, base, abf, show_divergence_advice);
+		format_branch_comparison(sb, !sti, ours, theirs, base, abf,
+					 base_branch_modes, show_divergence_advice);
+	}
+
+	if (push_branch_modes & BRANCH_MODE_PUSH) {
+		strbuf_addstr(sb, "\n");
+		format_branch_comparison(sb, !push_sti, push_ours, push_theirs, push, abf,
+					 push_branch_modes, show_divergence_advice);
 	}
 
 	free(base);
+	free(full_push);
+	free(push);
 	return 1;
 }
 

gitgitgadget

cc: Chris Torek [email protected] cc: Yee Cheng Chin [email protected] cc: "brian m. carlson" [email protected]
cc: Ben Knoble [email protected] cc: "Kristoffer Haugsbakk" [email protected] cc: Phillip Wood [email protected]
cc: Nico Williams [email protected] cc: Patrick Steinhardt [email protected]

Harald Nordgren (2):
refactor format_branch_comparison in preparation
status: show comparison with push remote tracking branch

 remote.c                 | 183 ++++++++++++++++++++-------
 t/t6040-tracking-info.sh | 262 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 403 insertions(+), 42 deletions(-)

base-commit: d529f3a197364881746f558e5652f0236131eb86
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2138%2FHaraldNordgren%2Fahead_of_main_status-v21
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2138/HaraldNordgren/ahead_of_main_status-v21
Pull-Request: https://github.com/git/git/pull/2138

Range-diff vs v20:

1: bb3e00863b ! 1: ce1f1eebb5 refactor format_branch_comparison in preparation

     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
      +			 enum ahead_behind_flags abf,
      +			 int show_divergence_advice)
      +{
     -+	int ours, theirs, sti;
     ++	int ours, theirs, cmp_fetch;
      +	const char *full_base;
      +	char *base;
      +	int upstream_is_gone = 0;
      +
     -+	sti = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
     -+	if (sti < 0) {
     ++	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
     ++	if (cmp_fetch < 0) {
      +		if (!full_base)
      +			return 0;
      +		upstream_is_gone = 1;
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
      +			strbuf_addstr(sb,
      +				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
      +	} else {
     -+		format_branch_comparison(sb, !sti, ours, theirs, base, abf, show_divergence_advice);
     ++		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
      +	}
      +
       	free(base);
 2:  050197eac3 ! 2:  51d8486fe0 status: show comparison with push remote tracking branch
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
       	char *base;
       	int upstream_is_gone = 0;
      +	unsigned base_branch_modes = BRANCH_MODE_PULL | BRANCH_MODE_PUSH;
     -+	int push_ours, push_theirs, push_sti;
     ++	int push_ours, push_theirs, push_cmp_fetch;
      +	char *full_push = NULL;
      +	char *push = NULL;
      +	unsigned push_branch_modes = 0;
       
     - 	sti = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
     - 	if (sti < 0) {
     + 	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
     + 	if (cmp_fetch < 0) {
      @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
       	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
       					    full_base, 0);
       
      +	push = get_remote_push_branch(branch, &full_push);
      +	if (push && strcmp(base, push)) {
     -+		push_sti = stat_branch_pair(branch->refname, full_push,
     ++		push_cmp_fetch = stat_branch_pair(branch->refname, full_push,
      +					   &push_ours, &push_theirs, abf);
     -+		if (push_sti >= 0) {
     ++		if (push_cmp_fetch >= 0) {
      +			base_branch_modes = BRANCH_MODE_PULL;
      +			push_branch_modes = BRANCH_MODE_PUSH;
      +		}
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
       			strbuf_addstr(sb,
       				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
       	} else {
     --		format_branch_comparison(sb, !sti, ours, theirs, base, abf, show_divergence_advice);
     -+		format_branch_comparison(sb, !sti, ours, theirs, base, abf,
     +-		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
     ++		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf,
      +					 base_branch_modes, show_divergence_advice);
      +	}
      +
      +	if (push_branch_modes & BRANCH_MODE_PUSH) {
      +		strbuf_addstr(sb, "\n");
     -+		format_branch_comparison(sb, !push_sti, push_ours, push_theirs, push, abf,
     ++		format_branch_comparison(sb, !push_cmp_fetch, push_ours, push_theirs, push, abf,
      +					 push_branch_modes, show_divergence_advice);
       	}

gitgitgadget

From: Harald Nordgren <[email protected]>

Refactor format_branch_comparison function in preparation for showing comparison with push remote tracking branch.

---
 remote.c | 91 +++++++++++++++++++++++++++++++-------------------------
 1 file changed, 50 insertions(+), 41 deletions(-)

index 59b3715120..af078817a4 100644
@@ -2237,42 +2237,21 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
-/*
- * Return true when there is anything to report, otherwise false.
- */
-int format_tracking_info(struct branch *branch, struct strbuf *sb,
-			 enum ahead_behind_flags abf,
-			 int show_divergence_advice)
-{
-	int ours, theirs, sti;
-	const char *full_base;
-	char *base;
-	int upstream_is_gone = 0;
-
-	sti = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
-	if (sti < 0) {
-		if (!full_base)
-			return 0;
-		upstream_is_gone = 1;
-	}
-
-	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
-					    full_base, 0);
-	if (upstream_is_gone) {
-		strbuf_addf(sb,
-			_("Your branch is based on '%s', but the upstream is gone.\n"),
-			base);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
-			strbuf_addstr(sb,
-				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
-	} else if (!sti) {
+static void format_branch_comparison(struct strbuf *sb,
+				     bool up_to_date,
+				     int ours, int theirs,
+				     const char *branch_name,
+				     enum ahead_behind_flags abf,
+				     bool show_divergence_advice)
+{
+	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),
-			base);
+			branch_name);
 	} else if (abf == AHEAD_BEHIND_QUICK) {
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
-			    base);
+			    branch_name);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");

@@ -2281,7 +2260,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			Q_("Your branch is ahead of '%s' by %d commit.\n",
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
-			base, ours);
+			branch_name, ours);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));

@@ -2292,25 +2271,55 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			   "Your branch is behind '%s' by %d commits, "
 			       "and can be fast-forwarded.\n",
 			   theirs),
-			base, theirs);
+			branch_name, theirs);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));
 	} else {
 		strbuf_addf(sb,
-			Q_("Your branch and '%s' have diverged,\n"
-			       "and have %d and %d different commit each, "
-			       "respectively.\n",
-			   "Your branch and '%s' have diverged,\n"
-			       "and have %d and %d different commits each, "
-			       "respectively.\n",
-			   ours + theirs),
-			base, ours, theirs);
+			"Your branch and '%s' have diverged,\n"
+			       "and have %d and %d different commits each, respectively.\n",
+			branch_name, ours, theirs);
 		if (show_divergence_advice &&
 		    advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}
+}
+
+/*
+ * Return true when there is anything to report, otherwise false.
+ */
+int format_tracking_info(struct branch *branch, struct strbuf *sb,
+			 enum ahead_behind_flags abf,
+			 int show_divergence_advice)
+{
+	int ours, theirs, cmp_fetch;
+	const char *full_base;
+	char *base;
+	int upstream_is_gone = 0;
+
+	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
+	if (cmp_fetch < 0) {
+		if (!full_base)
+			return 0;
+		upstream_is_gone = 1;
+	}
+
+	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
+					    full_base, 0);
+
+	if (upstream_is_gone) {
+		strbuf_addf(sb,
+			_("Your branch is based on '%s', but the upstream is gone.\n"),
+			base);
+		if (advice_enabled(ADVICE_STATUS_HINTS))
+			strbuf_addstr(sb,
+				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
+	} else {
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+	}
+
 	free(base);
 	return 1;
 }

gitgitgadget

From: Harald Nordgren <[email protected]>

"git status" on a branch that follows a remote branch compares commits on the current branch and the remote-tracking branch it builds upon, to show "ahead", "behind", or "diverged" status.

When working on a feature branch that tracks a remote feature branch, but you also want to track progress relative to the push destination tracking branch (which may differ from the upstream branch), git status now shows an additional comparison.

When the upstream tracking branch differs from the push destination tracking branch, git status shows both the comparison with the upstream tracking branch (as before) and an additional comparison with the push destination tracking branch. The push branch comparison appears on a separate line after the upstream branch status, using the same format.

Example output when tracking origin/main but push destination is origin/feature:
On branch feature
Your branch and 'origin/main' have diverged,
and have 3 and 1 different commits each, respectively.
(use "git pull" if you want to integrate the remote branch with yours)

Your branch is ahead of 'origin/feature' by 1 commit.
(use "git push" to publish your local commits)

The comparison is only shown when the push destination tracking branch differs from the upstream tracking branch, even if they are on the same remote.

---
 remote.c                 | 102 ++++++++++++++-
 t/t6040-tracking-info.sh | 262 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 358 insertions(+), 6 deletions(-)

index af078817a4..40e4ebb3b7 100644
@@ -29,6 +29,11 @@
 
 enum map_direction { FROM_SRC, FROM_DST };
 
+enum {
+	BRANCH_MODE_PULL = (1 << 0),
+	BRANCH_MODE_PUSH = (1 << 1),
+};
+
 struct counted_string {
 	size_t len;
 	const char *s;

@@ -2237,13 +2242,75 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
+static char *get_remote_push_branch(struct branch *branch, char **full_ref_out)
+{
+	struct remote *remote;
+	const char *push_remote;
+	char *push_dst = NULL;
+	char *tracking_ref;
+	const char *resolved;
+	char *ret;
+
+	if (!branch)
+		return NULL;
+
+	push_remote = pushremote_for_branch(branch, NULL);
+	if (!push_remote)
+		return NULL;
+
+	remote = remotes_remote_get(the_repository, push_remote);
+	if (!remote)
+		return NULL;
+
+	push_dst = remote_ref_for_branch(branch, 1);
+	if (!push_dst) {
+		if (remote->push.nr)
+			return NULL;
+		push_dst = xstrdup(branch->refname);
+	}
+
+	tracking_ref = (char *)tracking_for_push_dest(remote, push_dst, NULL);
+	free(push_dst);
+
+	if (!tracking_ref)
+		return NULL;
+
+	resolved = refs_resolve_ref_unsafe(
+		get_main_ref_store(the_repository),
+		tracking_ref,
+		RESOLVE_REF_READING,
+		NULL, NULL);
+
+	if (!resolved) {
+		free(tracking_ref);
+		return NULL;
+	}
+
+	if (full_ref_out)
+		*full_ref_out = xstrdup(resolved);
+
+	ret = refs_shorten_unambiguous_ref(
+		get_main_ref_store(the_repository), resolved, 0);
+	free(tracking_ref);
+	return ret;
+}
+
 static void format_branch_comparison(struct strbuf *sb,
 				     bool up_to_date,
 				     int ours, int theirs,
 				     const char *branch_name,
 				     enum ahead_behind_flags abf,
+				     unsigned flags,
 				     bool show_divergence_advice)
 {
+	bool want_push_advice = (flags & BRANCH_MODE_PUSH) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool want_pull_advice = (flags & BRANCH_MODE_PULL) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool want_divergence_advice = (flags & BRANCH_MODE_PULL) &&
+		show_divergence_advice &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+
 	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),

@@ -2252,7 +2319,7 @@ static void format_branch_comparison(struct strbuf *sb,
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
 			    branch_name);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_push_advice)
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");
 	} else if (!theirs) {

@@ -2261,7 +2328,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
 			branch_name, ours);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_push_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));
 	} else if (!ours) {

@@ -2272,7 +2339,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			       "and can be fast-forwarded.\n",
 			   theirs),
 			branch_name, theirs);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_pull_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));
 	} else {

@@ -2280,8 +2347,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			"Your branch and '%s' have diverged,\n"
 			       "and have %d and %d different commits each, respectively.\n",
 			branch_name, ours, theirs);
-		if (show_divergence_advice &&
-		    advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_divergence_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}

@@ -2298,6 +2364,11 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	const char *full_base;
 	char *base;
 	int upstream_is_gone = 0;
+	unsigned base_branch_modes = BRANCH_MODE_PULL | BRANCH_MODE_PUSH;
+	int push_ours, push_theirs, push_cmp_fetch;
+	char *full_push = NULL;
+	char *push = NULL;
+	unsigned push_branch_modes = 0;
 
 	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
 	if (cmp_fetch < 0) {

@@ -2309,6 +2380,16 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
 					    full_base, 0);
 
+	push = get_remote_push_branch(branch, &full_push);
+	if (push && strcmp(base, push)) {
+		push_cmp_fetch = stat_branch_pair(branch->refname, full_push,
+					   &push_ours, &push_theirs, abf);
+		if (push_cmp_fetch >= 0) {
+			base_branch_modes = BRANCH_MODE_PULL;
+			push_branch_modes = BRANCH_MODE_PUSH;
+		}
+	}
+
 	if (upstream_is_gone) {
 		strbuf_addf(sb,
 			_("Your branch is based on '%s', but the upstream is gone.\n"),

@@ -2317,10 +2398,19 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			strbuf_addstr(sb,
 				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
 	} else {
-		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf,
+					 base_branch_modes, show_divergence_advice);
+	}
+
+	if (push_branch_modes & BRANCH_MODE_PUSH) {
+		strbuf_addstr(sb, "\n");
+		format_branch_comparison(sb, !push_cmp_fetch, push_ours, push_theirs, push, abf,
+					 push_branch_modes, show_divergence_advice);
 	}
 
 	free(base);
+	free(full_push);
+	free(push);
 	return 1;
 }
 

gitgitgadget

cc: Chris Torek [email protected] cc: Yee Cheng Chin [email protected] cc: "brian m. carlson" [email protected]
cc: Ben Knoble [email protected] cc: "Kristoffer Haugsbakk" [email protected] cc: Phillip Wood [email protected]
cc: Nico Williams [email protected] cc: Patrick Steinhardt [email protected]

Harald Nordgren (2):
refactor format_branch_comparison in preparation
status: show comparison with push remote tracking branch

 remote.c                 | 174 ++++++++++++++++++++------
 t/t6040-tracking-info.sh | 262 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 401 insertions(+), 35 deletions(-)

base-commit: d529f3a197364881746f558e5652f0236131eb86
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2138%2FHaraldNordgren%2Fahead_of_main_status-v22
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2138/HaraldNordgren/ahead_of_main_status-v22
Pull-Request: https://github.com/git/git/pull/2138

Range-diff vs v21:

1: ce1f1eebb5 ! 1: 4aa4f1abc8 refactor format_branch_comparison in preparation
@@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
if (advice_enabled(ADVICE_STATUS_HINTS))
strbuf_addstr(sb,
_(" (use \"git pull\" to update your local branch)\n"));
- } else {
- strbuf_addf(sb,
-- Q_("Your branch and '%s' have diverged,\n"
-- "and have %d and %d different commit each, "
-- "respectively.\n",
-- "Your branch and '%s' have diverged,\n"
-- "and have %d and %d different commits each, "
-- "respectively.\n",
-- ours + theirs),
+@@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
+ "and have %d and %d different commits each, "
+ "respectively.\n",
+ ours + theirs),
- base, ours, theirs);
-+ "Your branch and '%s' have diverged,\n"
-+ "and have %d and %d different commits each, respectively.\n",
+ branch_name, ours, theirs);
if (show_divergence_advice &&
advice_enabled(ADVICE_STATUS_HINTS))
2: 51d8486fe0 ! 2: b7e29887d9 status: show comparison with push remote tracking branch
@@ remote.c: static void format_branch_comparison(struct strbuf *sb,
_(" (use \"git pull\" to update your local branch)\n"));
} else {
@@ remote.c: static void format_branch_comparison(struct strbuf *sb,
- "Your branch and '%s' have diverged,\n"
- "and have %d and %d different commits each, respectively.\n",
+ "respectively.\n",
+ ours + theirs),
branch_name, ours, theirs);
- if (show_divergence_advice &&
- advice_enabled(ADVICE_STATUS_HINTS))

gitgitgadget

From: Harald Nordgren <[email protected]>

Refactor format_branch_comparison function in preparation for showing comparison with push remote tracking branch.

---
 remote.c | 82 +++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 48 insertions(+), 34 deletions(-)

index 59b3715120..d5a6486026 100644
@@ -2237,42 +2237,21 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
-/*
- * Return true when there is anything to report, otherwise false.
- */
-int format_tracking_info(struct branch *branch, struct strbuf *sb,
-			 enum ahead_behind_flags abf,
-			 int show_divergence_advice)
-{
-	int ours, theirs, sti;
-	const char *full_base;
-	char *base;
-	int upstream_is_gone = 0;
-
-	sti = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
-	if (sti < 0) {
-		if (!full_base)
-			return 0;
-		upstream_is_gone = 1;
-	}
-
-	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
-					    full_base, 0);
-	if (upstream_is_gone) {
-		strbuf_addf(sb,
-			_("Your branch is based on '%s', but the upstream is gone.\n"),
-			base);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
-			strbuf_addstr(sb,
-				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
-	} else if (!sti) {
+static void format_branch_comparison(struct strbuf *sb,
+				     bool up_to_date,
+				     int ours, int theirs,
+				     const char *branch_name,
+				     enum ahead_behind_flags abf,
+				     bool show_divergence_advice)
+{
+	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),
-			base);
+			branch_name);
 	} else if (abf == AHEAD_BEHIND_QUICK) {
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
-			    base);
+			    branch_name);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");

@@ -2281,7 +2260,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			Q_("Your branch is ahead of '%s' by %d commit.\n",
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
-			base, ours);
+			branch_name, ours);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));

@@ -2292,7 +2271,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			   "Your branch is behind '%s' by %d commits, "
 			       "and can be fast-forwarded.\n",
 			   theirs),
-			base, theirs);
+			branch_name, theirs);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));

@@ -2305,12 +2284,47 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			       "and have %d and %d different commits each, "
 			       "respectively.\n",
 			   ours + theirs),
-			base, ours, theirs);
+			branch_name, ours, theirs);
 		if (show_divergence_advice &&
 		    advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}
+}
+
+/*
+ * Return true when there is anything to report, otherwise false.
+ */
+int format_tracking_info(struct branch *branch, struct strbuf *sb,
+			 enum ahead_behind_flags abf,
+			 int show_divergence_advice)
+{
+	int ours, theirs, cmp_fetch;
+	const char *full_base;
+	char *base;
+	int upstream_is_gone = 0;
+
+	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
+	if (cmp_fetch < 0) {
+		if (!full_base)
+			return 0;
+		upstream_is_gone = 1;
+	}
+
+	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
+					    full_base, 0);
+
+	if (upstream_is_gone) {
+		strbuf_addf(sb,
+			_("Your branch is based on '%s', but the upstream is gone.\n"),
+			base);
+		if (advice_enabled(ADVICE_STATUS_HINTS))
+			strbuf_addstr(sb,
+				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
+	} else {
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+	}
+
 	free(base);
 	return 1;
 }

gitgitgadget

From: Harald Nordgren <[email protected]>

"git status" on a branch that follows a remote branch compares commits on the current branch and the remote-tracking branch it builds upon, to show "ahead", "behind", or "diverged" status.

When working on a feature branch that tracks a remote feature branch, but you also want to track progress relative to the push destination tracking branch (which may differ from the upstream branch), git status now shows an additional comparison.

When the upstream tracking branch differs from the push destination tracking branch, git status shows both the comparison with the upstream tracking branch (as before) and an additional comparison with the push destination tracking branch. The push branch comparison appears on a separate line after the upstream branch status, using the same format.

Example output when tracking origin/main but push destination is origin/feature:
On branch feature
Your branch and 'origin/main' have diverged,
and have 3 and 1 different commits each, respectively.
(use "git pull" if you want to integrate the remote branch with yours)

Your branch is ahead of 'origin/feature' by 1 commit.
(use "git push" to publish your local commits)

The comparison is only shown when the push destination tracking branch differs from the upstream tracking branch, even if they are on the same remote.

---
 remote.c                 | 102 ++++++++++++++-
 t/t6040-tracking-info.sh | 262 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 358 insertions(+), 6 deletions(-)

index d5a6486026..f9aa4c61bc 100644
@@ -29,6 +29,11 @@
 
 enum map_direction { FROM_SRC, FROM_DST };
 
+enum {
+	BRANCH_MODE_PULL = (1 << 0),
+	BRANCH_MODE_PUSH = (1 << 1),
+};
+
 struct counted_string {
 	size_t len;
 	const char *s;

@@ -2237,13 +2242,75 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
+static char *get_remote_push_branch(struct branch *branch, char **full_ref_out)
+{
+	struct remote *remote;
+	const char *push_remote;
+	char *push_dst = NULL;
+	char *tracking_ref;
+	const char *resolved;
+	char *ret;
+
+	if (!branch)
+		return NULL;
+
+	push_remote = pushremote_for_branch(branch, NULL);
+	if (!push_remote)
+		return NULL;
+
+	remote = remotes_remote_get(the_repository, push_remote);
+	if (!remote)
+		return NULL;
+
+	push_dst = remote_ref_for_branch(branch, 1);
+	if (!push_dst) {
+		if (remote->push.nr)
+			return NULL;
+		push_dst = xstrdup(branch->refname);
+	}
+
+	tracking_ref = (char *)tracking_for_push_dest(remote, push_dst, NULL);
+	free(push_dst);
+
+	if (!tracking_ref)
+		return NULL;
+
+	resolved = refs_resolve_ref_unsafe(
+		get_main_ref_store(the_repository),
+		tracking_ref,
+		RESOLVE_REF_READING,
+		NULL, NULL);
+
+	if (!resolved) {
+		free(tracking_ref);
+		return NULL;
+	}
+
+	if (full_ref_out)
+		*full_ref_out = xstrdup(resolved);
+
+	ret = refs_shorten_unambiguous_ref(
+		get_main_ref_store(the_repository), resolved, 0);
+	free(tracking_ref);
+	return ret;
+}
+
 static void format_branch_comparison(struct strbuf *sb,
 				     bool up_to_date,
 				     int ours, int theirs,
 				     const char *branch_name,
 				     enum ahead_behind_flags abf,
+				     unsigned flags,
 				     bool show_divergence_advice)
 {
+	bool want_push_advice = (flags & BRANCH_MODE_PUSH) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool want_pull_advice = (flags & BRANCH_MODE_PULL) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool want_divergence_advice = (flags & BRANCH_MODE_PULL) &&
+		show_divergence_advice &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+
 	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),

@@ -2252,7 +2319,7 @@ static void format_branch_comparison(struct strbuf *sb,
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
 			    branch_name);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_push_advice)
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");
 	} else if (!theirs) {

@@ -2261,7 +2328,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
 			branch_name, ours);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_push_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));
 	} else if (!ours) {

@@ -2272,7 +2339,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			       "and can be fast-forwarded.\n",
 			   theirs),
 			branch_name, theirs);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_pull_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));
 	} else {

@@ -2285,8 +2352,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			       "respectively.\n",
 			   ours + theirs),
 			branch_name, ours, theirs);
-		if (show_divergence_advice &&
-		    advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_divergence_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}

@@ -2303,6 +2369,11 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	const char *full_base;
 	char *base;
 	int upstream_is_gone = 0;
+	unsigned base_branch_modes = BRANCH_MODE_PULL | BRANCH_MODE_PUSH;
+	int push_ours, push_theirs, push_cmp_fetch;
+	char *full_push = NULL;
+	char *push = NULL;
+	unsigned push_branch_modes = 0;
 
 	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
 	if (cmp_fetch < 0) {

@@ -2314,6 +2385,16 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
 					    full_base, 0);
 
+	push = get_remote_push_branch(branch, &full_push);
+	if (push && strcmp(base, push)) {
+		push_cmp_fetch = stat_branch_pair(branch->refname, full_push,
+					   &push_ours, &push_theirs, abf);
+		if (push_cmp_fetch >= 0) {
+			base_branch_modes = BRANCH_MODE_PULL;
+			push_branch_modes = BRANCH_MODE_PUSH;
+		}
+	}
+
 	if (upstream_is_gone) {
 		strbuf_addf(sb,
 			_("Your branch is based on '%s', but the upstream is gone.\n"),

@@ -2322,10 +2403,19 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			strbuf_addstr(sb,
 				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
 	} else {
-		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf,
+					 base_branch_modes, show_divergence_advice);
+	}
+
+	if (push_branch_modes & BRANCH_MODE_PUSH) {
+		strbuf_addstr(sb, "\n");
+		format_branch_comparison(sb, !push_cmp_fetch, push_ours, push_theirs, push, abf,
+					 push_branch_modes, show_divergence_advice);
 	}
 
 	free(base);
+	free(full_push);
+	free(push);
 	return 1;
 }
 

gitgitgadget

cc: Chris Torek [email protected] cc: Yee Cheng Chin [email protected] cc: "brian m. carlson" [email protected]
cc: Ben Knoble [email protected] cc: "Kristoffer Haugsbakk" [email protected] cc: Phillip Wood [email protected]
cc: Nico Williams [email protected] cc: Patrick Steinhardt [email protected]

Harald Nordgren (2):
refactor format_branch_comparison in preparation
status: show comparison with push remote tracking branch

 remote.c                 | 173 ++++++++++++++++++++------
 t/t6040-tracking-info.sh | 262 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 400 insertions(+), 35 deletions(-)

base-commit: 8745eae506f700657882b9e32b2aa00f234a6fb6
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2138%2FHaraldNordgren%2Fahead_of_main_status-v23
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2138/HaraldNordgren/ahead_of_main_status-v23
Pull-Request: https://github.com/git/git/pull/2138

Range-diff vs v22:

 1:  4aa4f1abc8 = 1:  fd05c7b778 refactor format_branch_comparison in preparation
 2:  b7e29887d9 ! 2:  f1ad7a1b6f status: show comparison with push remote tracking branch
     @@ remote.c: int stat_tracking_info(struct branch *branch, int *num_ours, int *num_
      +		advice_enabled(ADVICE_STATUS_HINTS);
      +	bool want_pull_advice = (flags & BRANCH_MODE_PULL) &&
      +		advice_enabled(ADVICE_STATUS_HINTS);
     -+	bool want_divergence_advice = (flags & BRANCH_MODE_PULL) &&
     -+		show_divergence_advice &&
     ++	bool want_divergence_advice = show_divergence_advice &&
      +		advice_enabled(ADVICE_STATUS_HINTS);
      +
       	if (up_to_date) {
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
      +	if (push_branch_modes & BRANCH_MODE_PUSH) {
      +		strbuf_addstr(sb, "\n");
      +		format_branch_comparison(sb, !push_cmp_fetch, push_ours, push_theirs, push, abf,
     -+					 push_branch_modes, show_divergence_advice);
     ++					 push_branch_modes, 0);
       	}
       
       	free(base);

gitgitgadget

From: Harald Nordgren <[email protected]>

Refactor format_branch_comparison function in preparation for showing comparison with push remote tracking branch.

---
 remote.c | 82 +++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 48 insertions(+), 34 deletions(-)

index b756ff6f15..fd592ec659 100644
@@ -2230,42 +2230,21 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
-/*
- * Return true when there is anything to report, otherwise false.
- */
-int format_tracking_info(struct branch *branch, struct strbuf *sb,
-			 enum ahead_behind_flags abf,
-			 int show_divergence_advice)
-{
-	int ours, theirs, sti;
-	const char *full_base;
-	char *base;
-	int upstream_is_gone = 0;
-
-	sti = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
-	if (sti < 0) {
-		if (!full_base)
-			return 0;
-		upstream_is_gone = 1;
-	}
-
-	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
-					    full_base, 0);
-	if (upstream_is_gone) {
-		strbuf_addf(sb,
-			_("Your branch is based on '%s', but the upstream is gone.\n"),
-			base);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
-			strbuf_addstr(sb,
-				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
-	} else if (!sti) {
+static void format_branch_comparison(struct strbuf *sb,
+				     bool up_to_date,
+				     int ours, int theirs,
+				     const char *branch_name,
+				     enum ahead_behind_flags abf,
+				     bool show_divergence_advice)
+{
+	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),
-			base);
+			branch_name);
 	} else if (abf == AHEAD_BEHIND_QUICK) {
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
-			    base);
+			    branch_name);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");

@@ -2274,7 +2253,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			Q_("Your branch is ahead of '%s' by %d commit.\n",
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
-			base, ours);
+			branch_name, ours);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));

@@ -2285,7 +2264,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			   "Your branch is behind '%s' by %d commits, "
 			       "and can be fast-forwarded.\n",
 			   theirs),
-			base, theirs);
+			branch_name, theirs);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));

@@ -2298,12 +2277,47 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			       "and have %d and %d different commits each, "
 			       "respectively.\n",
 			   ours + theirs),
-			base, ours, theirs);
+			branch_name, ours, theirs);
 		if (show_divergence_advice &&
 		    advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}
+}
+
+/*
+ * Return true when there is anything to report, otherwise false.
+ */
+int format_tracking_info(struct branch *branch, struct strbuf *sb,
+			 enum ahead_behind_flags abf,
+			 int show_divergence_advice)
+{
+	int ours, theirs, cmp_fetch;
+	const char *full_base;
+	char *base;
+	int upstream_is_gone = 0;
+
+	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
+	if (cmp_fetch < 0) {
+		if (!full_base)
+			return 0;
+		upstream_is_gone = 1;
+	}
+
+	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
+					    full_base, 0);
+
+	if (upstream_is_gone) {
+		strbuf_addf(sb,
+			_("Your branch is based on '%s', but the upstream is gone.\n"),
+			base);
+		if (advice_enabled(ADVICE_STATUS_HINTS))
+			strbuf_addstr(sb,
+				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
+	} else {
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+	}
+
 	free(base);
 	return 1;
 }

gitgitgadget

From: Harald Nordgren <[email protected]>

"git status" on a branch that follows a remote branch compares commits on the current branch and the remote-tracking branch it builds upon, to show "ahead", "behind", or "diverged" status.

When working on a feature branch that tracks a remote feature branch, but you also want to track progress relative to the push destination tracking branch (which may differ from the upstream branch), git status now shows an additional comparison.

When the upstream tracking branch differs from the push destination tracking branch, git status shows both the comparison with the upstream tracking branch (as before) and an additional comparison with the push destination tracking branch. The push branch comparison appears on a separate line after the upstream branch status, using the same format.

Example output when tracking origin/main but push destination is origin/feature:
On branch feature
Your branch and 'origin/main' have diverged,
and have 3 and 1 different commits each, respectively.
(use "git pull" if you want to integrate the remote branch with yours)

Your branch is ahead of 'origin/feature' by 1 commit.
(use "git push" to publish your local commits)

The comparison is only shown when the push destination tracking branch differs from the upstream tracking branch, even if they are on the same remote.

---
 remote.c                 | 101 ++++++++++++++-
 t/t6040-tracking-info.sh | 262 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 357 insertions(+), 6 deletions(-)

index fd592ec659..132fc6849f 100644
@@ -29,6 +29,11 @@
 
 enum map_direction { FROM_SRC, FROM_DST };
 
+enum {
+	BRANCH_MODE_PULL = (1 << 0),
+	BRANCH_MODE_PUSH = (1 << 1),
+};
+
 struct counted_string {
 	size_t len;
 	const char *s;

@@ -2230,13 +2235,74 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
+static char *get_remote_push_branch(struct branch *branch, char **full_ref_out)
+{
+	struct remote *remote;
+	const char *push_remote;
+	char *push_dst = NULL;
+	char *tracking_ref;
+	const char *resolved;
+	char *ret;
+
+	if (!branch)
+		return NULL;
+
+	push_remote = pushremote_for_branch(branch, NULL);
+	if (!push_remote)
+		return NULL;
+
+	remote = remotes_remote_get(the_repository, push_remote);
+	if (!remote)
+		return NULL;
+
+	push_dst = remote_ref_for_branch(branch, 1);
+	if (!push_dst) {
+		if (remote->push.nr)
+			return NULL;
+		push_dst = xstrdup(branch->refname);
+	}
+
+	tracking_ref = (char *)tracking_for_push_dest(remote, push_dst, NULL);
+	free(push_dst);
+
+	if (!tracking_ref)
+		return NULL;
+
+	resolved = refs_resolve_ref_unsafe(
+		get_main_ref_store(the_repository),
+		tracking_ref,
+		RESOLVE_REF_READING,
+		NULL, NULL);
+
+	if (!resolved) {
+		free(tracking_ref);
+		return NULL;
+	}
+
+	if (full_ref_out)
+		*full_ref_out = xstrdup(resolved);
+
+	ret = refs_shorten_unambiguous_ref(
+		get_main_ref_store(the_repository), resolved, 0);
+	free(tracking_ref);
+	return ret;
+}
+
 static void format_branch_comparison(struct strbuf *sb,
 				     bool up_to_date,
 				     int ours, int theirs,
 				     const char *branch_name,
 				     enum ahead_behind_flags abf,
+				     unsigned flags,
 				     bool show_divergence_advice)
 {
+	bool want_push_advice = (flags & BRANCH_MODE_PUSH) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool want_pull_advice = (flags & BRANCH_MODE_PULL) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool want_divergence_advice = show_divergence_advice &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+
 	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),

@@ -2245,7 +2311,7 @@ static void format_branch_comparison(struct strbuf *sb,
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
 			    branch_name);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_push_advice)
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");
 	} else if (!theirs) {

@@ -2254,7 +2320,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
 			branch_name, ours);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_push_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));
 	} else if (!ours) {

@@ -2265,7 +2331,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			       "and can be fast-forwarded.\n",
 			   theirs),
 			branch_name, theirs);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_pull_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));
 	} else {

@@ -2278,8 +2344,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			       "respectively.\n",
 			   ours + theirs),
 			branch_name, ours, theirs);
-		if (show_divergence_advice &&
-		    advice_enabled(ADVICE_STATUS_HINTS))
+		if (want_divergence_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}

@@ -2296,6 +2361,11 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	const char *full_base;
 	char *base;
 	int upstream_is_gone = 0;
+	unsigned base_branch_modes = BRANCH_MODE_PULL | BRANCH_MODE_PUSH;
+	int push_ours, push_theirs, push_cmp_fetch;
+	char *full_push = NULL;
+	char *push = NULL;
+	unsigned push_branch_modes = 0;
 
 	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
 	if (cmp_fetch < 0) {

@@ -2307,6 +2377,16 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
 					    full_base, 0);
 
+	push = get_remote_push_branch(branch, &full_push);
+	if (push && strcmp(base, push)) {
+		push_cmp_fetch = stat_branch_pair(branch->refname, full_push,
+					   &push_ours, &push_theirs, abf);
+		if (push_cmp_fetch >= 0) {
+			base_branch_modes = BRANCH_MODE_PULL;
+			push_branch_modes = BRANCH_MODE_PUSH;
+		}
+	}
+
 	if (upstream_is_gone) {
 		strbuf_addf(sb,
 			_("Your branch is based on '%s', but the upstream is gone.\n"),

@@ -2315,10 +2395,19 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			strbuf_addstr(sb,
 				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
 	} else {
-		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf,
+					 base_branch_modes, show_divergence_advice);
+	}
+
+	if (push_branch_modes & BRANCH_MODE_PUSH) {
+		strbuf_addstr(sb, "\n");
+		format_branch_comparison(sb, !push_cmp_fetch, push_ours, push_theirs, push, abf,
+					 push_branch_modes, 0);
 	}
 
 	free(base);
+	free(full_push);
+	free(push);
 	return 1;
 }
 

gitgitgadget

Good point. I changed it, it makes it nicer with one fewer parameter.

Thanks for all the help so far!

Harald

cc: Chris Torek [email protected] cc: Yee Cheng Chin [email protected] cc: "brian m. carlson" [email protected]
cc: Ben Knoble [email protected] cc: "Kristoffer Haugsbakk" [email protected] cc: Phillip Wood [email protected]
cc: Nico Williams [email protected] cc: Patrick Steinhardt [email protected]

Harald Nordgren (2):
refactor format_branch_comparison in preparation
status: show comparison with push remote tracking branch

 remote.c                 | 175 ++++++++++++++++++++------
 t/t6040-tracking-info.sh | 262 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 402 insertions(+), 35 deletions(-)

base-commit: 8745eae506f700657882b9e32b2aa00f234a6fb6
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2138%2FHaraldNordgren%2Fahead_of_main_status-v24
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2138/HaraldNordgren/ahead_of_main_status-v24
Pull-Request: https://github.com/git/git/pull/2138

Range-diff vs v23:

 1:  fd05c7b778 = 1:  fd05c7b778 refactor format_branch_comparison in preparation
 2:  f1ad7a1b6f ! 2:  138b79a0b9 status: show comparison with push remote tracking branch
     @@ remote.c
       enum map_direction { FROM_SRC, FROM_DST };
       
      +enum {
     -+	BRANCH_MODE_PULL = (1 << 0),
     -+	BRANCH_MODE_PUSH = (1 << 1),
     ++	ENABLE_ADVICE_PULL       = (1 << 0),
     ++	ENABLE_ADVICE_PUSH       = (1 << 1),
     ++	ENABLE_ADVICE_DIVERGENCE = (1 << 2),
      +};
      +
       struct counted_string {
     @@ remote.c: int stat_tracking_info(struct branch *branch, int *num_ours, int *num_
       	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
       }
       
     -+static char *get_remote_push_branch(struct branch *branch, char **full_ref_out)
     ++static char *get_remote_push_branch(struct branch *branch)
      +{
      +	struct remote *remote;
      +	const char *push_remote;
     @@ remote.c: int stat_tracking_info(struct branch *branch, int *num_ours, int *num_
      +		return NULL;
      +	}
      +
     -+	if (full_ref_out)
     -+		*full_ref_out = xstrdup(resolved);
     -+
     -+	ret = refs_shorten_unambiguous_ref(
     -+		get_main_ref_store(the_repository), resolved, 0);
     ++	ret = xstrdup(resolved);
      +	free(tracking_ref);
      +	return ret;
      +}
     @@ remote.c: int stat_tracking_info(struct branch *branch, int *num_ours, int *num_
       				     int ours, int theirs,
       				     const char *branch_name,
       				     enum ahead_behind_flags abf,
     -+				     unsigned flags,
     - 				     bool show_divergence_advice)
     +-				     bool show_divergence_advice)
     ++				     unsigned flags)
       {
     -+	bool want_push_advice = (flags & BRANCH_MODE_PUSH) &&
     ++	bool enable_push_advice = (flags & ENABLE_ADVICE_PUSH) &&
      +		advice_enabled(ADVICE_STATUS_HINTS);
     -+	bool want_pull_advice = (flags & BRANCH_MODE_PULL) &&
     ++	bool enable_pull_advice = (flags & ENABLE_ADVICE_PULL) &&
      +		advice_enabled(ADVICE_STATUS_HINTS);
     -+	bool want_divergence_advice = show_divergence_advice &&
     ++	bool enable_divergence_advice = (flags & ENABLE_ADVICE_DIVERGENCE) &&
      +		advice_enabled(ADVICE_STATUS_HINTS);
      +
       	if (up_to_date) {
     @@ remote.c: static void format_branch_comparison(struct strbuf *sb,
       			    _("Your branch and '%s' refer to different commits.\n"),
       			    branch_name);
      -		if (advice_enabled(ADVICE_STATUS_HINTS))
     -+		if (want_push_advice)
     ++		if (enable_push_advice)
       			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
       				    "git status --ahead-behind");
       	} else if (!theirs) {
     @@ remote.c: static void format_branch_comparison(struct strbuf *sb,
       			   ours),
       			branch_name, ours);
      -		if (advice_enabled(ADVICE_STATUS_HINTS))
     -+		if (want_push_advice)
     ++		if (enable_push_advice)
       			strbuf_addstr(sb,
       				_("  (use \"git push\" to publish your local commits)\n"));
       	} else if (!ours) {
     @@ remote.c: static void format_branch_comparison(struct strbuf *sb,
       			   theirs),
       			branch_name, theirs);
      -		if (advice_enabled(ADVICE_STATUS_HINTS))
     -+		if (want_pull_advice)
     ++		if (enable_pull_advice)
       			strbuf_addstr(sb,
       				_("  (use \"git pull\" to update your local branch)\n"));
       	} else {
     @@ remote.c: static void format_branch_comparison(struct strbuf *sb,
       			branch_name, ours, theirs);
      -		if (show_divergence_advice &&
      -		    advice_enabled(ADVICE_STATUS_HINTS))
     -+		if (want_divergence_advice)
     ++		if (enable_divergence_advice)
       			strbuf_addstr(sb,
       				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
       	}
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
       	const char *full_base;
       	char *base;
       	int upstream_is_gone = 0;
     -+	unsigned base_branch_modes = BRANCH_MODE_PULL | BRANCH_MODE_PUSH;
     ++	unsigned base_branch_flags = ENABLE_ADVICE_PULL | ENABLE_ADVICE_PUSH;
      +	int push_ours, push_theirs, push_cmp_fetch;
     -+	char *full_push = NULL;
     ++	char *full_push;
      +	char *push = NULL;
     -+	unsigned push_branch_modes = 0;
     ++	unsigned push_branch_flags = 0;
       
       	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
       	if (cmp_fetch < 0) {
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
       	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
       					    full_base, 0);
       
     -+	push = get_remote_push_branch(branch, &full_push);
     -+	if (push && strcmp(base, push)) {
     -+		push_cmp_fetch = stat_branch_pair(branch->refname, full_push,
     -+					   &push_ours, &push_theirs, abf);
     -+		if (push_cmp_fetch >= 0) {
     -+			base_branch_modes = BRANCH_MODE_PULL;
     -+			push_branch_modes = BRANCH_MODE_PUSH;
     ++	full_push = get_remote_push_branch(branch);
     ++	if (full_push) {
     ++		push = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
     ++						     full_push, 0);
     ++		if (push && base && strcmp(base, push)) {
     ++			push_cmp_fetch = stat_branch_pair(branch->refname, full_push,
     ++						   &push_ours, &push_theirs, abf);
     ++			if (push_cmp_fetch >= 0) {
     ++				base_branch_flags = ENABLE_ADVICE_PULL;
     ++				push_branch_flags = ENABLE_ADVICE_PUSH;
     ++			}
      +		}
      +	}
      +
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
       				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
       	} else {
      -		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
     ++		if (show_divergence_advice)
     ++			base_branch_flags |= ENABLE_ADVICE_DIVERGENCE;
      +		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf,
     -+					 base_branch_modes, show_divergence_advice);
     ++					 base_branch_flags);
      +	}
      +
     -+	if (push_branch_modes & BRANCH_MODE_PUSH) {
     ++	if (push_branch_flags & ENABLE_ADVICE_PUSH) {
      +		strbuf_addstr(sb, "\n");
      +		format_branch_comparison(sb, !push_cmp_fetch, push_ours, push_theirs, push, abf,
     -+					 push_branch_modes, 0);
     ++					 push_branch_flags);
       	}
       
       	free(base);

gitgitgadget

From: Harald Nordgren <[email protected]>

Refactor format_branch_comparison function in preparation for showing comparison with push remote tracking branch.

---
 remote.c | 82 +++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 48 insertions(+), 34 deletions(-)

index b756ff6f15..fd592ec659 100644
@@ -2230,42 +2230,21 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
-/*
- * Return true when there is anything to report, otherwise false.
- */
-int format_tracking_info(struct branch *branch, struct strbuf *sb,
-			 enum ahead_behind_flags abf,
-			 int show_divergence_advice)
-{
-	int ours, theirs, sti;
-	const char *full_base;
-	char *base;
-	int upstream_is_gone = 0;
-
-	sti = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
-	if (sti < 0) {
-		if (!full_base)
-			return 0;
-		upstream_is_gone = 1;
-	}
-
-	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
-					    full_base, 0);
-	if (upstream_is_gone) {
-		strbuf_addf(sb,
-			_("Your branch is based on '%s', but the upstream is gone.\n"),
-			base);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
-			strbuf_addstr(sb,
-				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
-	} else if (!sti) {
+static void format_branch_comparison(struct strbuf *sb,
+				     bool up_to_date,
+				     int ours, int theirs,
+				     const char *branch_name,
+				     enum ahead_behind_flags abf,
+				     bool show_divergence_advice)
+{
+	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),
-			base);
+			branch_name);
 	} else if (abf == AHEAD_BEHIND_QUICK) {
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
-			    base);
+			    branch_name);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");

@@ -2274,7 +2253,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			Q_("Your branch is ahead of '%s' by %d commit.\n",
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
-			base, ours);
+			branch_name, ours);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));

@@ -2285,7 +2264,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			   "Your branch is behind '%s' by %d commits, "
 			       "and can be fast-forwarded.\n",
 			   theirs),
-			base, theirs);
+			branch_name, theirs);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));

@@ -2298,12 +2277,47 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			       "and have %d and %d different commits each, "
 			       "respectively.\n",
 			   ours + theirs),
-			base, ours, theirs);
+			branch_name, ours, theirs);
 		if (show_divergence_advice &&
 		    advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}
+}
+
+/*
+ * Return true when there is anything to report, otherwise false.
+ */
+int format_tracking_info(struct branch *branch, struct strbuf *sb,
+			 enum ahead_behind_flags abf,
+			 int show_divergence_advice)
+{
+	int ours, theirs, cmp_fetch;
+	const char *full_base;
+	char *base;
+	int upstream_is_gone = 0;
+
+	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
+	if (cmp_fetch < 0) {
+		if (!full_base)
+			return 0;
+		upstream_is_gone = 1;
+	}
+
+	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
+					    full_base, 0);
+
+	if (upstream_is_gone) {
+		strbuf_addf(sb,
+			_("Your branch is based on '%s', but the upstream is gone.\n"),
+			base);
+		if (advice_enabled(ADVICE_STATUS_HINTS))
+			strbuf_addstr(sb,
+				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
+	} else {
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+	}
+
 	free(base);
 	return 1;
 }

gitgitgadget

From: Harald Nordgren <[email protected]>

"git status" on a branch that follows a remote branch compares commits on the current branch and the remote-tracking branch it builds upon, to show "ahead", "behind", or "diverged" status.

When working on a feature branch that tracks a remote feature branch, but you also want to track progress relative to the push destination tracking branch (which may differ from the upstream branch), git status now shows an additional comparison.

When the upstream tracking branch differs from the push destination tracking branch, git status shows both the comparison with the upstream tracking branch (as before) and an additional comparison with the push destination tracking branch. The push branch comparison appears on a separate line after the upstream branch status, using the same format.

Example output when tracking origin/main but push destination is origin/feature:
On branch feature
Your branch and 'origin/main' have diverged,
and have 3 and 1 different commits each, respectively.
(use "git pull" if you want to integrate the remote branch with yours)

Your branch is ahead of 'origin/feature' by 1 commit.
(use "git push" to publish your local commits)

The comparison is only shown when the push destination tracking branch differs from the upstream tracking branch, even if they are on the same remote.

---
 remote.c                 | 105 ++++++++++++++--
 t/t6040-tracking-info.sh | 262 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 360 insertions(+), 7 deletions(-)

index fd592ec659..8d64a3bee6 100644
@@ -29,6 +29,12 @@
 
 enum map_direction { FROM_SRC, FROM_DST };
 
+enum {
+	ENABLE_ADVICE_PULL       = (1 << 0),
+	ENABLE_ADVICE_PUSH       = (1 << 1),
+	ENABLE_ADVICE_DIVERGENCE = (1 << 2),
+};
+
 struct counted_string {
 	size_t len;
 	const char *s;

@@ -2230,13 +2236,69 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
+static char *get_remote_push_branch(struct branch *branch)
+{
+	struct remote *remote;
+	const char *push_remote;
+	char *push_dst = NULL;
+	char *tracking_ref;
+	const char *resolved;
+	char *ret;
+
+	if (!branch)
+		return NULL;
+
+	push_remote = pushremote_for_branch(branch, NULL);
+	if (!push_remote)
+		return NULL;
+
+	remote = remotes_remote_get(the_repository, push_remote);
+	if (!remote)
+		return NULL;
+
+	push_dst = remote_ref_for_branch(branch, 1);
+	if (!push_dst) {
+		if (remote->push.nr)
+			return NULL;
+		push_dst = xstrdup(branch->refname);
+	}
+
+	tracking_ref = (char *)tracking_for_push_dest(remote, push_dst, NULL);
+	free(push_dst);
+
+	if (!tracking_ref)
+		return NULL;
+
+	resolved = refs_resolve_ref_unsafe(
+		get_main_ref_store(the_repository),
+		tracking_ref,
+		RESOLVE_REF_READING,
+		NULL, NULL);
+
+	if (!resolved) {
+		free(tracking_ref);
+		return NULL;
+	}
+
+	ret = xstrdup(resolved);
+	free(tracking_ref);
+	return ret;
+}
+
 static void format_branch_comparison(struct strbuf *sb,
 				     bool up_to_date,
 				     int ours, int theirs,
 				     const char *branch_name,
 				     enum ahead_behind_flags abf,
-				     bool show_divergence_advice)
+				     unsigned flags)
 {
+	bool enable_push_advice = (flags & ENABLE_ADVICE_PUSH) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool enable_pull_advice = (flags & ENABLE_ADVICE_PULL) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool enable_divergence_advice = (flags & ENABLE_ADVICE_DIVERGENCE) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+
 	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),

@@ -2245,7 +2307,7 @@ static void format_branch_comparison(struct strbuf *sb,
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
 			    branch_name);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (enable_push_advice)
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");
 	} else if (!theirs) {

@@ -2254,7 +2316,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
 			branch_name, ours);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (enable_push_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));
 	} else if (!ours) {

@@ -2265,7 +2327,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			       "and can be fast-forwarded.\n",
 			   theirs),
 			branch_name, theirs);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (enable_pull_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));
 	} else {

@@ -2278,8 +2340,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			       "respectively.\n",
 			   ours + theirs),
 			branch_name, ours, theirs);
-		if (show_divergence_advice &&
-		    advice_enabled(ADVICE_STATUS_HINTS))
+		if (enable_divergence_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}

@@ -2296,6 +2357,11 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	const char *full_base;
 	char *base;
 	int upstream_is_gone = 0;
+	unsigned base_branch_flags = ENABLE_ADVICE_PULL | ENABLE_ADVICE_PUSH;
+	int push_ours, push_theirs, push_cmp_fetch;
+	char *full_push;
+	char *push = NULL;
+	unsigned push_branch_flags = 0;
 
 	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
 	if (cmp_fetch < 0) {

@@ -2307,6 +2373,20 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
 					    full_base, 0);
 
+	full_push = get_remote_push_branch(branch);
+	if (full_push) {
+		push = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
+						     full_push, 0);
+		if (push && base && strcmp(base, push)) {
+			push_cmp_fetch = stat_branch_pair(branch->refname, full_push,
+						   &push_ours, &push_theirs, abf);
+			if (push_cmp_fetch >= 0) {
+				base_branch_flags = ENABLE_ADVICE_PULL;
+				push_branch_flags = ENABLE_ADVICE_PUSH;
+			}
+		}
+	}
+
 	if (upstream_is_gone) {
 		strbuf_addf(sb,
 			_("Your branch is based on '%s', but the upstream is gone.\n"),

@@ -2315,10 +2395,21 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			strbuf_addstr(sb,
 				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
 	} else {
-		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+		if (show_divergence_advice)
+			base_branch_flags |= ENABLE_ADVICE_DIVERGENCE;
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf,
+					 base_branch_flags);
+	}
+
+	if (push_branch_flags & ENABLE_ADVICE_PUSH) {
+		strbuf_addstr(sb, "\n");
+		format_branch_comparison(sb, !push_cmp_fetch, push_ours, push_theirs, push, abf,
+					 push_branch_flags);
 	}
 
 	free(base);
+	free(full_push);
+	free(push);
 	return 1;
 }
 

gitgitgadget

cc: Chris Torek [email protected] cc: Yee Cheng Chin [email protected] cc: "brian m. carlson" [email protected]
cc: Ben Knoble [email protected] cc: "Kristoffer Haugsbakk" [email protected] cc: Phillip Wood [email protected]
cc: Nico Williams [email protected] cc: Patrick Steinhardt [email protected]

Harald Nordgren (2):
refactor format_branch_comparison in preparation
status: show comparison with push remote tracking branch

 remote.c                 | 175 +++++++++++++++++++-----
 t/t6040-tracking-info.sh | 285 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 425 insertions(+), 35 deletions(-)

base-commit: 8745eae506f700657882b9e32b2aa00f234a6fb6
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2138%2FHaraldNordgren%2Fahead_of_main_status-v25
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2138/HaraldNordgren/ahead_of_main_status-v25
Pull-Request: https://github.com/git/git/pull/2138

Range-diff vs v24:

 1:  fd05c7b778 = 1:  fd05c7b778 refactor format_branch_comparison in preparation
 2:  138b79a0b9 ! 2:  fa744efc59 status: show comparison with push remote tracking branch
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +	test_cmp expect actual
      +'
      +
     ++test_expect_success 'status with upstream ahead and push branch up to date' '
     ++	(
     ++		cd test &&
     ++		git checkout -b ahead upstream/main &&
     ++		advance work &&
     ++		git push upstream HEAD &&
     ++		git checkout -b feature8 upstream/main &&
     ++		git push origin &&
     ++		git branch --set-upstream-to upstream/ahead &&
     ++		git status >../actual
     ++	) &&
     ++	cat >expect <<-EOF &&
     ++	On branch feature8
     ++	Your branch is behind ${SQ}upstream/ahead${SQ} by 1 commit, and can be fast-forwarded.
     ++	  (use "git pull" to update your local branch)
     ++
     ++	Your branch is up to date with ${SQ}origin/feature8${SQ}.
     ++
     ++	nothing to commit, working tree clean
     ++	EOF
     ++	test_cmp expect actual
     ++'
     ++
      +test_expect_success 'status shows remapped push refspec' '
      +	(
      +		cd test &&
     -+		git checkout -b feature8 origin/main &&
     -+		git config remote.origin.push refs/heads/feature8:refs/heads/remapped &&
     ++		git checkout -b feature9 origin/main &&
     ++		git config remote.origin.push refs/heads/feature9:refs/heads/remapped &&
      +		git push &&
      +		advance work &&
      +		git status >../actual
      +	) &&
      +	cat >expect <<-EOF &&
     -+	On branch feature8
     ++	On branch feature9
      +	Your branch is ahead of ${SQ}origin/main${SQ} by 1 commit.
      +
      +	Your branch is ahead of ${SQ}origin/remapped${SQ} by 1 commit.
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +test_expect_success 'status shows remapped push refspec with upstream remote' '
      +	(
      +		cd test &&
     -+		git checkout -b feature9 upstream/main &&
     -+		git config remote.origin.push refs/heads/feature9:refs/heads/remapped &&
     ++		git checkout -b feature10 upstream/main &&
     ++		git config remote.origin.push refs/heads/feature10:refs/heads/remapped &&
      +		git push origin &&
      +		advance work &&
      +		git status >../actual
      +	) &&
      +	cat >expect <<-EOF &&
     -+	On branch feature9
     ++	On branch feature10
      +	Your branch is ahead of ${SQ}upstream/main${SQ} by 1 commit.
      +
      +	Your branch is ahead of ${SQ}origin/remapped${SQ} by 1 commit.

gitgitgadget

From: Harald Nordgren <[email protected]>

Refactor format_branch_comparison function in preparation for showing comparison with push remote tracking branch.

---
 remote.c | 82 +++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 48 insertions(+), 34 deletions(-)

index b756ff6f15..fd592ec659 100644
@@ -2230,42 +2230,21 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
-/*
- * Return true when there is anything to report, otherwise false.
- */
-int format_tracking_info(struct branch *branch, struct strbuf *sb,
-			 enum ahead_behind_flags abf,
-			 int show_divergence_advice)
-{
-	int ours, theirs, sti;
-	const char *full_base;
-	char *base;
-	int upstream_is_gone = 0;
-
-	sti = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
-	if (sti < 0) {
-		if (!full_base)
-			return 0;
-		upstream_is_gone = 1;
-	}
-
-	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
-					    full_base, 0);
-	if (upstream_is_gone) {
-		strbuf_addf(sb,
-			_("Your branch is based on '%s', but the upstream is gone.\n"),
-			base);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
-			strbuf_addstr(sb,
-				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
-	} else if (!sti) {
+static void format_branch_comparison(struct strbuf *sb,
+				     bool up_to_date,
+				     int ours, int theirs,
+				     const char *branch_name,
+				     enum ahead_behind_flags abf,
+				     bool show_divergence_advice)
+{
+	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),
-			base);
+			branch_name);
 	} else if (abf == AHEAD_BEHIND_QUICK) {
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
-			    base);
+			    branch_name);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");

@@ -2274,7 +2253,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			Q_("Your branch is ahead of '%s' by %d commit.\n",
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
-			base, ours);
+			branch_name, ours);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));

@@ -2285,7 +2264,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			   "Your branch is behind '%s' by %d commits, "
 			       "and can be fast-forwarded.\n",
 			   theirs),
-			base, theirs);
+			branch_name, theirs);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));

@@ -2298,12 +2277,47 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			       "and have %d and %d different commits each, "
 			       "respectively.\n",
 			   ours + theirs),
-			base, ours, theirs);
+			branch_name, ours, theirs);
 		if (show_divergence_advice &&
 		    advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}
+}
+
+/*
+ * Return true when there is anything to report, otherwise false.
+ */
+int format_tracking_info(struct branch *branch, struct strbuf *sb,
+			 enum ahead_behind_flags abf,
+			 int show_divergence_advice)
+{
+	int ours, theirs, cmp_fetch;
+	const char *full_base;
+	char *base;
+	int upstream_is_gone = 0;
+
+	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
+	if (cmp_fetch < 0) {
+		if (!full_base)
+			return 0;
+		upstream_is_gone = 1;
+	}
+
+	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
+					    full_base, 0);
+
+	if (upstream_is_gone) {
+		strbuf_addf(sb,
+			_("Your branch is based on '%s', but the upstream is gone.\n"),
+			base);
+		if (advice_enabled(ADVICE_STATUS_HINTS))
+			strbuf_addstr(sb,
+				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
+	} else {
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+	}
+
 	free(base);
 	return 1;
 }

gitgitgadget

From: Harald Nordgren <[email protected]>

"git status" on a branch that follows a remote branch compares commits on the current branch and the remote-tracking branch it builds upon, to show "ahead", "behind", or "diverged" status.

When working on a feature branch that tracks a remote feature branch, but you also want to track progress relative to the push destination tracking branch (which may differ from the upstream branch), git status now shows an additional comparison.

When the upstream tracking branch differs from the push destination tracking branch, git status shows both the comparison with the upstream tracking branch (as before) and an additional comparison with the push destination tracking branch. The push branch comparison appears on a separate line after the upstream branch status, using the same format.

Example output when tracking origin/main but push destination is origin/feature:
On branch feature
Your branch and 'origin/main' have diverged,
and have 3 and 1 different commits each, respectively.
(use "git pull" if you want to integrate the remote branch with yours)

Your branch is ahead of 'origin/feature' by 1 commit.
(use "git push" to publish your local commits)

The comparison is only shown when the push destination tracking branch differs from the upstream tracking branch, even if they are on the same remote.

---
 remote.c                 | 105 ++++++++++++++-
 t/t6040-tracking-info.sh | 285 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 383 insertions(+), 7 deletions(-)

index fd592ec659..8d64a3bee6 100644
@@ -29,6 +29,12 @@
 
 enum map_direction { FROM_SRC, FROM_DST };
 
+enum {
+	ENABLE_ADVICE_PULL       = (1 << 0),
+	ENABLE_ADVICE_PUSH       = (1 << 1),
+	ENABLE_ADVICE_DIVERGENCE = (1 << 2),
+};
+
 struct counted_string {
 	size_t len;
 	const char *s;

@@ -2230,13 +2236,69 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
+static char *get_remote_push_branch(struct branch *branch)
+{
+	struct remote *remote;
+	const char *push_remote;
+	char *push_dst = NULL;
+	char *tracking_ref;
+	const char *resolved;
+	char *ret;
+
+	if (!branch)
+		return NULL;
+
+	push_remote = pushremote_for_branch(branch, NULL);
+	if (!push_remote)
+		return NULL;
+
+	remote = remotes_remote_get(the_repository, push_remote);
+	if (!remote)
+		return NULL;
+
+	push_dst = remote_ref_for_branch(branch, 1);
+	if (!push_dst) {
+		if (remote->push.nr)
+			return NULL;
+		push_dst = xstrdup(branch->refname);
+	}
+
+	tracking_ref = (char *)tracking_for_push_dest(remote, push_dst, NULL);
+	free(push_dst);
+
+	if (!tracking_ref)
+		return NULL;
+
+	resolved = refs_resolve_ref_unsafe(
+		get_main_ref_store(the_repository),
+		tracking_ref,
+		RESOLVE_REF_READING,
+		NULL, NULL);
+
+	if (!resolved) {
+		free(tracking_ref);
+		return NULL;
+	}
+
+	ret = xstrdup(resolved);
+	free(tracking_ref);
+	return ret;
+}
+
 static void format_branch_comparison(struct strbuf *sb,
 				     bool up_to_date,
 				     int ours, int theirs,
 				     const char *branch_name,
 				     enum ahead_behind_flags abf,
-				     bool show_divergence_advice)
+				     unsigned flags)
 {
+	bool enable_push_advice = (flags & ENABLE_ADVICE_PUSH) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool enable_pull_advice = (flags & ENABLE_ADVICE_PULL) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+	bool enable_divergence_advice = (flags & ENABLE_ADVICE_DIVERGENCE) &&
+		advice_enabled(ADVICE_STATUS_HINTS);
+
 	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),

@@ -2245,7 +2307,7 @@ static void format_branch_comparison(struct strbuf *sb,
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
 			    branch_name);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (enable_push_advice)
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");
 	} else if (!theirs) {

@@ -2254,7 +2316,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
 			branch_name, ours);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (enable_push_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));
 	} else if (!ours) {

@@ -2265,7 +2327,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			       "and can be fast-forwarded.\n",
 			   theirs),
 			branch_name, theirs);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
+		if (enable_pull_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));
 	} else {

@@ -2278,8 +2340,7 @@ static void format_branch_comparison(struct strbuf *sb,
 			       "respectively.\n",
 			   ours + theirs),
 			branch_name, ours, theirs);
-		if (show_divergence_advice &&
-		    advice_enabled(ADVICE_STATUS_HINTS))
+		if (enable_divergence_advice)
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}

@@ -2296,6 +2357,11 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	const char *full_base;
 	char *base;
 	int upstream_is_gone = 0;
+	unsigned base_branch_flags = ENABLE_ADVICE_PULL | ENABLE_ADVICE_PUSH;
+	int push_ours, push_theirs, push_cmp_fetch;
+	char *full_push;
+	char *push = NULL;
+	unsigned push_branch_flags = 0;
 
 	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
 	if (cmp_fetch < 0) {

@@ -2307,6 +2373,20 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
 					    full_base, 0);
 
+	full_push = get_remote_push_branch(branch);
+	if (full_push) {
+		push = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
+						     full_push, 0);
+		if (push && base && strcmp(base, push)) {
+			push_cmp_fetch = stat_branch_pair(branch->refname, full_push,
+						   &push_ours, &push_theirs, abf);
+			if (push_cmp_fetch >= 0) {
+				base_branch_flags = ENABLE_ADVICE_PULL;
+				push_branch_flags = ENABLE_ADVICE_PUSH;
+			}
+		}
+	}
+
 	if (upstream_is_gone) {
 		strbuf_addf(sb,
 			_("Your branch is based on '%s', but the upstream is gone.\n"),

@@ -2315,10 +2395,21 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			strbuf_addstr(sb,
 				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
 	} else {
-		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+		if (show_divergence_advice)
+			base_branch_flags |= ENABLE_ADVICE_DIVERGENCE;
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf,
+					 base_branch_flags);
+	}
+
+	if (push_branch_flags & ENABLE_ADVICE_PUSH) {
+		strbuf_addstr(sb, "\n");
+		format_branch_comparison(sb, !push_cmp_fetch, push_ours, push_theirs, push, abf,
+					 push_branch_flags);
 	}
 
 	free(base);
+	free(full_push);
+	free(push);
 	return 1;
 }
 

gitgitgadget

Can we make this configurable?

I build my daily driver off of the 'jch' branch, which now includes this series, and I've found that for my triangular workflow the ahead/behind for the push branch is just useless noise. I treat my push destination like a mirror, where I always just push up everything at the end of the day.

I know that the output can be disabled with status.aheadbehind, but:

1. I noticed this first via "git checkout", which does not have such a flag (AFAIK).

2. That flag would also disable the upstream branch ahead/behind output, which I do find useful.

-Peff

This seems like a sub-optimal workflow 🤗

May I ask where you normally push (unless you only ever push once at the end) of the day? If it's another branch than your mirror, why not set that as your push destination then, and push to your push destination with the longer

git push origin my-mirror

It makes more sense to me to reserve the shorter and more convenient 'git push' for something you do many times a day.

Harald

I couldn't quite parse what you meant by "another branch than your mirror", but I'll describe my workflow:

1. My "origin" remote is https://github.com/gitster/git.

2. Most branches have origin/master as their upstream, though occasionally I'll have dependent branches that use "." as their remote and the local base branch for the "branch" field.

E.g.

git checkout -b jk/some-topic origin/master
...
git checkout -t -b jk/another-topic jk/some-topic

3. My mirror is https://github.com/peff/git, which I call "github" in the remote (arguably confusing, but back when I started that convention I was pulling Junio's tree from kernel.org ;) ). I point remote.pushdefault to the "github" remote.

4. My push.default setting is "current", so if I want to push up a single branch, I can just "git push". I hardly ever do that, though.

5. I usually push once per day or so. After integrating my topics into a shared daily-driver branch, I run something like:

make test && make install && git push -f github refs/heads/jk/*

(it's not exactly that; I have a script which picks out the local
refs, but it's the moral equivalent of that).

So I don't ever care about the relationship between a specific jk/foo and my mirror's version of it. I don't expect anybody to look at those, and they exist mostly for backup and CI purposes (though I don't run CI on the individual branches, but only the integrated result).

And having the extra output from "git checkout" is just extra noise for me, especially because it is easy to see only the second message (which looks just like the upstream ahead/behind message, of course) and get confused. The first time I saw it I thought I had misconfigured something with my branch.

-Peff

Hi Jeff!

I'm very happy that your responded respectfully despite me basically saying that you were using Git wrong. It's nice to see how some of the pros do it!

I'm wondering if since you are scripting this anyway, if you really need a push branch at all? Can't you just as easily switch to doing this in the script:

git config push.default upstream
git push github jk/some-topic

As a note, before I started working on this feature, I don't realize that there was such a thing as a push branch (i.e. something different from the tracking branch). So I had the habit of checking out and pushing like this:

    git branch --set-upstream-to upstream/master
    git push origin $(git rev-parse --abbrev-ref HEAD)

I worked really well for me. The only issue was missing the status info from my own branch -- which is why I started writing this feature.

Harald

The script is doing the "moral equivalent of" "git push -f github refs/heads/jk/*", so I'm not sure I follow the suggestion here.

My workflow is different from Peff's, but it is similar along at least one line: it's really convenient to have "git push" with no further arguments (only possibly flags) to push my branch to a remote mirror.

D. Ben Knoble

Would you also like the status reporting to be off for your push branch? I asking because that's what Jeff is arguing for.

I fully agree on the convenience of bare 'git push', I use it everyday together with these settings and commands for max convenience:

    git config --global remote.pushDefault origin # As opposed to upstream
    git config --global push.default current
    git config --global pull.rebase true
    git config --global rebase.autoStash true

    git checkout $(gr | rg '^(upstream|origin)$' | tail -n1)/HEAD -b new_branch
    git push
    git status
    git pull

Harald

I’m somewhat indifferent (mildly for having it on by default), but I meant that you don’t want to suggest that in order to use your new feature you don’t want folks to have to break their existing workflows ;)

I could (and in fact the script names the remote directly already, because you can't pass refspecs without specifying the remote). But I do occasionally push a single branch with a bare "git push". Usually this is the integration branch, when I am trying to trigger CI manually (e.g., when piling hacks on top in order to debug a CI failure ;) ).

So even if I only do it infrequently, it feels weird that a bare "git push" would try to push to the upstream remote (which I don't even have write access to!).

Yeah, though @{push} is usually not explicitly configured in the same way @{upstream} is, but rather a consequence of how push.default and remote.pushdefault interact. But it was added for exactly this kind of triangular workflow. I sometimes will do stuff like:

git range-diff origin @{push} HEAD

to compare two iterations of a branch if I know that I haven't pushed. It is a bit of a cheat, because what I really mean is "do a range-diff since the last thing I sent to the list". But if I have just been working on a branch, and I haven't run an integration cycle since then, then I know that the pushed version will match it.

There is also branch.*.pushRemote, but I have not found that useful (for my triangular flow there is always a single repo to push to, not one per branch).

-Peff

Maybe ’push.default=simple’ or ’push.default=nothing’ are better settings in your scenario. Then you get explicit pushing because no push branch gets set. And thus 'git status' reports not additinal status.

I imagine the same thing could be achieved with

    origin/$(git rev-parse --abbrev-ref HEAD)

Harald

If I did that, then the occasional "git push" (without arguments) that I do would fail. Likewise, @{push} would not be usable.

Sure, but:

1. It is a lot shorter to type @{push}. ;)

2. Using @{push} works everywhere, even on my non-triangular repos, because it takes into account the push configuration. So it's a much nicer muscle-memory to acquire.

-Peff

Makes sense, I’m all out of arguments here 😅 Please don’t take this the wrong way, but it reminds me of this XKCD: https://xkcd.com/1172/

As long as this is turned on by default then I’m mostly happy. Maybe JCH and others can weigh in on if this needs to be this configurable or always on.

Harald

Perhaps if the person in that comic was the one who implemented @{push} in the first place. ;)

That said, I really don't think my use case is exotic. I've set up "git push" in the only way that makes sense for my triangular setup. I just don't happen to use it that often, and I don't want to be reminded me unnecessarily of the relationship between each branch and its push destination.

IMHO not making it configurable is a show-stopper, because without that it leaves people who don't like the new behavior with no escape hatch.

As to the default for that config option, I don't have a strong opinion. I'd lean towards "off", as I do not find the feature that compelling myself, and I don't recall ever hearing of it as a pain point for other Git users. But I also recognize that's based on vague vibes, and I think users are generally not very savvy about setting up triangular workflows in the first place.

-Peff

Just so I’m clear, this is only with push.default=current, right? I could never make @{push} work otherwise.

I always use push.default=current, though I think @{push} should work with other modes. E.g., with this setup:

git checkout -b foo
git clone . tmp
cd tmp

  # for the sake of simplicity, our triangle goes to the same place ;)
  git remote add triangle ..
  git fetch triangle
  git config remote.pushdefault triangle

then doing:

  git -c push.default=current rev-parse --symbolic-full-name @{push}

and:

  git -c push.default=matching rev-parse --symbolic-full-name @{push}

should both point to refs/remotes/triangle/foo. Using "simple" will not work, because it demands that the upstream and the push destination are the same (so it doesn't really make sense in a triangular flow at all).

But in a non-triangular flow, it will happily point @{push} to the same as @{upstream}. I use a triangular flow for git.git, but most of my other repos are just personal projects, and I push/fetch from a single central source.

-Peff

Gotcha. Yeah, simple (the default) doesn't work. I suppose upstream
might, too. (I also have push.default=current globally, was just
wondering about what the minimum was to enabled triangular workflows;
see <https://lore.kernel.org/git/CALnO6CAUSU-Pq_r-WYm3o0to6H8MdqiYOuoKaRfL1PTt30VaoQ@mail.gmail.com/>.)

Ditto, yeah (_sometimes_ I actually do the triangle origin/main, local branch, origin/branch, so I almost always set upstream as origin/main anyways). Cool and thanks!

D. Ben Knoble

Yes, exactly. I was wondering where Harald's suggestion to swap the two remotes came from.

Great suggestion. It is fun to see that comparing notes among people with different workflows brings out these gems ;-)

It now is clear to me that this should be _optional_, so that those who do really want extra output from the command should explicitly opt into the feature. After all, any optional new feature that you must opt into by definition cannot regress end user experience for those who do not ;-)

At the same time, I suspect that extra comparison on top of what we already give against the @{upstream} may not be limited to what Harald implemented (is it essentially the same as specyfing @{push}, or something else?). I wonder if we can come up with a flexible and extensible notation to specify what branch(es) to compare with, so that we can use it as the value of this opt-in configuration variable? Something like

	[status] compareBranches = @{upstream} @{push}

signals that the current branch is compared against these two branches, and not having the configuration (i.e., traditional behaviour, which is left the default) would be equivalent to have

	[status] compareBranches = @{upstream}

or something like that, perhaps?

Thanks.

True, but then it also cannot pleasantly surprise people who didn't realize they wanted it.

Having your user experience regressed and then tweaking a config option to fix it is not too bad. The deciding factor to me is whether more people will be pleasantly surprised or annoyed. ;) I don't have a strong sense there.

As a general principle, though, I think a reasonable path forward for any behavior change is:

1. Implement the new behavior, hidden behind a config option.

2. Wait a while to see how people like the new option, and shake out any bugs.

3. If people like the option and are puzzled why it isn't the default, then flip the default on.

In other words, let the utility of the feature be proven in practice by people opting into it. There is a chicken-and-egg problem if they don't know about it, but if it is truly solving a problem people have, then hopefully some of them would look for a solution and find it.

End philosophical rambling. ;)

I haven't been following the feature closely, but my understanding is that yes, it's basically "also compare to @{push} if it is not the same as @{upstream}".

Interesting. That is more flexible, though I'm not sure how useful that flexibility is. I guess you could imagine putting in a static branch. E.g., if you base your branches off of "master", might you want to show ahead/behind to "maint" or "next"? I have trouble imagining a workflow where I would want to do that often enough for git-status (and checkout) to do it automatically, though.

But assuming it suppresses duplicates, then yeah, this feels like a more flexible superset of the functionality.

-Peff

Agreed generally, but the chicken-egg goes 2 layers deep here due to triangular workflows ;)

I favor something similar to what Junio described but also including @{push} by default (and ignoring it if non-existent), so that folks discovering triangular workflows for the first time are easily able to see what is happening.

Us ”already triangular” squares are probably well-versed enough in Git to find and tweak the new feature if desired.

Idk though. I think more folks at work should try triangular flows, so I’m biased :p

Ben has an excellent point about triangular workflows, and Jeff of course, your philosophical instincts seem correct to me, interesting to read!

I would think that most people don't have separate tracking and push branches to begin with. So it's not a lot of people would be bothered by having this be on by default. The people who know about triangular workflows will also be able to find how to turn this off.

Harald

(I'm somewhat behind all week so this is from Wednesday...)

Re: status.compareBranch (or similar): I like the idea; I'm not sure what sort of details might be needed in the end though.

This also seems to me likely to be the right default. It's useful for a lot of GitHub and similar forges, where you send fixes upstream by first forking some official repository and then cloning your fork (e.g., to a laptop), setting up your local clone (on laptop) to have two remotes: the official repository, and your fork, both on the same forge.

It's a little annoying to have to deal with *three* potential "upstream" repos, if
you need to back up your local work to a corporate server or forge *plus* a push-for-pull-request at the forge as well, of course. But then at least the "compare with all three" option becomes available. How you wish to spell the default push location is then up to you :-)

Chris

I agree with this too, would like to make '@{upstream} @{push}' the default.

Harald

If we go with that, then it becomes trickier code-wise to show push/pull advice for the correct branches. But not impossible since we can check if branch is the same as @{upstream} or @{push}.

Philosophically, two main git commands are 'git push' and 'git pull'. So it makes perfect sense to me to signal that those two are special, and not allow other compareBranches.

Harald

You are falling into the same trap as what the folks who designed the original ahead/behind comparison did by limiting yourself to push and pull. They said object transfer always interacts with the @{upstream}, hence only comparison with that is sufficient and it makes sense not to allow comparing with anything else.

Until you started wishing that you want to also compare with @{push}, that is ;-).

A static point that has nothing to do with pushing and pulling (e.g., "the latest official release tag") may be something useful to compare with in certain workflows (presumably workflow of the maintainer type), so limiting our sights to object transfer like push and pull is likely to be a mistake.

I'm implemented this now. Please take a look at the latest patch!

But there seems to be a memory leak that I can't figure out after spending some hours running the CI over and over.

Harald

This is a slight tangent but if we're taking about making things configurable I've never found the actual values of the ahead/behind numbers particularly useful. In a triangular workflow all I'm really interested in is whether (a) my local branch is behind the upstream branch and if so is it going to be a pig to rebase it, and (b) my local branch matches the push branch (i.e. do I need to run "git push"). I don't really care exactly how many commits ahead or behind the local branch is, the counts are just distracting and don't really answer the "is it going to be a pig to rebase" question - the only way to answer that is to try it and see.

So as well as configuring whether we show the comparison the push branch it would be nice to be able to configure a simpler output as well. That does not need to be part of this series but perhaps we should design the configuration to be extendable.

Thanks

Phillip

So, there are orthogonal axes that might benefit from configurabiliity.

What other branch to compare (e.g., @{upstream}, @{push}, something else?) and how detailed comparison we want (e.g., only tell me when we are ahead with just a single bit, give me ahead/behind count, only tell me when we are behind with just a single bit, etc.).

There may be other interesting axes people may be able to come up with in the future. We do not have to be exhaustive on values on all axes on the first day, but it would be nice to have a fairly complete coverage of what axes matter to users, and it is a great suggestion that the level of details can be one. Thanks.

I mostly feel the same way. The only time I recall thinking the numbers were important is when they are wildly out of place. You "git checkout" a branch and it is 1500 commits ahead/behind or something, and you know you've screwed up setting the tracking branch somehow. ;)

Yeah, I agree with all of that.

-Peff

cc: Chris Torek [email protected] cc: Yee Cheng Chin [email protected] cc: "brian m. carlson" [email protected]
cc: Ben Knoble [email protected] cc: "Kristoffer Haugsbakk" [email protected] cc: Phillip Wood [email protected]
cc: Nico Williams [email protected] cc: Patrick Steinhardt [email protected] cc:
Jeff King [email protected]

Harald Nordgren (2):
refactor format_branch_comparison in preparation
status: add status.compareBranches config for multiple branch
comparisons

 Documentation/config/status.adoc |  20 ++
 remote.c                         | 187 ++++++++++++++----
 t/t6040-tracking-info.sh         | 322 +++++++++++++++++++++++++++++++
 3 files changed, 492 insertions(+), 37 deletions(-)

base-commit: b5c409c40f1595e3e590760c6f14a16b6683e22c
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2138%2FHaraldNordgren%2Fahead_of_main_status-v26
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2138/HaraldNordgren/ahead_of_main_status-v26
Pull-Request: https://github.com/git/git/pull/2138

Range-diff vs v25:

 1:  fd05c7b778 = 1:  27a46f8d9c refactor format_branch_comparison in preparation
 2:  fa744efc59 ! 2:  caa761f615 status: show comparison with push remote tracking branch
     @@ Metadata
      Author: Harald Nordgren <[email protected]>
      
       ## Commit message ##
     -    status: show comparison with push remote tracking branch
     +    status: add status.compareBranches config for multiple branch comparisons
      
     -    "git status" on a branch that follows a remote branch compares
     -    commits on the current branch and the remote-tracking branch it
     -    builds upon, to show "ahead", "behind", or "diverged" status.
     +    Add a new configuration variable `status.compareBranches` that allows
     +    users to specify a space-separated list of branches to compare against
     +    the current branch in `git status` output.
      
     -    When working on a feature branch that tracks a remote feature branch,
     -    but you also want to track progress relative to the push destination
     -    tracking branch (which may differ from the upstream branch), git status
     -    now shows an additional comparison.
     +    Each branch in the list can be:
     +    - A remote-tracking branch name (e.g., `origin/main`)
     +    - The special reference `@{upstream}` for the tracking branch
     +    - The special reference `@{push}` for the push destination
      
     -    When the upstream tracking branch differs from the push destination
     -    tracking branch, git status shows both the comparison with the upstream
     -    tracking branch (as before) and an additional comparison with the push
     -    destination tracking branch. The push branch comparison appears on a
     -    separate line after the upstream branch status, using the same format.
     +    When not configured, the default behavior is equivalent to setting
     +    `status.compareBranches = @{upstream}`, preserving backward compatibility.
      
     -    Example output when tracking origin/main but push destination is
     -    origin/feature:
     -        On branch feature
     -        Your branch and 'origin/main' have diverged,
     -        and have 3 and 1 different commits each, respectively.
     -          (use "git pull" if you want to integrate the remote branch with yours)
     +    The advice messages shown are context-aware:
     +    - "git pull" advice is shown only when comparing against @{upstream}
     +    - "git push" advice is shown only when comparing against @{push}
     +    - Divergence advice is shown for upstream branch comparisons
      
     -        Your branch is ahead of 'origin/feature' by 1 commit.
     -          (use "git push" to publish your local commits)
     +    This is useful for triangular workflows where the upstream tracking
     +    branch differs from the push destination, allowing users to see their
     +    status relative to both branches at once.
      
     -    The comparison is only shown when the push destination tracking branch
     -    differs from the upstream tracking branch, even if they are on the same
     -    remote.
     +    Example configuration:
     +        [status]
     +            compareBranches = @{upstream} @{push}
      
          Signed-off-by: Harald Nordgren <[email protected]>
      
     + ## Documentation/config/status.adoc ##
     +@@ Documentation/config/status.adoc: status.aheadBehind::
     + 	`--no-ahead-behind` by default in linkgit:git-status[1] for
     + 	non-porcelain status formats.  Defaults to true.
     + 
     ++status.compareBranches::
     ++	A space-separated list of branches to compare the current branch
     ++	against in linkgit:git-status[1]. Each branch specification can be
     ++	a remote-tracking branch name (e.g. `origin/main`), or a special
     ++	reference like `@{upstream}` or `@{push}`. For each branch in the
     ++	list, git status shows whether the current branch is ahead, behind,
     ++	or has diverged from that branch.
     +++
     ++If not set, the default behavior is equivalent to `@{upstream}`, which
     ++compares against the configured upstream tracking branch.
     +++
     ++Example:
     +++
     ++----
     ++[status]
     ++	compareBranches = origin/main origin/develop
     ++----
     +++
     ++This would show comparisons against both `origin/main` and `origin/develop`.
     ++
     + status.displayCommentPrefix::
     + 	If set to true, linkgit:git-status[1] will insert a comment
     + 	prefix before each output line (starting with
     +
       ## remote.c ##
      @@
       
     @@ remote.c
       struct counted_string {
       	size_t len;
       	const char *s;
     +@@ remote.c: static void branch_release(struct branch *branch)
     + 	free((char *)branch->refname);
     + 	free(branch->remote_name);
     + 	free(branch->pushremote_name);
     ++	free((char *)branch->push_tracking_ref);
     + 	merge_clear(branch);
     + }
     + 
      @@ remote.c: int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
       	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
       }
       
     -+static char *get_remote_push_branch(struct branch *branch)
     ++static char *resolve_compare_branch(struct branch *branch, const char *name)
      +{
     -+	struct remote *remote;
     -+	const char *push_remote;
     -+	char *push_dst = NULL;
     -+	char *tracking_ref;
     -+	const char *resolved;
     ++	struct strbuf buf = STRBUF_INIT;
     ++	const char *resolved = NULL;
      +	char *ret;
      +
     -+	if (!branch)
     -+		return NULL;
     -+
     -+	push_remote = pushremote_for_branch(branch, NULL);
     -+	if (!push_remote)
     ++	if (!branch || !name)
      +		return NULL;
      +
     -+	remote = remotes_remote_get(the_repository, push_remote);
     -+	if (!remote)
     -+		return NULL;
     ++	if (!strcasecmp(name, "@{upstream}") || !strcasecmp(name, "@{u}"))
     ++		resolved = branch_get_upstream(branch, NULL);
     ++	else if (!strcasecmp(name, "@{push}"))
     ++		resolved = branch_get_push(branch, NULL);
      +
     -+	push_dst = remote_ref_for_branch(branch, 1);
     -+	if (!push_dst) {
     -+		if (remote->push.nr)
     -+			return NULL;
     -+		push_dst = xstrdup(branch->refname);
     -+	}
     -+
     -+	tracking_ref = (char *)tracking_for_push_dest(remote, push_dst, NULL);
     -+	free(push_dst);
     -+
     -+	if (!tracking_ref)
     -+		return NULL;
     ++	if (resolved)
     ++		return xstrdup(resolved);
      +
     ++	strbuf_addf(&buf, "refs/remotes/%s", name);
      +	resolved = refs_resolve_ref_unsafe(
      +		get_main_ref_store(the_repository),
     -+		tracking_ref,
     ++		buf.buf,
      +		RESOLVE_REF_READING,
      +		NULL, NULL);
     -+
     -+	if (!resolved) {
     -+		free(tracking_ref);
     -+		return NULL;
     ++	if (resolved) {
     ++		ret = xstrdup(resolved);
     ++		strbuf_release(&buf);
     ++		return ret;
      +	}
      +
     -+	ret = xstrdup(resolved);
     -+	free(tracking_ref);
     -+	return ret;
     ++	strbuf_release(&buf);
     ++	return NULL;
      +}
      +
       static void format_branch_comparison(struct strbuf *sb,
     @@ remote.c: static void format_branch_comparison(struct strbuf *sb,
       				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
       	}
      @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
     - 	const char *full_base;
     - 	char *base;
     - 	int upstream_is_gone = 0;
     -+	unsigned base_branch_flags = ENABLE_ADVICE_PULL | ENABLE_ADVICE_PUSH;
     -+	int push_ours, push_theirs, push_cmp_fetch;
     -+	char *full_push;
     -+	char *push = NULL;
     -+	unsigned push_branch_flags = 0;
     + 			 enum ahead_behind_flags abf,
     + 			 int show_divergence_advice)
     + {
     +-	int ours, theirs, cmp_fetch;
     +-	const char *full_base;
     +-	char *base;
     +-	int upstream_is_gone = 0;
     +-
     +-	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
     +-	if (cmp_fetch < 0) {
     +-		if (!full_base)
     +-			return 0;
     +-		upstream_is_gone = 1;
     ++	char *compare_branches_config = NULL;
     ++	struct string_list compare_branches = STRING_LIST_INIT_DUP;
     ++	struct string_list_item *item;
     ++	int reported = 0;
     ++	size_t i;
     ++	const char *upstream_ref;
     ++	const char *push_ref;
     ++
     ++	repo_config_get_string(the_repository, "status.comparebranches",
     ++			       &compare_branches_config);
     ++
     ++	if (compare_branches_config) {
     ++		string_list_split(&compare_branches, compare_branches_config,
     ++				  " ", -1);
     ++		string_list_remove_empty_items(&compare_branches, 0);
     ++	} else {
     ++		string_list_append(&compare_branches, "@{upstream}");
     + 	}
       
     - 	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
     - 	if (cmp_fetch < 0) {
     -@@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
     - 	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
     - 					    full_base, 0);
     +-	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
     +-					    full_base, 0);
     ++	upstream_ref = branch_get_upstream(branch, NULL);
     ++	push_ref = branch_get_push(branch, NULL);
       
     -+	full_push = get_remote_push_branch(branch);
     -+	if (full_push) {
     -+		push = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
     -+						     full_push, 0);
     -+		if (push && base && strcmp(base, push)) {
     -+			push_cmp_fetch = stat_branch_pair(branch->refname, full_push,
     -+						   &push_ours, &push_theirs, abf);
     -+			if (push_cmp_fetch >= 0) {
     -+				base_branch_flags = ENABLE_ADVICE_PULL;
     -+				push_branch_flags = ENABLE_ADVICE_PUSH;
     +-	if (upstream_is_gone) {
     +-		strbuf_addf(sb,
     +-			_("Your branch is based on '%s', but the upstream is gone.\n"),
     +-			base);
     +-		if (advice_enabled(ADVICE_STATUS_HINTS))
     +-			strbuf_addstr(sb,
     +-				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
     +-	} else {
     +-		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
     ++	for (i = 0; i < compare_branches.nr; i++) {
     ++		char *full_ref;
     ++		char *short_ref;
     ++		int ours, theirs, cmp;
     ++		int is_upstream, is_push;
     ++		unsigned flags = 0;
     ++
     ++		item = &compare_branches.items[i];
     ++		full_ref = resolve_compare_branch(branch, item->string);
     ++		if (!full_ref)
     ++			continue;
     ++
     ++		short_ref = refs_shorten_unambiguous_ref(
     ++			get_main_ref_store(the_repository), full_ref, 0);
     ++
     ++		is_upstream = upstream_ref && !strcmp(full_ref, upstream_ref);
     ++		is_push = push_ref && !strcmp(full_ref, push_ref);
     ++
     ++		if (is_upstream && (!push_ref || !strcmp(upstream_ref, push_ref)))
     ++			is_push = 1;
     ++
     ++		cmp = stat_branch_pair(branch->refname, full_ref,
     ++				       &ours, &theirs, abf);
     ++
     ++		if (cmp < 0) {
     ++			if (is_upstream) {
     ++				strbuf_addf(sb,
     ++					_("Your branch is based on '%s', but the upstream is gone.\n"),
     ++					short_ref);
     ++				if (advice_enabled(ADVICE_STATUS_HINTS))
     ++					strbuf_addstr(sb,
     ++						_("  (use \"git branch --unset-upstream\" to fixup)\n"));
     ++				reported = 1;
      +			}
     ++			free(full_ref);
     ++			free(short_ref);
     ++			continue;
      +		}
     -+	}
      +
     - 	if (upstream_is_gone) {
     - 		strbuf_addf(sb,
     - 			_("Your branch is based on '%s', but the upstream is gone.\n"),
     -@@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
     - 			strbuf_addstr(sb,
     - 				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
     - 	} else {
     --		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
     -+		if (show_divergence_advice)
     -+			base_branch_flags |= ENABLE_ADVICE_DIVERGENCE;
     -+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf,
     -+					 base_branch_flags);
     -+	}
     -+
     -+	if (push_branch_flags & ENABLE_ADVICE_PUSH) {
     -+		strbuf_addstr(sb, "\n");
     -+		format_branch_comparison(sb, !push_cmp_fetch, push_ours, push_theirs, push, abf,
     -+					 push_branch_flags);
     ++		if (reported)
     ++			strbuf_addstr(sb, "\n");
     ++
     ++		if (is_upstream)
     ++			flags |= ENABLE_ADVICE_PULL;
     ++		if (is_push)
     ++			flags |= ENABLE_ADVICE_PUSH;
     ++		if (show_divergence_advice && is_upstream)
     ++			flags |= ENABLE_ADVICE_DIVERGENCE;
     ++		format_branch_comparison(sb, !cmp, ours, theirs, short_ref,
     ++					 abf, flags);
     ++		reported = 1;
     ++
     ++		free(full_ref);
     ++		free(short_ref);
       	}
       
     - 	free(base);
     -+	free(full_push);
     -+	free(push);
     - 	return 1;
     +-	free(base);
     +-	return 1;
     ++	string_list_clear(&compare_branches, 0);
     ++	free(compare_branches_config);
     ++	return reported;
       }
       
     + static int one_local_ref(const struct reference *ref, void *cb_data)
      
       ## t/t6040-tracking-info.sh ##
      @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +	test_cmp expect actual
      +'
      +
     -+test_expect_success 'status shows ahead of both origin/main and feature branch' '
     ++test_expect_success 'setup for compareBranches tests' '
     ++	(
     ++		cd test &&
     ++		git config push.default current &&
     ++		git config status.compareBranches "@{upstream} @{push}"
     ++	)
     ++'
     ++
     ++test_expect_success 'status.compareBranches shows ahead of both upstream and push branch' '
      +	(
      +		cd test &&
      +		git checkout -b feature2 origin/main &&
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +	test_cmp expect actual
      +'
      +
     -+test_expect_success 'checkout shows ahead of both origin/main and feature branch' '
     ++test_expect_success 'checkout with status.compareBranches shows both branches' '
      +	(
      +		cd test &&
      +		git checkout feature2 >../actual
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +	)
      +'
      +
     -+test_expect_success 'status shows diverged from origin/main and ahead of feature branch' '
     ++test_expect_success 'status.compareBranches shows diverged and ahead' '
      +	(
      +		cd test &&
      +		git checkout feature4 &&
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +	test_cmp expect actual
      +'
      +
     -+test_expect_success 'status --no-ahead-behind shows diverged from origin/main and ahead of feature branch' '
     ++test_expect_success 'status --no-ahead-behind with status.compareBranches' '
      +	(
      +		cd test &&
      +		git checkout feature4 &&
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +	)
      +'
      +
     -+test_expect_success 'status with upstream remote and push.default set to origin' '
     ++test_expect_success 'status.compareBranches with upstream and origin remotes' '
      +	(
      +		cd test &&
      +		git checkout -b feature5 upstream/main &&
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +	test_cmp expect actual
      +'
      +
     -+test_expect_success 'status with upstream remote and push.default set to origin and diverged' '
     ++test_expect_success 'status.compareBranches with upstream and origin remotes multiple compare branches' '
      +	(
      +		cd test &&
      +		git checkout -b feature6 upstream/main &&
     ++		git push origin &&
     ++		advance work &&
     ++		git -c status.compareBranches="upstream/main origin/feature6 origin/feature5" status >../actual
     ++	) &&
     ++	cat >expect <<-EOF &&
     ++	On branch feature6
     ++	Your branch is ahead of ${SQ}upstream/main${SQ} by 1 commit.
     ++
     ++	Your branch is ahead of ${SQ}origin/feature6${SQ} by 1 commit.
     ++	  (use "git push" to publish your local commits)
     ++
     ++	Your branch is ahead of ${SQ}origin/feature5${SQ} by 1 commit.
     ++
     ++	nothing to commit, working tree clean
     ++	EOF
     ++	test_cmp expect actual
     ++'
     ++
     ++test_expect_success 'status.compareBranches with diverged push branch' '
     ++	(
     ++		cd test &&
     ++		git checkout -b feature7 upstream/main &&
      +		advance work &&
      +		git push origin &&
      +		git reset --hard upstream/main &&
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +		git status >../actual
      +	) &&
      +	cat >expect <<-EOF &&
     -+	On branch feature6
     ++	On branch feature7
      +	Your branch is ahead of ${SQ}upstream/main${SQ} by 1 commit.
      +
     -+	Your branch and ${SQ}origin/feature6${SQ} have diverged,
     ++	Your branch and ${SQ}origin/feature7${SQ} have diverged,
      +	and have 1 and 1 different commits each, respectively.
      +
      +	nothing to commit, working tree clean
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +	test_cmp expect actual
      +'
      +
     -+test_expect_success 'status with upstream remote and push branch up to date' '
     ++test_expect_success 'status.compareBranches shows up to date branches' '
      +	(
      +		cd test &&
     -+		git checkout -b feature7 upstream/main &&
     ++		git checkout -b feature8 upstream/main &&
      +		git push origin &&
      +		git status >../actual
      +	) &&
      +	cat >expect <<-EOF &&
     -+	On branch feature7
     ++	On branch feature8
      +	Your branch is up to date with ${SQ}upstream/main${SQ}.
      +
     -+	Your branch is up to date with ${SQ}origin/feature7${SQ}.
     ++	Your branch is up to date with ${SQ}origin/feature8${SQ}.
      +
      +	nothing to commit, working tree clean
      +	EOF
      +	test_cmp expect actual
      +'
      +
     -+test_expect_success 'status --no-ahead-behind with upstream remote and push branch up to date' '
     ++test_expect_success 'status --no-ahead-behind with status.compareBranches up to date' '
      +	(
      +		cd test &&
     -+		git checkout feature7 &&
     ++		git checkout feature8 &&
      +		git push origin &&
      +		git status --no-ahead-behind >../actual
      +	) &&
      +	cat >expect <<-EOF &&
     -+	On branch feature7
     ++	On branch feature8
      +	Your branch is up to date with ${SQ}upstream/main${SQ}.
      +
     -+	Your branch is up to date with ${SQ}origin/feature7${SQ}.
     ++	Your branch is up to date with ${SQ}origin/feature8${SQ}.
      +
      +	nothing to commit, working tree clean
      +	EOF
      +	test_cmp expect actual
      +'
      +
     -+test_expect_success 'checkout shows push branch up to date' '
     ++test_expect_success 'checkout with status.compareBranches shows up to date' '
      +	(
      +		cd test &&
     -+		git checkout feature7 >../actual
     ++		git checkout feature8 >../actual
      +	) &&
      +	cat >expect <<-EOF &&
      +	Your branch is up to date with ${SQ}upstream/main${SQ}.
      +
     -+	Your branch is up to date with ${SQ}origin/feature7${SQ}.
     ++	Your branch is up to date with ${SQ}origin/feature8${SQ}.
      +	EOF
      +	test_cmp expect actual
      +'
      +
     -+test_expect_success 'status with upstream ahead and push branch up to date' '
     ++test_expect_success 'status.compareBranches with upstream behind and push up to date' '
      +	(
      +		cd test &&
      +		git checkout -b ahead upstream/main &&
      +		advance work &&
      +		git push upstream HEAD &&
     -+		git checkout -b feature8 upstream/main &&
     ++		git checkout -b feature9 upstream/main &&
      +		git push origin &&
      +		git branch --set-upstream-to upstream/ahead &&
      +		git status >../actual
      +	) &&
      +	cat >expect <<-EOF &&
     -+	On branch feature8
     ++	On branch feature9
      +	Your branch is behind ${SQ}upstream/ahead${SQ} by 1 commit, and can be fast-forwarded.
      +	  (use "git pull" to update your local branch)
      +
     -+	Your branch is up to date with ${SQ}origin/feature8${SQ}.
     ++	Your branch is up to date with ${SQ}origin/feature9${SQ}.
      +
      +	nothing to commit, working tree clean
      +	EOF
      +	test_cmp expect actual
      +'
      +
     -+test_expect_success 'status shows remapped push refspec' '
     ++test_expect_success 'status.compareBranches with remapped push refspec' '
      +	(
      +		cd test &&
     -+		git checkout -b feature9 origin/main &&
     -+		git config remote.origin.push refs/heads/feature9:refs/heads/remapped &&
     ++		git checkout -b feature10 origin/main &&
     ++		git config remote.origin.push refs/heads/feature10:refs/heads/remapped &&
      +		git push &&
      +		advance work &&
      +		git status >../actual
      +	) &&
      +	cat >expect <<-EOF &&
     -+	On branch feature9
     ++	On branch feature10
      +	Your branch is ahead of ${SQ}origin/main${SQ} by 1 commit.
      +
      +	Your branch is ahead of ${SQ}origin/remapped${SQ} by 1 commit.
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +	test_cmp expect actual
      +'
      +
     -+test_expect_success 'status shows remapped push refspec with upstream remote' '
     ++test_expect_success 'status.compareBranches with remapped push and upstream remote' '
      +	(
      +		cd test &&
     -+		git checkout -b feature10 upstream/main &&
     -+		git config remote.origin.push refs/heads/feature10:refs/heads/remapped &&
     ++		git checkout -b feature11 upstream/main &&
     ++		git config remote.origin.push refs/heads/feature11:refs/heads/remapped &&
      +		git push origin &&
      +		advance work &&
      +		git status >../actual
      +	) &&
      +	cat >expect <<-EOF &&
     -+	On branch feature10
     ++	On branch feature11
      +	Your branch is ahead of ${SQ}upstream/main${SQ} by 1 commit.
      +
      +	Your branch is ahead of ${SQ}origin/remapped${SQ} by 1 commit.
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +	EOF
      +	test_cmp expect actual
      +'
     ++
     ++test_expect_success 'clean up after compareBranches tests' '
     ++	(
     ++		cd test &&
     ++		git config --unset status.compareBranches
     ++	)
     ++'
      +
       test_done

gitgitgadget

From: Harald Nordgren <[email protected]>

Refactor format_branch_comparison function in preparation for showing comparison with push remote tracking branch.

---
 remote.c | 82 +++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 48 insertions(+), 34 deletions(-)

index b756ff6f15..fd592ec659 100644
@@ -2230,42 +2230,21 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
-/*
- * Return true when there is anything to report, otherwise false.
- */
-int format_tracking_info(struct branch *branch, struct strbuf *sb,
-			 enum ahead_behind_flags abf,
-			 int show_divergence_advice)
-{
-	int ours, theirs, sti;
-	const char *full_base;
-	char *base;
-	int upstream_is_gone = 0;
-
-	sti = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
-	if (sti < 0) {
-		if (!full_base)
-			return 0;
-		upstream_is_gone = 1;
-	}
-
-	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
-					    full_base, 0);
-	if (upstream_is_gone) {
-		strbuf_addf(sb,
-			_("Your branch is based on '%s', but the upstream is gone.\n"),
-			base);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
-			strbuf_addstr(sb,
-				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
-	} else if (!sti) {
+static void format_branch_comparison(struct strbuf *sb,
+				     bool up_to_date,
+				     int ours, int theirs,
+				     const char *branch_name,
+				     enum ahead_behind_flags abf,
+				     bool show_divergence_advice)
+{
+	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),
-			base);
+			branch_name);
 	} else if (abf == AHEAD_BEHIND_QUICK) {
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
-			    base);
+			    branch_name);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");

@@ -2274,7 +2253,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			Q_("Your branch is ahead of '%s' by %d commit.\n",
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
-			base, ours);
+			branch_name, ours);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));

@@ -2285,7 +2264,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			   "Your branch is behind '%s' by %d commits, "
 			       "and can be fast-forwarded.\n",
 			   theirs),
-			base, theirs);
+			branch_name, theirs);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));

@@ -2298,12 +2277,47 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			       "and have %d and %d different commits each, "
 			       "respectively.\n",
 			   ours + theirs),
-			base, ours, theirs);
+			branch_name, ours, theirs);
 		if (show_divergence_advice &&
 		    advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}
+}
+
+/*
+ * Return true when there is anything to report, otherwise false.
+ */
+int format_tracking_info(struct branch *branch, struct strbuf *sb,
+			 enum ahead_behind_flags abf,
+			 int show_divergence_advice)
+{
+	int ours, theirs, cmp_fetch;
+	const char *full_base;
+	char *base;
+	int upstream_is_gone = 0;
+
+	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
+	if (cmp_fetch < 0) {
+		if (!full_base)
+			return 0;
+		upstream_is_gone = 1;
+	}
+
+	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
+					    full_base, 0);
+
+	if (upstream_is_gone) {
+		strbuf_addf(sb,
+			_("Your branch is based on '%s', but the upstream is gone.\n"),
+			base);
+		if (advice_enabled(ADVICE_STATUS_HINTS))
+			strbuf_addstr(sb,
+				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
+	} else {
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+	}
+
 	free(base);
 	return 1;
 }

gitgitgadget

From: Harald Nordgren <[email protected]>

Add a new configuration variable status.compareBranches that allows users to specify a space-separated list of branches to compare against the current branch in git status output.

Each branch in the list can be:
- A remote-tracking branch name (e.g., origin/main)
- The special reference @{upstream} for the tracking branch
- The special reference @{push} for the push destination

When not configured, the default behavior is equivalent to setting status.compareBranches = @{upstream}, preserving backward compatibility.

The advice messages shown are context-aware:
- "git pull" advice is shown only when comparing against @{upstream}
- "git push" advice is shown only when comparing against @{push}
- Divergence advice is shown for upstream branch comparisons

This is useful for triangular workflows where the upstream tracking branch differs from the push destination, allowing users to see their status relative to both branches at once.

Example configuration:

    [status]
        compareBranches = @{upstream} @{push}

---
 Documentation/config/status.adoc |  20 ++
 remote.c                         | 157 ++++++++++++---
 t/t6040-tracking-info.sh         | 322 +++++++++++++++++++++++++++++++
 3 files changed, 470 insertions(+), 29 deletions(-)

index 8caf90f51c..ab54f25fbc 100644
@@ -17,6 +17,26 @@ status.aheadBehind::
 	`--no-ahead-behind` by default in linkgit:git-status[1] for
 	non-porcelain status formats.  Defaults to true.
 
+status.compareBranches::
+	A space-separated list of branches to compare the current branch
+	against in linkgit:git-status[1]. Each branch specification can be
+	a remote-tracking branch name (e.g. `origin/main`), or a special
+	reference like `@{upstream}` or `@{push}`. For each branch in the
+	list, git status shows whether the current branch is ahead, behind,
+	or has diverged from that branch.
++
+If not set, the default behavior is equivalent to `@{upstream}`, which
+compares against the configured upstream tracking branch.
++
+Example:
++
+----
+[status]
+	compareBranches = origin/main origin/develop
+----
++
+This would show comparisons against both `origin/main` and `origin/develop`.
+
 status.displayCommentPrefix::
 	If set to true, linkgit:git-status[1] will insert a comment
 	prefix before each output line (starting with

gitgitgadget

This seems to not have helped my memory leak. I squashed and applied your commits on top of my work as a separate pull request on GitHub, the CI leak tests are still failing:

https://github.com/git/git/pull/2170

Harald

My bad, it does fix it! I think I applied your patch incorrectly the first time around.

Harald

I've queued your v26 on top of a merge of Peff's leakfix patches into 'master'. It hopefully will appear in today's pushout.

Thanks, both.

So are we all happy with v26 of the topic?

It addresses my main concern, which was having a way to turn it off. ;) (And I see it is not even changed by default now).

One thing that puzzled me a bit is that the show_divergence_advice flag is only respected for "use git pull if you want to integrate..." hint and not other advice. But that was true even before these patches. It feels funny to me that it is treated differently than the other advice. But I think we can ignore that for the purposes of this topic. If anything it is a defect in b6f3da5132 (wt-status: don't show divergence advice when committing, 2023-07-12), which perhaps should have covered more code paths.

Other than that, I did not see anything wrong from my (admittedly pretty cursory) read.

-Peff

I realized now that my code would benefit from branch de-duplication. When running it from the main branch (which has upsteam+push = origin/main) and my git setting is this which I intended to run from now on:

    git config --global status.compareBranches "@{upstream} @{push}"

then it reports status twice. I have a small fix ready and will push it out once the CI passes on GitHub.

Harald

... meaning that ...

... when @{upstream} and @{push} ends up being the same branch? Yes, if that happens, it would be irritating for the users if we do not deduplicate.

Thanks.

cc: Chris Torek [email protected] cc: Yee Cheng Chin [email protected] cc: "brian m. carlson" [email protected]
cc: Ben Knoble [email protected] cc: "Kristoffer Haugsbakk" [email protected] cc: Phillip Wood [email protected]
cc: Nico Williams [email protected] cc: Patrick Steinhardt [email protected] cc:
Jeff King [email protected]

Harald Nordgren (2):
refactor format_branch_comparison in preparation
status: add status.compareBranches config for multiple branch
comparisons

 Documentation/config/status.adoc |  20 ++
 remote.c                         | 192 ++++++++++++++----
 t/t6040-tracking-info.sh         | 337 +++++++++++++++++++++++++++++++
 3 files changed, 512 insertions(+), 37 deletions(-)

base-commit: b5c409c40f1595e3e590760c6f14a16b6683e22c
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2138%2FHaraldNordgren%2Fahead_of_main_status-v27
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2138/HaraldNordgren/ahead_of_main_status-v27
Pull-Request: https://github.com/git/git/pull/2138

Range-diff vs v26:

 1:  27a46f8d9c = 1:  27a46f8d9c refactor format_branch_comparison in preparation
 2:  caa761f615 ! 2:  0993420fc1 status: add status.compareBranches config for multiple branch comparisons
     @@ remote.c
       struct counted_string {
       	size_t len;
       	const char *s;
     -@@ remote.c: static void branch_release(struct branch *branch)
     - 	free((char *)branch->refname);
     - 	free(branch->remote_name);
     - 	free(branch->pushremote_name);
     -+	free((char *)branch->push_tracking_ref);
     - 	merge_clear(branch);
     - }
     - 
      @@ remote.c: int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
       	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
       }
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
      -	const char *full_base;
      -	char *base;
      -	int upstream_is_gone = 0;
     --
     ++	char *compare_branches = NULL;
     ++	struct string_list branches = STRING_LIST_INIT_DUP;
     ++	struct string_list processed_refs = STRING_LIST_INIT_DUP;
     ++	int reported = 0;
     ++	size_t i;
     ++	const char *upstream_ref;
     ++	const char *push_ref;
     + 
      -	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
      -	if (cmp_fetch < 0) {
      -		if (!full_base)
      -			return 0;
      -		upstream_is_gone = 1;
     -+	char *compare_branches_config = NULL;
     -+	struct string_list compare_branches = STRING_LIST_INIT_DUP;
     -+	struct string_list_item *item;
     -+	int reported = 0;
     -+	size_t i;
     -+	const char *upstream_ref;
     -+	const char *push_ref;
     -+
      +	repo_config_get_string(the_repository, "status.comparebranches",
     -+			       &compare_branches_config);
     ++			       &compare_branches);
      +
     -+	if (compare_branches_config) {
     -+		string_list_split(&compare_branches, compare_branches_config,
     -+				  " ", -1);
     -+		string_list_remove_empty_items(&compare_branches, 0);
     ++	if (compare_branches) {
     ++		string_list_split(&branches, compare_branches, " ", -1);
     ++		string_list_remove_empty_items(&branches, 0);
      +	} else {
     -+		string_list_append(&compare_branches, "@{upstream}");
     ++		string_list_append(&branches, "@{upstream}");
       	}
       
      -	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
      -				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
      -	} else {
      -		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
     -+	for (i = 0; i < compare_branches.nr; i++) {
     ++	for (i = 0; i < branches.nr; i++) {
      +		char *full_ref;
      +		char *short_ref;
      +		int ours, theirs, cmp;
      +		int is_upstream, is_push;
      +		unsigned flags = 0;
      +
     -+		item = &compare_branches.items[i];
     -+		full_ref = resolve_compare_branch(branch, item->string);
     ++		full_ref = resolve_compare_branch(branch,
     ++						  branches.items[i].string);
      +		if (!full_ref)
      +			continue;
      +
     ++		if (string_list_has_string(&processed_refs, full_ref)) {
     ++			free(full_ref);
     ++			continue;
     ++		}
     ++		string_list_insert(&processed_refs, full_ref);
     ++
      +		short_ref = refs_shorten_unambiguous_ref(
      +			get_main_ref_store(the_repository), full_ref, 0);
      +
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
       
      -	free(base);
      -	return 1;
     -+	string_list_clear(&compare_branches, 0);
     -+	free(compare_branches_config);
     ++	string_list_clear(&branches, 0);
     ++	string_list_clear(&processed_refs, 0);
     ++	free(compare_branches);
      +	return reported;
       }
       
     @@ t/t6040-tracking-info.sh: test_expect_success '--set-upstream-to @{-1}' '
      +	)
      +'
      +
     ++test_expect_success 'status.compareBranches from upstream has no duplicates' '
     ++	(
     ++		cd test &&
     ++		git checkout main &&
     ++		git status >../actual
     ++	) &&
     ++	cat >expect <<-EOF &&
     ++	On branch main
     ++	Your branch is up to date with ${SQ}origin/main${SQ}.
     ++
     ++	nothing to commit, working tree clean
     ++	EOF
     ++	test_cmp expect actual
     ++'
     ++
      +test_expect_success 'status.compareBranches shows ahead of both upstream and push branch' '
      +	(
      +		cd test &&

gitgitgadget

From: Harald Nordgren <[email protected]>

Refactor format_branch_comparison function in preparation for showing comparison with push remote tracking branch.

---
 remote.c | 82 +++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 48 insertions(+), 34 deletions(-)

index b756ff6f15..fd592ec659 100644
@@ -2230,42 +2230,21 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 	return stat_branch_pair(branch->refname, base, num_ours, num_theirs, abf);
 }
 
-/*
- * Return true when there is anything to report, otherwise false.
- */
-int format_tracking_info(struct branch *branch, struct strbuf *sb,
-			 enum ahead_behind_flags abf,
-			 int show_divergence_advice)
-{
-	int ours, theirs, sti;
-	const char *full_base;
-	char *base;
-	int upstream_is_gone = 0;
-
-	sti = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
-	if (sti < 0) {
-		if (!full_base)
-			return 0;
-		upstream_is_gone = 1;
-	}
-
-	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
-					    full_base, 0);
-	if (upstream_is_gone) {
-		strbuf_addf(sb,
-			_("Your branch is based on '%s', but the upstream is gone.\n"),
-			base);
-		if (advice_enabled(ADVICE_STATUS_HINTS))
-			strbuf_addstr(sb,
-				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
-	} else if (!sti) {
+static void format_branch_comparison(struct strbuf *sb,
+				     bool up_to_date,
+				     int ours, int theirs,
+				     const char *branch_name,
+				     enum ahead_behind_flags abf,
+				     bool show_divergence_advice)
+{
+	if (up_to_date) {
 		strbuf_addf(sb,
 			_("Your branch is up to date with '%s'.\n"),
-			base);
+			branch_name);
 	} else if (abf == AHEAD_BEHIND_QUICK) {
 		strbuf_addf(sb,
 			    _("Your branch and '%s' refer to different commits.\n"),
-			    base);
+			    branch_name);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addf(sb, _("  (use \"%s\" for details)\n"),
 				    "git status --ahead-behind");

@@ -2274,7 +2253,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			Q_("Your branch is ahead of '%s' by %d commit.\n",
 			   "Your branch is ahead of '%s' by %d commits.\n",
 			   ours),
-			base, ours);
+			branch_name, ours);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git push\" to publish your local commits)\n"));

@@ -2285,7 +2264,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			   "Your branch is behind '%s' by %d commits, "
 			       "and can be fast-forwarded.\n",
 			   theirs),
-			base, theirs);
+			branch_name, theirs);
 		if (advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" to update your local branch)\n"));

@@ -2298,12 +2277,47 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 			       "and have %d and %d different commits each, "
 			       "respectively.\n",
 			   ours + theirs),
-			base, ours, theirs);
+			branch_name, ours, theirs);
 		if (show_divergence_advice &&
 		    advice_enabled(ADVICE_STATUS_HINTS))
 			strbuf_addstr(sb,
 				_("  (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
 	}
+}
+
+/*
+ * Return true when there is anything to report, otherwise false.
+ */
+int format_tracking_info(struct branch *branch, struct strbuf *sb,
+			 enum ahead_behind_flags abf,
+			 int show_divergence_advice)
+{
+	int ours, theirs, cmp_fetch;
+	const char *full_base;
+	char *base;
+	int upstream_is_gone = 0;
+
+	cmp_fetch = stat_tracking_info(branch, &ours, &theirs, &full_base, 0, abf);
+	if (cmp_fetch < 0) {
+		if (!full_base)
+			return 0;
+		upstream_is_gone = 1;
+	}
+
+	base = refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
+					    full_base, 0);
+
+	if (upstream_is_gone) {
+		strbuf_addf(sb,
+			_("Your branch is based on '%s', but the upstream is gone.\n"),
+			base);
+		if (advice_enabled(ADVICE_STATUS_HINTS))
+			strbuf_addstr(sb,
+				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
+	} else {
+		format_branch_comparison(sb, !cmp_fetch, ours, theirs, base, abf, show_divergence_advice);
+	}
+
 	free(base);
 	return 1;
 }

gitgitgadget

From: Harald Nordgren <[email protected]>

Add a new configuration variable status.compareBranches that allows users to specify a space-separated list of branches to compare against the current branch in git status output.

Each branch in the list can be:
- A remote-tracking branch name (e.g., origin/main)
- The special reference @{upstream} for the tracking branch
- The special reference @{push} for the push destination

When not configured, the default behavior is equivalent to setting status.compareBranches = @{upstream}, preserving backward compatibility.

The advice messages shown are context-aware:
- "git pull" advice is shown only when comparing against @{upstream}
- "git push" advice is shown only when comparing against @{push}
- Divergence advice is shown for upstream branch comparisons

This is useful for triangular workflows where the upstream tracking branch differs from the push destination, allowing users to see their status relative to both branches at once.

Example configuration:

    [status]
        compareBranches = @{upstream} @{push}

---
 Documentation/config/status.adoc |  20 ++
 remote.c                         | 160 ++++++++++++---
 t/t6040-tracking-info.sh         | 337 +++++++++++++++++++++++++++++++
 3 files changed, 489 insertions(+), 28 deletions(-)

index 8caf90f51c..ab54f25fbc 100644
@@ -17,6 +17,26 @@ status.aheadBehind::
 	`--no-ahead-behind` by default in linkgit:git-status[1] for
 	non-porcelain status formats.  Defaults to true.
 
+status.compareBranches::
+	A space-separated list of branches to compare the current branch
+	against in linkgit:git-status[1]. Each branch specification can be
+	a remote-tracking branch name (e.g. `origin/main`), or a special
+	reference like `@{upstream}` or `@{push}`. For each branch in the
+	list, git status shows whether the current branch is ahead, behind,
+	or has diverged from that branch.
++
+If not set, the default behavior is equivalent to `@{upstream}`, which
+compares against the configured upstream tracking branch.
++
+Example:
++
+----
+[status]
+	compareBranches = origin/main origin/develop
+----
++
+This would show comparisons against both `origin/main` and `origin/develop`.
+
 status.displayCommentPrefix::
 	If set to true, linkgit:git-status[1] will insert a comment
 	prefix before each output line (starting with

gitgitgadget

Sounds like a good change. Very nice to have insert-and-check as a single operation!

I'll update it after passing CI on GitHub -- I'm running CI from two separate GitHub pull requests, because one has your memory leak fix on top to allow the leak tests to not fail. 🤗

Harald

Thanks. I think we are getting to the finish line with this topic, finally ;-)

Sounds like a follow-up rather of doing now, right? 🤗

Since the inteface won't change, just adding more functionality a new feature, we should be able to fix this behind the scenes later.

Harald

Disambiguation will make it harder or impossible to add such an enhancement later, though.

When the user says "git log origin" or "git show origin/main", refs.c::ref_rev_parse_rules[] is applied and turns these into refs/refs/remotes/origin/HEAD or refs/remotes/origin/main, but as you can see in refs.c::ref_rev_parse_rules[], these are at relatively low precedence order. Your version has refs/remotes/ as the first (and only) choice, so if a user has refs/heads/origin/main and refs/remotes/origin/main at the same time, "git show origin/main" would use the former. With the implementation of this round, "[status] compareBranches = origin/main" would pick refs/remotes/origin/main and nothing else first, and then would start behaving differently once such an enhancement to use the standard DWIMmery rules is introduced, which may appear to be an unnecessary regression to end-users.

So, no, I wouldn't recommend it as a follow-up. We should decide to do so now or declare that we would never do so.

Alternatively, if we remove the "a string that is not @{upstream} or @{push} gets refs/remotes/ prefixed" altogether, then "the interface won't change, just adding more functionality" would become true.

It is not my itch, so I can go either way, but I'd prefer not to see us take the "declare we will never use the unified ref DIWMmery rules here" route, if we can.

Yeah, it is unfortunate to have to special-case these names, even though the resolving functions already know about them. If we are looking at branch "foo" we could rewrite them as "foo@{upstream}", etc, but that also requires special-casing (though maybe slightly less, if we just accept the @ sign?).

I can think of two alternatives, though.

One is that repo_interpret_branch_name() could accept a field in its options struct to set the default branch (rather than "HEAD"). Something like this (totally untested):

index 8b862c124e..925a487d84 100644
@@ -1732,7 +1732,7 @@ static int interpret_branch_mark(struct repository *r,
 		branch = branch_get(name_str);
 		free(name_str);
 	} else
-		branch = branch_get(NULL);
+		branch = branch_get(options->default_branch);
 
 	value = get_data(branch, &err);
 	if (!value) {

index cda4934cd5..962f99b0f6 100644
@@ -119,6 +119,12 @@ struct interpret_branch_name_options {
 	 * of die()-ing.
 	 */
 	unsigned nonfatal_dangling_mark : 1;
+
+	/*
+	 * Pass this to branch_get() when interpreting @-marks without a
+	 * branch, rather than using HEAD.
+	 */
+	const char *default_branch;
 };
 int repo_interpret_branch_name(struct repository *r,
 			       const char *str, int len,

Most callers would continue to pass NULL in the usual way, but the resolution here would pass in the current branch name.

The second is a bit more complicated, but is even more flexible. Part of the point of this status.compareBranches approach is that you can add regular refnames to the list. But would a user want to use a name that is derived from the comparison branch, rather than just a static name? That is, to compare branch "foo" against "origin/foo"? Usually that is exactly the kind of refspec-application that @{upstream} and @{push} are computing (after taking into account various config). But if you have a third source of refs, would you want to be able to compare to "origin/%s", where %s is the shortened branch name?

In which case these values could become "%s@{upstream}" and "%s@{push}", and they could just be fed straight to the branch-interpret machinery.

Yeah, I think tags or even local branches would be plausible candidates. But at any rate, I'd expect these to be resolved in the "usual" way that we do elsewhere. If we switch to using repo_dwim_ref() or something that interprets @-marks, then that matches nicely with the suggestions I gave above.

-Peff

So here's a sketch to show what that might look like:

index 1071a23567..6f9a28970c 100644
@@ -2239,34 +2239,30 @@ int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs,
 static char *resolve_compare_branch(struct branch *branch, const char *name)
 {
 	struct strbuf buf = STRBUF_INIT;
-	const char *resolved = NULL;
+	struct object_id oid;
 	char *ret;
 
 	if (!branch || !name)
 		return NULL;
 
-	if (!strcasecmp(name, "@{upstream}") || !strcasecmp(name, "@{u}"))
-		resolved = branch_get_upstream(branch, NULL);
-	else if (!strcasecmp(name, "@{push}"))
-		resolved = branch_get_push(branch, NULL);
-
-	if (resolved)
-		return xstrdup(resolved);
-
-	strbuf_addf(&buf, "refs/remotes/%s", name);
-	resolved = refs_resolve_ref_unsafe(
-		get_main_ref_store(the_repository),
-		buf.buf,
-		RESOLVE_REF_READING,
-		NULL, NULL);
-	if (resolved) {
-		ret = xstrdup(resolved);
-		strbuf_release(&buf);
-		return ret;
+	while (strbuf_expand_step(&buf, &name)) {
+		if (skip_prefix(name, "%", &name))
+			strbuf_addch(&buf, '%');
+		else if (skip_prefix(name, "s", &name))
+			strbuf_addstr(&buf, branch->name);
+		else
+			die("bad compareBranches format: %%%s", name);
 	}
 
+	/*
+	 * This will leave "ret" as NULL if we don't find anything. If there
+	 * are multiple ambiguous matches it will pick the first. Should we
+	 * return an error instead?
+	 */
+	repo_dwim_ref(the_repository, buf.buf, buf.len, &oid, &ret, 1);
+
 	strbuf_release(&buf);
-	return NULL;
+	return ret;
 }
 
 static void format_branch_comparison(struct strbuf *sb,

@@ -2352,7 +2348,7 @@ int format_tracking_info(struct branch *branch, struct strbuf *sb,
 		string_list_split(&branches, compare_branches, " ", -1);
 		string_list_remove_empty_items(&branches, 0);
 	} else {
-		string_list_append(&branches, "@{upstream}");
+		string_list_append(&branches, "%s@{upstream}");
 	}
 
 	upstream_ref = branch_get_upstream(branch, NULL);

I ran into two small complications. The first is that there's an interesting race "git-checkout -b":

1. We read branch and remote config via remote.c:read_config(), caching it.

2. Then we write some new config for the branch we just created.

3. Then we try to report tracking info. This will read the cached config from step 1, without regard to the changes in 2.

It works without my patch above because the tracking code currently operates directly on a "struct branch" (that we just updated), rather than using the stale config from (1).

We can fix that like this:

index 243db7d0fc..cc24e8522d 100644
@@ -178,6 +178,12 @@ static int install_branch_config_multiple_remotes(int flag, const char *local,
 		string_list_clear(&friendly_ref_names, 0);
 	}
 
+	/*
+	 * We installed new config; flush any internal cache of the on-disk
+	 * config.
+	 */
+	remote_state_clear(the_repository->remote_state);
+
 	return 0;
 
 out_err:

index 6f9a28970c..e6056199f0 100644
@@ -2859,6 +2859,14 @@ void remote_state_clear(struct remote_state *remote_state)
 		free(b);
 	}
 	hashmap_clear(&remote_state->branches_hash);
+
+	/*
+	 * Eek, we just cleared everything out; we should mark ourselves as
+	 * uninitialized so we can be used again. Nobody seems to have noticed
+	 * because we only remote_state_clear() when we are about to discard
+	 * the struct entirely.
+	 */
+	remote_state->initialized = 0;
 }
 
 /*

The second issue concerns the case when an upstream is configured, but the tracking ref for it is missing. So imagine "foo" is configured with "refs/remotes/origin/foo" as its upstream, but that branch is gone.

Using branch_get_upstream() will return the name, even if it doesn't exist. And then the tracking-info code recognizes this and reports it. But repo_dwim_ref() won't return a missing ref at all, even with nonfatal_dangling_mark. So I think we'd need to teach it a new option to do so.

I don't know what all of it means. The "%s" thing was short to implement, but the real source of the extra complications is using repo_dwim_ref() to do the resolution. But I think the overall direction is more consistent with how the rest of Git behaves.

-Peff

So I think that nonfatal_dangling_mark could arguably return the name (but no oid) for this case, like so:

index 627b7f8698..2316d0b8a9 100644
@@ -813,7 +813,13 @@ int repo_dwim_ref(struct repository *r, const char *str, int len,
 	char *last_branch = substitute_branch_name(r, &str, &len,
 						   nonfatal_dangling_mark);
 	int   refs_found  = expand_ref(r, str, len, oid, ref);
-	free(last_branch);
+	if (nonfatal_dangling_mark && !refs_found && last_branch) {
+		oidclr(oid, r->hash_algo);
+		*ref = last_branch;
+		refs_found = 1;
+	} else {
+		free(last_branch);
+	}
 	return refs_found;
 }
 

But this brings up yet another corner case: substitute_branch_name() will call shorten_unambiguous_ref() on the result when expanding @-marks. So last_branch here might be "origin/foo" instead of "refs/remotes/origin/foo". It's usually not a big deal because expand_ref() will then reverse that shortening. Which is maybe wasteful, but not so bad (though if somebody racily creates an ambiguous ref, it could affect the results).

But if we return last_branch explicitly, then information is lost: we don't know what the fully-qualified version of "origin/foo" was supposed to be. And so the tracking-info code gets confused, because it doesn't realize that "origin/foo" was supposed to be our @{upstream}.

I think probably the interpret_branch_name() code should have an option to avoid that shortening. So if we do this on top:

index 8b862c124e..0663946f81 100644
@@ -1747,7 +1747,12 @@ static int interpret_branch_mark(struct repository *r,
 	if (!branch_interpret_allowed(value, options->allowed))
 		return -1;
 
-	set_shortened_ref(r, buf, value);
+	if (options->do_not_shorten) {
+		strbuf_reset(buf);
+		strbuf_addstr(buf, value);
+	} else {
+		set_shortened_ref(r, buf, value);
+	}
 	return len + at;
 }
 

index cda4934cd5..20393cb213 100644
@@ -119,6 +119,8 @@ struct interpret_branch_name_options {
 	 * of die()-ing.
 	 */
 	unsigned nonfatal_dangling_mark : 1;
+
+	unsigned do_not_shorten : 1;
 };
 int repo_interpret_branch_name(struct repository *r,
 			       const char *str, int len,

index 2316d0b8a9..58f945e213 100644
@@ -746,6 +746,7 @@ static char *substitute_branch_name(struct repository *r,
 {
 	struct strbuf buf = STRBUF_INIT;
 	struct interpret_branch_name_options options = {
+		.do_not_shorten = 1,
 		.nonfatal_dangling_mark = nonfatal_dangling_mark
 	};
 	int ret = repo_interpret_branch_name(r, *string, *len, &buf, &options);

then all of t6040 passes (curiously without me swapping in "%s@{push}" as appropriate; I guess we are often on the branch of interest anyway, so it accidentally works with just @{push}).

So I don't love how deep the rabbit-hole has gone here. But at the same time, it feels like all of these "if we just do this on top" fixes are actually smoothing some rough edges in the rest of Git. So maybe it's worth it.

-Peff

I can apply the changes from these three messages, but I don't really know the side-effects of it. Should I do it and submit a patch?

I noticed that it still won't work with tags (although it starts working with 'origin' which then defaults to origin/HEAD). I can imagine we need a few more tests on top of that.

Harald

Please do not send code you cannot answer to questions on it, whether it is written by somebody else, genAI, or your cat rolling on your keyboard ;-).

I think we are getting close but will need more polish before we can allow users to reuse their already acquired knowledge of how refname DWIMmery can be used to spell various refs they mean.

If we support only @{push} and @{upstream} and error out when we see anything else (like "origin" or "origin/main") in the initial version we ship to the end-users, that would probably be a good stopping point. On top of it, we can later add the DWIMmery Peff has shown (with necessary tweaks, as you found out, like supporting tags, perhaps), and that will be purely new feature that does not change any behaviour of what used to work for our users in the initial version.

Going that way is much safer and does not break end-user experiences, like shipping the first version with "we always prefix hardcoded refs/remotes/ unless it is @{something}", which will have to change the behaviour once the proper DWIMmery gets implemented.

In any case, that will have to happen all after the current cycle is over, it is way too late even for "@{push} and @{upstream} only" version for this cycle.

Hi Jeff!

Do you think this is ready to be merged? I think you are the holdout here 🤗

Harald

Yeah, I tend to agree. As long as we do not hardcode the prefixing of "refs/remotes/", we won't paint ourselves into a corner we cannot get out of, I guess.

Thanks.

"Harald Nordgren via GitGitGadget" <[email protected]> writes:

Before these list of CC's (which does not seem to have any effect, by the way. The message is going only to the list with your personal address on CC: and to nobody else), ...

... please summarize

(1) what this series of patches are about, to help those who encounter these patches for the first time, and

(2) what changed in this iteration (v27) relative to the previous

     iteration (v26).

I happen to have seen your other message so I can guess this is about deduping when more than one comparison target is listed and some happen to become the same branches, but others may not have seen that other message, and it is not helpful to just dump the range-diff and force them to read it to deduce what you did.

Thanks.

Hmm, I always just the 'git send-email' snippet from example here:
https://lore.kernel.org/git/[email protected]/, which for this message is:

  git send-email \
    [email protected] \
    [email protected] \
    [email protected] \
    [email protected] \
    [email protected] \
    [email protected] \
    /path/to/YOUR_REPLY

Fair point, but I always always use GitGitGadget to submit patches to here, I'm sure sure if there is a way to do that from there?

I just write '/submit' to create the whole patch:
https://github.com/git/git/pull/2138#issuecomment-3785055635

Harald

But the patch you sent was not using "git send-email", was it? I am not sure where those annoying and unused CC addresses comes from, but it would be from GGG, not from "git send-email", I suspect.

Sorry, I do not work on or use GGG; other users of it may be able to chime in?

Thanks.

Yes you are right, I misunderstood your point about the CC's.

Patches are 100% via GGG.

Harald

cc: Chris Torek [email protected] cc: Yee Cheng Chin [email protected] cc: "brian m. carlson" [email protected]
cc: Ben Knoble [email protected] cc: "Kristoffer Haugsbakk" [email protected] cc: Phillip Wood [email protected]
cc: Nico Williams [email protected] cc: Patrick Steinhardt [email protected] cc:
Jeff King [email protected]

Harald Nordgren (2):
refactor format_branch_comparison in preparation
status: add status.compareBranches config for multiple branch
comparisons

 Documentation/config/status.adoc |  20 ++
 remote.c                         | 191 ++++++++++++++----
 t/t6040-tracking-info.sh         | 337 +++++++++++++++++++++++++++++++
 3 files changed, 511 insertions(+), 37 deletions(-)

base-commit: 83a69f19359e6d9bc980563caca38b2b5729808c
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-2138%2FHaraldNordgren%2Fahead_of_main_status-v28
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-2138/HaraldNordgren/ahead_of_main_status-v28
Pull-Request: https://github.com/git/git/pull/2138

Range-diff vs v27:

 1:  27a46f8d9c = 1:  f3c8c782b0 refactor format_branch_comparison in preparation
 2:  0993420fc1 ! 2:  067978dd09 status: add status.compareBranches config for multiple branch comparisons
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
      -	int upstream_is_gone = 0;
      +	char *compare_branches = NULL;
      +	struct string_list branches = STRING_LIST_INIT_DUP;
     -+	struct string_list processed_refs = STRING_LIST_INIT_DUP;
     ++	struct strset processed_refs = STRSET_INIT;
      +	int reported = 0;
      +	size_t i;
      +	const char *upstream_ref;
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
      +		if (!full_ref)
      +			continue;
      +
     -+		if (string_list_has_string(&processed_refs, full_ref)) {
     ++		if (!strset_add(&processed_refs, full_ref)) {
      +			free(full_ref);
      +			continue;
      +		}
     -+		string_list_insert(&processed_refs, full_ref);
      +
      +		short_ref = refs_shorten_unambiguous_ref(
      +			get_main_ref_store(the_repository), full_ref, 0);
     @@ remote.c: int format_tracking_info(struct branch *branch, struct strbuf *sb,
      -	free(base);
      -	return 1;
      +	string_list_clear(&branches, 0);
     -+	string_list_clear(&processed_refs, 0);
     ++	strset_clear(&processed_refs);
      +	free(compare_branches);
      +	return reported;
       }

gitgitgadget

From: Harald Nordgren <[email protected]>

Refactor format_branch_comparison function in preparation for showing comparison with push remote tracking branch.