1

I made a ps1 prompt a few years ago. Took a while to config it, now after upgrading it no longer works.

The .bashprompt script (which gets loaded into my .bashrc along with git-sh-prompt) it will check to see what icons are being displayed and update the color (through the if statement). It will display the branch with a different icon for each status and different branch text color for each statement.

At the moment no git branch information is being displayed. Unless i place in the raw command __git_ps1.

I have seen that git puts its git-sh-prompt into /usr/lib/git-core so i changed the .bashrc file to point there and my gitprompt to look there. still no change.

here is the code.

###file##### .bashprompt ####

#!/bin/sh

# store colors
MAGENTA="\[\033[0;35m\]"
YELLOW="\[\033[038;5;154m\]"
BLUE="\[\033[038;5;33m\]"
LIGHT_GRAY="\[\033[0;37m\]"
CYAN="\[\033[038;5;51m\]"
GREEN="\[\033[00;32m\]"
RED="\[\033[38;5;160m\]"
VIOLET="\[\033[01;35m\]"
GREY="\[\033[038;5;234m\]"
BROWN="\[\033[038;5;130m\]"
ORANGE="\[\033[038;5;208m\]"

#Build PS1
function color_my_prompt {
  local __braceL="$BLUE["
  local __braceR="$BLUE]"
  local __cur_location="\W"
  local __location="\w"
  local __git_branch=
  local __prompt_tail="$BLUE➜"
  local __user_input_color="$LIGHT_GRAY"
  local __user="$BLUE[$YELLOW \u@\h $BLUE]"
  local __dollar="$YELLOW$"
  local _ip_add="$BLUE[$YELLOW $(ip addr | grep -w inet | gawk '{if (NR==2) {$0=$2; gsub(/\//," "); print $1;}}')$BLUE ]"
  local __returnLine="\n \n"
 # $BLUE\n$BLUE └─ "
 # colour branch name depending on state
  # if repository is dirty

 # local __filesCheck="$(/bin/ls -m | /usr/bin/wc -l | /bin/sed 's: ::g')"
#  local __minusNo="1"
# local __filesCalc="$(($__filesCheck-$__minusNo))"
 # local __filesReal="$__braceL $RED\$__filesCheck files $__braceR"

#  if [ "$(git rev-parse --is-inside-work-tree 2>/dev/null)" = "true" ]; then
#    __git_branch=$(git symbolic-ref --quiet --short HEAD || git rev-parse --short HEAD)
#  fi
  if [[ "$(__git_ps1 "%s")" =~ "*" ]]; then     # if repository is dirty
      __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
      files="$__filesReal"
      __git_branch_color="$BROWN"
  elif [[ "$(__git_ps1 "%s")" =~ "+" ]]; then   # if there are staged files
      __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
      files="$__filesReal"
      __git_branch_color="$CYAN"
  elif [[ "$(__git_ps1 "%s")" =~ "Ŧ" ]]; then   # if there are only untracked files
      __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
      files="$__filesReal"
      __git_branch_color="$RED"
  elif [[ "$(__git_ps1 "%s")" =~ "Š" ]]; then   # if there is something stashed
      __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
      files="$__filesReal"
      __git_branch_color="$GREEN"
  elif [[ "$(__git_ps1 "%s")" =~ "↩" ]]; then   # if behind
      __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
      files="$__filesReal"
      __git_branch_color="$ORANGE"
  elif [[ "$(__git_ps1 "%s")" =~ "↪" ]]; then   # if there are commiting files
      __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
        files="$__filesReal"
      __git_branch_color="$MAGENTA"
  elif [[ "$(__git_ps1 "%s")" =~ "✔" ]]; then   # if it is equal to repo
      __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
      __files="$__filesReal"
      __git_branch_color="$YELLOW"
  fi
  # Compile the PS1

 PS1="\n $__user $_ip_add $__braceL $YELLOW$__cur_location $__braceR $__git_branch$__git_branch_color $__returnLine $__prompt_tail $__user_input_color "
#export PS1="${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u:\[\033[01;34m\]\w\[\033[00m\]\$(__git_ps1)\[\033[00m\] $ "
}
# configure PROMPT_COMMAND which is executed each time before PS1
export PROMPT_COMMAND=color_my_prompt

