[PATCH] git-prompt.sh: shorter equal upstream branch name

From: Julien Carsique <redacted>

When using the "name" option of GIT_PS1_SHOWUPSTREAM to show the upstream
abbrev name, if the upstream name is the same as the local name, then some
space could be saved in the prompt. This is especially needed on long branch
names.

Replace the upstream name with the sign '=' if equal to the local one.
Example:    [master * u= origin/=]$
instead of: [master * u= origin/master]$

Signed-off-by: Julien Carsique <redacted>
---
 contrib/completion/git-prompt.sh | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/contrib/completion/git-prompt.sh b/contrib/completion/git-prompt.sh
index c5473dc..a9aba20 100644
--- a/contrib/completion/git-prompt.sh
+++ b/contrib/completion/git-prompt.sh

@@ -209,6 +209,13 @@ __git_ps1_show_upstream ()
 		if [[ -n "$count" && -n "$name" ]]; then
 			__git_ps1_upstream_name=$(git rev-parse \
 				--abbrev-ref "$upstream" 2>/dev/null)
+
+			__head=${b##refs/heads/}
+			if [ "$__head" = "${__git_ps1_upstream_name##*/}" ]; then
+				__git_ps1_upstream_name=${__git_ps1_upstream_name/$__head/=}
+			fi
+			unset __head
+
 			if [ $pcmode = yes ] && [ $ps1_expanded = yes ]; then
 				p="$p \${__git_ps1_upstream_name}"
 			else

-- 
2.1.0

On 2014-09-30 11:36, Julien Carsique wrote:

From: Julien Carsique <redacted>

When using the "name" option of GIT_PS1_SHOWUPSTREAM to show the upstream
abbrev name, if the upstream name is the same as the local name, then some
space could be saved in the prompt. This is especially needed on long branch
names.

Replace the upstream name with the sign '=' if equal to the local one.
Example:    [master * u= origin/=]$
instead of: [master * u= origin/master]$

Seems like a good idea to me.

Signed-off-by: Julien Carsique <redacted>
---
 contrib/completion/git-prompt.sh | 7 +++++++
 1 file changed, 7 insertions(+)

Please add some new tests in t/9903-bash-prompt.sh.  In particular:
  * upstream ref in refs/heads
  * upstream is git-svn
  * branch names containing slashes

To avoid colliding with other stuff, this variable should either be
local or prefixed with '__git_ps1'.

+			if [ "$__head" = "${__git_ps1_upstream_name##*/}" ]; then

This comparison breaks on branches containing a slash (e.g., foo/bar).

Also, how does this interact with git-svn?  (I don't use git-svn so I'm
not very familiar with how it manages refs.)

Assuming remote names can't contain a slash (which I think is true), a
safer approach might be parse the full ref and special-case refs/remotes:

    __git_ps1_upstream_name=$(git rev-parse \
        --abbrev-ref "${upstream}" 2>/dev/null)
    local tmp
    tmp=$(git rev-parse --symbolic-full-name "${upstream}" 2>/dev/null)
    case ${tmp} in
    refs/remotes/*)
        # todo: can ${b} be something other than refs/heads/* here?
        [ "${__git_ps1_upstream_name#*/}" != "${b#refs/heads/}" ] \
            || __git_ps1_upstream_name=${__git_ps1_upstream_name%%/*}/\=
        ;;
    esac

Additional cases could be added to handle git-svn if needed.

+				__git_ps1_upstream_name=${__git_ps1_upstream_name/$__head/=}

  * This could break if ${__head} contains any pattern-special
    characters.

  * While this syntax works in both Bash and Zsh (assuming no
    pattern-special characters), my preference is to stick to POSIX[1]
    when possible.  For example, assuming the upstream name is
    always in refs/remotes (which is not true, but this is an example)
    and remote names can't contain a '/', you could do this:

        __git_ps1_upstream_name=${__git_ps1_upstream_name%%/*}/\=

  * I don't think the CodingGuidelines explicitly prohibit long lines
    for shell code, and this file already contains plenty of long
    lines, but I really dislike lines longer than 80 characters.

[1] http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html

+			fi
+			unset __head
+
 			if [ $pcmode = yes ] && [ $ps1_expanded = yes ]; then
 				p="$p \${__git_ps1_upstream_name}"
 			else

-Richard

Julien Carsique [off-list ref] writes:

When you are on your "xyz" branch that was forked off of
"refs/remote/origin/xyz/xyz", $__git_ps1_upstream_name would be
"origin/xyz/xyz" and $__head is "xyz" at this point.  The latter
matches the former after stripping */ maximally from its front
(i.e. "xyz").  It is unclear if you really want to make these two
match, but as long as you correctly abbreviate you would not lose
information, I would imagine.  I am guessing that you would want to
see "origin/xyz/=" in such a case, and if you started your "xyz" off
of "origin/abc/xyz", you would want "origin/abc/=".

+				__git_ps1_upstream_name=${__git_ps1_upstream_name/$__head/=}

Now, what does ${__git_ps1_upstream_name/$__head/=} give us?
This should not do regexp substitution in the first place, I would
think.  You made sure $__head is the tail-matching substring of the
longer variable, so you chop that many bytes off of the latter.

Is this new feature something everybody should want unconditionally,
or are there valid reasons why some people may not want to see this
abbreviation happen (even if the implementation were not buggy)?

+			fi
+			unset __head

Unlike __git_ps1_upstream_name, this __head does not have to be
visible outside this function.  Wouldn't it be better to declare it
as local (this is bash prompt and we can afford to step outside
POSIX) and there is no need to "unset" after use if you did so, no?

 			if [ $pcmode = yes ] && [ $ps1_expanded = yes ]; then
 				p="$p \${__git_ps1_upstream_name}"
 			else