mirror of
https://github.com/romkatv/powerlevel10k.git
synced 2024-09-19 03:51:22 +02:00
273 lines
10 KiB
Bash
273 lines
10 KiB
Bash
[[ -o interactive ]] || return
|
|
autoload -Uz add-zsh-hook && zmodload zsh/datetime && zmodload zsh/system || return
|
|
|
|
# Retrives status of a git repo from a directory under its working tree.
|
|
#
|
|
# -d STR Directory to query. Defaults to $PWD. 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.
|
|
#
|
|
# 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 s 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. 40 hex digits.
|
|
# VCS_STATUS_LOCAL_BRANCH Local branch name or empty if not on a branch.
|
|
# 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_HAS_STAGED 1 if there are staged 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 first tag (in lexicographical order) that points to the same
|
|
# commit as HEAD.
|
|
# VCS_STATUS_ALL All of the above in an array. The order of elements is unspecified.
|
|
# More elements can be added in the future.
|
|
#
|
|
# 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
|
|
# 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=$PWD
|
|
local callback=''
|
|
local -F timeout=-1
|
|
while true; do
|
|
getopts "d:c:t:" opt || break
|
|
case $opt in
|
|
d) dir=$OPTARG;;
|
|
c) callback=$OPTARG;;
|
|
t) timeout=$OPTARG;;
|
|
?) return 1;;
|
|
done) break;;
|
|
esac
|
|
done
|
|
(( OPTIND == ARGC )) || { echo "usage: gitstatus_query [OPTION]... NAME" >&2; return 1 }
|
|
local name=${*[$OPTIND]}
|
|
|
|
[[ -v 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}"$'\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}
|
|
|
|
typeset -ga VCS_STATUS_ALL
|
|
typeset -g VCS_STATUS_RESULT
|
|
(( timeout >= 0 )) && local -a t=(-t $timeout) || local -a t=()
|
|
IFS=$'\x1f' read -rd $'\x1e' -u ${(P)resp_fd_var} $t -A VCS_STATUS_ALL || {
|
|
VCS_STATUS_RESULT=tout
|
|
unset VCS_STATUS_ALL
|
|
return
|
|
}
|
|
|
|
local -a header=("${(@Q)${(z)VCS_STATUS_ALL[1]}}")
|
|
[[ ${header[1]} == $req_id ]] && local -i ours=1 || local -i ours=0
|
|
shift header
|
|
[[ ${VCS_STATUS_ALL[2]} == 1 ]] && {
|
|
shift 2 VCS_STATUS_ALL
|
|
(( ours )) && VCS_STATUS_RESULT=ok-sync || VCS_STATUS_RESULT=ok-async
|
|
typeset -g VCS_STATUS_WORKDIR="${VCS_STATUS_ALL[1]}"
|
|
typeset -g VCS_STATUS_COMMIT="${VCS_STATUS_ALL[2]}"
|
|
typeset -g VCS_STATUS_LOCAL_BRANCH="${VCS_STATUS_ALL[3]}"
|
|
typeset -g VCS_STATUS_REMOTE_BRANCH="${VCS_STATUS_ALL[4]}"
|
|
typeset -g VCS_STATUS_REMOTE_URL="${VCS_STATUS_ALL[5]}"
|
|
typeset -g VCS_STATUS_ACTION="${VCS_STATUS_ALL[6]}"
|
|
typeset -gi VCS_STATUS_HAS_STAGED="${VCS_STATUS_ALL[7]}"
|
|
typeset -gi VCS_STATUS_HAS_UNSTAGED="${VCS_STATUS_ALL[8]}"
|
|
typeset -gi VCS_STATUS_HAS_UNTRACKED="${VCS_STATUS_ALL[9]}"
|
|
typeset -gi VCS_STATUS_COMMITS_AHEAD="${VCS_STATUS_ALL[10]}"
|
|
typeset -gi VCS_STATUS_COMMITS_BEHIND="${VCS_STATUS_ALL[11]}"
|
|
typeset -gi VCS_STATUS_STASHES="${VCS_STATUS_ALL[12]}"
|
|
typeset -g VCS_STATUS_TAG="${VCS_STATUS_ALL[13]}"
|
|
} || {
|
|
(( ours )) && VCS_STATUS_RESULT=norepo-sync || VCS_STATUS_RESULT=norepo-async
|
|
unset VCS_STATUS_ALL
|
|
unset VCS_STATUS_WORKDIR
|
|
unset VCS_STATUS_COMMIT
|
|
unset VCS_STATUS_LOCAL_BRANCH
|
|
unset VCS_STATUS_REMOTE_BRANCH
|
|
unset VCS_STATUS_REMOTE_URL
|
|
unset VCS_STATUS_ACTION
|
|
unset VCS_STATUS_HAS_STAGED
|
|
unset VCS_STATUS_HAS_UNSTAGED
|
|
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
|
|
}
|
|
|
|
# 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.
|
|
# -m INT Report -1 unstaged and untracked if there are more than this many files in the index.
|
|
# 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_dirty=-1
|
|
while true; do
|
|
getopts "t:m:" opt || break
|
|
case $opt in
|
|
t) timeout=$OPTARG;;
|
|
m) max_dirty=$OPTARG;;
|
|
?) return 1;;
|
|
done) break;;
|
|
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]}
|
|
|
|
[[ ! -v GITSTATUS_DAEMON_PID_${name} ]] || return 0
|
|
|
|
local os && os=$(uname -s) && [[ -n $os ]]
|
|
local arch && arch=$(uname -m) && [[ -n $arch ]]
|
|
|
|
local daemon && daemon=${GITSTATUS_DAEMON:-${${(%):-%x}:A:h}/bin/gitstatusd-${os:l}-${arch:l}}
|
|
[[ -f $daemon ]] || { echo "file not found: $daemon" >&2 && return 1 }
|
|
|
|
local lock_file req_fifo resp_fifo log_file
|
|
local -i lock_fd=-1 req_fd=-1 resp_fd=-1 daemon_pid=-1
|
|
|
|
function start() {
|
|
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
|
|
sysopen -rw -o cloexec,sync -u req_fd $req_fifo
|
|
command rm -f $req_fifo
|
|
|
|
resp_fifo=$(mktemp -u "${TMPDIR:-/tmp}"/gitstatus.$$.pipe.resp.XXXXXXXXXX)
|
|
mkfifo $resp_fifo
|
|
sysopen -rw -o cloexec -u resp_fd $resp_fifo
|
|
command rm -f $resp_fifo
|
|
|
|
function _gitstatus_process_response_${name}() {
|
|
_gitstatus_process_response ${${(%)${:-%N}}#_gitstatus_process_response_} 0 ''
|
|
}
|
|
zle -F $resp_fd _gitstatus_process_response_${name}
|
|
|
|
[[ ${GITSTATUS_ENABLE_LOGGING:-0} == 1 ]] &&
|
|
log_file=$(mktemp "${TMPDIR:-/tmp}"/gitstatus.$$.log.XXXXXXXXXX) ||
|
|
log_file=/dev/null
|
|
|
|
local -i threads=${GITSTATUS_NUM_THREADS:-0}
|
|
(( threads > 0)) || {
|
|
case $os in
|
|
FreeBSD) threads=$(sysctl -n hw.ncpu);;
|
|
*) threads=$(getconf _NPROCESSORS_ONLN);;
|
|
esac
|
|
}
|
|
|
|
# We use `zsh -c` instead of plain {} or () to work around bugs in zplug. It hangs on startup.
|
|
zsh -xc "
|
|
${(q)daemon} \
|
|
--lock-fd=3 \
|
|
--sigwinch-pid=$$ \
|
|
--num-threads=$threads \
|
|
--dirty-max-index-size=$max_dirty
|
|
echo -nE $'bye\x1f0\x1e'
|
|
" <&$req_fd >&$resp_fd 2>$log_file 3<$lock_file &!
|
|
|
|
daemon_pid=$!
|
|
command rm -f $lock_file
|
|
|
|
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 -i daemon_pid=${${(%)${:-%N}}#_gitstatus_cleanup_${ZSH_SUBSHELL}_}
|
|
[[ $daemon_pid -gt 0 ]] && kill -- -$daemon_pid &>/dev/null
|
|
}
|
|
add-zsh-hook zshexit _gitstatus_cleanup_${ZSH_SUBSHELL}_${daemon_pid}
|
|
}
|
|
|
|
start && {
|
|
typeset -g GITSTATUS_DAEMON_LOG_${name}=$log_file
|
|
typeset -gi GITSTATUS_DAEMON_PID_${name}=$daemon_pid
|
|
typeset -giH _GITSTATUS_REQ_FD_${name}=$req_fd
|
|
typeset -giH _GITSTATUS_RESP_FD_${name}=$resp_fd
|
|
typeset -giH _GITSTATUS_CLIENT_PID_${name}=$$
|
|
} || {
|
|
echo "gitstatus failed to initialize" >&2 || true
|
|
[[ $daemon_pid -gt 0 ]] && kill -- -$daemon_pid &>/dev/null || true
|
|
[[ $lock_fd -ge 0 ]] && zsystem flock -u $lock_fd || true
|
|
[[ $req_fd -ge 0 ]] && exec {req_fd}>&- || true
|
|
[[ $resp_fd -ge 0 ]] && { zle -F $resp_fd || true } && { exec {resp_fd}>&- || true}
|
|
command rm -f $lock_file $req_fifo $resp_fifo || true
|
|
return 1
|
|
}
|
|
}
|
|
|
|
# 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() {
|
|
local name=$1
|
|
[[ -v GITSTATUS_DAEMON_PID_${name} ]]
|
|
}
|