# if .git-prompt.sh exists, set options and execute it
if [ -f /usr/lib/git-core/git-sh-prompt ]; then
  GIT_PS1_SHOWDIRTYSTATE=true
  GIT_PS1_SHOWSTASHSTATE=true
  GIT_PS1_SHOWUNTRACKEDFILES=true
  GIT_PS1_SHOWUPSTREAM="auto"
  GIT_PS1_HIDE_IF_PWD_IGNORED=true
  GIT_PS1_SHOWCOLORHINTS=true
  GIT_PROMPT_SHOW_UNTRACKED_FILES=normal # can be no, normal or all; determines counting of untracked files
  . /usr/lib/git-core/git-sh-prompt
fi
my .bashrc (selection only of in regards to this)######
source ~/.bashprompt/.bash_prompt
source /usr/lib/git-core/git-sh-prompt

my git-sh-prompt (which has changed icons for the .bashprompt if statement work)

    # bash/zsh git prompt support
#
# Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
# Distributed under the GNU General Public License, version 2.0.
#
# This script allows you to see repository status in your prompt.
#
# To enable:
#
#    1) Copy this file to somewhere (e.g. ~/.git-prompt.sh).
#    2) Add the following line to your .bashrc/.zshrc:
#        source ~/.git-prompt.sh
#    3a) Change your PS1 to call __git_ps1 as
#        command-substitution:
#        Bash: PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
#        ZSH:  setopt PROMPT_SUBST ; PS1='[%n@%m %c$(__git_ps1 " (%s)")]\$ '
#        the optional argument will be used as format string.
#    3b) Alternatively, for a slightly faster prompt, __git_ps1 can
#        be used for PROMPT_COMMAND in Bash or for precmd() in Zsh
#        with two parameters, <pre> and <post>, which are strings
#        you would put in $PS1 before and after the status string
#        generated by the git-prompt machinery.  e.g.
#        Bash: PROMPT_COMMAND='__git_ps1 "\u@\h:\w" "\\\$ "'
#          will show username, at-sign, host, colon, cwd, then
#          various status string, followed by dollar and SP, as
#          your prompt.
#        ZSH:  precmd () { __git_ps1 "%n" ":%~$ " "|%s" }
#          will show username, pipe, then various status string,
#          followed by colon, cwd, dollar and SP, as your prompt.
#        Optionally, you can supply a third argument with a printf
#        format string to finetune the output of the branch status
#
# The repository status will be displayed only if you are currently in a
# git repository. The %s token is the placeholder for the shown status.
#
# The prompt status always includes the current branch name.
#
# In addition, if you set GIT_PS1_SHOWDIRTYSTATE to a nonempty value,
# unstaged (*) and staged (+) changes will be shown next to the branch
# name.  You can configure this per-repository with the
# bash.showDirtyState variable, which defaults to true once
# GIT_PS1_SHOWDIRTYSTATE is enabled.
#
# You can also see if currently something is stashed, by setting
# GIT_PS1_SHOWSTASHSTATE to a nonempty value. If something is stashed,
# then a '$' will be shown next to the branch name.
#
# If you would like to see if there're untracked files, then you can set
# GIT_PS1_SHOWUNTRACKEDFILES to a nonempty value. If there're untracked
# files, then a '%' will be shown next to the branch name.  You can
# configure this per-repository with the bash.showUntrackedFiles
# variable, which defaults to true once GIT_PS1_SHOWUNTRACKEDFILES is
# enabled.
#
# If you would like to see the difference between HEAD and its upstream,
# set GIT_PS1_SHOWUPSTREAM="auto".  A "<" indicates you are behind, ">"
# indicates you are ahead, "<>" indicates you have diverged and "="
# indicates that there is no difference. You can further control
# behaviour by setting GIT_PS1_SHOWUPSTREAM to a space-separated list
# of values:
#
#     verbose       show number of commits ahead/behind (+/-) upstream
#     name          if verbose, then also show the upstream abbrev name
#     legacy        don't use the '--count' option available in recent
#                   versions of git-rev-list
#     git           always compare HEAD to @{upstream}
#     svn           always compare HEAD to your SVN upstream
#
# You can change the separator between the branch name and the above
# state symbols by setting GIT_PS1_STATESEPARATOR. The default separator
# is SP.
#
# By default, __git_ps1 will compare HEAD to your SVN upstream if it can
# find one, or @{upstream} otherwise.  Once you have set
# GIT_PS1_SHOWUPSTREAM, you can override it on a per-repository basis by
# setting the bash.showUpstream config variable.
#
# If you would like to see more information about the identity of
# commits checked out as a detached HEAD, set GIT_PS1_DESCRIBE_STYLE
# to one of these values:
#
#     contains      relative to newer annotated tag (v1.6.3.2~35)
#     branch        relative to newer tag or branch (master~4)
#     describe      relative to older annotated tag (v1.6.3.1-13-gdd42c2f)
#     tag           relative to any older tag (v1.6.3.1-13-gdd42c2f)
#     default       exactly matching tag
#
# If you would like a colored hint about the current dirty state, set
# GIT_PS1_SHOWCOLORHINTS to a nonempty value. The colors are based on
# the colored output of "git status -sb" and are available only when
# using __git_ps1 for PROMPT_COMMAND or precmd.
#
# If you would like __git_ps1 to do nothing in the case when the current
# directory is set up to be ignored by git, then set
# GIT_PS1_HIDE_IF_PWD_IGNORED to a nonempty value. Override this on the
# repository level by setting bash.hideIfPwdIgnored to "false".

