Customization/powerlevel10k
1
0
Fork 0
mirror of https://github.com/romkatv/powerlevel10k.git synced 2024-12-21 06:41:57 +00:00
Code Releases Activity
powerlevel10k/gitstatus/gitstatus.plugin.zsh
romkatv 933c818a35 pull upstream changes from gitstatus
2019-07-07 19:02:35 +02:00

490 lines
18 KiB
Bash
Raw Blame History

# Copyright 2019 Roman Perepelitsa.
#
# This file is part of GitStatus. It provides ZSH bindings.
#
# GitStatus is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# GitStatus 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GitStatus. If not, see <https://www.gnu.org/licenses/>.
#
# ------------------------------------------------------------------
#
# Example: Start gitstatusd, send it a request, wait for response and print it.
#
# source gitstatus.plugin.zsh
# gitstatus_start MY
# gitstatus_query -d $PWD MY
# set | egrep '^VCS_STATUS'
#
# Output:
#
# VCS_STATUS_ACTION=''
# VCS_STATUS_COMMIT=6e86ec135bf77875e222463cbac8ef72a7e8d823
# VCS_STATUS_COMMITS_AHEAD=0
# VCS_STATUS_COMMITS_BEHIND=0
# VCS_STATUS_INDEX_SIZE=42
# VCS_STATUS_NUM_STAGED=0
# VCS_STATUS_NUM_UNSTAGED=2
# VCS_STATUS_NUM_UNTRACKED=3
# VCS_STATUS_HAS_STAGED=0
# VCS_STATUS_HAS_UNSTAGED=1
# VCS_STATUS_HAS_UNTRACKED=1
# VCS_STATUS_LOCAL_BRANCH=master
# VCS_STATUS_REMOTE_BRANCH=master
# VCS_STATUS_REMOTE_NAME=origin
# VCS_STATUS_REMOTE_URL=git@github.com:romkatv/powerlevel10k.git
# VCS_STATUS_RESULT=ok-sync
# VCS_STATUS_STASHES=0
# VCS_STATUS_TAG=''
# VCS_STATUS_WORKDIR=/home/romka/.oh-my-zsh/custom/themes/powerlevel10k
[[ -o interactive ]] || return
autoload -Uz add-zsh-hook && zmodload zsh/datetime zsh/system || return
# Retrives status of a git repo from a directory under its working tree.
#
## Usage: gitstatus_query [OPTION]... NAME
#
# -d STR Directory to query. Defaults to ${${GIT_DIR:-$PWD}:a}. Must be absolute.
# -c STR Callback function to call once the results are available. Called only after
# gitstatus_query returns 0 with VCS_STATUS_RESULT=tout.
# -t FLOAT Timeout in seconds. Will block for at most this long. If no results are
# available by then: if -c isn't specified, will return 1; otherwise will set
# VCS_STATUS_RESULT=tout and return 0.
# -p Don't compute anything that requires reading Git index. If this option is used,
# the following parameters will be 0: VCS_STATUS_INDEX_SIZE,
# VCS_STATUS_{NUM,HAS}_{STAGED,UNSTAGED,UNTRACKED}.
#
# On success sets VCS_STATUS_RESULT to one of the following values:
#
# tout Timed out waiting for data; will call the user-specified callback later.
# norepo-sync The directory isn't a git repo.
# ok-sync The directory is a git repo.
#
# When the callback is called VCS_STATUS_RESULT is set to one of the following values:
#
# norepo-async The directory isn't a git repo.
# ok-async The directory is a git repo.
#
# If VCS_STATUS_RESULT is ok-sync or ok-async, additional variables are set:
#
# VCS_STATUS_WORKDIR Git repo working directory. Not empty.
# VCS_STATUS_COMMIT Commit hash that HEAD is pointing to. Either 40 hex digits or empty
# if there is no HEAD (empty repo).
# VCS_STATUS_LOCAL_BRANCH Local branch name or empty if not on a branch.
# VCS_STATUS_REMOTE_NAME The remote name, e.g. "upstream" or "origin".
# VCS_STATUS_REMOTE_BRANCH Upstream branch name. Can be empty.
# VCS_STATUS_REMOTE_URL Remote URL. Can be empty.
# VCS_STATUS_ACTION Repository state, A.K.A. action. Can be empty.
# VCS_STATUS_INDEX_SIZE The number of files in the index.
# VCS_STATUS_NUM_STAGED The number of staged changes.
# VCS_STATUS_NUM_CONFLICTED The number of unstaged changes.
# VCS_STATUS_NUM_UNSTAGED The number of unstaged changes.
# VCS_STATUS_NUM_UNTRACKED The number of untracked files.
# VCS_STATUS_HAS_STAGED 1 if there are staged changes, 0 otherwise.
# VCS_STATUS_HAS_CONFLICTED 1 if there are conflicted changes, 0 otherwise.
# VCS_STATUS_HAS_UNSTAGED 1 if there are unstaged changes, 0 if there aren't, -1 if unknown.
# VCS_STATUS_HAS_UNTRACKED 1 if there are untracked files, 0 if there aren't, -1 if unknown.
# VCS_STATUS_COMMITS_AHEAD Number of commits the current branch is ahead of upstream.
# Non-negative integer.
# VCS_STATUS_COMMITS_BEHIND Number of commits the current branch is behind upstream. Non-negative
# integer.
# VCS_STATUS_STASHES Number of stashes. Non-negative integer.
# VCS_STATUS_TAG The last tag (in lexicographical order) that points to the same
# commit as HEAD.
#
# The point of reporting -1 as unstaged and untracked is to allow the command to skip scanning
# files in large repos. See -m flag of gitstatus_start.
#
# gitstatus_query returns an error if gitstatus_start hasn't been called in the same shell or
# the call had failed.
#
# !!!!! WARNING: CONCURRENT CALLS WITH THE SAME NAME ARE NOT ALLOWED !!!!!
#
# It's illegal to call gitstatus_query if the last asynchronous call with the same NAME hasn't
# completed yet. If you need to issue concurrent requests, use different NAME arguments.
function gitstatus_query() {
emulate -L zsh
setopt err_return no_unset
local opt
local dir=${${GIT_DIR:-$PWD}:a}
local callback=''
local -F timeout=-1
local no_diff=0
while true; do
getopts "d:c:t:p" opt || break
case $opt in
d) dir=$OPTARG;;
c) callback=$OPTARG;;
t) timeout=$OPTARG;;
p) no_diff=1;;
?) return 1;;
done) break;;
esac
done
(( OPTIND == ARGC )) || { echo "usage: gitstatus_query [OPTION]... NAME" >&2; return 1 }
local name=${*[$OPTIND]}
[[ -n ${(P)${:-GITSTATUS_DAEMON_PID_${name}}:-} ]]
# Verify that gitstatus_query is running in the same process that ran gitstatus_start.
local client_pid_var=_GITSTATUS_CLIENT_PID_${name}
[[ ${(P)client_pid_var} == $$ ]]
local req_fd_var=_GITSTATUS_REQ_FD_${name}
local -i req_fd=${(P)req_fd_var}
local -r req_id="$EPOCHREALTIME"
echo -nE $req_id' '$callback$'\x1f'$dir$'\x1f'$no_diff$'\x1e' >&$req_fd
while true; do
_gitstatus_process_response $name $timeout $req_id
[[ $VCS_STATUS_RESULT == *-async ]] || break
done
[[ $VCS_STATUS_RESULT != tout || -n $callback ]]
}
function _gitstatus_process_response() {
emulate -L zsh
setopt err_return no_unset
local name=$1
local -F timeout=$2
local req_id=$3
local resp_fd_var=_GITSTATUS_RESP_FD_${name}
local -i dirty_max_index_size=_GITSTATUS_DIRTY_MAX_INDEX_SIZE_${name}
typeset -g VCS_STATUS_RESULT
(( timeout >= 0 )) && local -a t=(-t $timeout) || local -a t=()
local -a resp
IFS=$'\x1f' read -rd $'\x1e' -u ${(P)resp_fd_var} $t -A resp || {
VCS_STATUS_RESULT=tout
return
}
local -a header=("${(@Q)${(z)resp[1]}}")
[[ ${header[1]} == $req_id ]] && local -i ours=1 || local -i ours=0
shift header
[[ ${resp[2]} == 1 ]] && {
(( ours )) && VCS_STATUS_RESULT=ok-sync || VCS_STATUS_RESULT=ok-async
typeset -g VCS_STATUS_WORKDIR="${resp[3]}"
typeset -g VCS_STATUS_COMMIT="${resp[4]}"
typeset -g VCS_STATUS_LOCAL_BRANCH="${resp[5]}"
typeset -g VCS_STATUS_REMOTE_BRANCH="${resp[6]}"
typeset -g VCS_STATUS_REMOTE_NAME="${resp[7]}"
typeset -g VCS_STATUS_REMOTE_URL="${resp[8]}"
typeset -g VCS_STATUS_ACTION="${resp[9]}"
typeset -gi VCS_STATUS_INDEX_SIZE="${resp[10]}"
typeset -gi VCS_STATUS_NUM_STAGED="${resp[11]}"
typeset -gi VCS_STATUS_NUM_UNSTAGED="${resp[12]}"
typeset -gi VCS_STATUS_NUM_CONFLICTED="${resp[13]}"
typeset -gi VCS_STATUS_NUM_UNTRACKED="${resp[14]}"
typeset -gi VCS_STATUS_COMMITS_AHEAD="${resp[15]}"
typeset -gi VCS_STATUS_COMMITS_BEHIND="${resp[16]}"
typeset -gi VCS_STATUS_STASHES="${resp[17]}"
typeset -g VCS_STATUS_TAG="${resp[18]}"
typeset -gi VCS_STATUS_HAS_STAGED=$((VCS_STATUS_NUM_STAGED > 0))
(( dirty_max_index_size >= 0 && VCS_STATUS_INDEX_SIZE > dirty_max_index_size )) && {
typeset -gi VCS_STATUS_HAS_UNSTAGED=-1
typeset -gi VCS_STATUS_HAS_CONFLICTED=-1
typeset -gi VCS_STATUS_HAS_UNTRACKED=-1
} || {
typeset -gi VCS_STATUS_HAS_UNSTAGED=$((VCS_STATUS_NUM_UNSTAGED > 0))
typeset -gi VCS_STATUS_HAS_CONFLICTED=$((VCS_STATUS_NUM_CONFLICTED > 0))
typeset -gi VCS_STATUS_HAS_UNTRACKED=$((VCS_STATUS_NUM_UNTRACKED > 0))
}
} || {
(( ours )) && VCS_STATUS_RESULT=norepo-sync || VCS_STATUS_RESULT=norepo-async
unset VCS_STATUS_WORKDIR
unset VCS_STATUS_COMMIT
unset VCS_STATUS_LOCAL_BRANCH
unset VCS_STATUS_REMOTE_BRANCH
unset VCS_STATUS_REMOTE_NAME
unset VCS_STATUS_REMOTE_URL
unset VCS_STATUS_ACTION
unset VCS_STATUS_INDEX_SIZE
unset VCS_STATUS_NUM_STAGED
unset VCS_STATUS_NUM_UNSTAGED
unset VCS_STATUS_NUM_CONFLICTED
unset VCS_STATUS_NUM_UNTRACKED
unset VCS_STATUS_HAS_STAGED
unset VCS_STATUS_HAS_UNSTAGED
unset VCS_STATUS_HAS_CONFLICTED
unset VCS_STATUS_HAS_UNTRACKED
unset VCS_STATUS_COMMITS_AHEAD
unset VCS_STATUS_COMMITS_BEHIND
unset VCS_STATUS_STASHES
unset VCS_STATUS_TAG
}
(( ! ours )) && (( #header )) && emulate -L zsh && "${header[@]}" || true
}
# Starts gitstatusd in the background. Does nothing and succeeds if gitstatusd is already running.
#
# Usage: gitstatus_start [OPTION]... NAME
#
# -t FLOAT Fail the self-check on initialization if not getting a response from gitstatusd for
# this this many seconds. Defaults to 5.
#
# -s INT Report at most this many staged changes; negative value means infinity.
# Defaults to 1.
#
# -u INT Report at most this many unstaged changes; negative value means infinity.
# Defaults to 1.
#
# -c INT Report at most this many conflicted changes; negative value means infinity.
# Defaults to 1.
#
# -d INT Report at most this many untracked files; negative value means infinity.
# Defaults to 1.
#
# -m INT If a repo has more files in its index than this, override -u and -d (but not -s)
# with zeros. Negative value means infinity. Defaults to -1.
function gitstatus_start() {
emulate -L zsh
setopt err_return no_unset no_bg_nice
local opt
local -F timeout=5
local -i max_num_staged=1
local -i max_num_unstaged=1
local -i max_num_conflicted=1
local -i max_num_untracked=1
local -i dirty_max_index_size=-1
while true; do
getopts "t:s:u:d:m:" opt || break
case $opt in
t) timeout=$OPTARG;;
s) max_num_staged=$OPTARG;;
u) max_num_unstaged=$OPTARG;;
c) max_num_conflicted=$OPTARG;;
d) max_num_untracked=$OPTARG;;
m) dirty_max_index_size=$OPTARG;;
?) return 1;;
esac
done
(( timeout > 0 )) || { echo "invalid -t: $timeout" >&2; return 1 }
(( OPTIND == ARGC )) || { echo "usage: gitstatus_start [OPTION]... NAME" >&2; return 1 }
local name=${*[$OPTIND]}
[[ -z ${(P)${:-GITSTATUS_DAEMON_PID_${name}}:-} ]] || return 0
local dir && dir=${${(%):-%x}:A:h}
local xtrace_file lock_file req_fifo resp_fifo log_file
local -i stderr_fd=-1 lock_fd=-1 req_fd=-1 resp_fd=-1 daemon_pid=-1
function gitstatus_start_impl() {
local log_level=${GITSTATUS_LOG_LEVEL:-}
[[ -n $log_level || ${GITSTATUS_ENABLE_LOGGING:-0} != 1 ]] || log_level=INFO
[[ -z $log_level ]] || {
xtrace_file=$(mktemp "${TMPDIR:-/tmp}"/gitstatus.$$.xtrace.XXXXXXXXXX)
typeset -g GITSTATUS_XTRACE_${name}=$xtrace_file
exec {stderr_fd}>&2 2>$xtrace_file
setopt xtrace
}
local os && os=$(uname -s) && [[ -n $os ]]
[[ $os != Linux || $(uname -o) != Android ]] || os=Android
local arch && arch=$(uname -m) && [[ -n $arch ]]
local daemon=${GITSTATUS_DAEMON:-$dir/bin/gitstatusd-${os:l}-${arch:l}}
[[ -f $daemon ]]
lock_file=$(mktemp "${TMPDIR:-/tmp}"/gitstatus.$$.lock.XXXXXXXXXX)
zsystem flock -f lock_fd $lock_file
req_fifo=$(mktemp -u "${TMPDIR:-/tmp}"/gitstatus.$$.pipe.req.XXXXXXXXXX)
mkfifo $req_fifo
resp_fifo=$(mktemp -u "${TMPDIR:-/tmp}"/gitstatus.$$.pipe.resp.XXXXXXXXXX)
mkfifo $resp_fifo
[[ -n $log_level ]] &&
log_file=$(mktemp "${TMPDIR:-/tmp}"/gitstatus.$$.daemon-log.XXXXXXXXXX) ||
log_file=/dev/null
typeset -g GITSTATUS_DAEMON_LOG_${name}=$log_file
local -i threads=${GITSTATUS_NUM_THREADS:-0}
(( threads > 0)) || {
threads=8
case $os in
FreeBSD) (( ! $+commands[sysctl] )) || threads=$(( 2 * $(command sysctl -n hw.ncpu) ));;
*) (( ! $+commands[getconf] )) || threads=$(( 2 * $(command getconf _NPROCESSORS_ONLN) ));;
esac
(( threads <= 32 )) || threads=32
}
local -a daemon_args=(
--lock-fd=3
--parent-pid=${(q)$}
--num-threads=${(q)threads}
--max-num-staged=${(q)max_num_staged}
--max-num-unstaged=${(q)max_num_unstaged}
--max-num-conflicted=${(q)max_num_conflicted}
--max-num-untracked=${(q)max_num_untracked}
--dirty-max-index-size=${(q)dirty_max_index_size}
${${log_level:#INFO}:+--log-level=$log_level})
# We use `zsh -c` instead of plain {} or () to work around bugs in zplug. It hangs on startup.
zsh -dfxc "
${(q)daemon} $daemon_args
if [[ \$? != (0|10) && \$? -le 128 &&
-z ${(q)GITSTATUS_DAEMON:-} &&
-f ${(q)daemon}-static ]]; then
${(q)daemon}-static $daemon_args
fi
echo -nE $'bye\x1f0\x1e'
" <$req_fifo >$resp_fifo 2>$log_file 3<$lock_file &!
daemon_pid=$!
sysopen -w -o cloexec,sync -u req_fd $req_fifo
sysopen -r -o cloexec -u resp_fd $resp_fifo
command rm -f $req_fifo $resp_fifo $lock_file
function _gitstatus_process_response_${name}() {
_gitstatus_process_response ${${(%)${:-%N}}#_gitstatus_process_response_} 0 ''
}
zle -F $resp_fd _gitstatus_process_response_${name}
local reply
echo -nE $'hello\x1f\x1e' >&$req_fd
IFS='' read -r -d $'\x1e' -u $resp_fd -t $timeout reply
[[ $reply == $'hello\x1f0' ]]
function _gitstatus_cleanup_${ZSH_SUBSHELL}_${daemon_pid}() {
emulate -L zsh
setopt err_return no_unset
local fname=${(%):-%N}
local prefix=_gitstatus_cleanup_${ZSH_SUBSHELL}_
[[ $fname == ${prefix}* ]] || return 0
local -i daemon_pid=${fname#$prefix}
kill -- -$daemon_pid &>/dev/null || true
}
add-zsh-hook zshexit _gitstatus_cleanup_${ZSH_SUBSHELL}_${daemon_pid}
[[ $stderr_fd == -1 ]] || {
unsetopt xtrace
exec 2>&$stderr_fd {stderr_fd}>&-
stderr_fd=-1
}
}
gitstatus_start_impl && {
typeset -gi GITSTATUS_DAEMON_PID_${name}=$daemon_pid
typeset -gi _GITSTATUS_REQ_FD_${name}=$req_fd
typeset -gi _GITSTATUS_RESP_FD_${name}=$resp_fd
typeset -gi _GITSTATUS_LOCK_FD_${name}=$lock_fd
typeset -gi _GITSTATUS_CLIENT_PID_${name}=$$
typeset -gi _GITSTATUS_DIRTY_MAX_INDEX_SIZE_${name}=$dirty_max_index_size
unset -f gitstatus_start_impl
} || {
unsetopt err_return
add-zsh-hook -d zshexit _gitstatus_cleanup_${ZSH_SUBSHELL}_${daemon_pid}
[[ $daemon_pid -gt 0 ]] && kill -- -$daemon_pid &>/dev/null
[[ $stderr_fd -ge 0 ]] && { exec 2>&$stderr_fd {stderr_fd}>&- }
[[ $lock_fd -ge 0 ]] && zsystem flock -u $lock_fd
[[ $req_fd -ge 0 ]] && exec {req_fd}>&-
[[ $resp_fd -ge 0 ]] && { zle -F $resp_fd; exec {resp_fd}>&- }
command rm -f $lock_file $req_fifo $resp_fifo
unset -f gitstatus_start_impl
>&2 print -P '[%F{red}ERROR%f]: gitstatus failed to initialize.'
>&2 echo -E ''
>&2 echo -E ' Your git prompt may disappear or become slow.'
if [[ -s $xtrace_file ]]; then
>&2 echo -E ''
>&2 echo -E " The content of ${(q-)xtrace_file} (gitstatus_start_impl xtrace):"
>&2 print -P '%F{yellow}'
>&2 awk '{print " " $0}' <$xtrace_file
>&2 print -P '%F{red} ^ this command failed%f'
fi
if [[ -s $log_file ]]; then
>&2 echo -E ''
>&2 echo -E " The content of ${(q-)log_file} (gitstatus daemon log):"
>&2 print -P '%F{yellow}'
>&2 awk '{print " " $0}' <$log_file
>&2 print -nP '%f'
fi
if [[ -n ${GITSTATUS_LOG_LEVEL:-} || ${GITSTATUS_ENABLE_LOGGING:-0} == 1 ]]; then
>&2 echo -E ''
>&2 echo -E ' Your system information:'
>&2 print -P '%F{yellow}'
>&2 echo -E " zsh: $ZSH_VERSION"
>&2 echo -E " uname -a: $(uname -a)"
>&2 print -P '%f'
>&2 echo -E ' If you need help, open an issue and attach this whole error message to it:'
>&2 echo -E ''
>&2 print -P ' %F{green}https://github.com/romkatv/gitstatus/issues/new%f'
else
>&2 echo -E ''
>&2 echo -E ' Run the following command to retry with extra diagnostics:'
>&2 print -P '%F{green}'
>&2 echo -E " GITSTATUS_LOG_LEVEL=DEBUG gitstatus_start ${(@q-)*}"
>&2 print -nP '%f'
fi
return 1
}
}
# Stops gitstatusd if it's running.
#
# Usage: gitstatus_stop NAME.
function gitstatus_stop() {
emulate -L zsh
setopt no_unset
(( ARGC == 1 )) || { echo "usage: gitstatus_stop NAME" >&2; return 1 }
local name=$1
local req_fd_var=_GITSTATUS_REQ_FD_${name}
local resp_fd_var=_GITSTATUS_RESP_FD_${name}
local lock_fd_var=_GITSTATUS_LOCK_FD_${name}
local daemon_pid_var=GITSTATUS_DAEMON_PID_${name}
local client_pid_var=_GITSTATUS_CLIENT_PID_${name}
local req_fd=${(P)req_fd_var:-}
local resp_fd=${(P)resp_fd_var:-}
local lock_fd=${(P)lock_fd_var:-}
local daemon_pid=${(P)daemon_pid_var:-}
local cleanup_func=_gitstatus_cleanup_${ZSH_SUBSHELL}_${daemon_pid}
[[ -n $daemon_pid ]] && kill -- -$daemon_pid &>/dev/null
[[ -n $req_fd ]] && exec {req_fd}>&-
[[ -n $resp_fd ]] && { zle -F $resp_fd; exec {resp_fd}>&- }
[[ -n $lock_fd ]] && zsystem flock -u $lock_fd
unset $req_fd_var $resp_fd_var $lock_fd_var $daemon_pid_var $client_pid_var
if (( $+functions[$cleanup_func] )); then
add-zsh-hook -d zshexit $cleanup_func
unfunction $cleanup_func
fi
return 0
}
# Usage: gitstatus_check NAME.
#
# Returns 0 if and only if `gitstatus_start NAME` has succeeded previously.
# If it returns non-zero, gitstatus_query NAME is guaranteed to return non-zero.
function gitstatus_check() {
emulate -L zsh
(( ARGC == 1 )) || { echo "usage: gitstatus_check NAME" >&2; return 1 }
[[ -n ${(P)${:-GITSTATUS_DAEMON_PID_${1}}} ]]
}
View git blame Copy permalink