mirror of
https://github.com/zdharma-continuum/zinit.git
synced 2026-09-10 07:36:38 -04:00
264526ab26
The ___moved guard skipped the restore whenever zinit did not cd itself, so an ice body that cds under nocd stranded the shell wherever the plugin left it. Make the restore unconditional and give .zinit-restore-dir a fast path so the case where nothing moved stays free. Signed-off-by: Vladislav Doster <mvdoster@gmail.com>
3451 lines
155 KiB
Bash
3451 lines
155 KiB
Bash
#
|
||
# zdharma-continuum/zinit/zinit.zsh
|
||
# Copyright (c) 2016-2021 Sebastian Gniazdowski
|
||
# Copyright (c) 2021-2023 zdharma-continuum
|
||
# Homepage: https://github.com/zdharma-continuum/zinit
|
||
# License: MIT License
|
||
#
|
||
|
||
#
|
||
# Main state variables.
|
||
#
|
||
|
||
typeset -gaH ZINIT_REGISTERED_PLUGINS ZINIT_TASKS ZINIT_RUN
|
||
typeset -ga zsh_loaded_plugins
|
||
if (( !${#ZINIT_TASKS} )) { ZINIT_TASKS=( "<no-data>" ); }
|
||
# Snippets loaded, url -> file name.
|
||
typeset -gAH ZINIT ZINIT_SNIPPETS ZINIT_REPORTS ZINIT_ICES ZINIT_SICE ZINIT_CUR_BIND_MAP ZINIT_EXTS ZINIT_EXTS2
|
||
typeset -gaH ZINIT_COMPDEF_REPLAY
|
||
|
||
# Compatibility with pre-rename project (Zplugin).
|
||
typeset -gAH ZPLGM
|
||
ZINIT=( "${(kv)ZPLGM[@]}" "${(kv)ZINIT[@]}" )
|
||
unset ZPLGM
|
||
|
||
#
|
||
# Allow configuring ZINIT[...] settings via zstyle, e.g.:
|
||
# zstyle ':zinit:config' home-dir ~/.zinit
|
||
# zstyle ':zinit:config' bin-dir ~/.zinit/zinit.git
|
||
# An explicitly-set ZINIT[KEY] always wins over the matching zstyle.
|
||
#
|
||
if zmodload -F zsh/zutil +b:zstyle 2>/dev/null || (( ${+builtins[zstyle]} )); then
|
||
() {
|
||
local _attr _key
|
||
local -A _map=(
|
||
bin-dir BIN_DIR home-dir HOME_DIR
|
||
plugins-dir PLUGINS_DIR completions-dir COMPLETIONS_DIR
|
||
snippets-dir SNIPPETS_DIR services-dir SERVICES_DIR
|
||
module-dir MODULE_DIR polaris-dir POLARIS_DIR
|
||
zpfx ZPFX man-dir MAN_DIR
|
||
list-command LIST_COMMAND zcompdump-path ZCOMPDUMP_PATH
|
||
compinit-opts COMPINIT_OPTS mute-warnings MUTE_WARNINGS
|
||
no-aliases NO_ALIASES packages-branch PACKAGES_BRANCH
|
||
packages-repo PACKAGES_REPO
|
||
optimize-out-disk-accesses OPTIMIZE_OUT_DISK_ACCESSES
|
||
)
|
||
for _attr _key in "${(kv)_map[@]}"; do
|
||
[[ -n ${ZINIT[$_key]} ]] && continue
|
||
zstyle -s ':zinit:config' "$_attr" "ZINIT[$_key]"
|
||
done
|
||
}
|
||
fi
|
||
|
||
#
|
||
# Common needed values.
|
||
#
|
||
|
||
[[ ! -e ${ZINIT[BIN_DIR]}/zinit.zsh ]] && ZINIT[BIN_DIR]=
|
||
|
||
# Respect the plugin standard too.
|
||
ZINIT[ZERO]="${ZERO:-${${0:#$ZSH_ARGZERO}:-${(%):-%N}}}"
|
||
[[ ! -o functionargzero || ${options[posixargzero]} = on || ${ZINIT[ZERO]} != */* ]] && ZINIT[ZERO]="${(%):-%N}"
|
||
|
||
: ${ZINIT[BIN_DIR]:="${ZINIT[ZERO]:h}"}
|
||
[[ ${ZINIT[BIN_DIR]} = \~* ]] && ZINIT[BIN_DIR]=${~ZINIT[BIN_DIR]}
|
||
|
||
# Make ZINIT[BIN_DIR] path absolute.
|
||
ZINIT[BIN_DIR]="${${(M)ZINIT[BIN_DIR]:#/*}:-$PWD/${ZINIT[BIN_DIR]}}"
|
||
|
||
# Final test of ZINIT[BIN_DIR].
|
||
if [[ ! -e ${ZINIT[BIN_DIR]}/zinit.zsh ]]; then
|
||
builtin print -P "%F{196}Could not establish ZINIT[BIN_DIR] hash field. It should point where Zinit's Git repository is.%f"
|
||
return 1
|
||
fi
|
||
|
||
# User can override ZINIT[HOME_DIR].
|
||
if [[ -z ${ZINIT[HOME_DIR]} ]]; then
|
||
# Search for zinit home in the usual locations
|
||
if [[ -d ${XDG_DATA_HOME:-${HOME}/.local/share}/zinit ]]; then
|
||
ZINIT[HOME_DIR]="${XDG_DATA_HOME:-${HOME}/.local/share}/zinit"
|
||
elif [[ -d $HOME/.zinit ]]; then
|
||
ZINIT[HOME_DIR]="$HOME/.zinit"
|
||
elif [[ -d ${ZDOTDIR:-$HOME}/.zinit ]]; then
|
||
ZINIT[HOME_DIR]="${ZDOTDIR:-$HOME}/.zinit"
|
||
elif [[ -d $HOME/.zplugin ]]; then
|
||
ZINIT[HOME_DIR]="$HOME/.zplugin"
|
||
elif [[ -d ${ZDOTDIR:-$HOME}/.zplugin ]]; then
|
||
ZINIT[HOME_DIR]="${ZDOTDIR:-$HOME}/.zplugin"
|
||
else
|
||
ZINIT[HOME_DIR]="${XDG_DATA_HOME:-${HOME}/.local/share}/zinit"
|
||
fi
|
||
fi
|
||
|
||
if [[ -z ${ZINIT[LIST_COMMAND]} ]]; then
|
||
if (( ${+commands[eza]} )); then
|
||
ZINIT[LIST_COMMAND]='eza --color=always --tree --icons -L3'
|
||
elif (( ${+commands[exa]} )); then
|
||
ZINIT[LIST_COMMAND]='exa --color=always --tree --icons -L3'
|
||
elif (( ${+commands[tree]} )); then
|
||
ZINIT[LIST_COMMAND]='tree -L 3 -C --charset utf-8'
|
||
else
|
||
ZINIT[LIST_COMMAND]='ls --tree'
|
||
fi
|
||
fi
|
||
|
||
ZINIT[ice-list]="\
|
||
\!bash|\!csh|\!ksh|\!sh|\
|
||
aliases|as|atclone|atdelete|atinit|atload|atpull|autoload|\
|
||
bash|binary|bindmap|blockf|bpick|build|\
|
||
cloneonly|cloneopts|cmake|compile|completions|configure|countdown|cp|csh|\
|
||
debug|depth|\
|
||
extract|\
|
||
from|git|\
|
||
has|\
|
||
id-as|if|install|is-snippet|\
|
||
ksh|\
|
||
light-mode|link|load|lucid|\
|
||
make|multisrc|mv|nocd|nocompile|nocompletions|notify|null|\
|
||
on-update-of|opts|\
|
||
pack|param|pick|proto|ps-on-unload|ps-on-update|pullopts|\
|
||
reset|reset-prompt|run-atpull|\
|
||
service|sh|silent|src|subscribe|subst|svn|\
|
||
teleid|trackbinds|trigger-load|\
|
||
unload|\
|
||
ver|verbose|\
|
||
wait|wrap"
|
||
ZINIT[nval-ice-list]="\
|
||
\!bash|\!csh|\!ksh|\!sh|\
|
||
aliases|\
|
||
bash|binary|blockf|\
|
||
cloneonly|cloneopts|cmake|configure|countdown|csh|\
|
||
debug|\
|
||
git|\
|
||
is-snippet|\
|
||
ksh|\
|
||
light-mode|lucid|\
|
||
make|\
|
||
nocd|nocompile|nocompletions|notify|null|\
|
||
pullopts|\
|
||
reset|run-atpull|\
|
||
sh|silent|\
|
||
trackbinds|\
|
||
verbose"
|
||
ZINIT[cmds]="\
|
||
add-fpath|\
|
||
bindkeys|\
|
||
cclear|cd|cdclear|cdisable|cdlist|cdreplay|cenable|changes|compile|compiled|compinit|completions|create|creinstall|csearch|cuninstall|\
|
||
delete|debug|\
|
||
edit|env-whitelist|\
|
||
fpath|\
|
||
glance|\
|
||
help|--help|-h|\
|
||
ice|\
|
||
light|load|\
|
||
man|module|\
|
||
plugins|\
|
||
recall|recently|report|run|\
|
||
self-update|snippet|snippets|srv|status|stress|\
|
||
times|\
|
||
uncompile|unload|update|\
|
||
version|\
|
||
zstatus"
|
||
|
||
# Can be customized.
|
||
: ${ZINIT[COMPLETIONS_DIR]:=${ZINIT[HOME_DIR]}/completions}
|
||
: ${ZINIT[MODULE_DIR]:=${ZINIT[HOME_DIR]}/module}
|
||
: ${ZINIT[PACKAGES_BRANCH]:=HEAD}
|
||
: ${ZINIT[PACKAGES_REPO]:=zdharma-continuum/zinit-packages}
|
||
: ${ZINIT[PLUGINS_DIR]:=${ZINIT[HOME_DIR]}/plugins}
|
||
: ${ZINIT[POLARIS_DIR]:=${ZINIT[HOME_DIR]}/polaris}
|
||
: ${ZINIT[SERVICES_DIR]:=${ZINIT[HOME_DIR]}/services}
|
||
: ${ZINIT[SNIPPETS_DIR]:=${ZINIT[HOME_DIR]}/snippets}
|
||
: ${ZINIT[ZPFX]:=${ZINIT[HOME_DIR]}/polaris}
|
||
typeset -g ZPFX
|
||
: ${ZPFX:=${ZINIT[ZPFX]}}
|
||
: ${ZINIT[ALIASES_OPT]::=${${options[aliases]:#off}:+1}}
|
||
: ${ZINIT[MAN_DIR]:=${ZPFX}/man}
|
||
|
||
ZINIT[PLUGINS_DIR]=${~ZINIT[PLUGINS_DIR]} ZINIT[COMPLETIONS_DIR]=${~ZINIT[COMPLETIONS_DIR]}
|
||
ZINIT[SNIPPETS_DIR]=${~ZINIT[SNIPPETS_DIR]} ZINIT[SERVICES_DIR]=${~ZINIT[SERVICES_DIR]}
|
||
|
||
# Make sure $ZSH_CACHE_DIR is writable, otherwise use a directory in $HOME
|
||
if [[ ! -w "$ZSH_CACHE_DIR" ]]; then
|
||
ZSH_CACHE_DIR="${XDG_CACHE_HOME:-$HOME/.cache}/zinit"
|
||
fi
|
||
|
||
export ZPFX=${~ZPFX} ZSH_CACHE_DIR="${ZSH_CACHE_DIR:-${XDG_CACHE_HOME:-$HOME/.cache}/zinit}" \
|
||
PMSPEC=0uUpiPsf
|
||
[[ -z ${path[(re)$ZPFX/bin]} ]] && [[ -d "$ZPFX/bin" ]] && path=( "$ZPFX/bin" "${path[@]}" )
|
||
[[ -z ${path[(re)$ZPFX/sbin]} ]] && [[ -d "$ZPFX/sbin" ]] && path=( "$ZPFX/sbin" "${path[@]}" )
|
||
|
||
hash -f
|
||
hash -d zinit=${ZINIT[HOME_DIR]}
|
||
hash -d plugins=${ZINIT[PLUGINS_DIR]}
|
||
hash -d zpfx=${ZINIT[HOME_DIR]}/polaris
|
||
|
||
# Add completions directory to fpath.
|
||
[[ -z ${fpath[(re)${ZINIT[COMPLETIONS_DIR]}]} ]] && fpath=( "${ZINIT[COMPLETIONS_DIR]}" "${fpath[@]}" )
|
||
|
||
[[ ! -d $ZSH_CACHE_DIR ]] && command mkdir -p "$ZSH_CACHE_DIR"
|
||
[[ -n ${ZINIT[ZCOMPDUMP_PATH]} ]] && ZINIT[ZCOMPDUMP_PATH]=${~ZINIT[ZCOMPDUMP_PATH]}
|
||
|
||
# Create "$ZSH_CACHE_DIR/completions" directory
|
||
[[ ! -d "$ZSH_CACHE_DIR/completions" ]] && command mkdir -p "$ZSH_CACHE_DIR/completions"
|
||
# Add "$ZSH_CACHE_DIR/completions" diretory to fpath
|
||
[[ -z ${fpath[(re)$ZSH_CACHE_DIR/completions]} ]] && fpath=( "$ZSH_CACHE_DIR/completions" "${fpath[@]}" )
|
||
|
||
ZINIT[UPAR]=";:^[[A;:^[OA;:\\e[A;:\\eOA;:${termcap[ku]/$'\e'/^\[};:${terminfo[kcuu1]/$'\e'/^\[};:"
|
||
ZINIT[DOWNAR]=";:^[[B;:^[OB;:\\e[B;:\\eOB;:${termcap[kd]/$'\e'/^\[};:${terminfo[kcud1]/$'\e'/^\[};:"
|
||
ZINIT[RIGHTAR]=";:^[[C;:^[OC;:\\e[C;:\\eOC;:${termcap[kr]/$'\e'/^\[};:${terminfo[kcuf1]/$'\e'/^\[};:"
|
||
ZINIT[LEFTAR]=";:^[[D;:^[OD;:\\e[D;:\\eOD;:${termcap[kl]/$'\e'/^\[};:${terminfo[kcub1]/$'\e'/^\[};:"
|
||
|
||
builtin autoload -Uz is-at-least
|
||
is-at-least 5.1 && ZINIT[NEW_AUTOLOAD]=1 || ZINIT[NEW_AUTOLOAD]=0
|
||
#is-at-least 5.4 && ZINIT[NEW_AUTOLOAD]=2
|
||
|
||
# Parameters [[[
|
||
# temporary substituting of functions
|
||
ZINIT[TMP_SUBST]=inactive ZINIT[DTRACE]=0 ZINIT[CUR_PLUGIN]=
|
||
|
||
# ice
|
||
declare -gA ZINIT_1MAP ZINIT_2MAP
|
||
ZINIT_1MAP=(
|
||
OMZ:: https://github.com/ohmyzsh/ohmyzsh/trunk/
|
||
OMZP:: https://github.com/ohmyzsh/ohmyzsh/trunk/plugins/
|
||
OMZT:: https://github.com/ohmyzsh/ohmyzsh/trunk/themes/
|
||
OMZL:: https://github.com/ohmyzsh/ohmyzsh/trunk/lib/
|
||
PZT:: https://github.com/sorin-ionescu/prezto/trunk/
|
||
PZTM:: https://github.com/sorin-ionescu/prezto/trunk/modules/
|
||
)
|
||
ZINIT_2MAP=(
|
||
OMZ:: https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/
|
||
OMZP:: https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/plugins/
|
||
OMZT:: https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/themes/
|
||
OMZL:: https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/lib/
|
||
PZT:: https://raw.githubusercontent.com/sorin-ionescu/prezto/master/
|
||
PZTM:: https://raw.githubusercontent.com/sorin-ionescu/prezto/master/modules/
|
||
)
|
||
# ]]]
|
||
|
||
# Init [[[
|
||
zmodload zsh/zutil || { builtin print -P "%F{196}zsh/zutil module is required, aborting Zinit set up.%f"; return 1; }
|
||
zmodload zsh/parameter || { builtin print -P "%F{196}zsh/parameter module is required, aborting Zinit set up.%f"; return 1; }
|
||
zmodload zsh/term{cap,info} 2>/dev/null
|
||
autoload -Uz colors && colors
|
||
|
||
if [[ -z $SOURCED && ( ${+terminfo} -eq 1 && -n ${terminfo[colors]} ) || ( ${+termcap} -eq 1 && -n ${termcap[Co]} ) ]]; then
|
||
ZINIT+=(
|
||
col-annex $'\e[38;5;153m' col-faint $'\e[38;5;238m' col-msg2 $'\e[38;5;172m' col-quo $'\e[1;38;5;33m'
|
||
col-apo $'\e[1;38;5;45m' col-file $'\e[3;38;5;117m' col-msg3 $'\e[38;5;238m' col-quos $'\e[1;38;5;160m'
|
||
col-aps $'\e[38;5;117m' col-flag $'\e[1;3;38;5;79m' col-nb $'\e[22m' col-rst $'\e[0m'
|
||
col-b $'\e[1m' col-func $'\e[38;5;219m' col-nit $'\e[23m' col-slight $'\e[38;5;230m'
|
||
col-b-lhi $'\e[1m\e[38;5;75m' col-glob $'\e[38;5;227m' col-nl $'\n' col-st $'\e[9m'
|
||
col-b-warn $'\e[1;38;5;214m' col-happy $'\e[1m\e[38;5;82m' col-note $'\e[38;5;148m' col-tab $' \t '
|
||
col-bapo $'\e[1;38;5;220m' col-hi $'\e[1m\e[38;5;183m' col-nst $'\e[29m' col-term $'\e[38;5;185m'
|
||
col-baps $'\e[1;38;5;82m' col-ice $'\e[38;5;39m' col-nu $'\e[24m' col-th-bar $'\e[38;5;82m'
|
||
col-bar $'\e[38;5;82m' col-id-as $'\e[4;38;5;220m' col-num $'\e[3;38;5;155m' col-time $'\e[38;5;220m'
|
||
col-bcmd $'\e[38;5;220m' col-info $'\e[38;5;82m' col-obj $'\e[38;5;218m' col-txt $'\e[38;5;254m'
|
||
col-bspc $'\b' col-info2 $'\e[38;5;227m' col-obj2 $'\e[38;5;118m' col-u $'\e[4m'
|
||
col-cmd $'\e[38;5;82m' col-info3 $'\e[1m\e[38;5;227m' col-ok $'\e[38;5;220m' col-u-warn $'\e[4;38;5;214m'
|
||
col-data $'\e[38;5;82m' col-it $'\e[3m' col-opt $'\e[38;5;219m' col-uname $'\e[1;4m\e[35m'
|
||
col-data2 $'\e[38;5;117m' col-keyword $'\e[32m' col-p $'\e[38;5;81m' col-uninst $'\e[38;5;118m'
|
||
col-dir $'\e[3;38;5;153m' col-lhi $'\e[38;5;81m' col-pkg $'\e[1;3;38;5;27m' col-url $'\e[38;5;75m'
|
||
col-ehi $'\e[1m\e[38;5;210m' col-meta $'\e[38;5;57m' col-pname $'\e[1;4m\e[32m' col-var $'\e[38;5;81m'
|
||
col-error $'\e[1m\e[38;5;204m' col-meta2 $'\e[38;5;147m' col-pre $'\e[38;5;135m' col-version $'\e[3;38;5;87m'
|
||
col-failure $'\e[38;5;204m' col-msg $'\e[0m' col-profile $'\e[38;5;148m' col-warn $'\e[38;5;214m'
|
||
|
||
col-dbg $'\e[2m\e[38;47;107m'"[debug]"$'\e[0m'
|
||
col-e $'\e[1m\e[38;5;204m'"Error"$'\e[0m'":"
|
||
col-i $'\e[1m\e[38;5;82m'"==>"$'\e[0m'
|
||
col-m $'\e[38;5;4m'"==>"$'\e[0m'
|
||
col-w $'\e[1m\e[38;5;214m'"Warning"$'\e[0m'":"
|
||
|
||
col--… "${${${(M)LANG:#*UTF-8*}:+⋯⋯}:-···}" col-lr "${${${(M)LANG:#*UTF-8*}:+↔}:-"«-»"}"
|
||
col-ndsh "${${${(M)LANG:#*UTF-8*}:+–}:-}" col-… "${${${(M)LANG:#*UTF-8*}:+…}:-...}"
|
||
|
||
col-mdsh $'\e[1;38;5;220m'"${${${(M)LANG:#*UTF-8*}:+–}:--}"$'\e[0m'
|
||
col-mmdsh $'\e[1;38;5;220m'"${${${(M)LANG:#*UTF-8*}:+――}:--}"$'\e[0m'
|
||
|
||
col-↔ ${${${(M)LANG:#*UTF-8*}:+$'\e[38;5;82m↔\e[0m'}:-$'\e[38;5;82m«-»\e[0m'}
|
||
)
|
||
if [[ ( ${+terminfo} -eq 1 && ${terminfo[colors]} -ge 256 ) || ( ${+termcap} -eq 1 && ${termcap[Co]} -ge 256 ) ]]; then
|
||
ZINIT+=( col-pname $'\e[1;4m\e[38;5;39m' col-uname $'\e[1;4m\e[38;5;207m' )
|
||
fi
|
||
fi
|
||
|
||
# Hooks
|
||
typeset -gAH ZINIT_ZLE_HOOKS_LIST
|
||
ZINIT_ZLE_HOOKS_LIST=(
|
||
zle-isearch-exit 1
|
||
zle-isearch-update 1
|
||
zle-line-pre-redraw 1
|
||
zle-line-init 1
|
||
zle-line-finish 1
|
||
zle-history-line-set 1
|
||
zle-keymap-select 1
|
||
paste-insert 1
|
||
)
|
||
builtin setopt noaliases
|
||
# ]]]
|
||
|
||
#
|
||
# Temporary substituting of functions-related functions.
|
||
#
|
||
|
||
# FUNCTION: :zinit-reload-and-run [[[
|
||
# Marks given function ($3) for autoloading, and executes it triggering the
|
||
# load. $1 is the fpath dedicated to the function, $2 are autoload options.
|
||
# This function replaces "autoload -X", because using that on older Zsh
|
||
# versions causes problems with traps.
|
||
#
|
||
# So basically one creates function stub that calls :zinit-reload-and-run()
|
||
# instead of "autoload -X".
|
||
#
|
||
# Author: Bart Schaefer
|
||
#
|
||
# $1 - FPATH dedicated to function
|
||
# $2 - autoload options
|
||
# $3 - function name (one that needs autoloading)
|
||
:zinit-reload-and-run() {
|
||
local fpath_prefix="$1" autoload_opts="$2" func="$3"
|
||
shift 3
|
||
|
||
# Unfunction caller function (its name is given).
|
||
unfunction -- "$func"
|
||
|
||
local -a ___fpath
|
||
___fpath=( ${fpath[@]} )
|
||
local -a +h fpath
|
||
# See #127.
|
||
[[ $FPATH != *${${(@0)fpath_prefix}[1]}* ]] && \
|
||
fpath=( ${(@0)fpath_prefix} ${___fpath[@]} )
|
||
|
||
# After this the function exists again.
|
||
builtin autoload ${(s: :)autoload_opts} -- "$func"
|
||
|
||
# User wanted to call the function, not only load it.
|
||
"$func" "$@"
|
||
} # ]]]
|
||
# FUNCTION: :zinit-tmp-subst-autoload [[[
|
||
# Hijack plugin's calls to the 'autoload' builtin.
|
||
#
|
||
# The hijacking gathers report data and runs custom `autoload' function, that doesn't need FPATH.
|
||
:zinit-tmp-subst-autoload() {
|
||
builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
|
||
builtin setopt extendedglob warncreateglobal typesetsilent rcquotes
|
||
local -a opts opts2 custom reply
|
||
local func
|
||
|
||
zparseopts -D -E -M -a opts ${(s::):-RTUXdkmrtWzwC} I+=opts2 S+:=custom
|
||
|
||
builtin set -- ${@:#--}
|
||
|
||
# Process the id-as''/teleid'' to get the plugin dir.
|
||
.zinit-any-to-user-plugin $ZINIT[CUR_USPL2]
|
||
[[ $reply[1] = % ]] && \
|
||
local PLUGIN_DIR="$reply[2]" || \
|
||
local PLUGIN_DIR="$ZINIT[PLUGINS_DIR]/${reply[1]:+$reply[1]---}${reply[2]//\//---}"
|
||
|
||
|
||
# "fpath elements" ---- those elements that lie inside the plug directory.
|
||
local -a fpath_elements
|
||
fpath_elements=( ${fpath[(r)$PLUGIN_DIR/*]} )
|
||
|
||
# Add a function subdirectory to items, if any (this action is
|
||
# according to the Plug Standard version 1.07 and later).
|
||
[[ -d $PLUGIN_DIR/functions ]] && fpath_elements+=( "$PLUGIN_DIR"/functions )
|
||
|
||
if (( ${+opts[(r)-X]} )); then
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Warning: Failed autoload ${(j: :)opts[@]} $*"
|
||
+zi-log -u2 "{error}builtin autoload required for {obj}${(j: :)opts[@]}{error} option(s)"
|
||
return 1
|
||
fi
|
||
if (( ${+opts[(r)-w]} )); then
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "-w-Autoload ${(j: :)opts[@]} ${(j: :)@}"
|
||
fpath+=( $PLUGIN_DIR )
|
||
builtin autoload ${opts[@]} "$@"
|
||
return $?
|
||
fi
|
||
if [[ -n ${(M)@:#+X} ]]; then
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Autoload +X ${opts:+${(j: :)opts[@]} }${(j: :)${@:#+X}}"
|
||
local +h FPATH=$PLUGINS_DIR${fpath_elements:+:${(j.:.)fpath_elements[@]}}:$FPATH
|
||
local +h -a fpath
|
||
fpath=( $PLUGIN_DIR $fpath_elements $fpath )
|
||
builtin autoload +X ${opts[@]} "${@:#+X}"
|
||
return $?
|
||
fi
|
||
|
||
for func; do
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Autoload $func${opts:+ with options ${(j: :)opts[@]}}"
|
||
done
|
||
|
||
integer count retval
|
||
for func; do
|
||
# Real autoload doesn't touch function if it already exists.
|
||
# Author of the idea of FPATH-clean autoloading: Bart Schaefer.
|
||
if (( ${+functions[$func]} != 1 )) {
|
||
builtin setopt noaliases
|
||
if [[ $func == /* ]] && is-at-least 5.4; then
|
||
builtin autoload ${opts[@]} $func
|
||
return $?
|
||
elif [[ $func == /* ]]; then
|
||
if [[ $ZINIT[MUTE_WARNINGS] != (1|true|on|yes) && \
|
||
-z $ZINIT[WARN_SHOWN_FOR_$ZINIT[CUR_USPL2]] ]]; then
|
||
+zi-log "{u-warn}Warning{b-warn}: {rst}the plugin {pid}$ZINIT[CUR_USPL2]" \
|
||
"{rst}is using autoload functions specified by their absolute path," \
|
||
"which is not supported by this Zsh version ({↔} {version}$ZSH_VERSION{rst}," \
|
||
"required is Zsh >= {version}5.4{rst})." \
|
||
"{nl}A fallback mechanism has been applied, which works well only" \
|
||
"for functions in the plugin {u}{slight}main{rst} directory." \
|
||
"{nl}(To mute this message, set" \
|
||
"{var}\$ZINIT[MUTE_WARNINGS]{rst} to a truth value.)"
|
||
ZINIT[WARN_SHOWN_FOR_$ZINIT[CUR_USPL2]]=1
|
||
fi
|
||
|
||
# Workaround
|
||
func=$func:t
|
||
fi
|
||
if [[ ${ZINIT[NEW_AUTOLOAD]} = 2 ]]; then
|
||
builtin autoload ${opts[@]} "$PLUGIN_DIR/$func"
|
||
retval=$?
|
||
elif [[ ${ZINIT[NEW_AUTOLOAD]} = 1 ]]; then
|
||
if (( ${+opts[(r)-C]} )) {
|
||
local pth nl=$'\n' sel=""
|
||
for pth ( $PLUGIN_DIR $fpath_elements $fpath ) {
|
||
[[ -f $pth/$func ]] && { sel=$pth; break; }
|
||
}
|
||
if [[ -z $sel ]] {
|
||
+zi-log '{u-warn}zinit{b-warn}:{error} Could not find autoload function{ehi}:' \
|
||
"{apo}\`{file}${func}{apo}\`{error} anywhere in {var}\$fpath{error}."
|
||
retval=1
|
||
} else {
|
||
eval "function ${(q)${custom[++count*2]}:-$func} {
|
||
local body=\"\$(<${(qqq)sel}/${(qqq)func})\" body2
|
||
() { setopt localoptions extendedglob
|
||
body2=\"\${body##[[:space:]]#${func}[[:blank:]]#\(\)[[:space:]]#\{}\"
|
||
[[ \$body2 != \$body ]] && \
|
||
body2=\"\${body2%\}[[:space:]]#([$nl]#([[:blank:]]#\#[^$nl]#((#e)|[$nl]))#)#}\"
|
||
}
|
||
|
||
functions[${${(q)custom[count*2]}:-$func}]=\"\$body2\"
|
||
${(q)${custom[count*2]}:-$func} \"\$@\"
|
||
}"
|
||
retval=$?
|
||
}
|
||
} else {
|
||
functions[$func]="
|
||
local -a fpath
|
||
fpath=( ${(qqq)PLUGIN_DIR} ${(qqq@)fpath_elements} ${(qqq@)fpath} )
|
||
builtin autoload -X ${(j: :)${(q-)opts[@]}}
|
||
"
|
||
retval=$?
|
||
}
|
||
else
|
||
eval "function ${(q)func} {
|
||
:zinit-reload-and-run ${(qqq)PLUGIN_DIR}"$'\0'"${(pj,\0,)${(qqq)fpath_elements[@]}} ${(qq)opts[*]} ${(q)func} "'"$@"
|
||
}'
|
||
retval=$?
|
||
fi
|
||
(( ZINIT[ALIASES_OPT] )) && builtin setopt aliases
|
||
}
|
||
if (( ${+opts2[(r)-I]} )) {
|
||
${custom[count*2]:-$func}
|
||
retval=$?
|
||
}
|
||
done
|
||
|
||
return $retval
|
||
} # ]]]
|
||
# FUNCTION: :zinit-tmp-subst-bindkey [[[
|
||
# Function defined to hijack plugin's calls to the `bindkey' builtin.
|
||
#
|
||
# The hijacking is to gather report data (which is used in unload).
|
||
:zinit-tmp-subst-bindkey() {
|
||
builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
|
||
builtin setopt extendedglob warncreateglobal typesetsilent noshortloops
|
||
|
||
is-at-least 5.3 && \
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Bindkey ${(j: :)${(q+)@}}" || \
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Bindkey ${(j: :)${(q)@}}"
|
||
|
||
# Remember to perform the actual bindkey call.
|
||
typeset -a pos
|
||
pos=( "$@" )
|
||
|
||
# Check if we have regular bindkey call, i.e.
|
||
# with no options or with -s, plus possible -M
|
||
# option.
|
||
local -A opts
|
||
zparseopts -A opts -D ${(s::):-lLdDAmrsevaR} M: N:
|
||
|
||
if (( ${#opts} == 0 ||
|
||
( ${#opts} == 1 && ${+opts[-M]} ) ||
|
||
( ${#opts} == 1 && ${+opts[-R]} ) ||
|
||
( ${#opts} == 1 && ${+opts[-s]} ) ||
|
||
( ${#opts} <= 2 && ${+opts[-M]} && ${+opts[-s]} ) ||
|
||
( ${#opts} <= 2 && ${+opts[-M]} && ${+opts[-R]} )
|
||
)); then
|
||
local string="${(q)1}" widget="${(q)2}"
|
||
local quoted
|
||
|
||
if [[ -n ${ICE[bindmap]} && ${ZINIT_CUR_BIND_MAP[empty]} -eq 1 ]]; then
|
||
local -a pairs
|
||
pairs=( "${(@s,;,)ICE[bindmap]}" )
|
||
if [[ -n ${(M)pairs:#*\\(#e)} ]] {
|
||
local prev
|
||
pairs=( ${pairs[@]//(#b)((*)\\(#e)|(*))/${match[3]:+${prev:+$prev\;}}${match[3]}${${prev::=${match[2]:+${prev:+$prev\;}}${match[2]}}:+}} )
|
||
}
|
||
pairs=( "${(@)${(@)${(@s:->:)pairs}##[[:space:]]##}%%[[:space:]]##}" )
|
||
ZINIT_CUR_BIND_MAP=( empty 0 )
|
||
(( ${#pairs} > 1 && ${#pairs[@]} % 2 == 0 )) && ZINIT_CUR_BIND_MAP+=( "${pairs[@]}" )
|
||
fi
|
||
|
||
local bmap_val="${ZINIT_CUR_BIND_MAP[${1}]}"
|
||
if (( !ZINIT_CUR_BIND_MAP[empty] )) {
|
||
[[ -z $bmap_val ]] && bmap_val="${ZINIT_CUR_BIND_MAP[${(qqq)1}]}"
|
||
[[ -z $bmap_val ]] && bmap_val="${ZINIT_CUR_BIND_MAP[${(qqq)${(Q)1}}]}"
|
||
[[ -z $bmap_val ]] && { bmap_val="${ZINIT_CUR_BIND_MAP[!${(qqq)1}]}"; integer val=1; }
|
||
[[ -z $bmap_val ]] && bmap_val="${ZINIT_CUR_BIND_MAP[!${(qqq)${(Q)1}}]}"
|
||
}
|
||
if [[ -n $bmap_val ]]; then
|
||
string="${(q)bmap_val}"
|
||
if (( val )) {
|
||
[[ ${pos[1]} = "-M" ]] && pos[4]="$bmap_val" || pos[2]="$bmap_val"
|
||
} else {
|
||
[[ ${pos[1]} = "-M" ]] && pos[3]="${(Q)bmap_val}" || pos[1]="${(Q)bmap_val}"
|
||
}
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" ":::Bindkey: combination <$1> changed to <$bmap_val>${${(M)bmap_val:#hold}:+, i.e. ${ZINIT[col-error]}unmapped${ZINIT[col-rst]}}"
|
||
((1))
|
||
elif [[ ( -n ${bmap_val::=${ZINIT_CUR_BIND_MAP[UPAR]}} && -n ${${ZINIT[UPAR]}[(r);:${(q)1};:]} ) || \
|
||
( -n ${bmap_val::=${ZINIT_CUR_BIND_MAP[DOWNAR]}} && -n ${${ZINIT[DOWNAR]}[(r);:${(q)1};:]} ) || \
|
||
( -n ${bmap_val::=${ZINIT_CUR_BIND_MAP[RIGHTAR]}} && -n ${${ZINIT[RIGHTAR]}[(r);:${(q)1};:]} ) || \
|
||
( -n ${bmap_val::=${ZINIT_CUR_BIND_MAP[LEFTAR]}} && -n ${${ZINIT[LEFTAR]}[(r);:${(q)1};:]} )
|
||
]]; then
|
||
string="${(q)bmap_val}"
|
||
if (( val )) {
|
||
[[ ${pos[1]} = "-M" ]] && pos[4]="$bmap_val" || pos[2]="$bmap_val"
|
||
} else {
|
||
[[ ${pos[1]} = "-M" ]] && pos[3]="${(Q)bmap_val}" || pos[1]="${(Q)bmap_val}"
|
||
}
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" ":::Bindkey: combination <$1> recognized as cursor-key and changed to <${bmap_val}>${${(M)bmap_val:#hold}:+, i.e. ${ZINIT[col-error]}unmapped${ZINIT[col-rst]}}"
|
||
fi
|
||
[[ $bmap_val = hold ]] && return 0
|
||
|
||
local prev="${(q)${(s: :)$(builtin bindkey ${(Q)string})}[-1]#undefined-key}"
|
||
|
||
# "-M map" given?
|
||
if (( ${+opts[-M]} )); then
|
||
local Mopt=-M
|
||
local Marg="${opts[-M]}"
|
||
|
||
Mopt="${(q)Mopt}"
|
||
Marg="${(q)Marg}"
|
||
|
||
quoted="$string $widget $prev $Mopt $Marg"
|
||
else
|
||
quoted="$string $widget $prev"
|
||
fi
|
||
|
||
# -R given?
|
||
if (( ${+opts[-R]} )); then
|
||
local Ropt=-R
|
||
Ropt="${(q)Ropt}"
|
||
|
||
if (( ${+opts[-M]} )); then
|
||
quoted="$quoted $Ropt"
|
||
else
|
||
# Two empty fields for non-existent -M arg.
|
||
local space=_
|
||
space="${(q)space}"
|
||
quoted="$quoted $space $space $Ropt"
|
||
fi
|
||
fi
|
||
|
||
quoted="${(q)quoted}"
|
||
|
||
# Remember the bindkey, only when load is in progress (it can be dstart that leads execution here).
|
||
[[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[BINDKEYS__${ZINIT[CUR_USPL2]}]+="$quoted "
|
||
# Remember for dtrace.
|
||
[[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[BINDKEYS___dtrace/_dtrace]+="$quoted "
|
||
else
|
||
# bindkey -A newkeymap main?
|
||
# Negative indices for KSH_ARRAYS immunity.
|
||
if [[ ${#opts} -eq 1 && ${+opts[-A]} = 1 && ${#pos} = 3 && ${pos[-1]} = main && ${pos[-2]} != -A ]]; then
|
||
# Save a copy of main keymap.
|
||
(( ZINIT[BINDKEY_MAIN_IDX] = ${ZINIT[BINDKEY_MAIN_IDX]:-0} + 1 ))
|
||
local pname="${ZINIT[CUR_PLUGIN]:-_dtrace}"
|
||
local name="${(q)pname}-main-${ZINIT[BINDKEY_MAIN_IDX]}"
|
||
builtin bindkey -N "$name" main
|
||
|
||
# Remember occurence of main keymap substitution, to revert on unload.
|
||
local keys=_ widget=_ prev= optA=-A mapname="${name}" optR=_
|
||
local quoted="${(q)keys} ${(q)widget} ${(q)prev} ${(q)optA} ${(q)mapname} ${(q)optR}"
|
||
quoted="${(q)quoted}"
|
||
|
||
# Remember the bindkey, only when load is in progress (it can be dstart that leads execution here).
|
||
[[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[BINDKEYS__${ZINIT[CUR_USPL2]}]+="$quoted "
|
||
[[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[BINDKEYS___dtrace/_dtrace]+="$quoted "
|
||
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Warning: keymap \`main' copied to \`${name}' because of \`${pos[-2]}' substitution"
|
||
# bindkey -N newkeymap [other].
|
||
elif [[ ${#opts} -eq 1 && ${+opts[-N]} = 1 ]]; then
|
||
local Nopt=-N
|
||
local Narg="${opts[-N]}"
|
||
|
||
local keys=_ widget=_ prev= optN=-N mapname="${Narg}" optR=_
|
||
local quoted="${(q)keys} ${(q)widget} ${(q)prev} ${(q)optN} ${(q)mapname} ${(q)optR}"
|
||
quoted="${(q)quoted}"
|
||
|
||
# Remember the bindkey, only when load is in progress (it can be dstart that leads execution here).
|
||
[[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[BINDKEYS__${ZINIT[CUR_USPL2]}]+="$quoted "
|
||
[[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[BINDKEYS___dtrace/_dtrace]+="$quoted "
|
||
else
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Warning: last bindkey used non-typical options: ${(kv)opts[*]}"
|
||
fi
|
||
fi
|
||
|
||
# Actual bindkey.
|
||
builtin bindkey "${pos[@]}"
|
||
return $? # testable
|
||
} # ]]]
|
||
# FUNCTION: :zinit-tmp-subst-zstyle [[[
|
||
# Function defined to hijack plugin's calls to the `zstyle' builtin.
|
||
#
|
||
# The hijacking is to gather report data (which is used in unload).
|
||
:zinit-tmp-subst-zstyle() {
|
||
builtin setopt localoptions noerrreturn noerrexit extendedglob nowarncreateglobal \
|
||
typesetsilent noshortloops unset
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Zstyle $*"
|
||
|
||
# Remember in order to perform the actual zstyle call.
|
||
typeset -a pos
|
||
pos=( "$@" )
|
||
|
||
# Check if we have regular zstyle call, i.e.
|
||
# with no options or with -e.
|
||
local -a opts
|
||
zparseopts -a opts -D ${(s::):-eLdgabsTtm}
|
||
|
||
if [[ ${#opts} -eq 0 || ( ${#opts} -eq 1 && ${+opts[(r)-e]} = 1 ) ]]; then
|
||
# Have to quote $1, then $2, then concatenate them, then quote them again.
|
||
local pattern="${(q)1}" style="${(q)2}"
|
||
local ps="$pattern $style"
|
||
ps="${(q)ps}"
|
||
|
||
# Remember the zstyle, only when load is in progress (it can be dstart that leads execution here).
|
||
[[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[ZSTYLES__${ZINIT[CUR_USPL2]}]+="$ps "
|
||
# Remember for dtrace.
|
||
[[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[ZSTYLES___dtrace/_dtrace]+=$ps
|
||
else
|
||
if [[ ! ${#opts[@]} = 1 && ( ${+opts[(r)-s]} = 1 || ${+opts[(r)-b]} = 1 || ${+opts[(r)-a]} = 1 ||
|
||
${+opts[(r)-t]} = 1 || ${+opts[(r)-T]} = 1 || ${+opts[(r)-m]} = 1 )
|
||
]]; then
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Warning: last zstyle used non-typical options: ${opts[*]}"
|
||
fi
|
||
fi
|
||
|
||
# Actual zstyle.
|
||
builtin zstyle "${pos[@]}"
|
||
return $? # testable
|
||
} # ]]]
|
||
# FUNCTION: :zinit-tmp-subst-alias [[[
|
||
# Function defined to hijack plugin's calls to the `alias' builtin.
|
||
#
|
||
# The hijacking is to gather report data (which is used in unload).
|
||
:zinit-tmp-subst-alias() {
|
||
builtin setopt localoptions noerrreturn noerrexit extendedglob warncreateglobal \
|
||
typesetsilent noshortloops unset
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Alias $*"
|
||
|
||
# Remember to perform the actual alias call.
|
||
typeset -a pos
|
||
pos=( "$@" )
|
||
|
||
local -a opts
|
||
zparseopts -a opts -D ${(s::):-gs}
|
||
|
||
local a quoted tmp
|
||
for a in "$@"; do
|
||
local aname="${a%%[=]*}"
|
||
local avalue="${a#*=}"
|
||
|
||
# Check if alias is to be redefined.
|
||
(( ${+aliases[$aname]} )) && .zinit-add-report "${ZINIT[CUR_USPL2]}" "Warning: redefining alias \`${aname}', previous value: ${aliases[$aname]}"
|
||
|
||
local bname=${(q)aliases[$aname]}
|
||
aname="${(q)aname}"
|
||
|
||
if (( ${+opts[(r)-s]} )); then
|
||
tmp=-s
|
||
tmp="${(q)tmp}"
|
||
quoted="$aname $bname $tmp"
|
||
elif (( ${+opts[(r)-g]} )); then
|
||
tmp=-g
|
||
tmp="${(q)tmp}"
|
||
quoted="$aname $bname $tmp"
|
||
else
|
||
quoted="$aname $bname"
|
||
fi
|
||
|
||
quoted="${(q)quoted}"
|
||
|
||
# Remember the alias, only when load is in progress (it can be dstart that leads execution here).
|
||
[[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[ALIASES__${ZINIT[CUR_USPL2]}]+="$quoted "
|
||
# Remember for dtrace.
|
||
[[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[ALIASES___dtrace/_dtrace]+="$quoted "
|
||
done
|
||
|
||
# Actual alias.
|
||
builtin alias "${pos[@]}"
|
||
return $? # testable
|
||
} # ]]]
|
||
# FUNCTION: :zinit-tmp-subst-zle [[[.
|
||
# Function defined to hijack plugin's calls to the `zle' builtin.
|
||
#
|
||
# The hijacking is to gather report data (which is used in unload).
|
||
:zinit-tmp-subst-zle() {
|
||
builtin setopt localoptions noerrreturn noerrexit extendedglob warncreateglobal \
|
||
typesetsilent noshortloops unset
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Zle $*"
|
||
|
||
# Remember to perform the actual zle call.
|
||
typeset -a pos
|
||
pos=( "$@" )
|
||
|
||
builtin set -- "${@:#--}"
|
||
|
||
# Try to catch game-changing "-N".
|
||
if [[ ( $1 = -N && ( $# = 2 || $# = 3 ) ) || ( $1 = -C && $# = 4 ) ]]; then
|
||
# Hooks.
|
||
if [[ ${ZINIT_ZLE_HOOKS_LIST[$2]} = 1 ]]; then
|
||
local quoted="$2"
|
||
quoted="${(q)quoted}"
|
||
# Remember only when load is in progress (it can be dstart that leads execution here).
|
||
[[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[WIDGETS_DELETE__${ZINIT[CUR_USPL2]}]+="$quoted "
|
||
# Remember for dtrace.
|
||
[[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[WIDGETS_DELETE___dtrace/_dtrace]+="$quoted "
|
||
# These will be saved and restored.
|
||
elif (( ${+widgets[$2]} )); then
|
||
# Have to remember original widget "$2" and
|
||
# the copy that it's going to be done.
|
||
local widname="$2" targetfun="${${${(M)1:#-C}:+$4}:-$3}"
|
||
local completion_widget="${${(M)1:#-C}:+$3}"
|
||
local saved_widcontents="${widgets[$widname]}"
|
||
|
||
widname="${(q)widname}"
|
||
completion_widget="${(q)completion_widget}"
|
||
targetfun="${(q)targetfun}"
|
||
saved_widcontents="${(q)saved_widcontents}"
|
||
local quoted="$1 $widname $completion_widget $targetfun $saved_widcontents"
|
||
quoted="${(q)quoted}"
|
||
# Remember only when load is in progress (it can be dstart that leads execution here).
|
||
[[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[WIDGETS_SAVED__${ZINIT[CUR_USPL2]}]+="$quoted "
|
||
# Remember for dtrace.
|
||
[[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[WIDGETS_SAVED___dtrace/_dtrace]+="$quoted "
|
||
# These will be deleted.
|
||
else
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Note: a new widget created via zle -N: \`$2'"
|
||
local quoted="$2"
|
||
quoted="${(q)quoted}"
|
||
# Remember only when load is in progress (it can be dstart that leads execution here).
|
||
[[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[WIDGETS_DELETE__${ZINIT[CUR_USPL2]}]+="$quoted "
|
||
# Remember for dtrace.
|
||
[[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[WIDGETS_DELETE___dtrace/_dtrace]+="$quoted "
|
||
fi
|
||
fi
|
||
|
||
# Actual zle.
|
||
builtin zle "${pos[@]}"
|
||
return $? # testable
|
||
} # ]]]
|
||
# FUNCTION: :zinit-tmp-subst-compdef [[[
|
||
# Function defined to hijack plugin's calls to the `compdef' function.
|
||
# The hijacking is not only for reporting, but also to save compdef
|
||
# calls so that `compinit' can be called after loading plugins.
|
||
:zinit-tmp-subst-compdef() {
|
||
builtin setopt localoptions noerrreturn noerrexit extendedglob warncreateglobal \
|
||
typesetsilent noshortloops unset
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Saving \`compdef $*' for replay"
|
||
ZINIT_COMPDEF_REPLAY+=( "${(j: :)${(q)@}}" )
|
||
|
||
return 0 # testable
|
||
} # ]]]
|
||
# FUNCTION: .zinit-tmp-subst-on [[[
|
||
# Turn on temporary substituting of functions of builtins and functions according to passed
|
||
# mode ("load", "light", "light-b" or "compdef"). The temporary substituting of functions is
|
||
# to gather report data, and to hijack 'autoload', 'bindkey' and 'compdef' calls.
|
||
.zinit-tmp-subst-on() {
|
||
local mode="$1"
|
||
|
||
# Enable temporary substituting of functions only once.
|
||
#
|
||
# One could expect possibility of widening of temporary substituting of functions, however
|
||
# such sequence doesn't exist, e.g. "light" then "load"/"dtrace", "compdef" then "load"/
|
||
# "dtrace", "light" then "compdef", "compdef" then "light".
|
||
#
|
||
# It is always "dtrace" then "load" (i.e. dtrace then load) "dtrace" then "light" (i.e.:
|
||
# dtrace then light load) "dtrace" then "compdef" (i.e.: dtrace then snippet).
|
||
[[ ${ZINIT[TMP_SUBST]} != inactive ]] && builtin return 0
|
||
|
||
ZINIT[TMP_SUBST]="$mode"
|
||
|
||
# The point about backuping is: does the key exist in functions array.
|
||
# If it does exist, then it will also exist as ZINIT[bkp-*].
|
||
|
||
# Defensive code, shouldn't be needed.
|
||
builtin unset "ZINIT[bkp-autoload]" "ZINIT[bkp-compdef]" # 0, E.
|
||
|
||
if [[ $mode != compdef ]]; then
|
||
# 0. Used, but not in temporary restoration, which doesn't happen for autoload.
|
||
(( ${+functions[autoload]} )) && ZINIT[bkp-autoload]="${functions[autoload]}"
|
||
functions[autoload]=':zinit-tmp-subst-autoload "$@";'
|
||
fi
|
||
|
||
# E. Always shade compdef.
|
||
(( ${+functions[compdef]} )) && ZINIT[bkp-compdef]="${functions[compdef]}"
|
||
functions[compdef]=':zinit-tmp-subst-compdef "$@";'
|
||
|
||
# Temporarily replace `source' if subst'' given.
|
||
if [[ -n ${ICE[subst]} ]] {
|
||
(( ${+functions[source]} )) && ZINIT[bkp-source]="${functions[source]}"
|
||
(( ${+functions[.]} )) && ZINIT[bkp-.]="${functions[.]}"
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
functions[source]=':zinit-tmp-subst-source "$@";'
|
||
functions[.]=':zinit-tmp-subst-source "$@";'
|
||
}
|
||
|
||
# Light and compdef temporary substituting of functions stops here. Dtrace and load go on.
|
||
[[ ( $mode = light && ${+ICE[trackbinds]} -eq 0 ) || $mode = compdef ]] && return 0
|
||
|
||
# Defensive code, shouldn't be needed. A, B, C, D.
|
||
builtin unset "ZINIT[bkp-bindkey]" "ZINIT[bkp-zstyle]" "ZINIT[bkp-alias]" "ZINIT[bkp-zle]"
|
||
|
||
# A.
|
||
(( ${+functions[bindkey]} )) && ZINIT[bkp-bindkey]="${functions[bindkey]}"
|
||
functions[bindkey]=':zinit-tmp-subst-bindkey "$@";'
|
||
|
||
# B, when `zinit light -b ...' or when `zinit ice trackbinds ...; zinit light ...'.
|
||
[[ $mode = light-b || ( $mode = light && ${+ICE[trackbinds]} -eq 1 ) ]] && return 0
|
||
|
||
# B.
|
||
(( ${+functions[zstyle]} )) && ZINIT[bkp-zstyle]="${functions[zstyle]}"
|
||
functions[zstyle]=':zinit-tmp-subst-zstyle "$@";'
|
||
|
||
# C.
|
||
(( ${+functions[alias]} )) && ZINIT[bkp-alias]="${functions[alias]}"
|
||
functions[alias]=':zinit-tmp-subst-alias "$@";'
|
||
|
||
# D.
|
||
(( ${+functions[zle]} )) && ZINIT[bkp-zle]="${functions[zle]}"
|
||
functions[zle]=':zinit-tmp-subst-zle "$@";'
|
||
|
||
builtin return 0
|
||
} # ]]]
|
||
# FUNCTION: .zinit-tmp-subst-off [[[
|
||
# Turn off temporary substituting of functions completely for a given mode ("load", "light",
|
||
# "light-b" (i.e. the `trackbinds' mode) or "compdef").
|
||
.zinit-tmp-subst-off() {
|
||
builtin setopt localoptions noerrreturn noerrexit extendedglob warncreateglobal \
|
||
typesetsilent noshortloops unset noaliases
|
||
local mode="$1"
|
||
|
||
# Disable temporary substituting of functions only once.
|
||
# Disable temporary substituting of functions only the way it was enabled first.
|
||
[[ ${ZINIT[TMP_SUBST]} = inactive || ${ZINIT[TMP_SUBST]} != $mode ]] && return 0
|
||
|
||
ZINIT[TMP_SUBST]=inactive
|
||
|
||
if [[ $mode != compdef ]]; then
|
||
# 0. Unfunction autoload.
|
||
(( ${+ZINIT[bkp-autoload]} )) && functions[autoload]="${ZINIT[bkp-autoload]}" || unfunction autoload
|
||
fi
|
||
|
||
# E. Restore original compdef if it existed.
|
||
(( ${+ZINIT[bkp-compdef]} )) && functions[compdef]="${ZINIT[bkp-compdef]}" || unfunction compdef
|
||
|
||
# Restore the possible source function.
|
||
(( ${+ZINIT[bkp-source]} )) && functions[source]="${ZINIT[bkp-source]}" || unfunction source 2>/dev/null
|
||
(( ${+ZINIT[bkp-.]} )) && functions[.]="${ZINIT[bkp-.]}" || unfunction . 2> /dev/null
|
||
|
||
# Light and compdef temporary substituting of functions stops here.
|
||
[[ ( $mode = light && ${+ICE[trackbinds]} -eq 0 ) || $mode = compdef ]] && return 0
|
||
|
||
# Unfunction temporary substituting of functions functions.
|
||
|
||
# A.
|
||
(( ${+ZINIT[bkp-bindkey]} )) && functions[bindkey]="${ZINIT[bkp-bindkey]}" || unfunction bindkey
|
||
|
||
# When `zinit light -b ...' or when `zinit ice trackbinds ...; zinit light ...'.
|
||
[[ $mode = light-b || ( $mode = light && ${+ICE[trackbinds]} -eq 1 ) ]] && return 0
|
||
|
||
# B.
|
||
(( ${+ZINIT[bkp-zstyle]} )) && functions[zstyle]="${ZINIT[bkp-zstyle]}" || unfunction zstyle
|
||
# C.
|
||
(( ${+ZINIT[bkp-alias]} )) && functions[alias]="${ZINIT[bkp-alias]}" || unfunction alias
|
||
# D.
|
||
(( ${+ZINIT[bkp-zle]} )) && functions[zle]="${ZINIT[bkp-zle]}" || unfunction zle
|
||
|
||
return 0
|
||
} # ]]]
|
||
# FUNCTION: pmodload [[[
|
||
# Compatibility with Prezto. Calls can be recursive
|
||
(( ${+functions[pmodload]} )) || pmodload() {
|
||
local -A ices
|
||
(( ${+ICE} )) && ices=( "${(kv)ICE[@]}" teleid '' )
|
||
local -A ICE ZINIT_ICE
|
||
ICE=( "${(kv)ices[@]}" ) ZINIT_ICE=( "${(kv)ices[@]}" )
|
||
while (( $# )); do
|
||
ICE[teleid]="PZT::modules/$1${ICE[svn]-/init.zsh}"
|
||
ZINIT_ICE[teleid]="PZT::modules/$1${ICE[svn]-/init.zsh}"
|
||
if zstyle -t ":prezto:module:$1" loaded 'yes' 'no'; then
|
||
shift
|
||
continue
|
||
else
|
||
[[ -z ${ZINIT_SNIPPETS[PZT::modules/$1${ICE[svn]-/init.zsh}]} && -z ${ZINIT_SNIPPETS[https://github.com/sorin-ionescu/prezto/trunk/modules/$1${ICE[svn]-/init.zsh}]} ]] && .zinit-load-snippet PZT::modules/"$1${ICE[svn]-/init.zsh}"
|
||
shift
|
||
fi
|
||
done
|
||
} # ]]]
|
||
|
||
#
|
||
# Diff functions.
|
||
#
|
||
|
||
# FUNCTION: .zinit-diff-functions [[[
|
||
# Implements detection of newly created functions. Performs
|
||
# data gathering, computation is done in *-compute().
|
||
#
|
||
# $1 - user/plugin (i.e. uspl2 format)
|
||
# $2 - command, can be "begin" or "end"
|
||
.zinit-diff-functions() {
|
||
local uspl2="$1"
|
||
local cmd="$2"
|
||
|
||
[[ $cmd = begin ]] && \
|
||
{ [[ -z ${ZINIT[FUNCTIONS_BEFORE__$uspl2]} ]] && \
|
||
ZINIT[FUNCTIONS_BEFORE__$uspl2]="${(j: :)${(qk)functions[@]}}"
|
||
} || \
|
||
ZINIT[FUNCTIONS_AFTER__$uspl2]+=" ${(j: :)${(qk)functions[@]}}"
|
||
} # ]]]
|
||
# FUNCTION: .zinit-diff-options [[[
|
||
# Implements detection of change in option state. Performs
|
||
# data gathering, computation is done in *-compute().
|
||
#
|
||
# $1 - user/plugin (i.e. uspl2 format)
|
||
# $2 - command, can be "begin" or "end"
|
||
.zinit-diff-options() {
|
||
local IFS=" "
|
||
|
||
[[ $2 = begin ]] && \
|
||
{ [[ -z ${ZINIT[OPTIONS_BEFORE__$uspl2]} ]] && \
|
||
ZINIT[OPTIONS_BEFORE__$1]="${(kv)options[@]}"
|
||
} || \
|
||
ZINIT[OPTIONS_AFTER__$1]+=" ${(kv)options[@]}"
|
||
} # ]]]
|
||
# FUNCTION: .zinit-diff-env [[[
|
||
# Implements detection of change in PATH and FPATH.
|
||
#
|
||
# $1 - user/plugin (i.e. uspl2 format)
|
||
# $2 - command, can be "begin" or "end"
|
||
.zinit-diff-env() {
|
||
typeset -a tmp
|
||
local IFS=" "
|
||
|
||
[[ $2 = begin ]] && {
|
||
{ [[ -z ${ZINIT[PATH_BEFORE__$uspl2]} ]] && \
|
||
tmp=( "${(q)path[@]}" )
|
||
ZINIT[PATH_BEFORE__$1]="${tmp[*]}"
|
||
}
|
||
{ [[ -z ${ZINIT[FPATH_BEFORE__$uspl2]} ]] && \
|
||
tmp=( "${(q)fpath[@]}" )
|
||
ZINIT[FPATH_BEFORE__$1]="${tmp[*]}"
|
||
}
|
||
} || {
|
||
tmp=( "${(q)path[@]}" )
|
||
ZINIT[PATH_AFTER__$1]+=" ${tmp[*]}"
|
||
tmp=( "${(q)fpath[@]}" )
|
||
ZINIT[FPATH_AFTER__$1]+=" ${tmp[*]}"
|
||
}
|
||
} # ]]]
|
||
# FUNCTION: .zinit-diff-parameter [[[
|
||
# Implements detection of change in any parameter's existence and type.
|
||
# Performs data gathering, computation is done in *-compute().
|
||
#
|
||
# $1 - user/plugin (i.e. uspl2 format)
|
||
# $2 - command, can be "begin" or "end"
|
||
.zinit-diff-parameter() {
|
||
typeset -a tmp
|
||
|
||
[[ $2 = begin ]] && {
|
||
{ [[ -z ${ZINIT[PARAMETERS_BEFORE__$uspl2]} ]] && \
|
||
ZINIT[PARAMETERS_BEFORE__$1]="${(j: :)${(qkv)parameters[@]}}"
|
||
}
|
||
} || {
|
||
ZINIT[PARAMETERS_AFTER__$1]+=" ${(j: :)${(qkv)parameters[@]}}"
|
||
}
|
||
} # ]]]
|
||
# FUNCTION: .zinit-diff [[[
|
||
# Performs diff actions of all types
|
||
.zinit-diff() {
|
||
.zinit-diff-functions "$1" "$2"
|
||
.zinit-diff-options "$1" "$2"
|
||
.zinit-diff-env "$1" "$2"
|
||
.zinit-diff-parameter "$1" "$2"
|
||
} # ]]]
|
||
|
||
#
|
||
# Utility functions.
|
||
#
|
||
|
||
# FUNCTION: .zinit-get-mtime-into [[[
|
||
.zinit-get-mtime-into() {
|
||
if (( ZINIT[HAVE_ZSTAT] )) {
|
||
local -a arr
|
||
{ zstat +mtime -A arr "$1"; } 2>/dev/null
|
||
: ${(P)2::="${arr[1]}"}
|
||
} else {
|
||
{ : ${(P)2::="$(stat -c %Y "$1")"}; } 2>/dev/null
|
||
}
|
||
} # ]]]
|
||
# FUNCTION: .zinit-cd-quiet [[[
|
||
# Changes directory without running chpwd hooks or touching the directory stack.
|
||
#
|
||
# $1 - directory to change into
|
||
.zinit-cd-quiet() {
|
||
() { setopt localoptions noautopushd; builtin cd -q "$1"; } "$1"
|
||
} # ]]]
|
||
# FUNCTION: .zinit-restore-dir [[[
|
||
# Returns to $1 without leaving the visited directory as the `cd -' target.
|
||
#
|
||
# The directory `cd -' goes to is tracked internally by zsh and is only updated
|
||
# by a real cd/pushd/popd, never by assigning to $OLDPWD. The only way to make
|
||
# `cd -' forget the directory we temporarily visited is to cd through the
|
||
# original $OLDPWD for real on the way back. Do not simplify this to a single
|
||
# cd plus an $OLDPWD assignment.
|
||
#
|
||
# Callers call it unconditionally: an ice body that cds on its own must be
|
||
# undone even when zinit itself never cd'd, so the fast path below keeps the
|
||
# case where nothing actually moved free.
|
||
#
|
||
# $1 - the $PWD to return to
|
||
# $2 - the $OLDPWD to restore; may be empty or since-deleted, in which case we
|
||
# bounce through $1 so that `cd -' degrades to a harmless no-op
|
||
.zinit-restore-dir() {
|
||
[[ $PWD == "$1" && $OLDPWD == "$2" ]] && return 0
|
||
[[ -n $2 && -d $2 ]] && .zinit-cd-quiet "$2" || .zinit-cd-quiet "$1"
|
||
.zinit-cd-quiet "$1"
|
||
} # ]]]
|
||
# FUNCTION: .zinit-any-to-user-plugin [[[
|
||
# Allows elastic plugin-spec across the code.
|
||
#
|
||
# $1 - plugin spec (4 formats: user---plugin, user/plugin, user, plugin)
|
||
# $2 - plugin (only when $1 - i.e. user - given)
|
||
#
|
||
# $REPLY - user and plugin
|
||
.zinit-any-to-user-plugin() {
|
||
builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
|
||
builtin setopt extendedglob typesetsilent noshortloops rcquotes \
|
||
${${${+reply}:#0}:+warncreateglobal}
|
||
|
||
# Two components given?
|
||
# That's a pretty fast track to call this function this way.
|
||
if [[ -n $2 ]]; then
|
||
2=${~2}
|
||
reply=( ${1:-${${(M)2#/}:+%}} ${${${(M)1#%}:+$2}:-${2//---//}} )
|
||
return 0
|
||
fi
|
||
|
||
# Is it absolute path?
|
||
if [[ $1 = /* ]]; then
|
||
reply=( % $1 )
|
||
return 0
|
||
fi
|
||
|
||
# Is it absolute path in zinit format?
|
||
if [[ $1 = %* ]]; then
|
||
local -A map
|
||
map=( ZPFX "$ZPFX" HOME $HOME SNIPPETS $ZINIT[SNIPPETS_DIR] PLUGINS $ZINIT[PLUGINS_DIR] )
|
||
reply=( % ${${1/(#b)(#s)%(${(~j:|:)${(@k)map}}|)/$map[$match[1]]}} )
|
||
reply[2]=${~reply[2]}
|
||
return 0
|
||
fi
|
||
|
||
# Rest is for single component given.
|
||
# It doesn't touch $2
|
||
|
||
1=${1//---//}
|
||
if [[ $1 = */* ]]; then
|
||
reply=( ${1%%/*} ${1#*/} )
|
||
return 0
|
||
fi
|
||
|
||
reply=( "" "${1:-_unknown}" )
|
||
|
||
return 0
|
||
} # ]]]
|
||
# FUNCTION: .zinit-any-to-pid [[[
|
||
.zinit-any-to-pid() {
|
||
builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
|
||
builtin setopt extendedglob typesetsilent noshortloops rcquotes \
|
||
${${${+REPLY}:#0}:+warncreateglobal}
|
||
|
||
1=${~1} 2=${~2}
|
||
|
||
# Two components given?
|
||
if [[ -n $2 ]] {
|
||
if [[ $1 == (%|/)* || ( -z $1 && $2 == /* ) ]] {
|
||
.zinit-util-shands-path $1${${(M)1#(%/?|%[^/]|/?)}:+/}$2
|
||
REPLY=${${REPLY:#%*}:+%}$REPLY
|
||
} else {
|
||
REPLY=$1${1:+/}$2
|
||
}
|
||
return 0
|
||
}
|
||
|
||
# Is it absolute path?
|
||
if [[ $1 = (%|/|\~)* ]] {
|
||
.zinit-util-shands-path $1
|
||
REPLY=${${REPLY:#%*}:+%}$REPLY
|
||
return 0
|
||
}
|
||
|
||
# Single component given.
|
||
REPLY=${1//---//}
|
||
|
||
return 0
|
||
} # ]]]
|
||
# FUNCTION: .zinit-util-shands-path [[[
|
||
# Replaces parts of path with %HOME, etc.
|
||
.zinit-util-shands-path() {
|
||
builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
|
||
builtin setopt extendedglob typesetsilent noshortloops rcquotes \
|
||
${${${+REPLY}:#0}:+warncreateglobal}
|
||
|
||
local -A map
|
||
map=( \~ %HOME $HOME %HOME $ZINIT[SNIPPETS_DIR] %SNIPPETS $ZINIT[PLUGINS_DIR] %PLUGINS
|
||
"$ZPFX" %ZPFX HOME %HOME SNIPPETS %SNIPPETS PLUGINS %PLUGINS "" "" )
|
||
REPLY=${${1/(#b)(#s)(%|)(${(~j:|:)${(@k)map:#$HOME}}|$HOME|)/$map[$match[2]]}}
|
||
return 0
|
||
} # ]]]
|
||
# FUNCTION: .zinit-find-other-matches [[[
|
||
# Plugin's main source file is in general `name.plugin.zsh'. However,
|
||
# there can be different conventions, if that file is not found, then
|
||
# this functions examines other conventions in the most sane order.
|
||
.zinit-find-other-matches() {
|
||
local pdir_path="$1" pbase="$2" limit="$3"
|
||
|
||
# Only *.plugin.zsh load? When loading service.
|
||
if [[ $limit == 1 ]]; then
|
||
reply=( "$pdir_path"/*.plugin.zsh(DN) )
|
||
elif [[ $limit == 0 ]]; then
|
||
reply=( "$pdir_path"/*.service.zsh(DN) )
|
||
else
|
||
if [[ -e $pdir_path/init.zsh ]] {
|
||
reply=( "$pdir_path"/init.zsh )
|
||
} elif [[ -e $pdir_path/$pbase.zsh-theme ]] {
|
||
reply=( "$pdir_path/$pbase".zsh-theme )
|
||
} elif [[ -e $pdir_path/$pbase.theme.zsh ]] {
|
||
reply=( "$pdir_path/$pbase".theme.zsh )
|
||
} else {
|
||
reply=(
|
||
"$pdir_path"/*.plugin.zsh(DN) "$pdir_path"/*.zsh-theme(DN) "$pdir_path"/*.lib.zsh(DN)
|
||
"$pdir_path"/*.zsh(DN) "$pdir_path"/*.sh(DN) "$pdir_path"/.zshrc(DN)
|
||
)
|
||
}
|
||
fi
|
||
reply=( "${(u)reply[@]}" )
|
||
|
||
return $(( ${#reply} > 0 ? 0 : 1 ))
|
||
} # ]]]
|
||
# FUNCTION: .zinit-register-plugin [[[
|
||
# Adds the plugin to ZINIT_REGISTERED_PLUGINS array and to the
|
||
# zsh_loaded_plugins array (managed according to the plugin standard:
|
||
# https://zdharma-continuum.github.io/Zsh-100-Commits-Club/Zsh-Plugin-Standard.html).
|
||
.zinit-register-plugin() {
|
||
local uspl2="$1" mode="$2" teleid="$3"
|
||
integer ret=0
|
||
|
||
if [[ -z ${ZINIT_REGISTERED_PLUGINS[(r)$uspl2]} ]]; then
|
||
ZINIT_REGISTERED_PLUGINS+=( "$uspl2" )
|
||
else
|
||
# Allow overwrite-load, however warn about it.
|
||
[[ -z ${ZINIT[TEST]}${${+ICE[wait]}:#0}${ICE[load]}${ICE[subscribe]} && ${ZINIT[MUTE_WARNINGS]} != (1|true|on|yes) ]] && +zi-log "{u-warn}Warning{b-warn}:{rst} plugin {apo}\`{pid}${uspl2}{apo}\`{rst} already registered, will overwrite-load."
|
||
ret=1
|
||
fi
|
||
|
||
# Support Zsh plugin standard.
|
||
zsh_loaded_plugins+=( "$teleid" )
|
||
|
||
# Full or light load?
|
||
[[ $mode == light ]] && ZINIT[STATES__$uspl2]=1 || ZINIT[STATES__$uspl2]=2
|
||
|
||
ZINIT_REPORTS[$uspl2]= ZINIT_CUR_BIND_MAP=( empty 1 )
|
||
# Functions.
|
||
ZINIT[FUNCTIONS_BEFORE__$uspl2]= ZINIT[FUNCTIONS_AFTER__$uspl2]=
|
||
ZINIT[FUNCTIONS__$uspl2]=
|
||
# Objects.
|
||
ZINIT[ZSTYLES__$uspl2]= ZINIT[BINDKEYS__$uspl2]=
|
||
ZINIT[ALIASES__$uspl2]=
|
||
# Widgets.
|
||
ZINIT[WIDGETS_SAVED__$uspl2]= ZINIT[WIDGETS_DELETE__$uspl2]=
|
||
# Rest (options and (f)path).
|
||
ZINIT[OPTIONS__$uspl2]= ZINIT[PATH__$uspl2]=
|
||
ZINIT[OPTIONS_BEFORE__$uspl2]= ZINIT[OPTIONS_AFTER__$uspl2]=
|
||
ZINIT[FPATH__$uspl2]=
|
||
|
||
return ret
|
||
} # ]]]
|
||
# FUNCTION: .zinit-get-object-path [[[
|
||
.zinit-get-object-path() {
|
||
local type="$1" id_as="$2" local_dir dirname
|
||
integer exists
|
||
|
||
id_as="${ICE[id-as]:-$id_as}"
|
||
|
||
# Remove leading whitespace and trailing /.
|
||
id_as="${${id_as#"${id_as%%[! $'\t']*}"}%/}"
|
||
|
||
for type ( ${=${${(M)type:#AUTO}:+snippet plugin}:-$type} ) {
|
||
if [[ $type == snippet ]] {
|
||
dirname="${${id_as%%\?*}:t}"
|
||
local_dir="${${${id_as%%\?*}/:\/\//--}:h}"
|
||
[[ $local_dir = . ]] && local_dir= || local_dir="${${${${${local_dir#/}//\//--}//=/-EQ-}//\?/-QM-}//\&/-AMP-}"
|
||
local_dir="${ZINIT[SNIPPETS_DIR]}${local_dir:+/$local_dir}"
|
||
} else {
|
||
.zinit-any-to-user-plugin "$id_as"
|
||
local_dir=${${${(M)reply[-2]:#%}:+${reply[2]}}:-${ZINIT[PLUGINS_DIR]}/${id_as//\//---}}
|
||
[[ $id_as == _local/* && -d $local_dir && ! -d $local_dir/._zinit ]] && command mkdir -p "$local_dir"/._zinit
|
||
dirname=""
|
||
}
|
||
[[ -e $local_dir/${dirname:+$dirname/}._zinit || \
|
||
-e $local_dir/${dirname:+$dirname/}._zplugin ]] && exists=1
|
||
|
||
(( exists )) && break
|
||
}
|
||
|
||
reply=( "$local_dir" "$dirname" "$exists" )
|
||
REPLY="$local_dir${dirname:+/$dirname}"
|
||
|
||
return $(( 1 - exists ))
|
||
} # ]]]
|
||
# FUNCTION: @zinit-substitute [[[
|
||
@zinit-substitute() {
|
||
builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
|
||
builtin setopt extendedglob warncreateglobal typesetsilent noshortloops
|
||
|
||
local -A ___subst_map
|
||
___subst_map=(
|
||
"%ID%" "${id_as_clean:-$id_as}"
|
||
"%USER%" "$user"
|
||
"%PLUGIN%" "${plugin:-$save_url}"
|
||
"%URL%" "${save_url:-${user:+$user/}$plugin}"
|
||
"%DIR%" "${local_path:-$local_dir${dirname:+/$dirname}}"
|
||
'$ZPFX' "$ZPFX"
|
||
'${ZPFX}' "$ZPFX"
|
||
'%OS%' "${OSTYPE%(-gnu|[0-9]##)}" '%MACH%' "$MACHTYPE" '%CPU%' "$CPUTYPE"
|
||
'%VENDOR%' "$VENDOR" '%HOST%' "$HOST" '%UID%' "$UID" '%GID%' "$GID"
|
||
)
|
||
if [[ -n ${ICE[param]} && ${ZINIT[SUBST_DONE_FOR]} != ${ICE[param]} ]] {
|
||
ZINIT[SUBST_DONE_FOR]=${ICE[param]}
|
||
ZINIT[PARAM_SUBST]=
|
||
local -a ___params
|
||
___params=( ${(s.;.)ICE[param]} )
|
||
local ___param ___from ___to
|
||
for ___param ( ${___params[@]} ) {
|
||
local ___from=${${___param%%([[:space:]]|)(->|→)*}##[[:space:]]##} \
|
||
___to=${${___param#*(->|→)([[:space:]]|)}%[[:space:]]}
|
||
___from=${___from//((#s)[[:space:]]##|[[:space:]]##(#e))/}
|
||
___to=${___to//((#s)[[:space:]]##|[[:space:]]##(#e))/}
|
||
ZINIT[PARAM_SUBST]+="%${(q)___from}% ${(q)___to} "
|
||
}
|
||
}
|
||
|
||
local -a ___add
|
||
___add=( "${ICE[param]:+${(@Q)${(@z)ZINIT[PARAM_SUBST]}}}" )
|
||
(( ${#___add} % 2 == 0 )) && ___subst_map+=( "${___add[@]}" )
|
||
|
||
local ___var_name
|
||
for ___var_name; do
|
||
local ___value=${(P)___var_name}
|
||
___value=${___value//(#m)(%[a-zA-Z0-9]##%|\$ZPFX|\$\{ZPFX\})/${___subst_map[$MATCH]}}
|
||
: ${(P)___var_name::=$___value}
|
||
done
|
||
} # ]]]
|
||
# FUNCTION: @zinit-register-annex [[[
|
||
# Registers the z-annex inside Zinit – i.e. an Zinit extension
|
||
@zinit-register-annex() {
|
||
builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
|
||
# See comment in zinit-register-hook() why nobanghist is needed
|
||
builtin setopt nobanghist
|
||
local name="$1" type="$2" handler="$3" helphandler="$4" icemods="$5" key="z-annex ${(q)2}"
|
||
ZINIT_EXTS[seqno]=$(( ${ZINIT_EXTS[seqno]:-0} + 1 ))
|
||
ZINIT_EXTS[$key${${(M)type#hook:}:+ ${ZINIT_EXTS[seqno]}}]="${ZINIT_EXTS[seqno]} z-annex-data: ${(q)name} ${(q)type} ${(q)handler} ${(q)helphandler} ${(q)icemods}"
|
||
() {
|
||
builtin emulate -LR zsh -o extendedglob ${=${options[xtrace]:#off}:+-o xtrace}
|
||
# See comment in zinit-register-hook() why nobanghist is needed
|
||
builtin setopt nobanghist
|
||
integer index="${type##[%a-zA-Z:_!-]##}"
|
||
ZINIT_EXTS[ice-mods]="${ZINIT_EXTS[ice-mods]}${icemods:+|}${(j:|:)${(@)${(@s:|:)icemods}/(#b)(#s)(?)/$index-$match[1]}}"
|
||
}
|
||
} # ]]]
|
||
# FUNCTION: @zinit-register-hook [[[
|
||
# Registers the z-annex inside Zinit (i.e., an Zinit extension)
|
||
@zinit-register-hook() {
|
||
builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
|
||
# zsh per default behaves differently in interactive sessions (escapes !) and
|
||
# non-interactive ones (does not). Setting 'nobanghist' option disables backslash
|
||
# escaping for "!" even in interactive sessions.
|
||
# Exclamation marks are used in a lot of hock names.
|
||
builtin setopt extendedglob nobanghist noshortloops typesetsilent warncreateglobal
|
||
local name="$1" type="$2" handler="$3" icemods="$4" key="zinit ${(q)2}"
|
||
ZINIT_EXTS2[seqno]=$(( ${ZINIT_EXTS2[seqno]:-0} + 1 ))
|
||
ZINIT_EXTS2[$key${${(M)type#hook:}:+ ${ZINIT_EXTS2[seqno]}}]="${ZINIT_EXTS2[seqno]} z-annex-data: ${(q)name} ${(q)type} ${(q)handler} '' ${(q)icemods}"
|
||
ZINIT_EXTS2[ice-mods]="${ZINIT_EXTS2[ice-mods]}${icemods:+|}$icemods"
|
||
} # ]]]
|
||
# FUNCTION: @zsh-plugin-run-on-unload [[[
|
||
# The Plugin Standard required mechanism, see:
|
||
# https://zdharma-continuum.github.io/Zsh-100-Commits-Club/Zsh-Plugin-Standard.html
|
||
@zsh-plugin-run-on-unload() {
|
||
ICE[ps-on-unload]="${(j.; .)@}"
|
||
.zinit-pack-ice "$id_as" ""
|
||
} # ]]]
|
||
# FUNCTION: @zsh-plugin-run-on-update [[[
|
||
# The Plugin Standard required mechanism
|
||
@zsh-plugin-run-on-update() {
|
||
ICE[ps-on-update]="${(j.; .)@}"
|
||
.zinit-pack-ice "$id_as" ""
|
||
} # ]]]
|
||
|
||
#
|
||
# Remaining functions.
|
||
#
|
||
|
||
# FUNCTION: .zinit-prepare-home [[[
|
||
# Creates all directories needed by Zinit, first checks if they
|
||
# already exist.
|
||
.zinit-prepare-home() {
|
||
[[ -n ${ZINIT[HOME_READY]} ]] && return
|
||
ZINIT[HOME_READY]=1
|
||
|
||
[[ ! -d ${ZINIT[HOME_DIR]} ]] && {
|
||
command mkdir -p "${ZINIT[HOME_DIR]}"
|
||
# For compaudit.
|
||
command chmod go-w "${ZINIT[HOME_DIR]}"
|
||
# Also set up */bin and ZPFX in general.
|
||
command mkdir -p "${ZPFX:-ZINIT[HOME_DIR]/polaris}/bin"
|
||
}
|
||
[[ ! -d ${ZINIT[PLUGINS_DIR]}/_local---zinit ]] && {
|
||
command rm -rf "${ZINIT[PLUGINS_DIR]:-${TMPDIR:-/tmp}/132bcaCAB}/_local---zplugin"
|
||
command mkdir -p "${ZINIT[PLUGINS_DIR]}/_local---zinit"
|
||
command chmod go-w "${ZINIT[PLUGINS_DIR]}"
|
||
command ln -s "${ZINIT[BIN_DIR]}/_zinit" "${ZINIT[PLUGINS_DIR]}/_local---zinit"
|
||
|
||
# Also set up */bin and ZPFX in general.
|
||
command mkdir -p "${ZPFX:-ZINIT[HOME_DIR]/polaris}/bin"
|
||
|
||
(( ${+functions[.zinit-setup-plugin-dir]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-install.zsh" || return 1
|
||
(( ${+functions[.zinit-confirm]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-autoload.zsh" || return 1
|
||
.zinit-clear-completions &>/dev/null
|
||
.zinit-compinit &>/dev/null
|
||
}
|
||
[[ ! -d ${ZINIT[COMPLETIONS_DIR]} ]] && {
|
||
command mkdir "${ZINIT[COMPLETIONS_DIR]}"
|
||
# For compaudit.
|
||
command chmod go-w "${ZINIT[COMPLETIONS_DIR]}"
|
||
|
||
# Symlink _zinit completion into _local---zinit directory.
|
||
command ln -s "${ZINIT[PLUGINS_DIR]}/_local---zinit/_zinit" "${ZINIT[COMPLETIONS_DIR]}"
|
||
|
||
# Also set up */bin and ZPFX in general.
|
||
command mkdir -p "${ZPFX:-ZINIT[HOME_DIR]/polaris}/bin"
|
||
|
||
(( ${+functions[.zinit-setup-plugin-dir]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-install.zsh" || return 1
|
||
.zinit-compinit &>/dev/null
|
||
}
|
||
[[ ! -d ${ZINIT[SNIPPETS_DIR]} ]] && {
|
||
command mkdir -p "${ZINIT[SNIPPETS_DIR]}/OMZ::plugins"
|
||
command chmod go-w "${ZINIT[SNIPPETS_DIR]}"
|
||
( builtin cd ${ZINIT[SNIPPETS_DIR]}; command ln -s OMZ::plugins plugins; )
|
||
|
||
# Also create the SERVICES_DIR.
|
||
command mkdir -p "${ZINIT[SERVICES_DIR]}"
|
||
command chmod go-w "${ZINIT[SERVICES_DIR]}"
|
||
|
||
# Also set up */bin and ZPFX in general.
|
||
command mkdir -p "${ZPFX:-ZINIT[HOME_DIR]/polaris}/bin"
|
||
}
|
||
[[ ! -d ${~ZINIT[MAN_DIR]}/man9 ]] && {
|
||
# Create ZINIT[MAN_DIR]/man{1..9}
|
||
command mkdir 2>/dev/null -p ${~ZINIT[MAN_DIR]}/man{1..9}
|
||
}
|
||
# Copy Zinit manpage so that man is able to find it
|
||
[[ ! -f $ZINIT[MAN_DIR]/man1/zinit.1 || \
|
||
$ZINIT[MAN_DIR]/man1/zinit.1 -ot $ZINIT[BIN_DIR]/doc/zinit.1 ]] && {
|
||
command mkdir -p $ZINIT[MAN_DIR]/man1
|
||
command cp -f $ZINIT[BIN_DIR]/doc/zinit.1 $ZINIT[MAN_DIR]/man1
|
||
}
|
||
} # ]]]
|
||
# FUNCTION: .zinit-load-object [[[
|
||
.zinit-load-object() {
|
||
local ___type="$1" ___id=$2
|
||
local -a ___opt
|
||
___opt=( ${@[3,-1]} )
|
||
|
||
if [[ $___type == snippet ]] {
|
||
.zinit-load-snippet $___opt "$___id"
|
||
} elif [[ $___type == plugin ]] {
|
||
.zinit-load "$___id" "" $___opt
|
||
}
|
||
___retval+=$?
|
||
|
||
return __retval
|
||
} # ]]]
|
||
# FUNCTION: .zinit-set-m-func [[[
|
||
# Sets and withdraws the temporary, atclone/atpull time function `m`.
|
||
.zinit-set-m-func() {
|
||
if [[ $1 == set ]]; then
|
||
ZINIT[___m_bkp]="${functions[m]}"
|
||
setopt noaliases
|
||
functions[m]="${functions[+zi-log]}"
|
||
setopt aliases
|
||
elif [[ $1 == unset ]]; then
|
||
if [[ -n ${ZINIT[___m_bkp]} ]]; then
|
||
setopt noaliases
|
||
functions[m]="${ZINIT[___m_bkp]}"
|
||
setopt aliases
|
||
else
|
||
noglob unset functions[m]
|
||
fi
|
||
else
|
||
+zi-log "{error}ERROR #1"
|
||
return 1
|
||
fi
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-load-snippet [[[
|
||
# Implements the exposed-to-user action of loading a snippet.
|
||
#
|
||
# $1 - url (can be local, absolute path).
|
||
.zinit-load-snippet() {
|
||
typeset -F 3 SECONDS=0
|
||
local -a opts
|
||
zparseopts -E -D -a opts f -command || { +zi-log "{u-warn}Error{b-warn}:{rst} Incorrect options (accepted ones: {opt}-f{rst}, {opt}--command{rst})."; return 1; }
|
||
local url="$1" limit="$3"
|
||
[[ -n ${ICE[teleid]} ]] && url="${ICE[teleid]}"
|
||
# Hide arguments from sourced scripts. Without this calls our "$@" are visible as "$@"
|
||
# within scripts that we `source`.
|
||
builtin set --
|
||
integer correct retval exists
|
||
[[ -o ksharrays ]] && correct=1
|
||
|
||
[[ -n ${ICE[(i)(\!|)(sh|bash|ksh|csh)]}${ICE[opts]} ]] && {
|
||
local -a precm
|
||
precm=(
|
||
builtin emulate
|
||
${${(M)${ICE[(i)(\!|)(sh|bash|ksh|csh)]}#\!}:+-R}
|
||
${${${ICE[(i)(\!|)(sh|bash|ksh|csh)]}#\!}:-zsh}
|
||
${${ICE[(i)(\!|)bash]}:+-${(s: :):-o noshglob -o braceexpand -o kshglob}}
|
||
${(s: :):-${${:-${(@s: :):--o}" "${(s: :)^ICE[opts]}}:#-o }}
|
||
-c
|
||
)
|
||
}
|
||
# Remove leading whitespace and trailing /.
|
||
url="${${url#"${url%%[! $'\t']*}"}%/}"
|
||
ICE[teleid]="${ICE[teleid]:-$url}"
|
||
[[ ${ICE[as]} = null || ${+ICE[null]} -eq 1 || ${+ICE[binary]} -eq 1 ]] && \
|
||
ICE[pick]="${ICE[pick]:-/dev/null}"
|
||
|
||
local local_dir dirname filename save_url="$url"
|
||
|
||
# Allow things like $OSTYPE in the URL.
|
||
eval "url=\"$url\""
|
||
|
||
local id_as="${ICE[id-as]:-$url}"
|
||
|
||
.zinit-set-m-func set
|
||
|
||
# Set up param'' objects (parameters).
|
||
if [[ -n ${ICE[param]} ]] {
|
||
.zinit-setup-params && local -x ${(Q)reply[@]}
|
||
}
|
||
|
||
.zinit-pack-ice "$id_as" ""
|
||
|
||
# Oh-My-Zsh, Prezto and manual shorthands.
|
||
[[ $url = *(${(~kj.|.)${(Mk)ZINIT_1MAP:#OMZ*}}|robbyrussell*oh-my-zsh|ohmyzsh/ohmyzsh)* ]] && local ZSH="${ZINIT[SNIPPETS_DIR]}"
|
||
|
||
# Construct containing directory, extract final directory
|
||
# into handy-variable $dirname.
|
||
.zinit-get-object-path snippet "$id_as"
|
||
filename="${reply[-2]}" dirname="${reply[-2]}"
|
||
local_dir="${reply[-3]}" exists=${reply[-1]}
|
||
|
||
local -a arr
|
||
local key
|
||
reply=(
|
||
${(on)ZINIT_EXTS2[(I)zinit hook:preinit-pre <->]}
|
||
${(on)ZINIT_EXTS[(I)z-annex hook:preinit-<-> <->]}
|
||
${(on)ZINIT_EXTS2[(I)zinit hook:preinit-post <->]}
|
||
)
|
||
for key in "${reply[@]}"; do
|
||
arr=( "${(Q)${(z@)ZINIT_EXTS[$key]:-$ZINIT_EXTS2[$key]}[@]}" )
|
||
if [[ -n "${arr[5]:-}" ]]; then
|
||
"${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" "${${key##(zinit|z-annex) hook:}%% <->}" load || \
|
||
return $(( 10 - $? ))
|
||
fi
|
||
done
|
||
|
||
# Download or copy the file.
|
||
if [[ -n ${opts[(r)-f]} || $exists -eq 0 ]] {
|
||
(( ${+functions[.zinit-download-snippet]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-install.zsh" || return 1
|
||
.zinit-download-snippet "$save_url" "$url" "$id_as" "$local_dir" "$dirname" "$filename"
|
||
retval=$?
|
||
}
|
||
|
||
(( ${+ICE[cloneonly]} || retval )) && return 0
|
||
|
||
ZINIT_SNIPPETS[$id_as]="$id_as <${${ICE[svn]+svn}:-single file}>"
|
||
|
||
ZINIT[CUR_USPL2]="$id_as" ZINIT_REPORTS[$id_as]=
|
||
|
||
reply=( ${(on)ZINIT_EXTS[(I)z-annex hook:\!atinit-<-> <->]} )
|
||
for key in "${reply[@]}"; do
|
||
arr=( "${(Q)${(z@)ZINIT_EXTS[$key]}[@]}" )
|
||
"${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" \!atinit || \
|
||
return $(( 10 - $? ))
|
||
done
|
||
|
||
(( ${+ICE[atinit]} )) && { local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; (( ${+ICE[nocd]} == 0 )) && { .zinit-cd-quiet "$local_dir/$dirname" && eval "${ICE[atinit]}"; ((1)); } || eval "${ICE[atinit]}"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; ((1)); }
|
||
|
||
reply=( ${(on)ZINIT_EXTS[(I)z-annex hook:atinit-<-> <->]} )
|
||
for key in "${reply[@]}"; do
|
||
arr=( "${(Q)${(z@)ZINIT_EXTS[$key]}[@]}" )
|
||
"${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" atinit || \
|
||
return $(( 10 - $? ))
|
||
done
|
||
|
||
local -a list
|
||
local ZERO
|
||
|
||
if [[ -z ${opts[(r)--command]} && ( -z ${ICE[as]} || ${ICE[as]} = null || ${+ICE[null]} -eq 1 || ${+ICE[binary]} -eq 1 ) ]]; then
|
||
# Source the file with compdef temporary substituting of functions.
|
||
if [[ ${ZINIT[TMP_SUBST]} = inactive ]]; then
|
||
# Temporary substituting of functions code is inlined from .zinit-tmp-subst-on.
|
||
(( ${+functions[compdef]} )) && ZINIT[bkp-compdef]="${functions[compdef]}" || builtin unset "ZINIT[bkp-compdef]"
|
||
functions[compdef]=':zinit-tmp-subst-compdef "$@";'
|
||
ZINIT[TMP_SUBST]=1
|
||
else
|
||
(( ++ ZINIT[TMP_SUBST] ))
|
||
fi
|
||
|
||
# Add to fpath.
|
||
if [[ -d $local_dir/$dirname/functions ]] {
|
||
[[ -z ${fpath[(r)$local_dir/$dirname/functions]} ]] && fpath+=( "$local_dir/$dirname/functions" )
|
||
() {
|
||
builtin setopt localoptions extendedglob
|
||
autoload $local_dir/$dirname/functions/^([_.]*|prompt_*_setup|README*)(D-.N:t)
|
||
}
|
||
}
|
||
|
||
# Source.
|
||
if (( ${+ICE[svn]} == 0 )) {
|
||
[[ ${+ICE[pick]} = 0 ]] && list=( "$local_dir/$dirname/$filename" )
|
||
[[ -n ${ICE[pick]} ]] && list=( ${(M)~ICE[pick]##/*}(DN) $local_dir/$dirname/${~ICE[pick]}(DN) )
|
||
} else {
|
||
if [[ -n ${ICE[pick]} ]]; then
|
||
list=( ${(M)~ICE[pick]##/*}(DN) $local_dir/$dirname/${~ICE[pick]}(DN) )
|
||
elif (( ${+ICE[pick]} == 0 )); then
|
||
.zinit-find-other-matches "$local_dir/$dirname" "$filename" "$limit"
|
||
list=( ${reply[@]} )
|
||
fi
|
||
}
|
||
|
||
if [[ -f ${list[1-correct]} ]] {
|
||
ZERO="${list[1-correct]}"
|
||
(( ${+ICE[silent]} )) && { { [[ -n $precm ]] && { builtin ${precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); builtin source "$ZERO"; }; } 2>/dev/null 1>&2; (( retval += $? )); ((1)); } || { ((1)); { [[ -n $precm ]] && { builtin ${precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); builtin source "$ZERO"; }; }; (( retval += $? )); }
|
||
(( 0 == retval )) && [[ $url = PZT::* || $url = https://github.com/sorin-ionescu/prezto/* ]] && zstyle ":prezto:module:${${id_as%/init.zsh}:t}" loaded 'yes'
|
||
} else { [[ ${+ICE[silent]} -eq 1 || ${+ICE[pick]} -eq 1 && -z ${ICE[pick]} || ${ICE[pick]} = /dev/null ]] || { +zi-log "Snippet not loaded ({url}${id_as}{rst})"; retval=1; } }
|
||
|
||
[[ -n ${ICE[src]} ]] && { ZERO="${${(M)ICE[src]##/*}:-$local_dir/$dirname/${ICE[src]}}"; (( ${+ICE[silent]} )) && { { [[ -n $precm ]] && { builtin ${precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); builtin source "$ZERO"; }; } 2>/dev/null 1>&2; (( retval += $? )); ((1)); } || { ((1)); { [[ -n $precm ]] && { builtin ${precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); builtin source "$ZERO"; }; }; (( retval += $? )); }; }
|
||
[[ -n ${ICE[multisrc]} ]] && { local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; .zinit-cd-quiet "$local_dir/$dirname"; eval "reply=(${ICE[multisrc]})"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; local fname; for fname in "${reply[@]}"; do ZERO="${${(M)fname:#/*}:-$local_dir/$dirname/$fname}"; (( ${+ICE[silent]} )) && { { [[ -n $precm ]] && { builtin ${precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); builtin source "$ZERO"; }; } 2>/dev/null 1>&2; (( retval += $? )); ((1)); } || { ((1)); { [[ -n $precm ]] && { builtin ${precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); builtin source "$ZERO"; }; }; (( retval += $? )); }; done; }
|
||
|
||
# Run the atload hooks right before atload ice.
|
||
reply=( ${(on)ZINIT_EXTS[(I)z-annex hook:\!atload-<-> <->]} )
|
||
for key in "${reply[@]}"; do
|
||
arr=( "${(Q)${(z@)ZINIT_EXTS[$key]}[@]}" )
|
||
"${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" \!atload
|
||
done
|
||
|
||
# Run the functions' wrapping & tracking requests.
|
||
if [[ -n ${ICE[wrap]} ]] {
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-wrap-functions "$save_url" "" "$id_as"
|
||
}
|
||
|
||
[[ ${ICE[atload][1]} = "!" ]] && { .zinit-add-report "$id_as" "Note: Starting to track the atload'!…' ice…"; ZERO="$local_dir/$dirname/-atload-"; local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; (( ${+ICE[nocd]} == 0 )) && { .zinit-cd-quiet "$local_dir/$dirname" && builtin eval "${ICE[atload]#\!}"; ((1)); } || eval "${ICE[atload]#\!}"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; ((1)); }
|
||
|
||
(( -- ZINIT[TMP_SUBST] == 0 )) && { ZINIT[TMP_SUBST]=inactive; builtin setopt noaliases; (( ${+ZINIT[bkp-compdef]} )) && functions[compdef]="${ZINIT[bkp-compdef]}" || unfunction compdef; (( ZINIT[ALIASES_OPT] )) && builtin setopt aliases; }
|
||
elif [[ -n ${opts[(r)--command]} || ${ICE[as]} = command ]]; then
|
||
[[ ${+ICE[pick]} = 1 && -z ${ICE[pick]} ]] && \
|
||
ICE[pick]="${id_as:t}"
|
||
# Subversion - directory and multiple files possible.
|
||
if (( ${+ICE[svn]} )); then
|
||
if [[ -n ${ICE[pick]} ]]; then
|
||
list=( ${(M)~ICE[pick]##/*}(DN) $local_dir/$dirname/${~ICE[pick]}(DN) )
|
||
[[ -n ${list[1-correct]} ]] && local xpath="${list[1-correct]:h}" xfilepath="${list[1-correct]}"
|
||
else
|
||
local xpath="$local_dir/$dirname"
|
||
fi
|
||
else
|
||
local xpath="$local_dir/$dirname" xfilepath="$local_dir/$dirname/$filename"
|
||
# This doesn't make sense, but users may come up with something.
|
||
[[ -n ${ICE[pick]} ]] && {
|
||
list=( ${(M)~ICE[pick]##/*}(DN) $local_dir/$dirname/${~ICE[pick]}(DN) )
|
||
[[ -n ${list[1-correct]} ]] && xpath="${list[1-correct]:h}" xfilepath="${list[1-correct]}"
|
||
}
|
||
fi
|
||
[[ -n $xpath && -z ${path[(er)$xpath]} ]] && path=( "${xpath%/}" ${path[@]} )
|
||
[[ -n $xfilepath && -f $xfilepath && ! -x "$xfilepath" ]] && command chmod a+x "$xfilepath" ${list[@]:#$xfilepath}
|
||
[[ -n ${ICE[src]} || -n ${ICE[multisrc]} || ${ICE[atload][1]} = "!" ]] && {
|
||
if [[ ${ZINIT[TMP_SUBST]} = inactive ]]; then
|
||
# Temporary substituting of functions code is inlined from .zinit-tmp-subst-on.
|
||
(( ${+functions[compdef]} )) && ZINIT[bkp-compdef]="${functions[compdef]}" || builtin unset "ZINIT[bkp-compdef]"
|
||
functions[compdef]=':zinit-tmp-subst-compdef "$@";'
|
||
ZINIT[TMP_SUBST]=1
|
||
else
|
||
(( ++ ZINIT[TMP_SUBST] ))
|
||
fi
|
||
}
|
||
|
||
if [[ -n ${ICE[src]} ]]; then
|
||
ZERO="${${(M)ICE[src]##/*}:-$local_dir/$dirname/${ICE[src]}}"
|
||
(( ${+ICE[silent]} )) && { { [[ -n $precm ]] && { builtin ${precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); builtin source "$ZERO"; }; } 2>/dev/null 1>&2; (( retval += $? )); ((1)); } || { ((1)); { [[ -n $precm ]] && { builtin ${precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); builtin source "$ZERO"; }; }; (( retval += $? )); }
|
||
fi
|
||
[[ -n ${ICE[multisrc]} ]] && { local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; .zinit-cd-quiet "$local_dir/$dirname"; eval "reply=(${ICE[multisrc]})"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; local fname; for fname in "${reply[@]}"; do ZERO="${${(M)fname:#/*}:-$local_dir/$dirname/$fname}"; (( ${+ICE[silent]} )) && { { [[ -n $precm ]] && { builtin ${precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); builtin source "$ZERO"; }; } 2>/dev/null 1>&2; (( retval += $? )); ((1)); } || { ((1)); { [[ -n $precm ]] && { builtin ${precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); builtin source "$ZERO"; }; }; (( retval += $? )); }; done; }
|
||
|
||
# Run the atload hooks right before atload ice.
|
||
reply=( ${(on)ZINIT_EXTS[(I)z-annex hook:\!atload-<-> <->]} )
|
||
for key in "${reply[@]}"; do
|
||
arr=( "${(Q)${(z@)ZINIT_EXTS[$key]}[@]}" )
|
||
"${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" \!atload
|
||
done
|
||
|
||
# Run the functions' wrapping & tracking requests.
|
||
if [[ -n ${ICE[wrap]} ]] {
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-wrap-functions "$save_url" "" "$id_as"
|
||
}
|
||
|
||
[[ ${ICE[atload][1]} = "!" ]] && { .zinit-add-report "$id_as" "Note: Starting to track the atload'!…' ice…"; ZERO="$local_dir/$dirname/-atload-"; local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; (( ${+ICE[nocd]} == 0 )) && { .zinit-cd-quiet "$local_dir/$dirname" && builtin eval "${ICE[atload]#\!}"; ((1)); } || eval "${ICE[atload]#\!}"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; ((1)); }
|
||
|
||
[[ -n ${ICE[src]} || -n ${ICE[multisrc]} || ${ICE[atload][1]} = "!" ]] && {
|
||
(( -- ZINIT[TMP_SUBST] == 0 )) && { ZINIT[TMP_SUBST]=inactive; builtin setopt noaliases; (( ${+ZINIT[bkp-compdef]} )) && functions[compdef]="${ZINIT[bkp-compdef]}" || unfunction compdef; (( ZINIT[ALIASES_OPT] )) && builtin setopt aliases; }
|
||
}
|
||
elif [[ ${ICE[as]} = completion ]]; then
|
||
((1))
|
||
fi
|
||
|
||
(( ${+ICE[atload]} )) && [[ ${ICE[atload][1]} != "!" ]] && { ZERO="$local_dir/$dirname/-atload-"; local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; (( ${+ICE[nocd]} == 0 )) && { .zinit-cd-quiet "$local_dir/$dirname" && builtin eval "${ICE[atload]}"; ((1)); } || eval "${ICE[atload]}"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; ((1)); }
|
||
|
||
reply=( ${(on)ZINIT_EXTS[(I)z-annex hook:atload-<-> <->]} )
|
||
for key in "${reply[@]}"; do
|
||
arr=( "${(Q)${(z@)ZINIT_EXTS[$key]}[@]}" )
|
||
"${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" atload
|
||
done
|
||
|
||
(( ${+ICE[notify]} == 1 )) && { [[ $retval -eq 0 || -n ${(M)ICE[notify]#\!} ]] && { local msg; eval "msg=\"${ICE[notify]#\!}\""; +zinit-deploy-message @msg "$msg" } || +zinit-deploy-message @msg "notify: Plugin not loaded / loaded with problem, the return code: $retval"; }
|
||
(( ${+ICE[reset-prompt]} == 1 )) && +zinit-deploy-message @rst
|
||
|
||
ZINIT[CUR_USPL2]=
|
||
ZINIT[TIME_INDEX]=$(( ${ZINIT[TIME_INDEX]:-0} + 1 ))
|
||
ZINIT[TIME_${ZINIT[TIME_INDEX]}_${id_as}]=$SECONDS
|
||
ZINIT[AT_TIME_${ZINIT[TIME_INDEX]}_${id_as}]=$EPOCHREALTIME
|
||
|
||
.zinit-set-m-func unset
|
||
return retval
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-load [[[
|
||
# Implements the exposed-to-user action of loading a plugin.
|
||
#
|
||
# $1 - plugin spec (4 formats: user---plugin, user/plugin, user, plugin)
|
||
# $2 - plugin name, if the third format is used
|
||
.zinit-load() {
|
||
typeset -F 3 SECONDS=0
|
||
local ___mode="$3" ___limit="$4" ___rst=0 ___retval=0 ___key
|
||
.zinit-any-to-user-plugin "$1" "$2"
|
||
local ___user="${reply[-2]}" ___plugin="${reply[-1]}" ___id_as="${ICE[id-as]:-${reply[-2]}${${reply[-2]:#(%|/)*}:+/}${reply[-1]}}"
|
||
local ___pdir_path="${${${(M)___user:#%}:+$___plugin}:-${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}}"
|
||
local ___pdir_orig="$___pdir_path"
|
||
ZINIT[CUR_USR]="$___user" ZINIT[CUR_PLUGIN]="$___plugin" ZINIT[CUR_USPL2]="$___id_as"
|
||
if [[ -n ${ICE[teleid]} ]] {
|
||
.zinit-any-to-user-plugin "${ICE[teleid]}"
|
||
___user="${reply[-2]}" ___plugin="${reply[-1]}"
|
||
} else {
|
||
ICE[teleid]="$___user${${___user:#%}:+/}$___plugin"
|
||
}
|
||
|
||
.zinit-set-m-func set
|
||
|
||
local -a ___arr
|
||
reply=(
|
||
${(on)ZINIT_EXTS2[(I)zinit hook:preinit-pre <->]}
|
||
${(on)ZINIT_EXTS[(I)z-annex hook:preinit-<-> <->]}
|
||
${(on)ZINIT_EXTS2[(I)zinit hook:preinit-post <->]}
|
||
)
|
||
for ___key in "${reply[@]}"; do
|
||
___arr=( "${(Q)${(z@)ZINIT_EXTS[$___key]:-$ZINIT_EXTS2[$___key]}[@]}" )
|
||
if [[ -n "${___arr[5]:-}" ]]; then
|
||
"${___arr[5]}" plugin "$___user" "$___plugin" "$___id_as" "$___pdir_orig" "${${___key##(zinit|z-annex) hook:}%% <->}" load || \
|
||
return $(( 10 - $? ))
|
||
fi
|
||
done
|
||
|
||
if [[ $___user != % && ! -d ${ZINIT[PLUGINS_DIR]}/${___id_as//\//---} ]] {
|
||
(( ${+functions[.zinit-setup-plugin-dir]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-install.zsh" || return 1
|
||
reply=( "$___user" "$___plugin" ) REPLY=github
|
||
if (( ${+ICE[pack]} )) {
|
||
if ! .zinit-get-package "$___user" "$___plugin" "$___id_as" \
|
||
"${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}" \
|
||
"${ICE[pack]:-default}"
|
||
then
|
||
zle && { builtin print; zle .reset-prompt; }
|
||
return 1
|
||
fi
|
||
___id_as="${ICE[id-as]:-${___user}${${___user:#(%|/)*}:+/}$___plugin}"
|
||
}
|
||
___user="${reply[-2]}" ___plugin="${reply[-1]}"
|
||
ICE[teleid]="$___user${${___user:#(%|/)*}:+/}$___plugin"
|
||
[[ $REPLY = snippet ]] && {
|
||
ICE[id-as]="${ICE[id-as]:-$___id_as}"
|
||
.zinit-load-snippet $___plugin "" $___limit && return
|
||
zle && { builtin print; zle .reset-prompt; }
|
||
return 1
|
||
}
|
||
.zinit-setup-plugin-dir "$___user" "$___plugin" "$___id_as" "$REPLY"
|
||
local rc="$?"
|
||
if [[ "$rc" -ne 0 ]]; then
|
||
zle && { builtin print; zle .reset-prompt; }
|
||
return "$rc"
|
||
fi
|
||
zle && ___rst=1
|
||
}
|
||
|
||
ZINIT_SICE[$___id_as]=
|
||
.zinit-pack-ice "$___id_as"
|
||
|
||
(( ${+ICE[cloneonly]} )) && return 0
|
||
|
||
.zinit-register-plugin "$___id_as" "$___mode" "${ICE[teleid]}"
|
||
|
||
# Set up param'' objects (parameters).
|
||
if [[ -n ${ICE[param]} ]] {
|
||
.zinit-setup-params && local -x ${(Q)reply[@]}
|
||
}
|
||
|
||
reply=( ${(on)ZINIT_EXTS[(I)z-annex hook:\!atinit-<-> <->]} )
|
||
for ___key in "${reply[@]}"; do
|
||
___arr=( "${(Q)${(z@)ZINIT_EXTS[$___key]}[@]}" )
|
||
"${___arr[5]}" plugin "$___user" "$___plugin" "$___id_as" "${${${(M)___user:#%}:+$___plugin}:-${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}}" \!atinit || \
|
||
return $(( 10 - $? ))
|
||
done
|
||
|
||
[[ ${+ICE[atinit]} = 1 && $ICE[atinit] != '!'* ]] && { local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; (( ${+ICE[nocd]} == 0 )) && { .zinit-cd-quiet "${${${(M)___user:#%}:+$___plugin}:-${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}}" && eval "${ICE[atinit]}"; ((1)); } || eval "${ICE[atinit]}"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; ((1)); }
|
||
|
||
reply=( ${(on)ZINIT_EXTS[(I)z-annex hook:atinit-<-> <->]} )
|
||
for ___key in "${reply[@]}"; do
|
||
___arr=( "${(Q)${(z@)ZINIT_EXTS[$___key]}[@]}" )
|
||
"${___arr[5]}" plugin "$___user" "$___plugin" "$___id_as" "${${${(M)___user:#%}:+$___plugin}:-${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}}" atinit || \
|
||
return $(( 10 - $? ))
|
||
done
|
||
|
||
.zinit-load-plugin "$___user" "$___plugin" "$___id_as" \
|
||
"$___mode" "$___rst" "$___limit" ; ___retval=$?
|
||
(( ${+ICE[notify]} == 1 )) && { [[ $___retval -eq 0 || -n ${(M)ICE[notify]#\!} ]] && { local msg; eval "msg=\"${ICE[notify]#\!}\""; +zinit-deploy-message @msg "$msg" } || +zinit-deploy-message @msg "notify: Plugin not loaded / loaded with problem, the return code: $___retval"; }
|
||
(( ${+ICE[reset-prompt]} == 1 )) && +zinit-deploy-message @___rst
|
||
|
||
# Unset the `m` function.
|
||
.zinit-set-m-func unset
|
||
|
||
# Mark no load is in progress.
|
||
ZINIT[CUR_USR]= ZINIT[CUR_PLUGIN]= ZINIT[CUR_USPL2]=
|
||
|
||
ZINIT[TIME_INDEX]=$(( ${ZINIT[TIME_INDEX]:-0} + 1 ))
|
||
ZINIT[TIME_${ZINIT[TIME_INDEX]}_${___id_as//\//---}]=$SECONDS
|
||
ZINIT[AT_TIME_${ZINIT[TIME_INDEX]}_${___id_as//\//---}]=$EPOCHREALTIME
|
||
return ___retval
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-load-plugin [[[
|
||
# Lower-level function for loading a plugin.
|
||
#
|
||
# $1 - user
|
||
# $2 - plugin
|
||
# $3 - mode (light or load)
|
||
.zinit-load-plugin() {
|
||
local ___user="$1" ___plugin="$2" ___id_as="$3" ___mode="$4" \
|
||
___rst="$5" ___limit="$6" ___correct=0 ___retval=0
|
||
local ___pbase="${${___plugin:t}%(.plugin.zsh|.zsh|.git)}" ___key
|
||
# Hide arguments from sourced scripts. Without this calls our "$@" are visible as "$@"
|
||
# within scripts that we `source`.
|
||
builtin set --
|
||
[[ -o ksharrays ]] && ___correct=1
|
||
|
||
[[ -n ${ICE[(i)(\!|)(sh|bash|ksh|csh)]}${ICE[opts]} ]] && {
|
||
local -a ___precm
|
||
___precm=(
|
||
builtin emulate
|
||
${${(M)${ICE[(i)(\!|)(sh|bash|ksh|csh)]}#\!}:+-R}
|
||
${${${ICE[(i)(\!|)(sh|bash|ksh|csh)]}#\!}:-zsh}
|
||
${${ICE[(i)(\!|)bash]}:+-${(s: :):-o noshglob -o braceexpand -o kshglob}}
|
||
${(s: :):-${${:-${(@s: :):--o}" "${(s: :)^ICE[opts]}}:#-o }}
|
||
-c
|
||
)
|
||
}
|
||
|
||
[[ -z ${ICE[subst]} ]] && local ___builtin=builtin
|
||
|
||
[[ ${ICE[as]} = null || ${+ICE[null]} -eq 1 || ${+ICE[binary]} -eq 1 ]] && \
|
||
ICE[pick]="${ICE[pick]:-/dev/null}"
|
||
|
||
if [[ -n ${ICE[autoload]} ]] {
|
||
:zinit-tmp-subst-autoload -Uz \
|
||
${(s: :)${${${(s.;.)ICE[autoload]#[\!\#]}#[\!\#]}//(#b)((*)(->|=>|→)(*)|(*))/${match[2]:+$match[2] -S $match[4]}${match[5]:+${match[5]} -S ${match[5]}}}} \
|
||
${${(M)ICE[autoload]:#*(->|=>|→)*}:+-C} ${${(M)ICE[autoload]#(?\!|\!)}:+-C} ${${(M)ICE[autoload]#(?\#|\#)}:+-I}
|
||
}
|
||
|
||
if [[ ${ICE[as]} = command ]]; then
|
||
[[ ${+ICE[pick]} = 1 && -z ${ICE[pick]} ]] && \
|
||
ICE[pick]="${___id_as:t}"
|
||
reply=()
|
||
if [[ -n ${ICE[pick]} && ${ICE[pick]} != /dev/null ]]; then
|
||
reply=( ${(M)~ICE[pick]##/*}(DN) $___pdir_path/${~ICE[pick]}(DN) )
|
||
[[ -n ${reply[1-correct]} ]] && ___pdir_path="${reply[1-correct]:h}"
|
||
fi
|
||
[[ -z ${path[(er)$___pdir_path]} ]] && {
|
||
[[ $___mode != light ]] && .zinit-diff-env "${ZINIT[CUR_USPL2]}" begin
|
||
path=( "${___pdir_path%/}" ${path[@]} )
|
||
[[ $___mode != light ]] && .zinit-diff-env "${ZINIT[CUR_USPL2]}" end
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "$ZINIT[col-info2]$___pdir_path$ZINIT[col-rst] added to \$PATH"
|
||
}
|
||
[[ -n ${reply[1-correct]} && ! -x ${reply[1-correct]} ]] && command chmod a+x ${reply[@]}
|
||
|
||
[[ ${ICE[atinit]} = '!'* || -n ${ICE[src]} || -n ${ICE[multisrc]} || ${ICE[atload][1]} = "!" ]] && {
|
||
if [[ ${ZINIT[TMP_SUBST]} = inactive ]]; then
|
||
(( ${+functions[compdef]} )) && ZINIT[bkp-compdef]="${functions[compdef]}" || builtin unset "ZINIT[bkp-compdef]"
|
||
functions[compdef]=':zinit-tmp-subst-compdef "$@";'
|
||
ZINIT[TMP_SUBST]=1
|
||
else
|
||
(( ++ ZINIT[TMP_SUBST] ))
|
||
fi
|
||
}
|
||
|
||
local ZERO
|
||
[[ $ICE[atinit] = '!'* ]] && { local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; (( ${+ICE[nocd]} == 0 )) && { .zinit-cd-quiet "${${${(M)___user:#%}:+$___plugin}:-${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}}" && eval "${ICE[atinit#!]}"; ((1)); } || eval "${ICE[atinit]#!}"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; ((1)); }
|
||
[[ -n ${ICE[src]} ]] && { ZERO="${${(M)ICE[src]##/*}:-$___pdir_orig/${ICE[src]}}"; (( ${+ICE[silent]} )) && { { [[ -n $___precm ]] && { builtin ${___precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); $___builtin source "$ZERO"; }; } 2>/dev/null 1>&2; (( ___retval += $? )); ((1)); } || { ((1)); { [[ -n $___precm ]] && { builtin ${___precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); $___builtin source "$ZERO"; }; }; (( ___retval += $? )); }; }
|
||
[[ -n ${ICE[multisrc]} ]] && { local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; .zinit-cd-quiet "$___pdir_orig"; eval "reply=(${ICE[multisrc]})"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; local ___fname; for ___fname in "${reply[@]}"; do ZERO="${${(M)___fname:#/*}:-$___pdir_orig/$___fname}"; (( ${+ICE[silent]} )) && { { [[ -n $___precm ]] && { builtin ${___precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); $___builtin source "$ZERO"; }; } 2>/dev/null 1>&2; (( ___retval += $? )); ((1)); } || { ((1)); { [[ -n $___precm ]] && { builtin ${___precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); $___builtin source "$ZERO"; }; }; (( ___retval += $? )); }; done; }
|
||
|
||
# Run the atload hooks right before atload ice.
|
||
reply=( ${(on)ZINIT_EXTS[(I)z-annex hook:\!atload-<-> <->]} )
|
||
for ___key in "${reply[@]}"; do
|
||
___arr=( "${(Q)${(z@)ZINIT_EXTS[$___key]}[@]}" )
|
||
"${___arr[5]}" plugin "$___user" "$___plugin" "$___id_as" "$___pdir_orig" \!atload
|
||
done
|
||
|
||
# Run the functions' wrapping & tracking requests.
|
||
if [[ -n ${ICE[wrap]} ]] {
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-wrap-functions "$___user" "$___plugin" "$___id_as"
|
||
}
|
||
|
||
[[ ${ICE[atload][1]} = "!" ]] && { .zinit-add-report "$___id_as" "Note: Starting to track the atload'!…' ice…"; ZERO="$___pdir_orig/-atload-"; local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; (( ${+ICE[nocd]} == 0 )) && { .zinit-cd-quiet "$___pdir_orig" && builtin eval "${ICE[atload]#\!}"; ((1)); } || eval "${ICE[atload]#\!}"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; ((1)); }
|
||
|
||
[[ -n ${ICE[src]} || -n ${ICE[multisrc]} || ${ICE[atload][1]} = "!" ]] && {
|
||
(( -- ZINIT[TMP_SUBST] == 0 )) && { ZINIT[TMP_SUBST]=inactive; builtin setopt noaliases; (( ${+ZINIT[bkp-compdef]} )) && functions[compdef]="${ZINIT[bkp-compdef]}" || unfunction compdef; (( ZINIT[ALIASES_OPT] )) && builtin setopt aliases; }
|
||
}
|
||
elif [[ ${ICE[as]} = completion ]]; then
|
||
((1))
|
||
else
|
||
if [[ -n ${ICE[pick]} ]]; then
|
||
[[ ${ICE[pick]} = /dev/null ]] && reply=( /dev/null ) || reply=( ${(M)~ICE[pick]##/*}(DN) $___pdir_path/${~ICE[pick]}(DN) )
|
||
elif [[ -e $___pdir_path/$___pbase.plugin.zsh && $___limit -ne 0 ]]; then
|
||
reply=( "$___pdir_path/$___pbase".plugin.zsh )
|
||
else
|
||
.zinit-find-other-matches "$___pdir_path" "$___pbase" "$___limit"
|
||
fi
|
||
|
||
#[[ ${#reply} -eq 0 ]] && return 1
|
||
|
||
# Get first one.
|
||
local ___fname="${reply[1-correct]:t}"
|
||
___pdir_path="${reply[1-correct]:h}"
|
||
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Source $___fname ${${${(M)___mode:#light}:+(no reporting)}:-$ZINIT[col-info2](reporting enabled)$ZINIT[col-rst]}"
|
||
|
||
# Light and compdef ___mode doesn't do diffs and temporary substituting of functions.
|
||
[[ $___mode != light(|-b) ]] && .zinit-diff "${ZINIT[CUR_USPL2]}" begin
|
||
|
||
.zinit-tmp-subst-on "${___mode:-load}"
|
||
|
||
# We need some state, but ___user wants his for his plugins.
|
||
(( ${+ICE[blockf]} )) && { local -a fpath_bkp; fpath_bkp=( "${fpath[@]}" ); }
|
||
local ZERO="$___pdir_path/$___fname"
|
||
(( ${+ICE[aliases]} )) || builtin setopt noaliases
|
||
[[ $ICE[atinit] = '!'* ]] && { local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; (( ${+ICE[nocd]} == 0 )) && { .zinit-cd-quiet "${${${(M)___user:#%}:+$___plugin}:-${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}}" && eval "${ICE[atinit]#!}"; ((1)); } || eval "${ICE[atinit]#1}"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; ((1)); }
|
||
(( ${+ICE[silent]} )) && { { [[ -n $___precm ]] && { builtin ${___precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); $___builtin source "$ZERO"; }; } 2>/dev/null 1>&2; (( ___retval += $? )); ((1)); } || { ((1)); { [[ -n $___precm ]] && { builtin ${___precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); $___builtin source "$ZERO"; }; }; (( ___retval += $? )); }
|
||
[[ -n ${ICE[src]} ]] && { ZERO="${${(M)ICE[src]##/*}:-$___pdir_orig/${ICE[src]}}"; (( ${+ICE[silent]} )) && { { [[ -n $___precm ]] && { builtin ${___precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); $___builtin source "$ZERO"; }; } 2>/dev/null 1>&2; (( ___retval += $? )); ((1)); } || { ((1)); { [[ -n $___precm ]] && { builtin ${___precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); $___builtin source "$ZERO"; }; }; (( ___retval += $? )); }; }
|
||
[[ -n ${ICE[multisrc]} ]] && { local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; .zinit-cd-quiet "$___pdir_orig"; eval "reply=(${ICE[multisrc]})"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; for ___fname in "${reply[@]}"; do ZERO="${${(M)___fname:#/*}:-$___pdir_orig/$___fname}"; (( ${+ICE[silent]} )) && { { [[ -n $___precm ]] && { builtin ${___precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); $___builtin source "$ZERO"; }; } 2>/dev/null 1>&2; (( ___retval += $? )); ((1)); } || { { [[ -n $___precm ]] && { builtin ${___precm[@]} 'source "$ZERO"'; ((1)); } || { ((1)); $___builtin source "$ZERO"; }; }; (( ___retval += $? )); } done; }
|
||
|
||
# Run the atload hooks right before atload ice.
|
||
reply=( ${(on)ZINIT_EXTS[(I)z-annex hook:\!atload-<-> <->]} )
|
||
for ___key in "${reply[@]}"; do
|
||
___arr=( "${(Q)${(z@)ZINIT_EXTS[$___key]}[@]}" )
|
||
"${___arr[5]}" plugin "$___user" "$___plugin" "$___id_as" "$___pdir_orig" \!atload
|
||
done
|
||
|
||
# Run the functions' wrapping & tracking requests.
|
||
if [[ -n ${ICE[wrap]} ]] {
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-wrap-functions "$___user" "$___plugin" "$___id_as"
|
||
}
|
||
|
||
[[ ${ICE[atload][1]} = "!" ]] && { .zinit-add-report "$___id_as" "Note: Starting to track the atload'!…' ice…"; ZERO="$___pdir_orig/-atload-"; local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; (( ${+ICE[nocd]} == 0 )) && { .zinit-cd-quiet "$___pdir_orig" && builtin eval "${ICE[atload]#\!}"; ((1)); } || eval "${ICE[atload]#\!}"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; ((1)); }
|
||
(( ZINIT[ALIASES_OPT] )) && builtin setopt aliases
|
||
(( ${+ICE[blockf]} )) && { fpath=( "${fpath_bkp[@]}" ); }
|
||
|
||
.zinit-tmp-subst-off "${___mode:-load}"
|
||
|
||
[[ $___mode != light(|-b) ]] && .zinit-diff "${ZINIT[CUR_USPL2]}" end
|
||
fi
|
||
|
||
[[ ${+ICE[atload]} = 1 && ${ICE[atload][1]} != "!" ]] && { ZERO="$___pdir_orig/-atload-"; local ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"; (( ${+ICE[nocd]} == 0 )) && { .zinit-cd-quiet "$___pdir_orig" && builtin eval "${ICE[atload]}"; ((1)); } || eval "${ICE[atload]}"; .zinit-restore-dir "$___oldcd" "$___oldoldpwd"; ((1)); }
|
||
|
||
reply=( ${(on)ZINIT_EXTS[(I)z-annex hook:atload-<-> <->]} )
|
||
for ___key in "${reply[@]}"; do
|
||
___arr=( "${(Q)${(z@)ZINIT_EXTS[$___key]}[@]}" )
|
||
"${___arr[5]}" plugin "$___user" "$___plugin" "$___id_as" "$___pdir_orig" atload
|
||
done
|
||
|
||
(( ___rst )) && { builtin print; zle .reset-prompt; }
|
||
|
||
return ___retval
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-compdef-replay [[[
|
||
# Runs gathered compdef calls. This allows to run 'compinit' after loading plugins.
|
||
.zinit-compdef-replay() {
|
||
local quiet="$1"
|
||
typeset -a pos
|
||
|
||
# Check if compinit was loaded.
|
||
if [[ ${+functions[compdef]} = 0 ]]; then
|
||
+zi-log "{u-warn}Error{b-warn}:{rst} The {func}compinit{rst}" \
|
||
"function hasn't been loaded, cannot do {it}{cmd}compdef replay{rst}."
|
||
return 1
|
||
fi
|
||
|
||
# In the same order.
|
||
local cdf
|
||
for cdf in "${ZINIT_COMPDEF_REPLAY[@]}"; do
|
||
pos=( "${(z)cdf}" )
|
||
# When ZINIT_COMPDEF_REPLAY empty (also when only white spaces).
|
||
[[ ${#pos[@]} = 1 && -z ${pos[-1]} ]] && continue
|
||
pos=( "${(Q)pos[@]}" )
|
||
[[ $quiet = -q ]] || +zi-log "Running compdef: {cmd}${pos[*]}{rst}"
|
||
compdef "${pos[@]}"
|
||
done
|
||
|
||
return 0
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-compdef-clear [[[
|
||
# Implements user-exposed functionality to clear gathered compdefs.
|
||
.zinit-compdef-clear() {
|
||
local quiet="$1" count="${#ZINIT_COMPDEF_REPLAY}"
|
||
ZINIT_COMPDEF_REPLAY=( )
|
||
[[ $quiet = -q ]] || +zi-log "Compdef-replay cleared (it had {num}${count}{rst} entries)."
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-add-report [[[
|
||
# Adds a report line for given plugin.
|
||
#
|
||
# $1 - uspl2, i.e. user/plugin
|
||
# $2 - the text
|
||
.zinit-add-report() {
|
||
# Use zinit binary module if available.
|
||
[[ -n $1 ]] && { (( ${+builtins[zpmod]} && 0 )) && zpmod report-append "$1" "$2"$'\n' || ZINIT_REPORTS[$1]+="$2"$'\n'; }
|
||
[[ ${ZINIT[DTRACE]} = 1 ]] && { (( ${+builtins[zpmod]} )) && zpmod report-append _dtrace/_dtrace "$2"$'\n' || ZINIT_REPORTS[_dtrace/_dtrace]+="$2"$'\n'; }
|
||
return 0
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-add-fpath [[[
|
||
.zinit-add-fpath() {
|
||
[[ $1 = (-f|--front) ]] && { shift; integer front=1; }
|
||
.zinit-any-to-user-plugin "$1" ""
|
||
local id_as="$1" add_dir="$2" user="${reply[-2]}" plugin="${reply[-1]}"
|
||
if (( front )) {
|
||
fpath[1,0]=${${${(M)user:#%}:+$plugin}:-${ZINIT[PLUGINS_DIR]}/${id_as//\//---}}${add_dir:+/$add_dir}
|
||
} else {
|
||
fpath+=(
|
||
${${${(M)user:#%}:+$plugin}:-${ZINIT[PLUGINS_DIR]}/${id_as//\//---}}${add_dir:+/$add_dir}
|
||
)
|
||
}
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-run [[[
|
||
# Run code inside plugins folder
|
||
# It uses the 'correct' parameter from uppers scope zinit().
|
||
.zinit-run() {
|
||
if [[ $1 = (-l|--last) ]]; then
|
||
{ set -- "${ZINIT[last-run-plugin]:-$(<${ZINIT[BIN_DIR]}/last-run-object.txt)}" "${@[2-correct,-1]}"; } &>/dev/null
|
||
[[ -z $1 ]] && { +zi-log "{u-warn}Error{b-warn}:{rst} No recent plugin-ID saved on the disk yet, please specify" \
|
||
"it as the first argument, i.e.{ehi}: {cmd}zi run {pid}usr/plg{slight} {…}the code to run{…} "; return 1; }
|
||
else
|
||
integer ___nolast=1
|
||
fi
|
||
.zinit-any-to-user-plugin "$1" ""
|
||
local ___id_as="$1" ___user="${reply[-2]}" ___plugin="${reply[-1]}" ___oldcd="$PWD" ___oldoldpwd="$OLDPWD"
|
||
() {
|
||
builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
|
||
builtin cd &>/dev/null -q ${${${(M)___user:#%}:+$___plugin}:-${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}} || {
|
||
.zinit-get-object-path snippet "$___id_as"
|
||
builtin cd &>/dev/null -q $REPLY
|
||
}
|
||
}
|
||
if (( $? == 0 )); then
|
||
(( ___nolast )) && { builtin print -r "$1" >! ${ZINIT[BIN_DIR]}/last-run-object.txt; }
|
||
ZINIT[last-run-plugin]="$1"
|
||
eval "${@[2-correct,-1]}"
|
||
.zinit-restore-dir "$___oldcd" "$___oldoldpwd"
|
||
else
|
||
+zi-log "{u-warn}Error{b-warn}:{rst} no such plugin or snippet."
|
||
fi
|
||
} # ]]]
|
||
|
||
# FUNCTION: +zinit-deploy-message [[[
|
||
# Deploys a sub-prompt message to be displayed OR a 'zle .reset-prompt'
|
||
# call to be invoked
|
||
+zinit-deploy-message() {
|
||
[[ $1 = <-> && ( ${#} = 1 || ( $2 = (hup|nval|err) && ${#} = 2 ) ) ]] && { zle && {
|
||
local alltext text IFS=$'\n' nl=$'\n'
|
||
repeat 25; do read -r -u"$1" text; alltext+="${text:+$text$nl}"; done
|
||
[[ $alltext = @rst$nl ]] && { builtin zle reset-prompt; ((1)); } || \
|
||
{ [[ -n $alltext ]] && builtin zle -M "$alltext"; }
|
||
}
|
||
builtin zle -F "$1"; exec {1}<&-
|
||
return 0
|
||
}
|
||
local THEFD=13371337 hasw
|
||
# The expansion is: if there is @sleep: pfx, then use what is after.
|
||
# it, otherwise substitute 0
|
||
exec {THEFD} < <(LANG=C sleep $(( 0.01 + ${${${(M)1#@sleep:}:+${1#@sleep:}}:-0} )); builtin print -r -- ${1:#(@msg|@sleep:*)} "${@[2,-1]}"; )
|
||
command true # workaround a Zsh bug, see: https://www.zsh.org/mla/workers/2018/msg00966.html
|
||
builtin zle -F "$THEFD" +zinit-deploy-message
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-formatter-auto [[[
|
||
.zinit-formatter-auto() {
|
||
emulate -L zsh -o extendedglob -o warncreateglobal -o typesetsilent
|
||
local out in=$1 i wrk match spaces rest
|
||
integer mbegin mend
|
||
local -a ice_order ecmds
|
||
ice_order=(
|
||
${(As:|:)ZINIT[ice-list]}
|
||
${(@)${(A@kons:|:)${ZINIT_EXTS[ice-mods]//\'\'/}}/(#s)<->-/}
|
||
)
|
||
ecmds=( ${ZINIT_EXTS[(I)z-annex subcommand:*]#z-annex subcommand:} )
|
||
|
||
in=${(j: :)${${(Z+Cn+)in}//[$'\t ']/$'\u00a0'}}
|
||
wrk=$in
|
||
# Work on input bit by bit on whitespace separated words
|
||
while [[ $in == (#b)([[:space:]]#)([^[:space:]]##)(*) ]]; do
|
||
spaces=$match[1]
|
||
rest=$match[3]
|
||
wrk=${match[2]//---//}
|
||
REPLY=$wrk
|
||
# Is it a time?
|
||
if [[ $wrk == ([[:space:]]##|(#s))[0-9.]##([[:space:]]##|(#e)) &&
|
||
$rest == ([[:space:]]#|(#s))[sm]([[:space:]]##*|(#e)) || $wrk == ([[:space:]]##|(#s))[0-9.]##[sm]([[:space:]]##|(#e)) ]]; then
|
||
REPLY=$ZINIT[col-time]$wrk$ZINIT[col-rst]
|
||
# Colorize next token
|
||
if [[ $wrk != *[sm]* ]]; then
|
||
rest=$ZINIT[col-time]${(M)rest##[[:space:]]#[sm]}$ZINIT[col-rst]${rest##[[:space:]]#[sm]}
|
||
fi
|
||
# Is it a number?
|
||
# TODO: differentiate floats
|
||
elif [[ $wrk == ([[:space:]]##|(#s))[0-9.]##([[:space:]]##|(#e)) ]]; then
|
||
REPLY=$ZINIT[col-num]$wrk$ZINIT[col-rst]
|
||
# Is it a URL?
|
||
elif [[ $wrk == (#b)(((http|ftp)(|s)|ssh|scp|ntp|file)://[[:alnum:].:+/]##) ]]; then
|
||
.zinit-formatter-url $wrk
|
||
# Is it an ice mod?
|
||
elif [[ $wrk == (--|)(${(~j:|:)ice_order})[:=\"\'\!a-zA-Z0-9-]* ]]; then
|
||
REPLY=$ZINIT[col-ice]$wrk$ZINIT[col-rst]
|
||
# Is it an object ID?
|
||
elif [[ $wrk == (OMZ([PLT]|)|PZT([MLT]|)):* || $wrk == [^/]##/[^/]## || -d $ZINIT[PLUGINS_DIR]/${wrk//\//---} ]]; then
|
||
.zinit-formatter-pid $wrk
|
||
# Is it a zinit command?
|
||
elif [[ $wrk == (${~ZINIT[cmds]}|${(~j:|:)ecmds}) ]]; then
|
||
REPLY=$ZINIT[col-cmd]$wrk$ZINIT[col-rst]
|
||
# Is it a binary or other runnable?
|
||
elif type $1 &>/dev/null; then
|
||
REPLY=$ZINIT[col-bcmd]$wrk$ZINIT[col-rst]
|
||
# Is it a single-char glymph?
|
||
elif [[ $wrk == (#b)(*)('<->'|'<–>'|'<—>')(*) || $wrk == (#b)(*)(…|–|—|↔|...)(*) ]]; then
|
||
local -A map=( … … - dsh – ndsh
|
||
— mdsh '<->' ↔ '<–>' ↔ '<—>' ↔
|
||
↔ ↔ ... …)
|
||
REPLY=$match[1]$ZINIT[col-$map[$wrk]]$match[3]
|
||
# Is it a quoted string?
|
||
# \1 - preceding \2 - open, \3 - string, \4 - close, \5 - following
|
||
elif [[ $wrk == (#b)(*)([\'\`\"])([^\'\`\"]##)([\'\`\"])(*) ]]; then
|
||
local -A map=( \` bapo \' apo \" quo
|
||
x\` baps x\' aps x\" quos )
|
||
local openq=$match[2] str=$match[3] closeq=$match[4] RST=$ZINIT[col-rst]
|
||
REPLY=$match[1]$ZINIT[col-$map[$openq]]$openq$RST$ZINIT[col-$map[x$openq]]$str$RST$ZINIT[col-$map[$closeq]]$closeq$RST$match[5]
|
||
fi
|
||
in=$rest
|
||
out+=${spaces//$'\n'/$'\013\015'}$REPLY
|
||
done
|
||
# Restore regular, not non-breaking (0xa0) spaces
|
||
REPLY=${out//$'\u00a0'/ }
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-formatter-pid [[[
|
||
.zinit-formatter-pid() {
|
||
builtin emulate -L zsh -o extendedglob ${=${options[xtrace]:#off}:+-o xtrace}
|
||
|
||
# Save whitespace location
|
||
local pbz=${(M)1##(#s)[[:space:]]##}
|
||
local kbz=${(M)1%%[[:space:]]##(#e)}
|
||
# trim whitespace
|
||
1=${1//((#s)[[:space:]]##|[[:space:]]##(#e))/}
|
||
|
||
((${+functions[.zinit-first]})) || source ${ZINIT[BIN_DIR]}/zinit-side.zsh
|
||
.zinit-any-colorify-as-uspl2 "$1";
|
||
|
||
# Replace at least one character with an unbreakable space, because
|
||
# due to implementation problems, marginal whitespace is lost ...
|
||
pbz=${pbz/[[:blank:]]/ }
|
||
local kbz_rev="${(j::)${(@Oas::)kbz}}"
|
||
kbz="${(j::)${(@Oas::)${kbz_rev/[[:blank:]]/ }}}"
|
||
|
||
# Re-add whitespace
|
||
REPLY=$pbz$REPLY$kbz
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-formatter-bar [[[
|
||
.zinit-formatter-bar() {
|
||
.zinit-formatter-bar-util ─ bar
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-formatter-th-bar [[[
|
||
.zinit-formatter-th-bar() {
|
||
.zinit-formatter-bar-util ━ th-bar
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-formatter-bar-util [[[
|
||
.zinit-formatter-bar-util() {
|
||
if [[ $LANG == (#i)*utf-8* ]]; then
|
||
ch=$1
|
||
else
|
||
ch=-
|
||
fi
|
||
|
||
REPLY=$ZINIT[col-$2]${(pl:COLUMNS-1::$ch:):-}$ZINIT[col-rst]
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-formatter-url [[[
|
||
.zinit-formatter-url() {
|
||
builtin emulate -LR zsh -o extendedglob ${=${options[xtrace]:#off}:+-o xtrace}
|
||
# 1:proto 3:domain/5:start 6:end-of-it 7:no-dot-domain 9:file-path
|
||
if [[ $1 = (#b)([^:]#)(://|::)((([[:alnum:]._+-]##).([[:alnum:]_+-]##))|([[:alnum:].+_-]##))(|/(*)) ]] {
|
||
# The advanced coloring if recognized the format…
|
||
match[9]=${match[9]//\//"%F{227}%B"/"%F{81}%b"}
|
||
if [[ -n $match[4] ]]; then
|
||
REPLY="$(builtin print -Pr -- %F{220}$match[1]%F{227}$match[2]\
|
||
%B%F{82}$match[5]\
|
||
%B%F{227}.\
|
||
%B%F{183}$match[6]%f%b)" # … this ·case· ends at: trailing component of the with-dot domain …
|
||
else
|
||
REPLY="$(builtin print -Pr -- %F{220}$match[1]%F{227}$match[2]\
|
||
%B%F{82}$match[7]%f%b)" # … this ·case· ends at: no-dot domain …
|
||
fi
|
||
# Is there any file-path part in the URL?
|
||
if [[ -n $match[9] ]]; then
|
||
REPLY+="$(print -Pr -- \
|
||
%F{227}%B/%F{81}%b$match[9]%f%b)" # … append it. This ends the URL.
|
||
fi
|
||
#endif
|
||
} else {
|
||
# …revert to the basic if not…
|
||
REPLY=$ZINIT[col-url]$1$ZINIT[col-rst]
|
||
}
|
||
} # ]]]
|
||
|
||
# FUNCTION: .zinit-main-message-formatter [[[
|
||
.zinit-main-message-formatter() {
|
||
if [[ -z $1 && -z $2 && -z $3 ]]; then
|
||
REPLY=""
|
||
return
|
||
fi
|
||
local append influx in_prepend
|
||
if [[ $2 == (b|u|it|st|nb|nu|nit|nst) ]]; then
|
||
# Code repetition to preserve any leading/trailing whitespace
|
||
# and to allow accumulation of this code with others.
|
||
append=$ZINIT[col-$2]
|
||
elif [[ $2 == (…|ndsh|mdsh|mmdsh|-…|lr|) || -z $2 || -z $ZINIT[col-$2] ]]; then
|
||
# Resume previous escape code, if one is present.
|
||
if [[ $ZINIT[__last-formatter-code] != (…|ndsh|mdsh|mmdsh|-…|lr|rst|nl|) ]]; then
|
||
in_prepend=$ZINIT[col-$ZINIT[__last-formatter-code]]
|
||
influx=$ZINIT[col-$ZINIT[__last-formatter-code]]
|
||
fi
|
||
# Otherwise no action - only copy of this code without color.
|
||
else
|
||
# End of escaping logic
|
||
append=$ZINIT[col-rst]
|
||
fi
|
||
|
||
# Construct the text.
|
||
REPLY=$in_prepend${ZINIT[col-$2]:-$1}$influx$3$append
|
||
|
||
# Replace new lines with characters that work the same but are not
|
||
# deleted in the substitution $ (...) - vertical tab 0xB <-> 13 in the system
|
||
# octagonal connected back carriage (015).
|
||
local nl=$'\n' vertical=$'\013' carriager=$'\015'
|
||
REPLY=${REPLY//$nl/$vertical$carriager}
|
||
|
||
# REPLY+="x(${3}…)"
|
||
} # ]]]
|
||
|
||
# FUNCTION: +zi-log [[[
|
||
# Logging function
|
||
+zi-log() {
|
||
builtin emulate -LR zsh -o extendedglob ${=${options[xtrace]:#off}:+-o xtrace}
|
||
local opt msg
|
||
[[ $1 = -* ]] && { local opt=$1; shift; }
|
||
|
||
ZINIT[__last-formatter-code]=
|
||
msg=${${(j: :)${@:#--}}//\%/%%}
|
||
|
||
if [[ -z $ZINIT[DEBUG] ]] && [[ "$msg" = (#s){dbg}* ]]; then
|
||
return
|
||
fi
|
||
|
||
# First try a dedicated formatter, marking its empty output with ←→, then
|
||
# the general formatter and in the end filter-out the ←→ from the message.
|
||
msg=${${msg//(#b)(([\\]|(%F))([\{]([^\}]##)[\}])|([\{]([^\}]##)[\}])([^\%\{\\]#))/\
|
||
${match[4]:+${${match[3]:-$ZINIT[col-${ZINIT[__last-formatter-code]}]}:#%F}}$match[3]$match[4]\
|
||
${${functions[.zinit-formatter-$match[7]]:+\
|
||
${$(.zinit-formatter-$match[7] "$match[8]"; builtin print -rn -- $REPLY):-←→}}:-\
|
||
$(.zinit-main-message-formatter "$match[6]" "$match[7]" "$match[8]"; \
|
||
builtin print -rn -- "$REPLY"
|
||
)${${ZINIT[__last-formatter-code]::=${${${match[7]:#(…|ndsh|mdsh|mmdsh|-…|lr)}:+\
|
||
$match[7]}:-${ZINIT[__last-formatter-code]}}}:+}}}//←→}
|
||
|
||
[[ -z $msg ]] && return
|
||
|
||
# Reset color attributes at the end of the message
|
||
msg=$msg$ZINIT[col-rst]
|
||
# Output the processed message:
|
||
builtin print -Pr ${opt:#--} -- $msg
|
||
|
||
# Needed to correctly end a message with {nl}.
|
||
if [[ -n ${opt:#*n*} || -z $opt ]]; then
|
||
print -n $'\015'
|
||
fi
|
||
} # ]]]
|
||
# FUNCTION: +zinit-message [[[
|
||
# Wrapper function to maintain backward compatibility
|
||
+zinit-message(){
|
||
+zi-log $@
|
||
} # ]]]
|
||
|
||
# FUNCTION: +zinit-prehelp-usage-message [[[
|
||
+zinit-prehelp-usage-message() {
|
||
builtin emulate -LR zsh -o extendedglob ${=${options[xtrace]:#off}:+-o xtrace}
|
||
local cmd=$1 allowed=$2 sep="$ZINIT[col-msg2], $ZINIT[col-ehi]" \
|
||
sep2="$ZINIT[col-msg2], $ZINIT[col-opt]" bcol
|
||
|
||
# -h/--help given?
|
||
if (( OPTS[opt_-h,--help] )) {
|
||
# Yes – a help message:
|
||
+zi-log "{lhi}HELP FOR {apo}\`{cmd}$cmd{apo}\`{lhi} subcommand {mdsh}" \
|
||
"the available {b-lhi}options{ehi}:{rst}"
|
||
local opt
|
||
for opt ( ${(kos:|:)allowed} ) {
|
||
[[ $opt == --* ]] && continue
|
||
local msg=${___opt_map[$opt]#*:} txt=${___opt_map[(r)opt_$opt,--[^:]##]}
|
||
if [[ $msg == *":["* ]] {
|
||
msg=${${(MS)msg##$cmd:\[[^]]##}:-${(MS)msg##\*:\[[^]]##}}
|
||
msg=${msg#($cmd|\*):\[}
|
||
}
|
||
local pre_msg=`+zi-log -n {opt}${(r:14:)${txt#opt_}}`
|
||
+zi-log ${(r:35:: :)pre_msg}{rst}{ehi}→{rst}" $msg"
|
||
}
|
||
} elif [[ -n $allowed ]] {
|
||
shift 2
|
||
# No – an error message:
|
||
+zi-log "{b}{u-warn}ERROR{b-warn}:{rst}{msg2} Incorrect options given{ehi}:" \
|
||
"${(Mpj:$sep:)@:#-*}{rst}{msg2}. Allowed for the subcommand{ehi}:{rst}" \
|
||
"{apo}\`{cmd}$cmd{apo}\`{msg2} are{ehi}:{rst}" \
|
||
"{nl} {opt}${allowed//\|/$sep2}{msg2}."
|
||
} else {
|
||
local -a cmds
|
||
cmds=( load snippet update delete )
|
||
local bcol="{$cmd}" sep="${ZINIT[col-rst]}${ZINIT[col-$cmd]}\`, \`${ZINIT[col-cmd]}"
|
||
+zi-log "$bcol(it should be one of, e.g.{ehi}:" \
|
||
"{nb}$bcol\`{cmd}${(pj:$sep:)cmds}$bcol\`," \
|
||
"{cmd}{…}$bcol, e.g.{ehi}: {nb}$bcol\`{lhi}zinit {b}{cmd}load" \
|
||
"{pid}username/reponame$bcol\`) or a {b}{hi}for{nb}$bcol-based" \
|
||
"command body (i.e.{ehi}:{rst}$bcol e.g.{ehi}: {rst}$bcol\`{lhi}zinit" \
|
||
"{…}{b}ice-spec{nb}{…} {hi}for{nb}{lhi} {…}({b}plugin" \
|
||
"{nb}or{b} snippet) {pname}ID-1 ID-2 {-…} {lhi}{…}$bcol\`)." \
|
||
"See \`{cmd}help$bcol\` for a more detailed usage information and" \
|
||
"the list of the {cmd}subcommands$bcol.{rst}"
|
||
}
|
||
} # ]]]
|
||
# FUNCTION: .zinit-parse-opts [[[
|
||
.zinit-parse-opts() {
|
||
builtin emulate -LR zsh -o extendedglob ${=${options[xtrace]:#off}:+-o xtrace}
|
||
reply=( "${(@)${@[2,-1]//([ $'\t']##|(#s))(#b)(${(~j.|.)${(@s.|.)___opt_map[$1]}})(#B)([ $'\t']##|(#e))/${OPTS[${___opt_map[${match[1]}]%%:*}]::=1}ß←↓→}:#1ß←↓→}" )
|
||
} # ]]]
|
||
|
||
# Ice support
|
||
|
||
# FUNCTION: .zinit-ice [[[
|
||
# Parses ICE specification, puts the result into ICE global hash.
|
||
# The ice-spec is valid for next command only (i.e. it "melts"), but
|
||
# it can then stick to plugin and activate e.g. at update.
|
||
.zinit-ice() {
|
||
builtin setopt localoptions noksharrays extendedglob warncreateglobal typesetsilent noshortloops
|
||
integer retval
|
||
local bit exts="${(j:|:)${(@)${(@Akons:|:)${ZINIT_EXTS[ice-mods]//\'\'/}}/(#s)<->-/}}"
|
||
for bit; do
|
||
[[ $bit = (#b)(--|)(${~ZINIT[ice-list]}${~exts})(*) ]] && ZINIT_ICES[${match[2]}]+="${ZINIT_ICES[${match[2]}]:+;}${match[3]#(:|=)}" || break
|
||
retval+=1
|
||
done
|
||
[[ ${ZINIT_ICES[as]} = program ]] && ZINIT_ICES[as]=command
|
||
[[ -n ${ZINIT_ICES[on-update-of]} ]] && ZINIT_ICES[subscribe]="${ZINIT_ICES[subscribe]:-${ZINIT_ICES[on-update-of]}}"
|
||
[[ -n ${ZINIT_ICES[pick]} ]] && ZINIT_ICES[pick]="${ZINIT_ICES[pick]//\$ZPFX/${ZPFX%/}}"
|
||
if (( $+ZINIT_ICES[build] )); then
|
||
+zi-log -- "{dbg} {ice}build{rst}: setting configure & make ices"
|
||
ZINIT_ICES[configure]=
|
||
ZINIT_ICES[make]=
|
||
fi
|
||
if (( $+ZINIT_ICES[configure] || $+ZINIT_ICES[cmake] || $+ZINIT_ICES[make] )); then
|
||
ZINIT_ICES[null]=
|
||
fi
|
||
(( $+ZINIT_ICES[configure] )) && ZINIT_ICES[configure]="${ZINIT_ICES[configure]}"
|
||
(( $+ZINIT_ICES[make] )) && ZINIT_ICES[make]="${ZINIT_ICES[make]:-install}"
|
||
.zinit-validate-ice
|
||
return retval
|
||
} # ]]]
|
||
# FUNCTION: .zinit-validate-ice [[[
|
||
# Validates ice values at parse time.
|
||
# Warns (not errors) about invalid values — behavior is unchanged.
|
||
.zinit-validate-ice() {
|
||
builtin setopt localoptions noksharrays extendedglob typesetsilent noshortloops
|
||
if (( $+ZINIT_ICES[as] )) && [[ -n ${ZINIT_ICES[as]} ]]; then
|
||
case ${ZINIT_ICES[as]} in
|
||
(command|program|null|completion) ;;
|
||
(*)
|
||
+zi-log "{warn}Warning{b-warn}:{rst} {ice}as{rst} ice received invalid" \
|
||
"value {apo}\`{data}${ZINIT_ICES[as]}{apo}\`{rst}." \
|
||
"Expected one of: {data2}null{rst}, {data2}command{rst}," \
|
||
"{data2}program{rst}, {data2}completion{rst}."
|
||
;;
|
||
esac
|
||
fi
|
||
if (( $+ZINIT_ICES[wait] )) && [[ -n ${ZINIT_ICES[wait]} ]]; then
|
||
local w="${ZINIT_ICES[wait]#\!}"
|
||
w="${w%%.[0-9]##}"
|
||
local suffix="${w##[0-9]##}"
|
||
if [[ ${w%%[^0-9]*} = <-> && -n $suffix && $suffix != [abc] ]]; then
|
||
+zi-log "{warn}Warning{b-warn}:{rst} {ice}wait{rst} ice received invalid" \
|
||
"suffix letter {apo}\`{data}${suffix}{apo}\`{rst}." \
|
||
"Expected one of: {data2}a{rst}, {data2}b{rst}, {data2}c{rst}, or none."
|
||
fi
|
||
fi
|
||
if (( $+ZINIT_ICES[depth] )) && [[ -n ${ZINIT_ICES[depth]} ]]; then
|
||
if [[ ${ZINIT_ICES[depth]} != <1-> ]]; then
|
||
+zi-log "{warn}Warning{b-warn}:{rst} {ice}depth{rst} ice received invalid" \
|
||
"value {apo}\`{data}${ZINIT_ICES[depth]}{apo}\`{rst}." \
|
||
"Expected a positive integer."
|
||
fi
|
||
fi
|
||
} # ]]]
|
||
# FUNCTION: .zinit-pack-ice [[[
|
||
# Remembers all ice-mods, assigns them to concrete plugin. Ice spec
|
||
# is in general forgotten for second-next command (i.e., ice melts quickly), however they
|
||
# glue to the object (plugin or snippet) mentioned in the next command for later use with (e.g. 'zinit update ...').
|
||
.zinit-pack-ice() {
|
||
ZINIT_SICE[$1${1:+${2:+/}}$2]+="${(j: :)${(qkv)ICE[@]}} "
|
||
ZINIT_SICE[$1${1:+${2:+/}}$2]="${ZINIT_SICE[$1${1:+${2:+/}}$2]# }"
|
||
return 0
|
||
} # ]]]
|
||
# FUNCTION: .zinit-load-ices [[[
|
||
.zinit-load-ices() {
|
||
local id_as="$1" ___key ___path
|
||
local -a ice_order
|
||
ice_order=(
|
||
${(As:|:)ZINIT[ice-list]}
|
||
${(@)${(A@kons:|:)${ZINIT_EXTS[ice-mods]//\'\'/}}/(#s)<->-/}
|
||
)
|
||
___path="${ZINIT[PLUGINS_DIR]}/${id_as//\//---}"/._zinit
|
||
# TODO: snippets dir computation
|
||
if [[ ! -d $___path ]] {
|
||
if ! .zinit-get-object-path snippet "${id_as//\//---}"; then
|
||
return 1
|
||
fi
|
||
___path="$REPLY"/._zinit
|
||
}
|
||
for ___key ( "${ice_order[@]}" ) {
|
||
(( ${+ICE[$___key]} )) && [[ ${ICE[$___key]} != +* ]] && continue
|
||
[[ -e $___path/$___key ]] && ICE[$___key]="$(<$___path/$___key)"
|
||
}
|
||
[[ -n ${ICE[on-update-of]} ]] && ICE[subscribe]="${ICE[subscribe]:-${ICE[on-update-of]}}"
|
||
[[ ${ICE[as]} = program ]] && ICE[as]=command
|
||
[[ -n ${ICE[pick]} ]] && ICE[pick]="${ICE[pick]//\$ZPFX/${ZPFX%/}}"
|
||
|
||
return 0
|
||
} # ]]]
|
||
# FUNCTION: .zinit-setup-params [[[
|
||
.zinit-setup-params() {
|
||
builtin emulate -LR zsh -o extendedglob ${=${options[xtrace]:#off}:+-o xtrace}
|
||
reply=( ${(@)${(@s.;.)ICE[param]}/(#m)*/${${MATCH%%(-\>|→|=\>)*}//((#s)[[:space:]]##|[[:space:]]##(#e))}${${(M)MATCH#*(-\>|→|=\>)}:+\=${${MATCH#*(-\>|→|=\>)}//((#s)[[:space:]]##|[[:space:]]##(#e))}}} )
|
||
(( ${#reply} )) && return 0 || return 1
|
||
} # ]]]
|
||
|
||
#
|
||
# Turbo.
|
||
#
|
||
|
||
# FUNCTION: .zinit-run-task [[[
|
||
# A backend, worker function of .zinit-scheduler. It obtains the tasks
|
||
# index and a few of its properties (like the type: plugin, snippet,
|
||
# service plugin, service snippet) and executes it first checking for
|
||
# additional conditions (like non-numeric wait'' ice).
|
||
#
|
||
# $1 - current pass: 1 or 2
|
||
# $2 - time assigned to the task
|
||
# $3 - type: plugin, service plugin, service snippet, snippet
|
||
# $4 - tasks index in the ZINIT[WAIT_ICE_...] fields
|
||
# $5 - mode: load, light
|
||
# $6 - details: alias name (derived from id-as''), plugin-spec, or snippet URL
|
||
.zinit-run-task() {
|
||
local ___pass="$1" ___t="$2" ___tpe="$3" ___idx="$4" ___mode="$5" ___id="${(Q)6}" ___opt="${(Q)7}" ___action ___s=1 ___retval=0
|
||
|
||
local -A ICE ZINIT_ICE
|
||
ICE=( "${(@Q)${(z@)ZINIT[WAIT_ICE_${___idx}]}}" )
|
||
ZINIT_ICE=( "${(kv)ICE[@]}" )
|
||
|
||
local ___id_as=${ICE[id-as]:-$___id}
|
||
|
||
if [[ $___pass = 1 && ${${ICE[wait]#\!}%%[^0-9]([^0-9]|)([^0-9]|)([^0-9]|)} = <-> ]]; then
|
||
___action="${(M)ICE[wait]#\!}load"
|
||
elif [[ $___pass = 1 && -n ${ICE[wait]#\!} ]] && { eval "${ICE[wait]#\!}" || [[ $(( ___s=0 )) = 1 ]]; }; then
|
||
___action="${(M)ICE[wait]#\!}load"
|
||
elif [[ -n ${ICE[load]#\!} && -n $(( ___s=0 )) && $___pass = 3 && -z ${ZINIT_REGISTERED_PLUGINS[(r)$___id_as]} ]] && eval "${ICE[load]#\!}"; then
|
||
___action="${(M)ICE[load]#\!}load"
|
||
elif [[ -n ${ICE[unload]#\!} && -n $(( ___s=0 )) && $___pass = 2 && -n ${ZINIT_REGISTERED_PLUGINS[(r)$___id_as]} ]] && eval "${ICE[unload]#\!}"; then
|
||
___action="${(M)ICE[unload]#\!}remove"
|
||
elif [[ -n ${ICE[subscribe]#\!} && -n $(( ___s=0 )) && $___pass = 3 ]] && \
|
||
{ local -a fts_arr
|
||
eval "fts_arr=( ${ICE[subscribe]}(DNms-$(( EPOCHSECONDS -
|
||
ZINIT[fts-${ICE[subscribe]}] ))) ); (( \${#fts_arr} ))" && \
|
||
{ ZINIT[fts-${ICE[subscribe]}]="$EPOCHSECONDS"; ___s=${+ICE[once]}; } || \
|
||
(( 0 ))
|
||
}
|
||
then
|
||
___action="${(M)ICE[subscribe]#\!}load"
|
||
fi
|
||
|
||
if [[ $___action = *load ]]; then
|
||
if [[ $___tpe = p* ]]; then
|
||
.zinit-load "${(@)=___id}" "" "$___mode" ${___tpe#p}; (( ___retval += $? ))
|
||
elif [[ $___tpe = s* ]]; then
|
||
.zinit-load-snippet $___opt "$___id" "" ${___tpe#s}; (( ___retval += $? ))
|
||
fi
|
||
if [[ $___tpe = p1 || $___tpe = s1 ]]; then
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
zpty -b "${___id//\//:} / ${ICE[service]}" '.zinit-service '"${(M)___tpe#?}"' "$___mode" "$___id"'
|
||
fi
|
||
(( ${+ICE[silent]} == 0 && ${+ICE[lucid]} == 0 && ___retval == 0 )) && zle && zle -M "Loaded $___id"
|
||
elif [[ $___action = *remove ]]; then
|
||
(( ${+functions[.zinit-confirm]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-autoload.zsh" || return 1
|
||
[[ $___tpe = p ]] && .zinit-unload "$___id_as" "" -q
|
||
(( ${+ICE[silent]} == 0 && ${+ICE[lucid]} == 0 && ___retval == 0 )) && zle && zle -M "Unloaded $___id_as"
|
||
fi
|
||
|
||
[[ ${REPLY::=$___action} = \!* ]] && zle && zle .reset-prompt
|
||
|
||
return ___s
|
||
} # ]]]
|
||
# FUNCTION: .zinit-submit-turbo [[[
|
||
# If `zinit load`, `zinit light` or `zinit snippet` will be
|
||
# preceded with 'wait', 'load', 'unload' or 'on-update-of'/'subscribe'
|
||
# ice-mods then the plugin or snipped is to be loaded in turbo-mode,
|
||
# and this function adds it to internal data structures. @zinit-scheduler uses the data to
|
||
# create load or unload tasks.
|
||
.zinit-submit-turbo() {
|
||
local tpe="$1" mode="$2" opt_uspl2="$3" opt_plugin="$4"
|
||
|
||
ICE[wait]="${ICE[wait]%%.[0-9]##}"
|
||
ZINIT[WAIT_IDX]=$(( ${ZINIT[WAIT_IDX]:-0} + 1 ))
|
||
ZINIT[WAIT_ICE_${ZINIT[WAIT_IDX]}]="${(j: :)${(qkv)ICE[@]}}"
|
||
ZINIT[fts-${ICE[subscribe]}]="${ICE[subscribe]:+$EPOCHSECONDS}"
|
||
|
||
[[ $tpe = s* ]] && \
|
||
local id="${${opt_plugin:+$opt_plugin}:-$opt_uspl2}" || \
|
||
local id="${${opt_plugin:+$opt_uspl2${${opt_uspl2:#%*}:+/}$opt_plugin}:-$opt_uspl2}"
|
||
|
||
if [[ ${${ICE[wait]}%%[^0-9]([^0-9]|)([^0-9]|)([^0-9]|)} = (\!|.|)<-> ]]; then
|
||
ZINIT_TASKS+=( "$EPOCHSECONDS+${${ICE[wait]#(\!|.)}%%[^0-9]([^0-9]|)([^0-9]|)([^0-9]|)}+${${${(M)ICE[wait]%a}:+1}:-${${${(M)ICE[wait]%b}:+2}:-${${${(M)ICE[wait]%c}:+3}:-1}}} $tpe ${ZINIT[WAIT_IDX]} ${mode:-_} ${(q)id} ${opt_plugin:+${(q)opt_uspl2}}" )
|
||
elif [[ -n ${ICE[wait]}${ICE[load]}${ICE[unload]}${ICE[subscribe]} ]]; then
|
||
ZINIT_TASKS+=( "${${ICE[wait]:+0}:-1}+0+1 $tpe ${ZINIT[WAIT_IDX]} ${mode:-_} ${(q)id} ${opt_plugin:+${(q)opt_uspl2}}" )
|
||
fi
|
||
} # ]]]
|
||
# FUNCTION: -zinit_scheduler_add_sh [[[
|
||
# Copies task into ZINIT_RUN array, called when a task timeouts.
|
||
# A small function ran from pattern in /-substitution as a math
|
||
# function.
|
||
-zinit_scheduler_add_sh() {
|
||
local idx="$1" in_wait="$___ar2" in_abc="$___ar3" ver_wait="$___ar4" ver_abc="$___ar5"
|
||
if [[ ( $in_wait = $ver_wait || $in_wait -ge 4 ) && $in_abc = $ver_abc ]]; then
|
||
ZINIT_RUN+=( "${ZINIT_TASKS[$idx]}" )
|
||
return 1
|
||
else
|
||
return idx
|
||
fi
|
||
} # ]]]
|
||
# FUNCTION: @zinit-scheduler [[[
|
||
# Searches for timeout tasks, executes them. Theres an array of tasks
|
||
# waiting for execution, this scheduler manages them, detects which ones
|
||
# should be run at current moment, decides to remove (or not) them from
|
||
# the array after execution.
|
||
#
|
||
# $1 - if "following", then it is non-first (second and more)
|
||
# invocation of the scheduler; this results in chain of 'sched'
|
||
# invocations that results in repetitive @zinit-scheduler activity.
|
||
#
|
||
# if "burst", then all tasks are marked timeout and executed one
|
||
# by one; this is handy if e.g. a docker image starts up and
|
||
# needs to install all turbo-mode plugins without any hesitation
|
||
# (delay), i.e. "burst" allows to run package installations from
|
||
# script, not from prompt.
|
||
@zinit-scheduler() {
|
||
integer ___ret="${${ZINIT[lro-data]%:*}##*:}"
|
||
# lro stands for lastarg-retval-option.
|
||
[[ $1 = following ]] && sched +1 'ZINIT[lro-data]="$_:$?:${options[printexitvalue]}"; @zinit-scheduler following "${ZINIT[lro-data]%:*:*}"'
|
||
[[ -n $1 && $1 != (following*|burst) ]] && { local THEFD="$1"; zle -F "$THEFD"; exec {THEFD}<&-; }
|
||
[[ $1 = burst ]] && local -h EPOCHSECONDS=$(( EPOCHSECONDS+10000 ))
|
||
ZINIT[START_TIME]="${ZINIT[START_TIME]:-$EPOCHREALTIME}"
|
||
|
||
integer ___t=EPOCHSECONDS ___i correct
|
||
local -a match mbegin mend reply
|
||
local MATCH REPLY AFD; integer MBEGIN MEND
|
||
|
||
[[ -o ksharrays ]] && correct=1
|
||
|
||
if [[ -n $1 ]] {
|
||
if [[ ${#ZINIT_RUN} -le 1 || $1 = following ]] {
|
||
() {
|
||
builtin emulate -L zsh ${=${options[xtrace]:#off}:+-o xtrace}
|
||
builtin setopt extendedglob
|
||
# Example entry:
|
||
# 1531252764+2+1 p 18 light zdharma/zsh-diff-so-fancy
|
||
#
|
||
# This either doesnt change ZINIT_TASKS entry - when
|
||
# ___i is used in the ternary expression, or replaces
|
||
# an entry with "<no-data>", i.e. ZINIT_TASKS[1] entry.
|
||
integer ___idx1 ___idx2
|
||
local ___ar2 ___ar3 ___ar4 ___ar5
|
||
for (( ___idx1 = 0; ___idx1 <= 4; ___idx1 ++ )) {
|
||
for (( ___idx2 = 1; ___idx2 <= (___idx >= 4 ? 1 : 3); ___idx2 ++ )) {
|
||
# The following substitution could be just (well, 'just'..) this:
|
||
#
|
||
# ZINIT_TASKS=( ${ZINIT_TASKS[@]/(#b)([0-9]##)+([0-9]##)+([1-3])(*)/
|
||
# ${ZINIT_TASKS[$(( (${match[1]}+${match[2]}) <= $___t ?
|
||
# zinit_scheduler_add(___i++, ${match[2]},
|
||
# ${(M)match[3]%[1-3]}, ___idx1, ___idx2) : ___i++ ))]}} )
|
||
#
|
||
# However, there's a severe bug in Zsh <= 5.3.1 - use of the period
|
||
# (,) is impossible inside ${..//$arr[$(( ... ))]}.
|
||
___i=2
|
||
|
||
ZINIT_TASKS=( ${ZINIT_TASKS[@]/(#b)([0-9]##)+([0-9]##)+([1-3])(*)/${ZINIT_TASKS[
|
||
$(( (___ar2=${match[2]}+1) ? (
|
||
(___ar3=${(M)match[3]%[1-3]}) ? (
|
||
(___ar4=___idx1+1) ? (
|
||
(___ar5=___idx2) ? (
|
||
(${match[1]}+${match[2]}) <= $___t ?
|
||
zinit_scheduler_add(___i++) : ___i++ )
|
||
: 1 )
|
||
: 1 )
|
||
: 1 )
|
||
: 1 ))]}} )
|
||
ZINIT_TASKS=( "<no-data>" ${ZINIT_TASKS[@]:#<no-data>} )
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
add-zsh-hook -d -- precmd @zinit-scheduler
|
||
add-zsh-hook -- chpwd @zinit-scheduler
|
||
() {
|
||
builtin emulate -L zsh ${=${options[xtrace]:#off}:+-o xtrace}
|
||
builtin setopt extendedglob
|
||
# No "+" in this pattern, it will match only "1531252764"
|
||
# in "1531252764+2" and replace it with current time.
|
||
ZINIT_TASKS=( ${ZINIT_TASKS[@]/(#b)([0-9]##)(*)/$(( ${match[1]} <= 1 ? ${match[1]} : ___t ))${match[2]}} )
|
||
}
|
||
# Theres a bug in Zsh: first sched call would not be issued
|
||
# until a key-press, if "sched +1 ..." would be called inside
|
||
# zle -F handler. So its done here, in precmd-handle code.
|
||
sched +1 'ZINIT[lro-data]="$_:$?:${options[printexitvalue]}"; @zinit-scheduler following ${ZINIT[lro-data]%:*:*}'
|
||
|
||
AFD=13371337 # for older Zsh + noclobber option
|
||
exec {AFD}< <(LANG=C command sleep 0.002; builtin print run;)
|
||
command true # workaround a Zsh bug, see: https://www.zsh.org/mla/workers/2018/msg00966.html
|
||
zle -F "$AFD" @zinit-scheduler
|
||
}
|
||
|
||
local ___task ___idx=0 ___count=0 ___idx2
|
||
# All wait'' objects.
|
||
for ___task ( "${ZINIT_RUN[@]}" ) {
|
||
.zinit-run-task 1 "${(@z)___task}" && ZINIT_TASKS+=( "$___task" )
|
||
if [[ $(( ++___idx, ___count += ${${REPLY:+1}:-0} )) -gt 0 && $1 != burst ]] {
|
||
AFD=13371337 # for older Zsh + noclobber option
|
||
exec {AFD}< <(LANG=C command sleep 0.0002; builtin print run;)
|
||
command true
|
||
# The $? and $_ will be left unchanged automatically by Zsh.
|
||
zle -F "$AFD" @zinit-scheduler
|
||
break
|
||
}
|
||
}
|
||
# All unload'' objects.
|
||
for (( ___idx2=1; ___idx2 <= ___idx; ++ ___idx2 )) {
|
||
.zinit-run-task 2 "${(@z)ZINIT_RUN[___idx2-correct]}"
|
||
}
|
||
# All load'' & subscribe'' objects.
|
||
for (( ___idx2=1; ___idx2 <= ___idx; ++ ___idx2 )) {
|
||
.zinit-run-task 3 "${(@z)ZINIT_RUN[___idx2-correct]}"
|
||
}
|
||
ZINIT_RUN[1-correct,___idx-correct]=()
|
||
|
||
[[ ${ZINIT[lro-data]##*:} = on ]] && return 0 || return ___ret
|
||
} # ]]]
|
||
|
||
#
|
||
# Exposed functions.
|
||
#
|
||
|
||
# FUNCTION: zinit [[[
|
||
# Entrypoint function directly exposed to user, consumes subcommands with respective arguments,
|
||
# and completion.
|
||
zinit() {
|
||
local -A ICE ZINIT_ICE
|
||
ICE=( "${(kv)ZINIT_ICES[@]}" )
|
||
ZINIT_ICE=( "${(kv)ICE[@]}" )
|
||
ZINIT_ICES=()
|
||
|
||
integer ___retval ___retval2 ___correct
|
||
local -a match mbegin mend
|
||
local MATCH cmd ___q="\`" ___q2="'" IFS=$' \t\n\0'; integer MBEGIN MEND
|
||
|
||
# An annexs subcommand might use the reply vars.
|
||
match=( ${ZINIT_EXTS[(I)z-annex subcommand:$1]} )
|
||
if (( !${#match} )) {
|
||
local -a reply; local REPLY
|
||
}
|
||
|
||
[[ -o ksharrays ]] && ___correct=1
|
||
|
||
local -A ___opt_map OPTS
|
||
___opt_map=(
|
||
-q opt_-q,--quiet:"update:[Turn off almost-all messages from the {cmd}update{rst} operation {b-lhi}FOR the objects{rst} which don't have any {b-lhi}new version{rst} available.] *:[Turn off any (or: almost-any) messages from the operation.]"
|
||
--quiet opt_-q,--quiet
|
||
-v opt_-v,--verbose:"Turn on more messages from the operation."
|
||
--verbose opt_-v,--verbose
|
||
-r opt_-r,--reset:"Reset the repository before updating (or remove the files for single-file snippets and gh-r plugins)."
|
||
--reset opt_-r,--reset
|
||
-a opt_-a,--all:"delete:[Delete {hi}all{rst} plugins and snippets.] update:[Update {b-lhi}all{rst} plugins and snippets.]"
|
||
--all opt_-a,--all
|
||
-c opt_-c,--clean:"Delete {b-lhi}only{rst} the {b-lhi}currently-not loaded{rst} plugins and snippets."
|
||
--clean opt_-c,--clean
|
||
-y opt_-y,--yes:"Automatically confirm any yes/no prompts."
|
||
--yes opt_-y,--yes
|
||
-f opt_-f,--force:"Force new download of the snippet file."
|
||
--force opt_-f,--force
|
||
-p opt_-p,--parallel:"Turn on concurrent, multi-thread update (of all objects)."
|
||
--parallel opt_-p,--parallel
|
||
-s opt_-s,--snippets:"snippets:[Update only snippets (i.e.: skip updating plugins).] times:[Show times in seconds instead of milliseconds.]"
|
||
--snippets opt_-s,--snippets
|
||
-L opt_-l,--plugins:"Update only plugins (i.e.: skip updating snippets)."
|
||
--plugins opt_-l,--plugins
|
||
-h opt_-h,--help:"Show this help message."
|
||
--help opt_-h,--help
|
||
-u opt_-u,--urge:"Cause all the hooks like{ehi}:{rst} {ice}atpull{apo}''{rst}, {ice}cp{apo}''{rst}, etc. to execute even when there aren't any new commits {b}/{rst} any new version of the {b}{meta}gh-r{rst} file {b}/{rst} etc.{…} available for download {ehi}{lr}{rst} simulate a non-empty update."
|
||
--urge opt_-u,--urge
|
||
-n opt_-n,--no-pager:"Disable the use of the pager."
|
||
--no-pager opt_-n,--no-pager
|
||
-m opt_-m,--moments:"Show the {apo}*{b-lhi}moments{apo}*{rst} of object (i.e.: a plugin or snippet) loading time."
|
||
--moments opt_-m,--moments
|
||
-b opt_-b,--bindkeys:"Load in light mode, however do still track {cmd}bindkey{rst} calls (to allow remapping the keys bound)."
|
||
--bindkeys opt_-b,--bindkeys
|
||
-x opt_-x,--command:"Load the snippet as a {cmd}command{rst}, i.e.: add it to {var}\$PATH{rst} and set {b-lhi}+x{rst} on it."
|
||
--command opt_-x,--command
|
||
cdclear "--help|--quiet|-h|-q"
|
||
cdreplay "--help|--quiet|-h|-q"
|
||
delete "--all|--clean|--help|--quiet|--yes|-a|-c|-h|-q|-y"
|
||
env-whitelist "--help|--verbose|-h|-v"
|
||
light "--help|-b|-h"
|
||
snippet "--command|--force|--help|-f|-h|-x"
|
||
times "--help|-h|-m|-s"
|
||
self-update "--help|--quiet|-h|-q"
|
||
unload "--help|--quiet|-h|-q"
|
||
update "--all|--help|--no-pager|--parallel|--plugins|--quiet|--reset|--snippets|--urge|--verbose|-L|-a|-h|-n|-p|-q|-r|-s|-u|-v"
|
||
version ""
|
||
)
|
||
|
||
cmd="$1"
|
||
if [[ $cmd == (times|unload|env-whitelist|update|snippet|load|light|cdreplay|cdclear|self-update) ]]; then
|
||
if (( $@[(I)-*] || OPTS[opt_-h,--help] )); then
|
||
.zinit-parse-opts "$cmd" "$@"
|
||
if (( OPTS[opt_-h,--help] )); then
|
||
+zinit-prehelp-usage-message $cmd $___opt_map[$cmd] $@
|
||
return 1;
|
||
elif (( ${reply[(I)-*]} )); then
|
||
+zinit-prehelp-usage-message $cmd $___opt_map[$cmd] ${reply[@]}
|
||
return 1
|
||
fi
|
||
fi
|
||
fi
|
||
|
||
reply=( ${ZINIT_EXTS[(I)z-annex subcommand:*]} )
|
||
|
||
[[ -n $1 && $1 != (${~ZINIT[cmds]}|${(~j:|:)reply[@]#z-annex subcommand:}) || $1 = (load|light|snippet) ]] && \
|
||
{
|
||
integer ___error
|
||
if [[ $1 = (load|light|snippet) ]] {
|
||
integer ___is_snippet
|
||
# Classic syntax -> simulate a call through the for-syntax.
|
||
() {
|
||
builtin setopt localoptions extendedglob
|
||
: ${@[@]//(#b)([ $'\t']##|(#s))(-b|--command|-f|--force)([ $'\t']##|(#e))/${OPTS[${match[2]}]::=1}}
|
||
} "$@"
|
||
builtin set -- "${@[@]:#(-b|--command|-f|--force)}"
|
||
[[ $1 = light && -z ${OPTS[(I)-b]} ]] && ICE[light-mode]=
|
||
[[ $1 = snippet ]] && ICE[is-snippet]= || ___is_snippet=-1
|
||
shift
|
||
|
||
ZINIT_ICES=( "${(kv)ICE[@]}" )
|
||
ICE=() ZINIT_ICE=()
|
||
1="${1:+@}${1#@}${2:+/$2}"
|
||
(( $# > 1 )) && { shift -p $(( $# - 1 )); }
|
||
[[ -z $1 ]] && {
|
||
+zi-log "Argument needed, try: {cmd}help."
|
||
return 1
|
||
}
|
||
} else {
|
||
.zinit-ice "$@"
|
||
___retval2=$?
|
||
local ___last_ice=${@[___retval2]}
|
||
shift ___retval2
|
||
if [[ $# -gt 0 && $1 != for ]] {
|
||
+zi-log -n "{b}{u-warn}ERROR{b-warn}:{rst} Unknown subcommand{ehi}:" \
|
||
"{apo}\`{cmd}$1{apo}\`{rst} "
|
||
+zinit-prehelp-usage-message rst
|
||
return 1
|
||
} elif (( $# == 0 )) {
|
||
___error=1
|
||
} else {
|
||
shift
|
||
}
|
||
}
|
||
integer ___had_wait
|
||
local ___id ___ehid ___etid ___key
|
||
local -a ___arr
|
||
ZINIT[annex-exposed-processed-IDs]=
|
||
if (( $# )) {
|
||
local -a ___ices
|
||
___ices=( "${(kv)ZINIT_ICES[@]}" )
|
||
ZINIT_ICES=()
|
||
while (( $# )) {
|
||
.zinit-ice "$@"
|
||
___retval2=$?
|
||
local ___last_ice=${@[___retval2]}
|
||
shift ___retval2
|
||
if [[ -n $1 ]] {
|
||
ICE=( "${___ices[@]}" "${(kv)ZINIT_ICES[@]}" )
|
||
ZINIT_ICE=( "${(kv)ICE[@]}" ) ZINIT_ICES=()
|
||
integer ___msgs=${+ICE[debug]}
|
||
(( ___msgs )) && +zi-log "{pre}zinit-main:{faint} Processing {pname}$1{faint}{…}{rst}"
|
||
|
||
# Delete up to the final space to get the previously-processed ID.
|
||
ZINIT[annex-exposed-processed-IDs]+="${___id:+ $___id}"
|
||
|
||
# Strip the ID-qualifier (`@') and GitHub domain from the ID.
|
||
___id="${${1#@}%%(///|//|/)}"
|
||
(( ___is_snippet == -1 )) && ___id="${___id#https://github.com/}"
|
||
|
||
# Effective handle-ID – the label under which the object
|
||
# will be identified / referred-to by Zinit.
|
||
___ehid="${ICE[id-as]:-$___id}"
|
||
|
||
# Effective remote-ID (i.e.: URL, GitHub username/repo,
|
||
# package name, etc.). teleid'' allows "overriding" of $1.
|
||
# In case of a package using teleid'', the value here
|
||
# is being took from the given ices, before disk-ices.
|
||
___etid="${ICE[teleid]:-$___id}"
|
||
|
||
if (( ${+ICE[pack]} )); then
|
||
___had_wait=${+ICE[wait]}
|
||
.zinit-load-ices "$___ehid"
|
||
# wait'' isn't possible via the disk-ices (for
|
||
# packages), only via the command's ice-spec.
|
||
[[ $___had_wait -eq 0 ]] && unset 'ICE[wait]'
|
||
fi
|
||
|
||
[[ ${ICE[id-as]} = (auto|) && ${+ICE[id-as]} == 1 ]] && ICE[id-as]="${___etid:t}"
|
||
|
||
integer ___is_snippet=${${(M)___is_snippet:#-1}:-0}
|
||
() {
|
||
builtin setopt localoptions extendedglob
|
||
if [[ $___is_snippet -ge 0 && ( -n ${ICE[is-snippet]+1} || $___etid = ((#i)(http(s|)|ftp(s|)):/|(${(~kj.|.)ZINIT_1MAP}))* ) ]] {
|
||
___is_snippet=1
|
||
}
|
||
} "$@"
|
||
|
||
local ___type=${${${(M)___is_snippet:#1}:+snippet}:-plugin}
|
||
reply=(
|
||
${(on)ZINIT_EXTS2[(I)zinit hook:before-load-pre <->]}
|
||
${(on)ZINIT_EXTS[(I)z-annex hook:before-load-<-> <->]}
|
||
${(on)ZINIT_EXTS2[(I)zinit hook:before-load-post <->]}
|
||
)
|
||
for ___key in "${reply[@]}"; do
|
||
___arr=( "${(Q)${(z@)ZINIT_EXTS[$___key]:-$ZINIT_EXTS2[$___key]}[@]}" )
|
||
"${___arr[5]}" "$___type" "$___id" "${ICE[id_as]}" \
|
||
"${(j: :)${(q)@[2,-1]}}" "${(j: :)${(qkv)___ices[@]}}" \
|
||
"${${___key##(zinit|z-annex) hook:}%% <->}" load
|
||
___retval2=$?
|
||
if (( ___retval2 )) {
|
||
# An error is actually only an odd return code.
|
||
___retval+=$(( ___retval2 & 1 ? ___retval2 : 0 ))
|
||
(( ___retval2 & 1 && $# )) && shift
|
||
|
||
# Override $@?
|
||
if (( ___retval2 & 2 )) {
|
||
local -a ___args
|
||
___args=( "${(@Q)${(@z)ZINIT[annex-before-load:new-@]}}" )
|
||
builtin set -- "${___args[@]}"
|
||
}
|
||
|
||
# Override $___ices?
|
||
if (( ___retval2 & 4 )) {
|
||
local -a ___new_ices
|
||
___new_ices=( "${(Q@)${(@z)ZINIT[annex-before-load:new-global-ices]}}" )
|
||
(( 0 == ${#___new_ices} % 2 )) && \
|
||
___ices=( "${___new_ices[@]}" ) || \
|
||
{ [[ ${ZINIT[MUTE_WARNINGS]} != (1|true|on|yes) ]] && \
|
||
+zi-log "{u-warn}Warning{b-warn}:{msg} Bad new-ices returned" \
|
||
"from the annex{ehi}:{rst} {annex}${___arr[3]}{msg}," \
|
||
"please file an issue report at:{url}" \
|
||
"https://github.com/zdharma-continuum/${___arr[3]}/issues/new{msg}.{rst}"
|
||
___ices=( ) ___retval+=7
|
||
}
|
||
}
|
||
continue 2
|
||
}
|
||
done
|
||
integer ___action_load=0 ___turbo=0
|
||
if [[ -n ${(M)${+ICE[wait]}:#1}${ICE[load]}${ICE[unload]}${ICE[service]}${ICE[subscribe]} ]] {
|
||
___turbo=1
|
||
}
|
||
|
||
if [[ -n ${ICE[trigger-load]} || \
|
||
( ${+ICE[wait]} == 1 &&
|
||
${ICE[wait]} = (\!|)(<->(a|b|c|)|) )
|
||
]] && (( !ZINIT[OPTIMIZE_OUT_DISK_ACCESSES]
|
||
)) {
|
||
if (( ___is_snippet > 0 )) {
|
||
.zinit-get-object-path snippet $___ehid
|
||
} else {
|
||
.zinit-get-object-path plugin $___ehid
|
||
}
|
||
(( $? )) && [[ ${zsh_eval_context[1]} = file ]] && { ___action_load=1; }
|
||
local ___object_path="$REPLY"
|
||
} elif (( ! ___turbo )) {
|
||
___action_load=1
|
||
reply=( 1 )
|
||
} else {
|
||
reply=( 1 )
|
||
}
|
||
|
||
if [[ ${reply[-1]} -eq 1 && -n ${ICE[trigger-load]} ]] {
|
||
() {
|
||
builtin setopt localoptions extendedglob
|
||
local ___mode
|
||
(( ___is_snippet > 0 )) && ___mode=snippet || ___mode="${${${ICE[light-mode]+light}}:-load}"
|
||
for MATCH ( ${(s.;.)ICE[trigger-load]} ) {
|
||
eval "${MATCH#!}() {
|
||
${${(M)MATCH#!}:+unset -f ${MATCH#!}}
|
||
local a b; local -a ices
|
||
# The wait'' ice is filtered-out.
|
||
for a b ( ${(qqkv@)${(kv@)ICE[(I)^(trigger-load|wait|light-mode)]}} ) {
|
||
ices+=( \"\$a\$b\" )
|
||
}
|
||
zinit ice \${ices[@]}; zinit $___mode ${(qqq)___id}
|
||
${${(M)MATCH#!}:+# Forward the call
|
||
eval ${MATCH#!} \$@}
|
||
}"
|
||
}
|
||
} "$@"
|
||
___retval+=$?
|
||
(( $# )) && shift
|
||
continue
|
||
}
|
||
|
||
if (( ${+ICE[if]} )) {
|
||
eval "${ICE[if]}" || { (( $# )) && shift; continue; };
|
||
}
|
||
for REPLY ( ${(s.;.)ICE[has]} ) {
|
||
(( ${+commands[$REPLY]} )) || \
|
||
{ (( $# )) && shift; continue 2; }
|
||
}
|
||
|
||
integer ___had_cloneonly=0
|
||
ICE[wait]="${${(M)${+ICE[wait]}:#1}:+${(M)ICE[wait]#!}${${ICE[wait]#!}:-0}}"
|
||
if (( ___action_load || !ZINIT[HAVE_SCHEDULER] )) {
|
||
if (( ___turbo && ZINIT[HAVE_SCHEDULER] )) {
|
||
___had_cloneonly=${+ICE[cloneonly]}
|
||
ICE[cloneonly]=""
|
||
}
|
||
|
||
(( ___is_snippet )) && \
|
||
local ___opt="${(k)OPTS[*]}" || \
|
||
local ___opt="${${ICE[light-mode]+light}:-${OPTS[(I)-b]:+light-b}}"
|
||
|
||
.zinit-load-object ${${${(M)___is_snippet:#1}:+snippet}:-plugin} $___id $___opt
|
||
integer ___last_retval=$?
|
||
___retval+=___last_retval
|
||
|
||
if (( ___turbo && !___had_cloneonly && ZINIT[HAVE_SCHEDULER] )) {
|
||
command rm -f $___object_path/._zinit/cloneonly
|
||
unset 'ICE[cloneonly]'
|
||
}
|
||
}
|
||
if (( ___turbo && ZINIT[HAVE_SCHEDULER] && 0 == ___last_retval )) {
|
||
ICE[wait]="${ICE[wait]:-${ICE[service]:+0}}"
|
||
if (( ___is_snippet > 0 )); then
|
||
ZINIT_SICE[$___ehid]=
|
||
.zinit-submit-turbo s${ICE[service]:+1} "" \
|
||
"$___id" "${(k)OPTS[*]}"
|
||
else
|
||
ZINIT_SICE[$___ehid]=
|
||
.zinit-submit-turbo p${ICE[service]:+1} \
|
||
"${${${ICE[light-mode]+light}}:-load}" \
|
||
"$___id" ""
|
||
fi
|
||
___retval+=$?
|
||
}
|
||
} else {
|
||
___error=1
|
||
}
|
||
(( $# )) && shift
|
||
___is_snippet=0
|
||
}
|
||
} else {
|
||
___error=1
|
||
}
|
||
|
||
if (( ___error )) {
|
||
() {
|
||
builtin emulate -LR zsh -o extendedglob ${=${options[xtrace]:#off}:+-o xtrace}
|
||
+zi-log -n "{u-warn}Error{b-warn}:{rst} No plugin or snippet ID given"
|
||
if [[ -n $___last_ice ]] {
|
||
+zi-log -n " (the last recognized ice was: {ice}"\
|
||
"${___last_ice/(#m)(${~ZINIT[ice-list]})/"{data}$MATCH"}{apo}''{rst}).{error}
|
||
You can try to prepend {apo}${___q}{lhi}@{apo}'{error} to the ID if the last ice is in fact a plugin.{rst}
|
||
{note}Note:{rst} The {apo}\`{ice}ice{apo}\`{rst} subcommand is now again required if not using the for-syntax"
|
||
}
|
||
+zi-log "."
|
||
}
|
||
return 2
|
||
} elif (( ! $# )) {
|
||
return ___retval
|
||
}
|
||
}
|
||
|
||
case "$1" in
|
||
(ice)
|
||
shift
|
||
.zinit-ice "$@"
|
||
;;
|
||
(cdreplay)
|
||
.zinit-compdef-replay "$2"; ___retval=$?
|
||
;;
|
||
(cdclear)
|
||
.zinit-compdef-clear "$2"
|
||
;;
|
||
((add-|)fpath)
|
||
.zinit-add-fpath "${@[2-correct,-1]}"
|
||
;;
|
||
(run)
|
||
.zinit-run "${@[2-correct,-1]}"
|
||
;;
|
||
(man)
|
||
man "${ZINIT[BIN_DIR]}/doc/zinit.1"
|
||
;;
|
||
(env-whitelist)
|
||
shift
|
||
.zinit-parse-opts env-whitelist "$@"
|
||
builtin set -- "${reply[@]}"
|
||
|
||
if (( $# == 0 )) {
|
||
ZINIT[ENV-WHITELIST]=
|
||
(( OPTS[opt_-v,--verbose] )) && +zi-log "{msg2}Cleared the parameter whitelist.{rst}"
|
||
} else {
|
||
ZINIT[ENV-WHITELIST]+="${(j: :)${(q-kv)@}} "
|
||
local ___sep="$ZINIT[col-msg2], $ZINIT[col-data2]"
|
||
(( OPTS[opt_-v,--verbose] )) && +zi-log "{msg2}Extended the parameter whitelist with: {data2}${(pj:$___sep:)@}{msg2}.{rst}"
|
||
}
|
||
;;
|
||
(*)
|
||
# Check if there is a z-annex registered for the subcommand.
|
||
reply=( ${ZINIT_EXTS[z-annex subcommand:${(q)1}]} )
|
||
(( ${#reply} )) && {
|
||
reply=( "${(Q)${(z@)reply[1]}[@]}" )
|
||
(( ${+functions[${reply[5]}]} )) && \
|
||
{ "${reply[5]}" "$@"; return $?; } || \
|
||
{ +zi-log "({error}Couldn't find the subcommand-handler \`{obj}${reply[5]}{error}' of the z-annex \`{file}${reply[3]}{error}')"; return 1; }
|
||
}
|
||
(( ${+functions[.zinit-confirm]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-autoload.zsh" || return 1
|
||
case "$1" in
|
||
(zstatus)
|
||
.zinit-show-zstatus
|
||
;;
|
||
(delete)
|
||
shift
|
||
.zinit-delete "$@"
|
||
;;
|
||
(times)
|
||
.zinit-show-times "${@[2-correct,-1]}"
|
||
;;
|
||
(self-update)
|
||
.zinit-self-update
|
||
;;
|
||
(unload)
|
||
(( ${+functions[.zinit-unload]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-autoload.zsh" || return 1
|
||
if [[ -z $2 && -z $3 ]]; then
|
||
builtin print "Argument needed, try: help"; ___retval=1
|
||
else
|
||
[[ $2 = -q ]] && { 5=-q; shift; }
|
||
# Unload given plugin. Cloned directory remains intact
|
||
# so as are completions.
|
||
.zinit-unload "${2%%(///|//|/)}" "${${3:#-q}%%(///|//|/)}" "${${(M)4:#-q}:-${(M)3:#-q}}"; ___retval=$?
|
||
fi
|
||
;;
|
||
(bindkeys)
|
||
.zinit-list-bindkeys
|
||
;;
|
||
(update)
|
||
if (( ${+ICE[if]} )) {
|
||
eval "${ICE[if]}" || return 1;
|
||
}
|
||
for REPLY ( ${(s.;.)ICE[has]} ) {
|
||
(( ${+commands[$REPLY]} )) || return 1
|
||
}
|
||
shift
|
||
.zinit-parse-opts update "$@"
|
||
builtin set -- "${reply[@]}"
|
||
if [[ ${OPTS[opt_-a,--all]} -eq 1 || ${OPTS[opt_-p,--parallel]} -eq 1 || ${OPTS[opt_-s,--snippets]} -eq 1 || ${OPTS[opt_-l,--plugins]} -eq 1 || -z $1$2${ICE[teleid]}${ICE[id-as]} ]]; then
|
||
[[ -z $1$2 && $(( OPTS[opt_-a,--all] + OPTS[opt_-p,--parallel] + OPTS[opt_-s,--snippets] + OPTS[opt_-l,--plugins] )) -eq 0 ]] && { builtin print -r -- "Assuming --all is passed"; }
|
||
(( OPTS[opt_-p,--parallel] )) && OPTS[value]=${1:-15}
|
||
.zinit-update-or-status-all update; ___retval=$?
|
||
else
|
||
local ___key ___id="${1%%(///|//|/)}${2:+/}${2%%(///|//|/)}"
|
||
[[ -z ${___id//[[:space:]]/} ]] && ___id="${ICE[id-as]:-$ICE[teleid]}"
|
||
.zinit-update-or-status update "$___id" ""; ___retval=$?
|
||
fi
|
||
;;
|
||
(status)
|
||
if [[ $2 = --all || ( -z $2 && -z $3 ) ]]; then
|
||
[[ -z $2 ]] && { builtin print -r -- "Assuming --all is passed"; }
|
||
.zinit-update-or-status-all status; ___retval=$?
|
||
else
|
||
.zinit-update-or-status status "${2%%(///|//|/)}" "${3%%(///|//|/)}"; ___retval=$?
|
||
fi
|
||
;;
|
||
(report)
|
||
if [[ $2 = --all || ( -z $2 && -z $3 ) ]]; then
|
||
[[ -z $2 ]] && { builtin print -r -- "Assuming --all is passed"; }
|
||
.zinit-show-all-reports
|
||
else
|
||
.zinit-show-report "${2%%(///|//|/)}" "${3%%(///|//|/)}"; ___retval=$?
|
||
fi
|
||
;;
|
||
(plugins)
|
||
.zinit-list-plugins "$2"
|
||
;;
|
||
(snippets)
|
||
.zinit-list-snippets "$2"
|
||
;;
|
||
(completions) # Show installed, enabled or disabled, completions and detect stray and improper ones
|
||
.zinit-show-completions "$2"
|
||
;;
|
||
(cclear) # Delete stray and improper completions.
|
||
.zinit-clear-completions
|
||
;;
|
||
(cdisable)
|
||
if [[ -z $2 ]]; then
|
||
builtin print "Argument needed, try: help"; ___retval=1
|
||
else
|
||
local ___f="_${2#_}"
|
||
# Disable completion given by completion function name
|
||
# with or without leading _, e.g. cp, _cp.
|
||
if .zinit-cdisable "$___f"; then
|
||
(( ${+functions[.zinit-forget-completion]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-install.zsh" || return 1
|
||
.zinit-forget-completion "$___f"
|
||
+zi-log "Initializing completion system ({func}compinit{rst}){…}"
|
||
builtin autoload -Uz compinit
|
||
compinit -d ${ZINIT[ZCOMPDUMP_PATH]:-${ZDOTDIR:-$HOME}/.zcompdump} "${(Q@)${(z@)ZINIT[COMPINIT_OPTS]}}"
|
||
else
|
||
___retval=1
|
||
fi
|
||
fi
|
||
;;
|
||
(cenable)
|
||
if [[ -z $2 ]]; then
|
||
builtin print "Argument needed, try: help"; ___retval=1
|
||
else
|
||
local ___f="_${2#_}"
|
||
# Enable completion given by completion function name
|
||
# with or without leading _, e.g. cp, _cp.
|
||
if .zinit-cenable "$___f"; then
|
||
(( ${+functions[.zinit-forget-completion]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-install.zsh" || return 1
|
||
.zinit-forget-completion "$___f"
|
||
+zi-log "Initializing completion system ({func}compinit{rst}){…}"
|
||
builtin autoload -Uz compinit
|
||
compinit -d ${ZINIT[ZCOMPDUMP_PATH]:-${ZDOTDIR:-$HOME}/.zcompdump} "${(Q@)${(z@)ZINIT[COMPINIT_OPTS]}}"
|
||
else
|
||
___retval=1
|
||
fi
|
||
fi
|
||
;;
|
||
(creinstall)
|
||
(( ${+functions[.zinit-install-completions]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-install.zsh" || return 1
|
||
# Installs completions for plugin. Enables them all. It is a reinstallation, thus every obstacle gets overwritten or removed.
|
||
[[ $2 = -[qQ] ]] && { 5=$2; shift; }
|
||
.zinit-install-completions "${2%%(///|//|/)}" "${3%%(///|//|/)}" 1 "${(M)4:#-[qQ]}"; ___retval=$?
|
||
[[ -z ${(M)4:#-[qQ]} ]] && +zi-log "Initializing completion ({func}compinit{rst}){…}"
|
||
builtin autoload -Uz compinit
|
||
compinit -d ${ZINIT[ZCOMPDUMP_PATH]:-${ZDOTDIR:-$HOME}/.zcompdump} "${(Q@)${(z@)ZINIT[COMPINIT_OPTS]}}"
|
||
;;
|
||
(cuninstall)
|
||
if [[ -z $2 && -z $3 ]]; then
|
||
builtin print "Argument needed, try: help"; ___retval=1
|
||
else
|
||
(( ${+functions[.zinit-forget-completion]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-install.zsh" || return 1
|
||
# Uninstalls completions for plugin.
|
||
.zinit-uninstall-completions "${2%%(///|//|/)}" "${3%%(///|//|/)}"; ___retval=$?
|
||
+zi-log "Initializing completion ({func}compinit{rst}){…}"
|
||
builtin autoload -Uz compinit
|
||
compinit -d ${ZINIT[ZCOMPDUMP_PATH]:-${ZDOTDIR:-$HOME}/.zcompdump} "${(Q@)${(z@)ZINIT[COMPINIT_OPTS]}}"
|
||
fi
|
||
;;
|
||
(csearch)
|
||
.zinit-search-completions
|
||
;;
|
||
(compinit)
|
||
(( ${+functions[.zinit-forget-completion]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-install.zsh" || return 1
|
||
.zinit-compinit; ___retval=$?
|
||
;;
|
||
(compiled)
|
||
.zinit-compiled
|
||
;;
|
||
(compile|uncompile)
|
||
(( ${+functions[.zinit-compile-plugin]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-autoload.zsh" || return 1
|
||
local action="$1" all f help quiet
|
||
shift
|
||
zparseopts -D -F -K -- {a,-all}=all {h,-help}=help {q,-quiet}=quiet || return
|
||
if (( $#help )); then
|
||
print "Usage:"
|
||
print " zinit ${0} <options> <plugin>"
|
||
print " "
|
||
print "Options:"
|
||
print " -a, --all Checkout the specified branch"
|
||
print " -h, --help Checkout the specified branch"
|
||
print " -q, --quiet Checkout the specified tag or commit"
|
||
fi
|
||
if (( $#all )); then
|
||
.zinit-compile-uncompile-all ${action}; ___retval="${?}"
|
||
else
|
||
for f in ${(q+)^@}; do
|
||
.zinit-$action-plugin "${f}"; (( ___retval += ${?} ))
|
||
done
|
||
fi
|
||
;;
|
||
(debug)
|
||
shift;
|
||
(( ${+functions[+zinit-debug]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
+zinit-debug $@
|
||
;;
|
||
|
||
(cdlist)
|
||
.zinit-list-compdef-replay
|
||
;;
|
||
((c(hanges|d))|create|edit|glance|recall|stress)
|
||
.zinit-"$1" "${@[2-correct,-1]%%(///|//|/)}"; ___retval=$?
|
||
;;
|
||
(recently)
|
||
shift
|
||
.zinit-recently "$@"; ___retval=$?
|
||
;;
|
||
(-h|--help|help)
|
||
.zinit-help
|
||
;;
|
||
(version)
|
||
zi::version
|
||
;;
|
||
(srv)
|
||
() { setopt localoptions extendedglob warncreateglobal
|
||
[[ ! -e ${ZINIT[SERVICES_DIR]}/"$2".fifo ]] && { builtin print "No such service: $2"; } ||
|
||
{ [[ $3 = (#i)(next|stop|quit|restart) ]] &&
|
||
{ builtin print "${(U)3}" >>! ${ZINIT[SERVICES_DIR]}/"$2".fifo || builtin print "Service $2 inactive"; ___retval=1; } ||
|
||
{ [[ $3 = (#i)start ]] && rm -f ${ZINIT[SERVICES_DIR]}/"$2".stop ||
|
||
{ builtin print "Unknown service-command: $3"; ___retval=1; }
|
||
}
|
||
}
|
||
} "$@"
|
||
;;
|
||
(module)
|
||
.zinit-module "${@[2-correct,-1]}"; ___retval=$?
|
||
;;
|
||
(*)
|
||
if [[ -z $1 ]] {
|
||
+zi-log -n "{b}{u-warn}ERROR{b-warn}:{rst} Missing a {cmd}subcommand "
|
||
+zinit-prehelp-usage-message rst
|
||
} else {
|
||
+zi-log -n "{b}{u-warn}ERROR{b-warn}:{rst} Unknown subcommand{ehi}:{rst}" \
|
||
"{apo}\`{error}$1{apo}\`{rst} "
|
||
+zinit-prehelp-usage-message rst
|
||
}
|
||
___retval=1
|
||
;;
|
||
esac
|
||
;;
|
||
esac
|
||
|
||
return ___retval
|
||
} # ]]]
|
||
# FUNCTION: zicdreplay [[[
|
||
# A function that can be invoked from within "atinit", "atload", etc.
|
||
# ice-mod. It works like "zinit cdreplay", which cannot be invoked from such hook ices
|
||
zicdreplay() {
|
||
.zinit-compdef-replay -q
|
||
} # ]]]
|
||
# FUNCTION: zicdclear [[[
|
||
# A wrapper for "zinit cdclear -q" which can be called from hook
|
||
# ices like the atinit"", atload"", etc. ices.
|
||
zicdclear() {
|
||
.zinit-compdef-clear -q
|
||
} # ]]]
|
||
# FUNCTION: zicompinit [[[
|
||
# A function that can be invoked from within "atinit", "atload", etc.
|
||
# ice-mod. It runs "autoload compinit; compinit" and respects
|
||
# ZINIT[ZCOMPDUMP_PATH] and ZINIT[COMPINIT_OPTS].
|
||
zicompinit() {
|
||
autoload -Uz compinit
|
||
compinit -d ${ZINIT[ZCOMPDUMP_PATH]:-${ZDOTDIR:-$HOME}/.zcompdump} "${(Q@)${(z@)ZINIT[COMPINIT_OPTS]}}"
|
||
} # ]]]
|
||
# FUNCTION: zicompdef [[[
|
||
# Stores compdef for a replay with "zicdreplay" (turbo mode) or
|
||
# with "zinit cdreplay" (normal mode). An utility functton of an undefined use case.
|
||
zicompdef() {
|
||
ZINIT_COMPDEF_REPLAY+=( "${(j: :)${(q)@}}" )
|
||
} # ]]]
|
||
# FUNCTION: @autoload [[[
|
||
@autoload() {
|
||
:zinit-tmp-subst-autoload -Uz \
|
||
${(s: :)${${(j: :)${@#\!}}//(#b)((*)(->|=>|→)(*)|(*))/${match[2]:+$match[2] \
|
||
-S $match[4]}${match[5]:+${match[5]} \
|
||
-S ${match[5]}}}} \
|
||
${${${(@M)${@#\!}:#*(->|=>|→)*}}:+-C} \
|
||
${${@#\!}:+-C}
|
||
} # ]]]
|
||
|
||
#
|
||
# Compatibility functions
|
||
#
|
||
|
||
# FUNCTION: zplugin [[[
|
||
zplugin() {
|
||
zinit "$@"
|
||
} # ]]]
|
||
# FUNCTION: zpcdreplay [[[
|
||
zpcdreplay() {
|
||
.zinit-compdef-replay -q
|
||
} # ]]]
|
||
# FUNCTION: zpcdclear [[[
|
||
zpcdclear() {
|
||
.zinit-compdef-clear -q
|
||
} # ]]]
|
||
# FUNCTION: zpcompinit [[[
|
||
zpcompinit() {
|
||
autoload -Uz compinit
|
||
compinit -d ${ZINIT[ZCOMPDUMP_PATH]:-${ZDOTDIR:-$HOME}/.zcompdump} "${(Q@)${(z@)ZINIT[COMPINIT_OPTS]}}"
|
||
} # ]]]
|
||
# FUNCTION: zpcompdef [[[
|
||
zpcompdef() {
|
||
ZINIT_COMPDEF_REPLAY+=( "${(j: :)${(q)@}}" )
|
||
} # ]]]
|
||
|
||
#
|
||
# Source-executed code.
|
||
#
|
||
|
||
(( ZINIT[ALIASES_OPT] )) && builtin setopt aliases
|
||
(( ZINIT[SOURCED] ++ )) && return
|
||
|
||
autoload add-zsh-hook
|
||
if { zmodload zsh/datetime } {
|
||
add-zsh-hook -- precmd @zinit-scheduler # zsh/datetime required for wait/load/unload ice-mods
|
||
ZINIT[HAVE_SCHEDULER]=1
|
||
}
|
||
functions -M -- zinit_scheduler_add 1 1 -zinit_scheduler_add_sh 2>/dev/null
|
||
zmodload zsh/zpty zsh/system 2>/dev/null
|
||
zmodload -F zsh/stat b:zstat 2>/dev/null && ZINIT[HAVE_ZSTAT]=1
|
||
|
||
# code [[[
|
||
if [[ -z $ZINIT[NO_ALIASES] ]]; then
|
||
builtin alias zpl=zinit zplg=zinit zi=zinit zini=zinit
|
||
fi
|
||
|
||
.zinit-prepare-home
|
||
|
||
# Remember source timestamps for the automatic-reload feature.
|
||
typeset -g ZINIT_TMP
|
||
for ZINIT_TMP ( "" -side -install -autoload ) {
|
||
.zinit-get-mtime-into "${ZINIT[BIN_DIR]}/zinit$ZINIT_TMP.zsh" "ZINIT[mtime$ZINIT_TMP]"
|
||
}
|
||
|
||
# Simulate existence of _local/zinit plugin (enables cuninstall of related completions)
|
||
ZINIT_REGISTERED_PLUGINS=( _local/zinit "${(u)ZINIT_REGISTERED_PLUGINS[@]:#_local/zinit}" )
|
||
ZINIT[STATES___local/zinit]=1
|
||
|
||
# inform prezto that the compdef function is available.
|
||
zstyle ':prezto:module:completion' loaded 1
|
||
|
||
# Colorize completions for commands unload, report, creinstall, cuninstall.
|
||
zstyle ':completion:*:zinit:argument-rest:plugins' list-colors '=(#b)(*)/(*)==1;35=1;33'
|
||
zstyle ':completion:*:zinit:argument-rest:plugins' matcher 'r:|=** l:|=*'
|
||
zstyle ':completion:*:*:zinit:*' group-name ""
|
||
# ]]]
|
||
|
||
# module recompilation for the project rename. [[[
|
||
if [[ -e ${${ZINIT[BIN_DIR]}}/zmodules/Src/zdharma/zplugin.so ]] {
|
||
if [[ ! -f ${${ZINIT[BIN_DIR]}}/zmodules/COMPILED_AT || ( ${${ZINIT[BIN_DIR]}}/zmodules/COMPILED_AT -ot ${${ZINIT[BIN_DIR]}}/zmodules/RECOMPILE_REQUEST ) ]] {
|
||
# Don't trust access times and verify hard stored values.
|
||
[[ -e ${${ZINIT[BIN_DIR]}}/module/COMPILED_AT ]] && local compiled_at_ts="$(<${${ZINIT[BIN_DIR]}}/module/COMPILED_AT)"
|
||
[[ -e ${${ZINIT[BIN_DIR]}}/module/RECOMPILE_REQUEST ]] && local recompile_request_ts="$(<${${ZINIT[BIN_DIR]}}/module/RECOMPILE_REQUEST)"
|
||
|
||
if [[ ${recompile_request_ts:-1} -gt ${compiled_at_ts:-0} ]] {
|
||
+zi-log "{u-warn}WARNING{b-warn}:{rst}{msg} A {lhi}recompilation{rst}" \
|
||
"of the Zinit module has been requested… {hi}Building{rst}…"
|
||
(( ${+functions[.zinit-confirm]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-autoload.zsh" || return 1
|
||
command make -C "${ZINIT[BIN_DIR]}/zmodules" distclean &>/dev/null
|
||
.zinit-module build &>/dev/null
|
||
if command make -C "${ZINIT[BIN_DIR]}/zmodules" &>/dev/null; then
|
||
+zi-log "{ok}Build successful!{rst}"
|
||
else
|
||
builtin print -r -- "${ZINIT[col-error]}Compilation failed.${ZINIT[col-rst]}" \
|
||
"${ZINIT[col-pre]}You can enter the following command:${ZINIT[col-rst]}" \
|
||
'make -C "${ZINIT[BIN_DIR]}/zmodules' \
|
||
"${ZINIT[col-pre]}to see the error messages and e.g.: report an issue" \
|
||
"at GitHub${ZINIT[col-rst]}"
|
||
fi
|
||
|
||
command date '+%s' >! "${ZINIT[BIN_DIR]}/zmodules/COMPILED_AT"
|
||
}
|
||
}
|
||
} # ]]]
|
||
|
||
# Hook-group naming convention for atpull:
|
||
# hook:e-!atpull-* — fires alongside the user's atpull'!...' ice
|
||
# (runs before the pull)
|
||
# hook:no-e-!atpull-* — fires alongside the user's plain atpull'...' ice
|
||
# (runs after the pull)
|
||
# The 'e' stands for "exclamation" (the ! prefix on the user's atpull ice),
|
||
# not "early".
|
||
|
||
# e-!atpull-pre.
|
||
@zinit-register-hook "-r/--reset" hook:e-\!atpull-pre ∞zinit-reset-hook
|
||
# e-!atpull-post.
|
||
@zinit-register-hook "ICE[reset]" hook:e-\!atpull-post ∞zinit-reset-hook
|
||
@zinit-register-hook "atpull'!'" hook:e-\!atpull-post ∞zinit-atpull-e-hook
|
||
|
||
# no-e-!atpull-pre.
|
||
@zinit-register-hook "make'!!'" hook:no-e-\!atpull-pre ∞zinit-make-ee-hook
|
||
@zinit-register-hook "extract" hook:no-e-\!atpull-pre ∞zinit-extract-hook
|
||
@zinit-register-hook "mv''" hook:no-e-\!atpull-pre ∞zinit-mv-hook
|
||
@zinit-register-hook "cp''" hook:no-e-\!atpull-pre ∞zinit-cp-hook
|
||
@zinit-register-hook "compile-plugin" hook:no-e-\!atpull-pre ∞zinit-compile-plugin-hook
|
||
# no-e-!atpull-post.
|
||
@zinit-register-hook "configure'!'" hook:no-e-\!atpull-post ∞zinit-configure-e-hook
|
||
@zinit-register-hook "make'!'" hook:no-e-\!atpull-post ∞zinit-make-e-hook
|
||
@zinit-register-hook "configure''" hook:no-e-\!atpull-post ∞zinit-configure-hook
|
||
@zinit-register-hook "atpull" hook:no-e-\!atpull-post ∞zinit-atpull-hook
|
||
@zinit-register-hook "make''" hook:no-e-\!atpull-post ∞zinit-make-hook
|
||
@zinit-register-hook "cmake''" hook:no-e-\!atpull-post +zinit-cmake-hook
|
||
# atpull-post.
|
||
@zinit-register-hook "compile-plugin" hook:atpull-post ∞zinit-compile-plugin-hook
|
||
@zinit-register-hook "ps-on-update" hook:%atpull-post ∞zinit-ps-on-update-hook
|
||
|
||
# !atclone-pre.
|
||
@zinit-register-hook "make'!!'" hook:\!atclone-pre ∞zinit-make-ee-hook
|
||
@zinit-register-hook "extract" hook:\!atclone-pre ∞zinit-extract-hook
|
||
@zinit-register-hook "mv''" hook:\!atclone-pre ∞zinit-mv-hook
|
||
@zinit-register-hook "cp''" hook:\!atclone-pre ∞zinit-cp-hook
|
||
@zinit-register-hook "compile-plugin" hook:\!atclone-pre ∞zinit-compile-plugin-hook
|
||
# !atclone-post.
|
||
@zinit-register-hook "configure'!'" hook:\!atclone-post ∞zinit-configure-e-hook
|
||
@zinit-register-hook "make'!'" hook:\!atclone-post ∞zinit-make-e-hook
|
||
@zinit-register-hook "configure''" hook:\!atclone-post ∞zinit-configure-hook
|
||
@zinit-register-hook "atclone" hook:\!atclone-post ∞zinit-atclone-hook
|
||
@zinit-register-hook "make''" hook:\!atclone-post ∞zinit-make-hook
|
||
@zinit-register-hook "cmake''" hook:\!atclone-post +zinit-cmake-hook
|
||
# atclone-post.
|
||
@zinit-register-hook "compile-plugin" hook:atclone-post ∞zinit-compile-plugin-hook
|
||
|
||
# create so that for sure no warncreateglobal warning is issued
|
||
typeset -g REPLY
|
||
|
||
# a searchable menu of tags for current directory
|
||
zinit null light-mode autoload'zi-browse-symbol' for %$ZINIT[BIN_DIR]
|
||
zle -N zi-browse-symbol
|
||
zle -N zi-browse-symbol-backwards zi-browse-symbol
|
||
zle -N zi-browse-symbol-pbackwards zi-browse-symbol
|
||
zle -N zi-browse-symbol-pforwards zi-browse-symbol
|
||
zstyle -s ':zinit:browse-symbol' key ZINIT_TMP || ZINIT_TMP='\eQ'
|
||
[[ -n $ZINIT_TMP ]] && bindkey $ZINIT_TMP zi-browse-symbol
|
||
|
||
# Local Variables:
|
||
# mode: Shell-Script
|
||
# sh-indentation: 2
|
||
# indent-tabs-mode: nil
|
||
# sh-basic-offset: 2
|
||
# End:
|
||
# vim: ft=zsh sw=2 ts=2 et foldmarker=[[[,]]] foldmethod=marker
|