# check whether printf supports -v
__git_printf_supports_v=
printf -v __git_printf_supports_v -- '%s' yes >/dev/null 2>&1

# stores the divergence from upstream in $p
# used by GIT_PS1_SHOWUPSTREAM
__git_ps1_show_upstream ()
{
    local key value
    local svn_remote svn_url_pattern count n
    local upstream=git legacy="" verbose="" name=""

    svn_remote=()
    # get some config options from git-config
    local output="$(git config -z --get-regexp '^(svn-remote\..*\.url|bash\.showupstream)$' 2>/dev/null | tr '\0\n' '\n ')"
    while read -r key value; do
        case "$key" in
        bash.showupstream)
            GIT_PS1_SHOWUPSTREAM="$value"
            if [[ -z "${GIT_PS1_SHOWUPSTREAM}" ]]; then
                p=""
                return
            fi
            ;;
        svn-remote.*.url)
            svn_remote[$((${#svn_remote[@]} + 1))]="$value"
            svn_url_pattern="$svn_url_pattern\\|$value"
            upstream=svn+git # default upstream is SVN if available, else git
            ;;
        esac
    done <<< "$output"

    # parse configuration values
    for option in ${GIT_PS1_SHOWUPSTREAM}; do
        case "$option" in
        git|svn) upstream="$option" ;;
        verbose) verbose=1 ;;
        legacy)  legacy=1  ;;
        name)    name=1 ;;
        esac
    done

    # Find our upstream
    case "$upstream" in
    git)    upstream="@{upstream}" ;;
    svn*)
        # get the upstream from the "git-svn-id: ..." in a commit message
        # (git-svn uses essentially the same procedure internally)
        local -a svn_upstream
        svn_upstream=($(git log --first-parent -1 \
                    --grep="^git-svn-id: \(${svn_url_pattern#??}\)" 2>/dev/null))
        if [[ 0 -ne ${#svn_upstream[@]} ]]; then
            svn_upstream=${svn_upstream[${#svn_upstream[@]} - 2]}
            svn_upstream=${svn_upstream%@*}
            local n_stop="${#svn_remote[@]}"
            for ((n=1; n <= n_stop; n++)); do
                svn_upstream=${svn_upstream#${svn_remote[$n]}}
            done

            if [[ -z "$svn_upstream" ]]; then
                # default branch name for checkouts with no layout:
                upstream=${GIT_SVN_ID:-git-svn}
            else
                upstream=${svn_upstream#/}
            fi
        elif [[ "svn+git" = "$upstream" ]]; then
            upstream="@{upstream}"
        fi
        ;;
    esac

    # Find how many commits we are ahead/behind our upstream
    if [[ -z "$legacy" ]]; then
        count="$(git rev-list --count --left-right \
                "$upstream"...HEAD 2>/dev/null)"
    else
        # produce equivalent output to --count for older versions of git
        local commits
        if commits="$(git rev-list --left-right "$upstream"...HEAD 2>/dev/null)"
        then
            local commit behind=0 ahead=0
            for commit in $commits
            do
                case "$commit" in
                "↩ "*) ((behind++)) ;;
                *)    ((ahead++))  ;;
                esac
            done
            count="$behind  $ahead"
        else
            count=""
        fi
    fi

    # calculate the result
    if [[ -z "$verbose" ]]; then
        case "$count" in
        "") # no upstream
            p="" ;;
        "0  0") # equal to upstream
            p=" \[\033[00;32m\]✔" ;;
        "0  "*) # ahead of upstream
            p=" ↪" ;;
        *"  0") # behind upstream
            p=" ↩" ;;
        *)      # diverged from upstream
            p=" ✘" ;;
        esac
    else
        case "$count" in
        "") # no upstream
            p="" ;;
        "0  0") # equal to upstream
            p=" u=" ;;
        "0  "*) # ahead of upstream
            p=" u+${count#0 }" ;;
        *"  0") # behind upstream
            p=" u-${count%  0}" ;;
        *)      # diverged from upstream
            p=" u+${count#* }-${count%  *}" ;;
        esac
        if [[ -n "$count" && -n "$name" ]]; then
            __git_ps1_upstream_name=$(git rev-parse \
                --abbrev-ref "$upstream" 2>/dev/null)
            if [ $pcmode = yes ] && [ $ps1_expanded = yes ]; then
                p="$p \${__git_ps1_upstream_name}"
            else
                p="$p ${__git_ps1_upstream_name}"
                # not needed anymore; keep user's
                # environment clean
                unset __git_ps1_upstream_name
            fi
        fi
    fi

}

