liquidprompt

################################################################################
# LIQUID PROMPT
# An intelligent and non-intrusive prompt for Bash and zsh
################################################################################

# Licensed under the AGPL version 3
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# See the README.md file for a summary of features.

# Issue #161: do not load if not an interactive shell
# Do not exit if '--no-activate' flag was passed, as it overrides this check
[ "x${-##*i}" = "x$-" ] || [ -z "${TERM-}" ] || [ "x${TERM-}" = xdumb ] && [ "x${1-}" != "x--no-activate" ] && return

if test -n "${BASH_VERSION-}"; then
    # Check for recent enough version of bash.
    if (( ${BASH_VERSINFO[0]:-0} < 3 || ( ${BASH_VERSINFO[0]:-0} == 3 && ${BASH_VERSINFO[1]:-0} < 2 ) )); then
        echo "liquidprompt: Bash version $BASH_VERSION not supported" 2>&1
        return
    fi

    _LP_SHELL_bash=1
    _LP_SHELL_zsh=0
    _LP_OPEN_ESC="\["
    _LP_CLOSE_ESC="\]"

    _LP_MARK_SYMBOL='$'

    _LP_FIRST_INDEX=0
    _LP_PERCENT='%'    # must be escaped on zsh

    # Sed expression using extended regexp to match terminal
    # escape sequences with their wrappers
    _LP_CLEAN_ESC='\\\[([^\]+|\\[^]])*\\\]'

    # Escape the given strings
    # Must be used for all strings injected in PS1 that may comes from remote sources,
    # like $PWD, VCS branch names...
    __lp_escape() {
        ret="${1//\\/\\\\}"
        if shopt -q promptvars ; then
            ret="${ret//\$/\\\$}"
            ret="${ret//\`/\\\`}"
        fi
    }
elif test -n "${ZSH_VERSION-}" ; then
    # Check for recent enough version of zsh.
    if (( ${ZSH_VERSION:0:1} < 5 )); then
        echo "liquidprompt: Zsh version $ZSH_VERSION not supported" 2>&1
        return
    fi

    _LP_SHELL_bash=0
    _LP_SHELL_zsh=1
    _LP_OPEN_ESC="%{"
    _LP_CLOSE_ESC="%}"

    _LP_MARK_SYMBOL='%%'

    _LP_FIRST_INDEX=1
    _LP_PERCENT='%%'

    _LP_CLEAN_ESC='%\{([^%]+|%[^}])*%\}'

    __lp_escape() {
        ret="${1//\\/\\\\}"
        ret="${ret//\%/%%}"
        if [[ -o promptbang ]]; then
            ret="${ret//!/!!}"
        fi
        if [[ -o promptsubst ]]; then
            ret="${ret//\$/\\\$}"
            ret="${ret//\`/\\\`}"
        fi
    }
else
    echo "liquidprompt: shell not supported" >&2
    return
fi

###############
# OS specific #
###############

# LP_OS detection, default to Linux
case "$(uname)" in
    FreeBSD)   LP_OS=FreeBSD ;;
    DragonFly) LP_OS=FreeBSD ;;
    OpenBSD)   LP_OS=OpenBSD ;;
    Darwin)    LP_OS=Darwin  ;;
    SunOS)     LP_OS=SunOS   ;;
    *)         LP_OS=Linux   ;;
esac

# Extended regexp patterns for sed
# GNU/BSD sed
_LP_SED_EXTENDED=r
[[ "$LP_OS" = Darwin ]] && _LP_SED_EXTENDED=E

#################
# CONFIGURATION #
#################