# Helper function that is meant to be called from __git_ps1.  It
# injects color codes into the appropriate gitstring variables used
# to build a gitstring.
__git_ps1_colorize_gitstring ()
{
    if [[ -n ${ZSH_VERSION-} ]]; then
        local c_red='%F{red}'
        local c_green='%F{green}'
        local c_lblue='%F{blue}'
        local c_clear='%f'
    else
        # Using \[ and \] around colors is necessary to prevent
        # issues with command line editing/browsing/completion!
        local c_red='\[\e[31m\]'
        local c_green='\[\e[32m\]'
        local c_lblue='\[\e[1;34m\]'
        local c_clear='\[\e[0m\]'
            local c_yellow='\e[38;5;154m\]'
        fi
    local bad_color=$c_red
    local ok_color=$c_green
    local flags_color="$c_lblue"

    local branch_color=""
    if [ $detached = no ]; then
        branch_color="$ok_color"
    else
        branch_color="$bad_color"
    fi
    c="$branch_color$c"

    z="$c_clear$z"
    if [ "$w" = "*" ]; then
        w="$bad_color$w"
    fi
    if [ -n "$i" ]; then
        i="$ok_color$i"
    fi
    if [ -n "$s" ]; then
        s="$flags_color$s"
    fi
    if [ -n "$u" ]; then
        u="$bad_color$u"
    fi
    r="$c_clear$r"
}