# Load the user configuration and setup defaults.
__lp_source_config() {

    local lp_terminal_format af_color= ab_color=

    # Colors: variables are local so they will have a value only
    # during config loading and will not conflict with other values
    # with the same names defined by the user outside the config.
    local BOLD="${_LP_OPEN_ESC}${_LP_TI_BOLD-}${_LP_CLOSE_ESC}"

    # Foreground colors
    __lp_foreground_color 0
    local BLACK="${_LP_OPEN_ESC}${af_color}${_LP_CLOSE_ESC}"
    local BOLD_GRAY="${_LP_OPEN_ESC}${_LP_TI_BOLD-}${af_color}${_LP_CLOSE_ESC}"

    __lp_foreground_color 1
    local RED="${_LP_OPEN_ESC}${af_color}${_LP_CLOSE_ESC}"
    local BOLD_RED="${_LP_OPEN_ESC}${_LP_TI_BOLD-}${af_color}${_LP_CLOSE_ESC}"
    __lp_foreground_color 0
    __lp_background_color 1
    local WARN_RED="${_LP_OPEN_ESC}${af_color}${ab_color}${_LP_CLOSE_ESC}"
    __lp_foreground_color 7
    local CRIT_RED="${_LP_OPEN_ESC}${_LP_TI_BOLD-}${af_color}${ab_color}${_LP_CLOSE_ESC}"
    __lp_foreground_color 3
    local DANGER_RED="${_LP_OPEN_ESC}${_LP_TI_BOLD-}${af_color}${ab_color}${_LP_CLOSE_ESC}"

    __lp_foreground_color 2
    local GREEN="${_LP_OPEN_ESC}${af_color}${_LP_CLOSE_ESC}"
    local BOLD_GREEN="${_LP_OPEN_ESC}${_LP_TI_BOLD-}${af_color}${_LP_CLOSE_ESC}"

    __lp_foreground_color 3
    local YELLOW="${_LP_OPEN_ESC}${af_color}${_LP_CLOSE_ESC}"
    local BOLD_YELLOW="${_LP_OPEN_ESC}${_LP_TI_BOLD-}${af_color}${_LP_CLOSE_ESC}"

    __lp_foreground_color 4
    local BLUE="${_LP_OPEN_ESC}${af_color}${_LP_CLOSE_ESC}"
    local BOLD_BLUE="${_LP_OPEN_ESC}${_LP_TI_BOLD-}${af_color}${_LP_CLOSE_ESC}"

    __lp_foreground_color 5
    local PURPLE="${_LP_OPEN_ESC}${af_color}${_LP_CLOSE_ESC}"
    local MAGENTA="${PURPLE}"
    local PINK="${_LP_OPEN_ESC}${_LP_TI_BOLD-}${af_color}${_LP_CLOSE_ESC}"
    local BOLD_PURPLE="${PINK}"
    local BOLD_MAGENTA="${PINK}"

    __lp_foreground_color 6
    local CYAN="${_LP_OPEN_ESC}${af_color}${_LP_CLOSE_ESC}"
    local BOLD_CYAN="${_LP_OPEN_ESC}${_LP_TI_BOLD-}${af_color}${_LP_CLOSE_ESC}"

    __lp_foreground_color 7
    local WHITE="${_LP_OPEN_ESC}${af_color}${_LP_CLOSE_ESC}"
    local BOLD_WHITE="${_LP_OPEN_ESC}${_LP_TI_BOLD-}${af_color}${_LP_CLOSE_ESC}"

    # NO_COL is special: it will be used at runtime, not just during config loading
    NO_COL="${_LP_OPEN_ESC}${_LP_TI_RESET-}${_LP_CLOSE_ESC}"

    # compute the hash of the hostname and get the corresponding number in
    # [1-6] (red,green,yellow,blue,purple or cyan)
    local lp_hostname_hash
    __lp_hostname_hash
    __lp_foreground_color "$(( 1 + lp_hostname_hash % 6 ))"
    LP_COLOR_HOST_HASH="${_LP_OPEN_ESC}${af_color}${_LP_CLOSE_ESC}"


    # Default values (globals)
    LP_TIME_FORMAT=${LP_TIME_FORMAT:-"%H:%M:%S"}
    LP_BATTERY_THRESHOLD=${LP_BATTERY_THRESHOLD:-75}
    LP_LOAD_THRESHOLD=${LP_LOAD_THRESHOLD:-0.60}
    LP_LOAD_CAP=${LP_LOAD_CAP:-2.0}
    LP_TEMP_THRESHOLD=${LP_TEMP_THRESHOLD:-60}
    LP_RUNTIME_THRESHOLD=${LP_RUNTIME_THRESHOLD:-2}
    LP_RUNTIME_BELL_THRESHOLD=${LP_RUNTIME_BELL_THRESHOLD:-10}
    LP_PATH_LENGTH=${LP_PATH_LENGTH:-35}
    LP_PATH_KEEP=${LP_PATH_KEEP:-2}
    LP_PATH_CHARACTER_KEEP=${LP_PATH_CHARACTER_KEEP:-3}
    LP_PATH_METHOD=${LP_PATH_METHOD:-truncate_chars_from_path_left}
    LP_PATH_VCS_ROOT=${LP_PATH_VCS_ROOT:-1}
    LP_HOSTNAME_ALWAYS=${LP_HOSTNAME_ALWAYS:-0}
    LP_USER_ALWAYS=${LP_USER_ALWAYS:-1}
    LP_PERCENTS_ALWAYS=${LP_PERCENTS_ALWAYS:-1}
    LP_PS1=${LP_PS1:-""}
    LP_PS1_PREFIX=${LP_PS1_PREFIX:-""}
    LP_PS1_POSTFIX=${LP_PS1_POSTFIX:-""}
    LP_MARK_KUBECONTEXT=${LP_MARK_KUBECONTEXT:-"⎈"}
    LP_DELIMITER_KUBECONTEXT_SUFFIX=${LP_DELIMITER_KUBECONTEXT_SUFFIX:-""}
    LP_DELIMITER_KUBECONTEXT_PREFIX=${LP_DELIMITER_KUBECONTEXT_PREFIX:-""}

    LP_ENABLE_PERM=${LP_ENABLE_PERM:-1}
    LP_ENABLE_SHORTEN_PATH=${LP_ENABLE_SHORTEN_PATH:-1}
    LP_ENABLE_PROXY=${LP_ENABLE_PROXY:-1}
    LP_ENABLE_TEMP=${LP_ENABLE_TEMP:-1}
    LP_ENABLE_JOBS=${LP_ENABLE_JOBS:-1}
    LP_ENABLE_DETACHED_SESSIONS=${LP_ENABLE_DETACHED_SESSIONS:-1}
    LP_ENABLE_LOAD=${LP_ENABLE_LOAD:-1}
    LP_ENABLE_BATT=${LP_ENABLE_BATT:-1}
    LP_ENABLE_GIT=${LP_ENABLE_GIT:-1}
    LP_ENABLE_SVN=${LP_ENABLE_SVN:-1}
    LP_ENABLE_FOSSIL=${LP_ENABLE_FOSSIL:-1}
    LP_ENABLE_HG=${LP_ENABLE_HG:-1}
    LP_ENABLE_BZR=${LP_ENABLE_BZR:-1}
    LP_ENABLE_TIME=${LP_ENABLE_TIME:-0}
    LP_TIME_ANALOG=${LP_TIME_ANALOG:-0}
    LP_ENABLE_RUNTIME=${LP_ENABLE_RUNTIME:-1}
    LP_ENABLE_RUNTIME_BELL=${LP_ENABLE_RUNTIME_BELL:-0}
    LP_ENABLE_VIRTUALENV=${LP_ENABLE_VIRTUALENV:-1}
    LP_ENABLE_RUBY_VENV=${LP_ENABLE_RUBY_VENV:-1}
    LP_RUBY_RVM_PROMPT_OPTIONS=( ${LP_RUBY_RVM_PROMPT_OPTIONS[@]+"${LP_RUBY_RVM_PROMPT_OPTIONS[@]}"} )
    [[ ${#LP_RUBY_RVM_PROMPT_OPTIONS[@]} == 0 ]] && LP_RUBY_RVM_PROMPT_OPTIONS=(i v g s)
    LP_ENABLE_TERRAFORM=${LP_ENABLE_TERRAFORM:-0}
    LP_ENABLE_SCLS=${LP_ENABLE_SCLS:-1}
    LP_ENABLE_AWS_PROFILE=${LP_ENABLE_AWS_PROFILE:-1}
    LP_ENABLE_VCS_ROOT=${LP_ENABLE_VCS_ROOT:-0}
    LP_ENABLE_TITLE=${LP_ENABLE_TITLE:-0}
    LP_ENABLE_SCREEN_TITLE=${LP_ENABLE_SCREEN_TITLE:-0}
    LP_ENABLE_TITLE_COMMAND=${LP_ENABLE_TITLE_COMMAND:-1}
    LP_ENABLE_SSH_COLORS=${LP_ENABLE_SSH_COLORS:-0}
    LP_ENABLE_FQDN=${LP_ENABLE_FQDN:-0}
    LP_DISABLED_VCS_PATHS=( ${LP_DISABLED_VCS_PATHS[@]+"${LP_DISABLED_VCS_PATHS[@]}"} )
    LP_ENABLE_SUDO=${LP_ENABLE_SUDO:-0}
    LP_ENABLE_COLOR=${LP_ENABLE_COLOR:-1}
    LP_ENABLE_ERROR=${LP_ENABLE_ERROR:-1}
    LP_ENABLE_DIRSTACK=${LP_ENABLE_DIRSTACK:-0}
    LP_ENABLE_KUBECONTEXT=${LP_ENABLE_KUBECONTEXT:-0}

    LP_MARK_DEFAULT="${LP_MARK_DEFAULT:-$_LP_MARK_SYMBOL}"
    LP_MARK_BATTERY="${LP_MARK_BATTERY:-"⌁"}"
    LP_MARK_ADAPTER="${LP_MARK_ADAPTER:-"⏚"}"
    LP_MARK_LOAD="${LP_MARK_LOAD:-"⌂"}"
    LP_MARK_TEMP="${LP_MARK_TEMP:-"θ"}"
    LP_MARK_PROXY="${LP_MARK_PROXY:-"↥"}"
    LP_MARK_HG="${LP_MARK_HG:-"☿"}"
    LP_MARK_SVN="${LP_MARK_SVN:-"‡"}"
    LP_MARK_GIT="${LP_MARK_GIT:-"±"}"
    LP_MARK_VCSH="${LP_MARK_VCSH:-"|"}"
    LP_MARK_FOSSIL="${LP_MARK_FOSSIL:-"⌘"}"
    LP_MARK_BZR="${LP_MARK_BZR:-"⚯"}"
    LP_MARK_DISABLED="${LP_MARK_DISABLED:-"⌀"}"
    LP_MARK_UNTRACKED="${LP_MARK_UNTRACKED:-"*"}"
    LP_MARK_STASH="${LP_MARK_STASH:-"+"}"
    LP_MARK_BRACKET_OPEN="${LP_MARK_BRACKET_OPEN:-"["}"
    LP_MARK_BRACKET_CLOSE="${LP_MARK_BRACKET_CLOSE:-"]"}"
    LP_MARK_SHORTEN_PATH="${LP_MARK_SHORTEN_PATH:-" … "}"
    LP_MARK_PREFIX="${LP_MARK_PREFIX:-" "}"
    LP_MARK_PERM="${LP_MARK_PERM:-":"}"
    LP_MARK_DIRSTACK="${LP_MARK_DIRSTACK:-"⚞"}"

    LP_COLOR_PATH=${LP_COLOR_PATH:-$NO_COL}
    lp_terminal_format 8 -1 0 0 -1
    LP_COLOR_PATH_SEPARATOR=${LP_COLOR_PATH_SEPARATOR:-$lp_terminal_format}
    LP_COLOR_PATH_SHORTENED=${LP_COLOR_PATH_SHORTENED:-$lp_terminal_format}
    lp_terminal_format -1 -1 1 0
    LP_COLOR_PATH_VCS_ROOT=${LP_COLOR_PATH_VCS_ROOT:-$lp_terminal_format}
    LP_COLOR_PATH_LAST_DIR=${LP_COLOR_PATH_LAST_DIR:-$lp_terminal_format}
    LP_COLOR_PATH_ROOT=${LP_COLOR_PATH_ROOT:-$BOLD_YELLOW}
    LP_COLOR_PROXY=${LP_COLOR_PROXY:-$BOLD_BLUE}
    LP_COLOR_JOB_D=${LP_COLOR_JOB_D:-$YELLOW}
    LP_COLOR_JOB_R=${LP_COLOR_JOB_R:-$BOLD_YELLOW}
    LP_COLOR_JOB_Z=${LP_COLOR_JOB_Z:-$BOLD_YELLOW}
    LP_COLOR_ERR=${LP_COLOR_ERR:-$PURPLE}
    LP_COLOR_MARK=${LP_COLOR_MARK:-$BOLD}
    LP_COLOR_MARK_ROOT=${LP_COLOR_MARK_ROOT:-$BOLD_RED}
    LP_COLOR_MARK_SUDO=${LP_COLOR_MARK_SUDO:-$LP_COLOR_MARK_ROOT}
    LP_COLOR_USER_LOGGED=${LP_COLOR_USER_LOGGED:-""}
    LP_COLOR_USER_ALT=${LP_COLOR_USER_ALT:-$BOLD}
    LP_COLOR_USER_ROOT=${LP_COLOR_USER_ROOT:-$BOLD_YELLOW}
    LP_COLOR_HOST=${LP_COLOR_HOST:-""}
    LP_COLOR_SSH=${LP_COLOR_SSH:-$BLUE}
    LP_COLOR_SU=${LP_COLOR_SU:-$BOLD_YELLOW}
    LP_COLOR_TELNET=${LP_COLOR_TELNET:-$WARN_RED}
    LP_COLOR_X11_ON=${LP_COLOR_X11_ON:-$GREEN}
    LP_COLOR_X11_OFF=${LP_COLOR_X11_OFF:-$YELLOW}
    LP_COLOR_WRITE=${LP_COLOR_WRITE:-$GREEN}
    LP_COLOR_NOWRITE=${LP_COLOR_NOWRITE:-$RED}
    LP_COLOR_UP=${LP_COLOR_UP:-$GREEN}
    LP_COLOR_COMMITS=${LP_COLOR_COMMITS:-$YELLOW}
    LP_COLOR_COMMITS_BEHIND=${LP_COLOR_COMMITS_BEHIND:-$BOLD_RED}
    LP_COLOR_CHANGES=${LP_COLOR_CHANGES:-$RED}
    LP_COLOR_DIFF=${LP_COLOR_DIFF:-$PURPLE}
    LP_COLOR_CHARGING_ABOVE=${LP_COLOR_CHARGING_ABOVE:-$GREEN}
    LP_COLOR_CHARGING_UNDER=${LP_COLOR_CHARGING_UNDER:-$YELLOW}
    LP_COLOR_DISCHARGING_ABOVE=${LP_COLOR_DISCHARGING_ABOVE:-$YELLOW}
    LP_COLOR_DISCHARGING_UNDER=${LP_COLOR_DISCHARGING_UNDER:-$RED}
    LP_COLOR_TIME=${LP_COLOR_TIME:-$BLUE}
    LP_COLOR_IN_MULTIPLEXER=${LP_COLOR_IN_MULTIPLEXER:-$BOLD_BLUE}
    LP_COLOR_RUNTIME=${LP_COLOR_RUNTIME:-$YELLOW}
    LP_COLOR_VIRTUALENV=${LP_COLOR_VIRTUALENV:-$CYAN}
    LP_COLOR_TERRAFORM=${LP_COLOR_TERRAFORM:-$PINK}
    LP_COLOR_DIRSTACK=${LP_COLOR_DIRSTACK:-$BOLD_YELLOW}
    LP_COLOR_KUBECONTEXT=${LP_COLOR_KUBECONTEXT:-$CYAN}
    LP_COLOR_AWS_PROFILE=${LP_COLOR_AWS_PROFILE:-$YELLOW}

    LP_COLORMAP=( ${LP_COLORMAP[@]+"${LP_COLORMAP[@]}"} )
    if [[ ${#LP_COLORMAP[@]} == 0 ]]; then
        LP_COLORMAP=(
            ""               # 0
            "$GREEN"         # 1
            "$BOLD_GREEN"    # 2
            "$YELLOW"        # 3
            "$BOLD_YELLOW"   # 4
            "$RED"           # 5
            "$BOLD_RED"      # 6
            "$WARN_RED"      # 7
            "$CRIT_RED"      # 8
            "$DANGER_RED"    # 9
        )
    fi

    # Debugging flags
    LP_DEBUG_TIME=${LP_DEBUG_TIME:-0}

    if [[ ${1-} == --no-config ]]; then
        return
    fi

    # Default config file may be the XDG standard ~/.config/liquidpromptrc,
    # but heirloom dotfile has priority.
    local -a configfiles
    configfiles=("$HOME/.liquidpromptrc" "${XDG_CONFIG_HOME:-"$HOME/.config"}/liquidpromptrc")

    # trailing ":" is so that ${search#*:} always removes something
    local configfile search="${XDG_CONFIG_DIRS:-/etc/xdg}:"
    while [[ -n "$search" ]]; do
        configfiles+=("${search%%:*}/liquidpromptrc")
        search="${search#*:}"
    done

    configfiles+=("/etc/liquidpromptrc")

    for configfile in "${configfiles[@]}"; do
        if [[ -f "$configfile" ]]; then
            source "$configfile"
            break
        fi
    done

    # Deprecations and compatibility shims

    if [[ -n "${LP_DISABLED_VCS_PATH-}" ]]; then
        echo "liquidprompt: LP_DISABLED_VCS_PATH is deprecated. Update your config to use LP_DISABLED_VCS_PATHS array." >&2

        (( _LP_SHELL_zsh )) && setopt local_options && setopt sh_word_split
        local _path IFS=:
        for _path in $LP_DISABLED_VCS_PATH; do
            LP_DISABLED_VCS_PATHS+=("$_path")
        done
    fi

    # Delete this code in version 1.11
    if [[ -n "${LP_COLORMAP_1-}" ]]; then
        echo "liquidprompt: LP_COLORMAP_x variables are deprecated. Update your theme to use LP_COLORMAP array." >&2
        LP_COLORMAP=(
            "$LP_COLORMAP_0"
            "$LP_COLORMAP_1"
            "$LP_COLORMAP_2"
            "$LP_COLORMAP_3"
            "$LP_COLORMAP_4"
            "$LP_COLORMAP_5"
            "$LP_COLORMAP_6"
            "$LP_COLORMAP_7"
            "$LP_COLORMAP_8"
            "$LP_COLORMAP_9"
        )
        unset LP_COLORMAP_0 LP_COLORMAP_1 LP_COLORMAP_2 LP_COLORMAP_3 LP_COLORMAP_4 \
              LP_COLORMAP_5 LP_COLORMAP_6 LP_COLORMAP_7 LP_COLORMAP_8 LP_COLORMAP_9
    fi

    if [[ -n ${LP_PATH_DEFAULT-} ]]; then
        echo "liquidprompt: LP_PATH_DEFAULT is deprecated. Update your config to set LP_PATH_METHOD." >&2
        if (( ! LP_ENABLE_SHORTEN_PATH )); then
            # There is just no elegant way to handle this. Fallback to the old way with basic formatting support.
            _lp_path_format() {
                lp_path=$LP_PATH_DEFAULT
                lp_path_format="${LP_COLOR_PATH}${lp_path}${NO_COL}"
            }
        fi
    fi

    if [[ -n ${PROMPT_DIRTRIM-} ]] && (( ! LP_ENABLE_SHORTEN_PATH )); then
        echo "liquidprompt: PROMPT_DIRTRIM support is deprecated. Update your config to set
            LP_PATH_METHOD='truncate_chars_from_path_left' instead." >&2
        # This does mostly the same thing, but with our formatting.
        LP_ENABLE_SHORTEN_PATH=1
        LP_PATH_METHOD="truncate_chars_from_path_left"
        LP_PATH_KEEP=1
    fi

    if [[ $LP_PATH_KEEP == "-1" ]]; then
        echo "liquidprompt: LP_PATH_KEEP set to '-1' is deprecated. Update your config to set
              LP_PATH_METHOD='truncate_to_last_dir' instead." >&2
        LP_PATH_METHOD="truncate_to_last_dir"
    fi
}

# Initialize features based on the user config.
lp_activate() {
    if (( _LP_SHELL_bash )); then
        complete -F __lp_theme_bash_complete lp_theme
    else # zsh
        # For ZSH, autoload required functions
        autoload -Uz add-zsh-hook

        # Enable the autocomplete if the autocomplete system is initialized.
        __lp_is_function compdef && compdef __lp_theme_zsh_complete lp_theme
    fi

    # Disable hooks that we don't need if features will be disabled.
    __lp_disable_hooks

    # TermInfo feature detection
    _lp_af_colors=() _lp_ab_colors=()

    __lp_foreground_color() { return 2 ; }
    __lp_background_color() { return 2 ; }

    # TODO handle this case better. With no colors, no need for any escaping
    if ! command -v tput >/dev/null; then
        echo "liquidprompt: 'tput' not available; will not be able to format terminal" >&2
        LP_ENABLE_COLOR=0
    else
        _LP_TI_RESET="$( { tput sgr0 || tput me ; } 2>/dev/null )"
        _LP_TI_BOLD="$( { tput bold || tput md ; } 2>/dev/null )"
        _LP_TI_UNDERLINE="$( { tput smul || tput us ; } 2>/dev/null )"
        _LP_TI_COLORS="$( tput colors 2>/dev/null )"
        _LP_TI_COLORS=${_LP_TI_COLORS:-8}

        _LP_TI_BELL="$( { tput bel || tput bl ; } 2>/dev/null )"

        if tput setaf 0 >/dev/null 2>&1; then
            __lp_foreground_color() { af_color="${_lp_af_colors[$1+1]:=$(tput setaf "$1")}"; }
        elif tput AF 0 >/dev/null 2>&1; then
            # FreeBSD
            __lp_foreground_color() { af_color="${_lp_af_colors[$1+1]:=$(tput AF "$1")}"; }
        elif tput AF 0 0 0 >/dev/null 2>&1; then
            # OpenBSD
            __lp_foreground_color() { af_color="${_lp_af_colors[$1+1]:=$(tput AF "$1" 0 0)}"; }
        else
            echo "liquidprompt: terminal '${TERM-}' does not support foreground colors" >&2
        fi
        if tput setab 0 >/dev/null 2>&1; then
            __lp_background_color() { ab_color="${_lp_ab_colors[$1+1]:=$(tput setab "$1")}"; }
        elif tput AB 0 >/dev/null 2>&1; then
            # FreeBSD
            __lp_background_color() { ab_color="${_lp_ab_colors[$1+1]:=$(tput AB "$1")}"; }
        elif tput AB 0 0 0 >/dev/null 2>&1; then
            # OpenBSD
            __lp_background_color() { ab_color="${_lp_ab_colors[$1+1]:=$(tput AB "$1" 0 0)}"; }
        else
            echo "liquidprompt: terminal '${TERM-}' does not support background colors" >&2
        fi
    fi

    # If tput doesn't exist or lookup failed, still try to send bell
    _LP_TI_BELL=${_LP_TI_BELL:-$'\a'}

    __lp_source_config "$@"

    # Disable feature if the tool is not installed
    _lp_require_tool()
    {
        (( LP_ENABLE_$1 )) && { command -v "$2" >/dev/null || eval LP_ENABLE_$1=0 ; }
    }

    _lp_require_tool GIT git
    _lp_require_tool SVN svn
    _lp_require_tool FOSSIL fossil
    _lp_require_tool HG hg
    _lp_require_tool BZR bzr

    _LP_ENABLED_VCSS=()
    (( LP_ENABLE_GIT )) && _LP_ENABLED_VCSS+=(git)
    (( LP_ENABLE_SVN )) && _LP_ENABLED_VCSS+=(svn)
    (( LP_ENABLE_HG )) && _LP_ENABLED_VCSS+=(hg)
    (( LP_ENABLE_BZR )) && _LP_ENABLED_VCSS+=(bzr)

    if [[ "$LP_OS" = Darwin ]]; then
        _lp_require_tool BATT pmset
    else
        _lp_require_tool BATT acpi
    fi

    _lp_require_tool KUBECONTEXT kubectl
    _lp_require_tool TERRAFORM terraform

    unset -f _lp_require_tool

    # LP_ENABLE_RUBY_VENV depends either from rvm or rbenv. Thus we cannot
    # directly use _lp_require_tool for it.
    # Also, to avoid to check twice which is the current ruby virtual env
    # program in use, we set here an internal variable holding its name if we
    # detect one of them.
    if (( LP_ENABLE_RUBY_VENV )) ; then
        if command -v rvm-prompt >/dev/null ; then
            _LP_RUBY_VENV_PROGRAM=rvm
        elif command -v rbenv >/dev/null ; then
            _LP_RUBY_VENV_PROGRAM=rbenv
        else
            LP_ENABLE_RUBY_VENV=0
        fi
    fi

    if (( LP_ENABLE_DETACHED_SESSIONS )); then
        command -v screen >/dev/null ; _LP_ENABLE_SCREEN=$(( ! $? ))
        command -v tmux >/dev/null   ; _LP_ENABLE_TMUX=$(( ! $? ))
    fi

    # Use standard path symbols inside Midnight Commander
    [[ -n "${MC_SID-}" ]] && LP_ENABLE_SHORTEN_PATH=0

    # If we are running in a terminal multiplexer, special title escapes
    if _lp_multiplexer; then
        (( LP_ENABLE_TITLE = LP_ENABLE_TITLE && LP_ENABLE_SCREEN_TITLE ))
        LP_TITLE_OPEN=$'\Ek'
        LP_TITLE_CLOSE=$'\E\\'
    else
        LP_TITLE_OPEN=$'\E]0;'
        LP_TITLE_CLOSE=$'\a'
    fi

    [[ "_${TERM-}" == _linux* ]] && LP_ENABLE_TITLE=0

    # Can not show title command if the title feature is disabled.
    (( LP_ENABLE_TITLE )) || LP_ENABLE_TITLE_COMMAND=0

    # update_terminal_cwd is a shell function available on MacOS X Lion that
    # will update an icon of the directory displayed in the title of the terminal
    # window.
    # See http://hints.macworld.com/article.php?story=20110722211753852
    if [[ "${TERM_PROGRAM-}" == Apple_Terminal ]] && command -v update_terminal_cwd >/dev/null; then
        _LP_TERM_UPDATE_DIR=update_terminal_cwd
        # Remove "update_terminal_cwd; " that has been add by Apple in /et/bashrc.
        # See issue #196
        PROMPT_COMMAND="${PROMPT_COMMAND//update_terminal_cwd; /}"
    else
        _LP_TERM_UPDATE_DIR=:
    fi

    ###############
    # Who are we? #
    ###############

    _lp_user
    local -i user="$?"

    if (( user < 2 )); then  # if user is not root
        # "sudo -n" is only supported from sudo 1.7.0
        if (( LP_ENABLE_SUDO )); then
            command -v sudo >/dev/null \
            && LC_MESSAGES=C sudo -V | GREP_OPTIONS= \grep -qE '^Sudo version (1(\.([789]\.|[1-9][0-9])|[0-9])|[2-9])' \
            || LP_ENABLE_SUDO=0
        fi

        if (( user == 1 )); then
            LP_COLOR_USER=$LP_COLOR_USER_ALT
        else
            LP_COLOR_USER=$LP_COLOR_USER_LOGGED
        fi
    else # root!
        LP_ENABLE_SUDO=0
        if (( ! LP_ENABLE_VCS_ROOT )); then
            LP_DISABLED_VCS_PATHS=("/")
        fi

        LP_MARK_DEFAULT='#'

        LP_COLOR_MARK=$LP_COLOR_MARK_ROOT
        LP_COLOR_PATH=$LP_COLOR_PATH_ROOT
        LP_COLOR_USER=$LP_COLOR_USER_ROOT
    fi

    #################
    # Where are we? #
    #################

    if (( LP_ENABLE_TEMP )); then
        # Try each _lp_temp method
        # If no function worked, disable the feature
        __lp_temp_detect acpi sensors || LP_ENABLE_TEMP=0
    fi

    if (( LP_ENABLE_LOAD )); then
        # Find and save the number of CPUs
        __lp_cpu_count

        # Convert load config values into usable integers.
        local ret
        # if load threshold does not have a period in it.
        if [[ -z ${LP_LOAD_THRESHOLD//[!\.]} ]]; then
            # This is an old value, no need to convert
            _LP_LOAD_THRESHOLD=$LP_LOAD_THRESHOLD
        else
            __lp_floating_scale "$LP_LOAD_THRESHOLD" 100
            _LP_LOAD_THRESHOLD=$ret
        fi
        __lp_floating_scale "$LP_LOAD_CAP" 100
        _LP_LOAD_CAP=$ret
    fi

    if [[ -n ${_LP_THEME_ACTIVATE_FUNCTION-} ]]; then
        # Reactivate current theme
        "$_LP_THEME_ACTIVATE_FUNCTION"
        prompt_on
    else
        # Set default theme if no theme set
        lp_theme default
    fi
}

#####################
# Utility Functions #
#####################

# Remove all colors and escape characters of the given string and return a pure text
_lp_as_text() {
    # Remove all terminal sequences that we wrapped with $_LP_OPEN_ESC and
    # $_LP_CLOSE_ESC.
    printf '%s' "$1" | sed "-$_LP_SED_EXTENDED" "s,$_LP_CLEAN_ESC,,g"
}

# Store $2 (or $?) as a true/false value in variable named $1
# Deprecated since v2.0.
_lp_bool() {
    local res="${2:-$?}"
    if (( res )); then
        eval "$1=false"
    else
        eval "$1=true"
    fi
    return "$res"
}

_lp_color_map() {
    # Default scale: 0..100
    # Custom scale: 0..$2
    local -i scale value
    scale=${2:-100}
    if (( $1 >= scale )); then
      value=scale-1
    elif (( $1 < 0 )); then
      value=0
    else
      value=$1
    fi
    # Transform the value to a 0..${#COLOR_MAP} scale
    ret="${LP_COLORMAP[_LP_FIRST_INDEX+value*${#LP_COLORMAP[*]}/scale]}"
}

# Return true if the input is the name of a function.
__lp_is_function() {
    if (( _LP_SHELL_bash )); then
        [[ $(LC_ALL=C \type -t "$1") == function ]]
    else
        [[ $(LC_ALL=C \type -w "$1") == *function ]]
    fi
}

# Count the number of lines in the input string. A faster substitute for 'wc -l'.
__lp_line_count() {
  local var="${1//[!$'\n']}"
  count=${#var}
}

__lp_hostname_hash() {
    # cksum is separated with tab on SunOS, space on others
    local cksum="$(hostname | cksum)"
    lp_hostname_hash=${cksum%%[$' \t']*}
}

__lp_floating_scale() {
    local integer decimal=0 scale=$(( ${#2} - 1 ))
    integer=${1%\.*}

    if [[ -n ${1//[!\.]} ]]; then
        decimal=${1#*\.}
        decimal=${decimal:0:$scale}

        while (( ${#decimal} < scale )); do
            decimal+='0'
        done

        while [[ ${decimal:0:1} == '0' ]]; do
            decimal=${decimal:1}
        done
    fi

    ret=$(( integer * $2 + decimal ))
}

# Return $PWD with $HOME at the start replaced by "~".
__lp_pwd_tilde() {  # [path]
    # Needs to be in a variable, as different versions of Bash treat '~' in a
    # substitution differently
    local _path="${1:-$PWD}" tilde="~"
    lp_pwd_tilde="${_path/#$HOME/$tilde}"
}

# insert a space on the right
# Deprecated since v2.0.
_lp_sr() {
    [[ -n "$1" ]] && echo -nE "$1 "
}

# insert a space on the left
# Deprecated since v2.0.
_lp_sl() {
    [[ -n "$1" ]] && echo -nE " $1"
}

# insert two spaces, before and after
# Deprecated since v2.0.
_lp_sb() {
    [[ -n "$1" ]] && echo -nE " $1 "
}

# Generates a terminal escape sequence to format the terminal.
lp_terminal_format() {  # fg, bg, bold, underline, fallback_fg, fallback_bg
    lp_terminal_format=
    (( LP_ENABLE_COLOR )) || return 2

    local af_color ab_color fg bg previous_af_color
    fg=$1
    bg=${2:-"-1"}
    previous_af_color=${_lp_last_af_color-}

    lp_terminal_format=${_LP_OPEN_ESC}${_LP_TI_RESET}

    if (( $fg >= _LP_TI_COLORS )) && [[ -n ${5-} ]]; then
        _lp_last_af_color=$5
    elif (( $fg == -2 )); then
        :  # do nothing, _lp_last_af_color already correct
    elif (( $fg == -3 )); then
        _lp_last_af_color=$_lp_last_ab_color
    elif (( $fg >= 0 )); then
        _lp_last_af_color=$fg
    else  # -1
        _lp_last_af_color=-1
    fi

    if (( ${_lp_last_af_color:-"-1"} >= 0 )); then
        __lp_foreground_color "$_lp_last_af_color" && lp_terminal_format+=$af_color
    fi

    if (( $bg >= _LP_TI_COLORS )) && [[ -n ${6-} ]]; then
        _lp_last_ab_color=$6
    elif (( $bg == -2 )); then
        :  # do nothing, _lp_last_ab_color already correct
    elif (( $bg == -3 )); then
        _lp_last_ab_color=$previous_af_color
    elif (( $bg >= 0 )); then
        _lp_last_ab_color=$bg
    else  # -1
        _lp_last_ab_color=-1
    fi

    if (( ${_lp_last_ab_color:-"-1"} >= 0 )); then
        __lp_background_color "$_lp_last_ab_color" && lp_terminal_format+=$ab_color
    fi

    # It turns out there are sequences to reset bold and underline to normal
    # (\E[22m and \E[24m in xterm), but they aren't universally supported. This
    # means we must reset to all defaults then enable if they are wanted.
    # Explicit is safer anyway.
    if (( ${3:-0} )); then
        lp_terminal_format+=$_LP_TI_BOLD
    fi

    if (( ${4:-0} )); then
        lp_terminal_format+=$_LP_TI_UNDERLINE
    fi

    lp_terminal_format+=$_LP_CLOSE_ESC
}

# Get a list of themes currently loaded. Looks for functions matching
# _lp_<theme>_theme_prompt().
__lp_theme_list() {
    lp_theme_list=()

    local -a _functions
    if (( _LP_SHELL_zsh )); then
        _functions=( "${(ko)functions[@]}" )
    else
        local IFS=$'\n'
        _functions=( $(declare -F) )
    fi

    local function
    for function in "${_functions[@]}"; do
        if [[ $function == *_lp_*_theme_prompt ]]; then
            function=${function#*_lp_}
            lp_theme_list+=("${function%_theme_prompt}")
        fi
    done
}

__lp_theme_bash_complete() {
    COMPREPLY=()
    local -a lp_theme_list
    local theme partial_theme
    partial_theme=${2-}

    __lp_theme_list

    for theme in "${lp_theme_list[@]}"; do
        [[ -n $partial_theme && $theme != "$partial_theme"* ]] && continue
        COMPREPLY+=("$theme")
    done
}

__lp_theme_zsh_complete() {
    local -a lp_theme_list
    __lp_theme_list
    _describe 'theme' lp_theme_list
}

##########################
# Working Directory Path #
##########################

__lp_get_unique_directory() {
    local directory="${1##*/}" root="${1%/*}"
    local -a matching
    local -i i
    for (( i=1; i < ${#directory}; i++ )); do
        lp_unique_directory=${directory:0:$i}
        matching=("${root}/${lp_unique_directory}"*/)
        if (( ${#matching[@]} == 1 )); then
            return 0
        fi
    done

    return 1
}

__lp_end_path_left_shortening() {
    if (( is_shortening )); then
        shortened_path_length+=${#separator}
        if (( shortened_path_length < unshortened_path_length )); then
            lp_path_format+="${shortened_directory_format}${LP_MARK_SHORTEN_PATH}"
            # This indescriminate adding of a separator can sometimes mean the path
            # is slightly longer than it should be, but it is more clear.
            lp_path_format+="${separator_format}${separator}"
            lp_path+="${LP_MARK_SHORTEN_PATH}/"
        else
            lp_path+=$unshortened_path_shorten_string
            lp_path_format+=$unshortened_path_format_shorten_string
            shortened_path_length=$unshortened_path_length
        fi
        is_shortening=0
    fi
}

# methods:
#   truncate_chars_from_path_left
#   truncate_chars_from_dir_middle
#   truncate_chars_from_dir_right
#   truncate_chars_to_unique_dir
#   truncate_to_last_dir
_lp_path_format() {
    local path_format="${1-$LP_COLOR_PATH}"
    local last_directory_format="${2:-$path_format}"
    local vcs_root_format="${3:-$last_directory_format}"
    local shortened_directory_format="${4:-$path_format}"
    local separator="${5-"/"}"
    local separator_format="${6-}"

    lp_path=
    lp_path_format=

    local ret

    local lp_pwd_tilde
    __lp_pwd_tilde
    local display_path="$lp_pwd_tilde"

    local -i path_length="${#display_path}"

    local lp_vcs_root lp_vcs_type
    local vcs_root_directory=
    if (( LP_PATH_VCS_ROOT )) && _lp_find_vcs; then
        __lp_pwd_tilde "$lp_vcs_root"
        vcs_root_directory=$lp_pwd_tilde
    fi

    if [[ $path_length == 1 || $LP_PATH_METHOD == "truncate_to_last_dir" ]]; then
        if [[ $path_length > 1 ]]; then
            lp_path=${display_path##*/}
        else
            # only root or home to show
            lp_path=$display_path
        fi

        __lp_escape "$lp_path"

        if [[ $display_path == $vcs_root_directory ]]; then
            lp_path_format="${vcs_root_format}${ret}"
        else
            lp_path_format="${last_directory_format}${ret}"
        fi
        return
    else
        if [[ $separator != "/" && ${display_path:0:1} == "/" ]]; then
            # The root directory ('/') becomes a directory name instead of a leading separator
            # Add one to account for the first / needing to be both replaced and shown
            path_length+=1
        fi
        if [[ ${#separator} > 1 ]]; then
            # Add length to account for multichar separators
            local slash_count="${display_path//[!\/]}"
            path_length+=$(( ${#slash_count} * ( ${#separator} - 1 ) ))
        fi
    fi

    local path_to_proccess="${display_path}/" current_path="" current_directory="" lp_unique_directory

    local -i max_len=$(( ${COLUMNS:-80} * LP_PATH_LENGTH / 100 )) directory_count=0 needed_length
    local -i shortened_path_length="$path_length" is_shortening=0 unshortened_path_length
    local unshortened_path_shorten_string unshortened_path_format_shorten_string shortened_path

    while [[ -n $path_to_proccess ]]; do

        if [[ ${path_to_proccess:0:1} == "/" ]]; then
            # Start of root
            current_directory="/"
        else
            current_directory=${path_to_proccess%%/*}
            if [[ -n $current_path && $current_path != "/" ]]; then
                current_path+="/"
            fi
        fi

        directory_count+=1
        current_path+=${current_directory}
        path_to_proccess=${path_to_proccess#*/}

        if [[ $current_path == $vcs_root_directory ]]; then
            __lp_end_path_left_shortening
            # No shortening
            lp_path+=$current_directory
            __lp_escape "$current_directory"
            lp_path_format+="${vcs_root_format}${ret}"
        elif [[ -z $path_to_proccess ]]; then
            __lp_end_path_left_shortening
            # Last directory
            lp_path+=$current_directory
            __lp_escape "$current_directory"
            lp_path_format+="${last_directory_format}${ret}"
        elif (( LP_ENABLE_SHORTEN_PATH && directory_count > LP_PATH_KEEP \
            && ( shortened_path_length > max_len || ( shortened_path_length >= max_len && is_shortening ) ) )); then

            if [[ $LP_PATH_METHOD == "truncate_chars_to_unique_dir" ]] && \
                __lp_get_unique_directory "$current_path"; then

                lp_path+=$lp_unique_directory
                __lp_escape "$lp_unique_directory"
                lp_path_format+="${shortened_directory_format}${ret}"
                shortened_path_length=$(( shortened_path_length - ${#current_directory} + ${#lp_unique_directory} ))
            elif [[ $LP_PATH_METHOD == "truncate_chars_from_path_left" ]]; then
                # The only way to know if this consecutive directory shortening
                # will actually shorten the path is to both do it and do not and
                # compare at the end.

                if (( ! is_shortening )); then
                    unshortened_path_shorten_string=
                    unshortened_path_format_shorten_string=
                    unshortened_path_length=$shortened_path_length
                    shortened_path_length+=${#LP_MARK_SHORTEN_PATH}
                fi
                needed_length=$(( shortened_path_length - max_len ))

                unshortened_path_shorten_string+="${current_directory}/"
                unshortened_path_format_shorten_string+="${path_format}${current_directory}${separator_format}${separator}"

                if (( needed_length >= ${#current_directory} )); then
                    # One directory was not enough, need to shorten more.
                    # Shorten by current directory length plus separator.
                    shortened_path_length=$(( shortened_path_length - ${#current_directory} - ${#separator} ))
                    is_shortening=1
                else
                    # Do not need to check if the shortened version is actually shorter.
                    # If we got to here, it wasn't a forced ending, which means it is.
                    shortened_path_length=$(( shortened_path_length - needed_length ))

                    shortened_path="${LP_MARK_SHORTEN_PATH}${current_directory:$needed_length}"
                    lp_path+=$shortened_path
                    __lp_escape "$shortened_path"