# Helper function to read the first line of a file into a variable.
# __git_eread requires 2 arguments, the file path and the name of the
# variable, in that order.
__git_eread ()
{
    test -r "$1" && IFS=$'\r\n' read "$2" <"$1"
}

# see if a cherry-pick or revert is in progress, if the user has committed a
# conflict resolution with 'git commit' in the middle of a sequence of picks or
# reverts then CHERRY_PICK_HEAD/REVERT_HEAD will not exist so we have to read
# the todo file.
__git_sequencer_status ()
{
    local todo
    if test -f "$g/CHERRY_PICK_HEAD"
    then
        r="|CHERRY-PICKING"
        return 0;
    elif test -f "$g/REVERT_HEAD"
    then
        r="|REVERTING"
        return 0;
    elif __git_eread "$g/sequencer/todo" todo
    then
        case "$todo" in
        p[\ \   ]|pick[\ \  ]*)
            r="|CHERRY-PICKING"
            return 0
        ;;
        revert[\ \  ]*)
            r="|REVERTING"
            return 0
        ;;
        esac
    fi
    return 1
}

# __git_ps1 accepts 0 or 1 arguments (i.e., format string)
# when called from PS1 using command substitution
# in this mode it prints text to add to bash PS1 prompt (includes branch name)
#
# __git_ps1 requires 2 or 3 arguments when called from PROMPT_COMMAND (pc)
# in that case it _sets_ PS1. The arguments are parts of a PS1 string.
# when two arguments are given, the first is prepended and the second appended
# to the state string when assigned to PS1.
# The optional third parameter will be used as printf format string to further
# customize the output of the git-status string.
# In this mode you can request colored hints using GIT_PS1_SHOWCOLORHINTS=true
__git_ps1 ()
{
    # preserve exit status
    local exit=$?
    local pcmode=no
    local detached=no
    local ps1pc_start='\u@\h:\w '
    local ps1pc_end='\$ '
    local printf_format=' (%s)'

    case "$#" in
        2|3)    pcmode=yes
            ps1pc_start="$1"
            ps1pc_end="$2"
            printf_format="${3:-$printf_format}"
            # set PS1 to a plain prompt so that we can
            # simply return early if the prompt should not
            # be decorated
            PS1="$ps1pc_start$ps1pc_end"
        ;;
        0|1)    printf_format="${1:-$printf_format}"
        ;;
        *)  return $exit
        ;;
    esac

    # ps1_expanded:  This variable is set to 'yes' if the shell
    # subjects the value of PS1 to parameter expansion:
    #
    #   * bash does unless the promptvars option is disabled
    #   * zsh does not unless the PROMPT_SUBST option is set
    #   * POSIX shells always do
    #
    # If the shell would expand the contents of PS1 when drawing
    # the prompt, a raw ref name must not be included in PS1.
    # This protects the user from arbitrary code execution via
    # specially crafted ref names.  For example, a ref named
    # 'refs/heads/$(IFS=_;cmd=sudo_rm_-rf_/;$cmd)' might cause the
    # shell to execute 'sudo rm -rf /' when the prompt is drawn.
    #
    # Instead, the ref name should be placed in a separate global
    # variable (in the __git_ps1_* namespace to avoid colliding
    # with the user's environment) and that variable should be
    # referenced from PS1.  For example:
    #
    #     __git_ps1_foo=$(do_something_to_get_ref_name)
    #     PS1="...stuff...\${__git_ps1_foo}...stuff..."
    #
    # If the shell does not expand the contents of PS1, the raw
    # ref name must be included in PS1.
    #
    # The value of this variable is only relevant when in pcmode.
    #
    # Assume that the shell follows the POSIX specification and
    # expands PS1 unless determined otherwise.  (This is more
    # likely to be correct if the user has a non-bash, non-zsh
    # shell and safer than the alternative if the assumption is
    # incorrect.)
    #
    local ps1_expanded=yes
    [ -z "${ZSH_VERSION-}" ] || [[ -o PROMPT_SUBST ]] || ps1_expanded=no
    [ -z "${BASH_VERSION-}" ] || shopt -q promptvars || ps1_expanded=no

    local repo_info rev_parse_exit_code
    repo_info="$(git rev-parse --git-dir --is-inside-git-dir \
        --is-bare-repository --is-inside-work-tree \
        --short HEAD 2>/dev/null)"
    rev_parse_exit_code="$?"

    if [ -z "$repo_info" ]; then
        return $exit
    fi

    local short_sha=""
    if [ "$rev_parse_exit_code" = "0" ]; then
        short_sha="${repo_info##*$'\n'}"
        repo_info="${repo_info%$'\n'*}"
    fi
    local inside_worktree="${repo_info##*$'\n'}"
    repo_info="${repo_info%$'\n'*}"
    local bare_repo="${repo_info##*$'\n'}"
    repo_info="${repo_info%$'\n'*}"
    local inside_gitdir="${repo_info##*$'\n'}"
    local g="${repo_info%$'\n'*}"

    if [ "true" = "$inside_worktree" ] &&
       [ -n "${GIT_PS1_HIDE_IF_PWD_IGNORED-}" ] &&
       [ "$(git config --bool bash.hideIfPwdIgnored)" != "false" ] &&
       git check-ignore -q .
    then
        return $exit
    fi

    local r=""
    local b=""
    local step=""
    local total=""
    if [ -d "$g/rebase-merge" ]; then
        __git_eread "$g/rebase-merge/head-name" b
        __git_eread "$g/rebase-merge/msgnum" step
        __git_eread "$g/rebase-merge/end" total
        if [ -f "$g/rebase-merge/interactive" ]; then
            r="|REBASE-i"
        else
            r="|REBASE-m"
        fi
    else
        if [ -d "$g/rebase-apply" ]; then
            __git_eread "$g/rebase-apply/next" step
            __git_eread "$g/rebase-apply/last" total
            if [ -f "$g/rebase-apply/rebasing" ]; then
                __git_eread "$g/rebase-apply/head-name" b
                r="|REBASE"
            elif [ -f "$g/rebase-apply/applying" ]; then
                r="|AM"
            else
                r="|AM/REBASE"
            fi
        elif [ -f "$g/MERGE_HEAD" ]; then
            r="|MERGING"
        elif __git_sequencer_status; then
            :
        elif [ -f "$g/BISECT_LOG" ]; then
            r="|BISECTING"
        fi

        if [ -n "$b" ]; then
            :
        elif [ -h "$g/HEAD" ]; then
            # symlink symbolic ref
            b="$(git symbolic-ref HEAD 2>/dev/null)"
        else
            local head=""
            if ! __git_eread "$g/HEAD" head; then
                return $exit
            fi
            # is it a symbolic ref?
            b="${head#ref: }"
            if [ "$head" = "$b" ]; then
                detached=yes
                b="$(
                case "${GIT_PS1_DESCRIBE_STYLE-}" in
                (contains)
                    git describe --contains HEAD ;;
                (branch)
                    git describe --contains --all HEAD ;;
                (tag)
                    git describe --tags HEAD ;;
                (describe)
                    git describe HEAD ;;
                (* | default)
                    git describe --tags --exact-match HEAD ;;
                esac 2>/dev/null)" ||

                b="$short_sha..."
                b="($b)"
            fi
        fi
    fi

    if [ -n "$step" ] && [ -n "$total" ]; then
        r="$r $step/$total"
    fi

    local w=""
    local i=""
    local s=""
    local u=""
    local c=""
    local p=""

    if [ "true" = "$inside_gitdir" ]; then
        if [ "true" = "$bare_repo" ]; then
            c="BARE:"
        else
            b="GIT_DIR!"
        fi
    elif [ "true" = "$inside_worktree" ]; then
        if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ] &&
           [ "$(git config --bool bash.showDirtyState)" != "false" ]
        then
            git diff --no-ext-diff --quiet || w="\e[38;5;154m\]★"
            git diff --no-ext-diff --cached --quiet || i="\e[38;5;154m\] +"
            if [ -z "$short_sha" ] && [ -z "$i" ]; then
                i="#"
            fi
        fi
        if [ -n "${GIT_PS1_SHOWSTASHSTATE-}" ] &&
           git rev-parse --verify --quiet refs/stash >/dev/null
        then
            s=" \e[38;5;154m\]S"
        fi

        if [ -n "${GIT_PS1_SHOWUNTRACKEDFILES-}" ] &&
           [ "$(git config --bool bash.showUntrackedFiles)" != "false" ] &&
           git ls-files --others --exclude-standard --directory --no-empty-directory --error-unmatch -- ':/*' >/dev/null 2>/dev/null
        then
            u=" \e[38;5;154m\]Ŧ${ZSH_VERSION+%}"
        fi

        if [ -n "${GIT_PS1_SHOWUPSTREAM-}" ]; then
            __git_ps1_show_upstream
        fi
    fi

    local z="${GIT_PS1_STATESEPARATOR-" "}"

    # NO color option unless in PROMPT_COMMAND mode
    if [ $pcmode = yes ] && [ -n "${GIT_PS1_SHOWCOLORHINTS-}" ]; then
        __git_ps1_colorize_gitstring
    fi

    b=${b##refs/heads/}
    if [ $pcmode = yes ] && [ $ps1_expanded = yes ]; then
        __git_ps1_branch_name=$b
        b="\${__git_ps1_branch_name}"
    fi

    local f="$w$i$s$u"
    local gitstring="$c$b${f:+$z$f}$r$p"

    if [ $pcmode = yes ]; then
        if [ "${__git_printf_supports_v-}" != yes ]; then
            gitstring=$(printf -- "$printf_format" "$gitstring")
        else
            printf -v gitstring -- "$printf_format" "$gitstring"
        fi
        PS1="$ps1pc_start$gitstring$ps1pc_end"
    else
        printf -- "$printf_format" "$gitstring"
    fi

    return $exit
}
1

The problem is that you have your own git-sh-prompt file with all the fancy icons that you're using, but then you are explicitly sourcing /usr/lib/git-core/git-sh-prompt both in your ~/.bashrc and in the .bashprompt. Then, your icons will only appear when you have certain variables set, so you need to set those too. I managed to get this to work with the following:

  1. ~/.bashrc:

    You don't need to source . $HOME/git-sh-prompt here, you source it inside the .bash_prompt script anyway. So all you need is:

    . "$HOME"/.bashprompt/.bash_prompt
    
  2. ~/git-sh-prompt

    Exactly as you have it in your question, although you can remove the shebang line, it is not relevant here.

  3. ~/.bashprompt/.bash_prompt

    The important change is here, in the final if block. You were checking if /usr/lib/git-core/git-sh-prompt existed, and if it did, you were sourcing it. However, since that file does exist and has its own definition of the __git_ps1 function, that was overriding your own fancy one with the icons. So you were reading the system-wide git-sh-prompt instead of yours.

    I also removed the shebang line (#!/bin/sh) since that's not needed in sourced files and you're not using sh anyway.

     # store colors
     MAGENTA="\[\033[0;35m\]"
     YELLOW="\[\033[038;5;154m\]"
     BLUE="\[\033[038;5;33m\]"
     LIGHT_GRAY="\[\033[0;37m\]"
     CYAN="\[\033[038;5;51m\]"
     GREEN="\[\033[00;32m\]"
     RED="\[\033[38;5;160m\]"
     VIOLET="\[\033[01;35m\]"
     GREY="\[\033[038;5;234m\]"
     BROWN="\[\033[038;5;130m\]"
     ORANGE="\[\033[038;5;208m\]"
    
     #Build PS1
     function color_my_prompt {
       local __braceL="$BLUE["
       local __braceR="$BLUE]"
       local __cur_location="\W"
       local __location="\w"
       local __git_branch=
       local __prompt_tail="$BLUE➜"
       local __user_input_color="$LIGHT_GRAY"
       local __user="$BLUE[$YELLOW \u@\h $BLUE]"
       local __dollar="$YELLOW$"
       local _ip_add="$BLUE[$YELLOW $(ip addr | grep -w inet | gawk '{if (NR==2) {$0=$2; gsub(/\//," "); print $1;}}')$BLUE ]"
       local __returnLine="\n \n"
    
       # $BLUE\n$BLUE └─ "
      # colour branch name depending on state
       # if repository is dirty
    
      # local __filesCheck="$(/bin/ls -m | /usr/bin/wc -l | /bin/sed 's: ::g')"
     #  local __minusNo="1"
     # local __filesCalc="$(($__filesCheck-$__minusNo))"
      # local __filesReal="$__braceL $RED\$__filesCheck files $__braceR"
    
     #  if [ "$(git rev-parse --is-inside-work-tree 2>/dev/null)" = "true" ]; then
     #    __git_branch=$(git symbolic-ref --quiet --short HEAD || git rev-parse --short HEAD)
       #  fi
       if [[ "$(__git_ps1 "%s")" =~ "*" ]]; then     # if repository is dirty
           __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
           files="$__filesReal"
           __git_branch_color="$BROWN"
       elif [[ "$(__git_ps1 "%s")" =~ "+" ]]; then   # if there are staged files
           __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
           files="$__filesReal"
           __git_branch_color="$CYAN"
       elif [[ "$(__git_ps1 "%s")" =~ "Ŧ" ]]; then   # if there are only untracked files
           __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
           files="$__filesReal"
           __git_branch_color="$RED"
       elif [[ "$(__git_ps1 "%s")" =~ "Š" ]]; then   # if there is something stashed
           __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
           files="$__filesReal"
           __git_branch_color="$GREEN"
       elif [[ "$(__git_ps1 "%s")" =~ "↩" ]]; then   # if behind
           __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
           files="$__filesReal"
           __git_branch_color="$ORANGE"
       elif [[ "$(__git_ps1 "%s")" =~ "↪" ]]; then   # if there are commiting files
           __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
             files="$__filesReal"
           __git_branch_color="$MAGENTA"
       elif [[ "$(__git_ps1 "%s")" =~ "✔" ]]; then   # if it is equal to repo
           __git_branch="$__braceL $__git_branch_color$(__git_ps1 "%s") $__braceR"
           files="$__filesReal"
           __git_branch_color="$YELLOW"
       fi
       # Compile the PS1
    
      PS1="\n $__user $_ip_add $__braceL $YELLOW$__cur_location $__braceR $__git_branch$__git_branch_color $__returnLine $__prompt_tail $__user_input_color "
     #export PS1="${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u:\[\033[01;34m\]\w\[\033[00m\]\$(__git_ps1)\[\033[00m\] $ "
     }
     # configure PROMPT_COMMAND which is executed each time before PS1
    
     # if .git-prompt.sh exists, set options and execute it
     if [ -f $HOME/git-sh-prompt ]; then
       GIT_PS1_SHOWDIRTYSTATE=true
       GIT_PS1_SHOWSTASHSTATE=true
       GIT_PS1_SHOWUNTRACKEDFILES=true
       GIT_PS1_SHOWUPSTREAM="auto"
       GIT_PS1_HIDE_IF_PWD_IGNORED=true
       GIT_PS1_SHOWCOLORHINTS=true
       GIT_PROMPT_SHOW_UNTRACKED_FILES=normal # can be no, normal or all; determines counting of untracked files
       . $HOME/git-sh-prompt
     fi
    
    
     export PROMPT_COMMAND=color_my_prompt
    
| improve this answer | |
  • working thank you for all your help and step by step guidance. Your very kind and patient – alwayslearning Jun 19 at 20:17

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.