2597 lines
117 KiB
Bash
2597 lines
117 KiB
Bash
# -*- mode: sh; sh-indentation: 4; indent-tabs-mode: nil; sh-basic-offset: 4; -*-
|
||
# Copyright (c) 2016-2020 Sebastian Gniazdowski and contributors
|
||
|
||
#
|
||
# 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_REGISTERED_STATES ZINIT_SNIPPETS ZINIT_REPORTS ZINIT_ICES ZINIT_SICE ZINIT_CUR_BIND_MAP ZINIT_EXTS
|
||
typeset -gaH ZINIT_COMPDEF_REPLAY
|
||
|
||
# Compatibility with pre-rename project (Zplugin)
|
||
typeset -gAH ZPLGM
|
||
ZINIT=( "${(kv)ZPLGM[@]}" "${(kv)ZINIT[@]}" )
|
||
unset ZPLGM
|
||
|
||
#
|
||
# Common needed values
|
||
#
|
||
|
||
[[ ! -e ${ZINIT[BIN_DIR]}/zinit.zsh ]] && ZINIT[BIN_DIR]=
|
||
|
||
ZINIT[ZERO]="$0"
|
||
[[ ! -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
|
||
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
|
||
# Ignore ZDOTDIR if user manually put Zinit to $HOME
|
||
if [[ -d $HOME/.zinit ]]; then
|
||
ZINIT[HOME_DIR]="$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]="${ZDOTDIR:-$HOME}/.zinit"
|
||
fi
|
||
fi
|
||
|
||
ZINIT[ice-list]="svn|proto|from|teleid|bindmap|cloneopts|id-as|depth|if|wait|load|\
|
||
unload|blockf|pick|bpick|src|as|ver|silent|lucid|notify|mv|cp|\
|
||
atinit|atclone|atload|atpull|nocd|run-atpull|has|cloneonly|make|\
|
||
service|trackbinds|multisrc|compile|nocompile|nocompletions|\
|
||
reset-prompt|wrap-track|reset|sh|\!sh|bash|\!bash|ksh|\!ksh|csh|\
|
||
\!csh|aliases|countdown|ps-on-unload|ps-on-update|trigger-load|\
|
||
light-mode|is-snippet|atdelete|pack|git|verbose|on-update-of|\
|
||
subscribe|extract|param|opts|autoload|subst"
|
||
ZINIT[nval-ice-list]="blockf|silent|lucid|trackbinds|cloneonly|nocd|run-atpull|\
|
||
nocompletions|sh|\!sh|bash|\!bash|ksh|\!ksh|csh|\!csh|\
|
||
aliases|countdown|light-mode|is-snippet|git|verbose|cloneopts"
|
||
|
||
# Can be customized
|
||
: ${ZINIT[PLUGINS_DIR]:=${ZINIT[HOME_DIR]}/plugins}
|
||
: ${ZINIT[COMPLETIONS_DIR]:=${ZINIT[HOME_DIR]}/completions}
|
||
: ${ZINIT[SNIPPETS_DIR]:=${ZINIT[HOME_DIR]}/snippets}
|
||
: ${ZINIT[SERVICES_DIR]:=${ZINIT[HOME_DIR]}/services}
|
||
typeset -g ZPFX
|
||
: ${ZPFX:=${ZINIT[HOME_DIR]}/polaris}
|
||
: ${ZINIT[ALIASES_OPT]::=${${options[aliases]:#off}:+1}}
|
||
|
||
ZINIT[PLUGINS_DIR]=${~ZINIT[PLUGINS_DIR]} ZINIT[COMPLETIONS_DIR]=${~ZINIT[COMPLETIONS_DIR]}
|
||
ZINIT[SNIPPETS_DIR]=${~ZINIT[SNIPPETS_DIR]} ZINIT[SERVICES_DIR]=${~ZINIT[SERVICES_DIR]}
|
||
export ZPFX=${~ZPFX} ZSH_CACHE_DIR="${ZSH_CACHE_DIR:-${XDG_CACHE_HOME:-$HOME/.cache}/zinit}" \
|
||
PMSPEC=0uUpiPsf
|
||
[[ -z ${path[(re)$ZPFX/bin]} ]] && path=( "$ZPFX/bin" "${path[@]}" )
|
||
|
||
# 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]}
|
||
|
||
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 - shadeing [[[
|
||
ZINIT[SHADOWING]=inactive ZINIT[DTRACE]=0 ZINIT[CUR_PLUGIN]=
|
||
# ]]]
|
||
# Parameters - 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://github.com/ohmyzsh/ohmyzsh/raw/master/
|
||
OMZP:: https://github.com/ohmyzsh/ohmyzsh/raw/master/plugins/
|
||
OMZT:: https://github.com/ohmyzsh/ohmyzsh/raw/master/themes/
|
||
OMZL:: https://github.com/ohmyzsh/ohmyzsh/raw/master/lib/
|
||
PZT:: https://github.com/sorin-ionescu/prezto/raw/master/
|
||
PZTM:: https://github.com/sorin-ionescu/prezto/raw/master/modules/
|
||
)
|
||
# ]]]
|
||
|
||
# Init [[[
|
||
zmodload zsh/zutil || { print -P "%F{196}zsh/zutil module is required, aborting Zinit set up.%f"; return 1; }
|
||
zmodload zsh/parameter || { print -P "%F{196}zsh/parameter module is required, aborting Zinit set up.%f"; return 1; }
|
||
zmodload zsh/terminfo 2>/dev/null
|
||
zmodload zsh/termcap 2>/dev/null
|
||
|
||
[[ -z $SOURCED && ( ${+terminfo} = 1 && -n ${terminfo[colors]} ) || ( ${+termcap} = 1 && -n ${termcap[Co]} ) ]] && {
|
||
ZINIT+=(
|
||
col-title ""
|
||
col-pname $'\e[33m'
|
||
col-uname $'\e[35m'
|
||
col-keyword $'\e[32m'
|
||
col-note $'\e[33m'
|
||
col-error $'\e[31m'
|
||
col-p $'\e[01m\e[34m'
|
||
col-bar $'\e[01m\e[35m'
|
||
col-info $'\e[32m'
|
||
col-info2 $'\e[33m'
|
||
col-info3 $'\e[01m\e[33m'
|
||
col-uninst $'\e[01m\e[34m'
|
||
col-success $'\e[01m\e[32m'
|
||
col-failure $'\e[31m'
|
||
col-rst $'\e[0m'
|
||
col-bold $'\e[1m'
|
||
|
||
col-pre $'\e[38;5;141m'
|
||
col-msg1 $'\e[0m'
|
||
col-msg2 $'\e[38;5;172m'
|
||
col-obj $'\e[38;5;221m'
|
||
col-obj2 $'\e[38;5;154m'
|
||
col-file $'\e[38;5;110m'
|
||
col-url $'\e[38;5;45m'
|
||
col-data $'\e[38;5;82m'
|
||
col-data2 $'\e[38;5;50m'
|
||
col-hi $'\e[38;5;184m'
|
||
col-ehi $'\e[01m\e[31m'
|
||
)
|
||
}
|
||
|
||
# List of 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
|
||
|
||
# ]]]
|
||
|
||
#
|
||
# Shadowing-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".
|
||
#
|
||
# $1 - FPATH dedicated to function
|
||
# $2 - autoload options
|
||
# $3 - function name (one that needs autoloading)
|
||
#
|
||
# Author: Bart Schaefer
|
||
: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-shade-autoload [[[
|
||
# Function defined to hijack plugin's calls to `autoload' builtin.
|
||
#
|
||
# The hijacking is not only to gather report data, but also to
|
||
# run custom `autoload' function, that doesn't need FPATH.
|
||
:zinit-shade-autoload () {
|
||
emulate -LR zsh
|
||
builtin setopt extendedglob warncreateglobal typesetsilent noshortloops rcquotes
|
||
local -a opts custom
|
||
local func
|
||
|
||
zparseopts -D -E -M -a opts ${(s::):-RTUXdkmrtWzwC} S+:=custom
|
||
|
||
[[ $ZINIT[CUR_USR] = % ]] && \
|
||
local PLUGIN_DIR="$ZINIT[CUR_PLUGIN]" || \
|
||
local PLUGIN_DIR="${ZINIT[PLUGINS_DIR]}/${${ZINIT[CUR_USR]}:+${ZINIT[CUR_USR]}---}${ZINIT[CUR_PLUGIN]//\//---}"
|
||
|
||
if (( ${+opts[(r)-X]} )); then
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Warning: Failed autoload ${(j: :)opts[@]} $*"
|
||
+zinit-message -u2 "[error]builtin autoload required for [obj]${(j: :)opts[@]}[error] option(s)[rst]"
|
||
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 0
|
||
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"
|
||
builtin autoload +X ${opts[@]} "${@:#+X}"
|
||
return 0
|
||
fi
|
||
# Report ZPLUGIN's "native" autoloads
|
||
for func; do
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Autoload $func${opts:+ with options ${(j: :)opts[@]}}"
|
||
done
|
||
|
||
local -a fpath_elements
|
||
fpath_elements=( ${fpath[(r)$PLUGIN_DIR/*]} )
|
||
|
||
[[ -d $PLUGIN_DIR/functions ]] && fpath_elements+=( "$PLUGIN_DIR"/functions )
|
||
|
||
integer count
|
||
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 [[ ${ZINIT[NEW_AUTOLOAD]} = 2 ]]; then
|
||
builtin autoload ${opts[@]} "$PLUGIN_DIR/$func"
|
||
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 ]] {
|
||
+zinit-message '[error]zinit: Couldn''t find autoload function[ehi]:' \
|
||
"[data2]\`[data]${func}[data2]'[error] anywhere in [obj]\$fpath[error].[rst]"
|
||
} 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} \"\$@\"
|
||
}"
|
||
}
|
||
} else {
|
||
eval "function ${(q)func} {
|
||
local -a fpath
|
||
fpath=( ${(qqq)PLUGIN_DIR} ${(qqq@)fpath_elements} ${(qqq@)fpath} )
|
||
builtin autoload -X ${(j: :)${(q-)opts[@]}}
|
||
}"
|
||
}
|
||
else
|
||
eval "function ${(q)func} {
|
||
:zinit-reload-and-run ${(qqq)PLUGIN_DIR}"$'\0'"${(pj,\0,)${(qqq)fpath_elements[@]}} ${(qq)opts[*]} ${(q)func} "'"$@"
|
||
}'
|
||
fi
|
||
(( ZINIT[ALIASES_OPT] )) && builtin setopt aliases
|
||
}
|
||
done
|
||
|
||
return 0
|
||
} # ]]]
|
||
# FUNCTION: :zinit-shade-bindkey [[[
|
||
# Function defined to hijack plugin's calls to `bindkey' builtin.
|
||
#
|
||
# The hijacking is to gather report data (which is used in unload).
|
||
:zinit-shade-bindkey() {
|
||
emulate -LR zsh
|
||
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 ${ZINIT_ICE[bindmap]} && ${ZINIT_CUR_BIND_MAP[empty]} -eq 1 ]]; then
|
||
local -a pairs
|
||
pairs=( "${(@s,;,)ZINIT_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-shade-zstyle [[[
|
||
# Function defined to hijack plugin's calls to `zstyle' builtin.
|
||
#
|
||
# The hijacking is to gather report data (which is used in unload).
|
||
:zinit-shade-zstyle() {
|
||
builtin setopt localoptions noerrreturn noerrexit extendedglob nowarncreateglobal \
|
||
typesetsilent noshortloops unset
|
||
.zinit-add-report "${ZINIT[CUR_USPL2]}" "Zstyle $*"
|
||
|
||
# Remember 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-shade-alias [[[
|
||
# Function defined to hijack plugin's calls to `alias' builtin.
|
||
#
|
||
# The hijacking is to gather report data (which is used in unload).
|
||
:zinit-shade-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-shade-zle [[[
|
||
# Function defined to hijack plugin's calls to `zle' builtin.
|
||
#
|
||
# The hijacking is to gather report data (which is used in unload).
|
||
:zinit-shade-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=( "$@" )
|
||
|
||
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-shade-compdef [[[
|
||
# Function defined to hijack plugin's calls to `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-shade-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-shade-on [[[
|
||
# Turn on shadeing of builtins and functions according to passed
|
||
# mode ("load", "light", "light-b" or "compdef"). The shadeing is
|
||
# to gather report data, and to hijack `autoload', `bindkey' and
|
||
# `compdef' calls.
|
||
.zinit-shade-on() {
|
||
local mode="$1"
|
||
|
||
# Enable shadeing only once
|
||
#
|
||
# One could expect possibility of widening of shadeing, 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[SHADOWING]} != inactive ]] && builtin return 0
|
||
|
||
ZINIT[SHADOWING]="$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-shade-autoload "$@";'
|
||
fi
|
||
|
||
# E. Always shade compdef
|
||
(( ${+functions[compdef]} )) && ZINIT[bkp-compdef]="${functions[compdef]}"
|
||
functions[compdef]=':zinit-shade-compdef "$@";'
|
||
|
||
# Temporarily replace `source' if subst'' given
|
||
if [[ -n ${ZINIT_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-shade-source "$@";'
|
||
functions[.]=':zinit-shade-source "$@";'
|
||
}
|
||
|
||
# Light and compdef shadeing stops here. Dtrace and load go on
|
||
[[ ( $mode = light && ${+ZINIT_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-shade-bindkey "$@";'
|
||
|
||
# B, when `zinit light -b ...' or when `zinit ice trackbinds ...; zinit light ...'
|
||
[[ $mode = light-b || ( $mode = light && ${+ZINIT_ICE[trackbinds]} -eq 1 ) ]] && return 0
|
||
|
||
# B.
|
||
(( ${+functions[zstyle]} )) && ZINIT[bkp-zstyle]="${functions[zstyle]}"
|
||
functions[zstyle]=':zinit-shade-zstyle "$@";'
|
||
|
||
# C.
|
||
(( ${+functions[alias]} )) && ZINIT[bkp-alias]="${functions[alias]}"
|
||
functions[alias]=':zinit-shade-alias "$@";'
|
||
|
||
# D.
|
||
(( ${+functions[zle]} )) && ZINIT[bkp-zle]="${functions[zle]}"
|
||
functions[zle]=':zinit-shade-zle "$@";'
|
||
|
||
builtin return 0
|
||
} # ]]]
|
||
# FUNCTION: .zinit-shade-off [[[
|
||
# Turn off shadeing completely for a given mode ("load", "light",
|
||
# "light-b" (i.e. the `trackbinds' mode) or "compdef").
|
||
.zinit-shade-off() {
|
||
builtin setopt localoptions noerrreturn noerrexit extendedglob warncreateglobal \
|
||
typesetsilent noshortloops unset noaliases
|
||
local mode="$1"
|
||
|
||
# Disable shadeing only once
|
||
# Disable shadeing only the way it was enabled first
|
||
[[ ${ZINIT[SHADOWING]} = inactive || ${ZINIT[SHADOWING]} != $mode ]] && return 0
|
||
|
||
ZINIT[SHADOWING]=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 shadeing stops here
|
||
[[ ( $mode = light && ${+ZINIT_ICE[trackbinds]} -eq 0 ) || $mode = compdef ]] && return 0
|
||
|
||
# Unfunction shadeing 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 && ${+ZINIT_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 [[[
|
||
# {function:pmodload} Compatibility with Prezto. Calls can be recursive.
|
||
(( ${+functions[pmodload]} )) || pmodload() {
|
||
while (( $# )); do
|
||
if zstyle -t ":prezto:module:$1" loaded 'yes' 'no'; then
|
||
shift
|
||
continue
|
||
else
|
||
[[ -z ${ZINIT_SNIPPETS[PZT::modules/$1${ZINIT_ICE[svn]-/init.zsh}]} && -z ${ZINIT_SNIPPETS[https://github.com/sorin-ionescu/prezto/trunk/modules/$1${ZINIT_ICE[svn]-/init.zsh}]} ]] && .zinit-load-snippet PZT::modules/"$1${ZINIT_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-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)
|
||
#
|
||
# Returns user and plugin in $reply
|
||
#
|
||
.zinit-any-to-user-plugin() {
|
||
# 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
|
||
reply=( "%" "${${${1/\%HOME/$HOME}/\%SNIPPETS/${ZINIT[SNIPPETS_DIR]}}#%}" )
|
||
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-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"
|
||
|
||
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)
|
||
)
|
||
}
|
||
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:
|
||
# http://zdharma.org/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]}${${+ZINIT_ICE[wait]}:#0}${ZINIT_ICE[load]}${ZINIT_ICE[subscribe]} && ${ZINIT[MUTE_WARNINGS]} != 1 ]] && +zinit-message "[error]Warning:[rst] plugin \`[pname]${uspl2}[rst]' already registered, will overwrite-load"
|
||
ret=1
|
||
fi
|
||
|
||
# Support Zsh plugin standard
|
||
zsh_loaded_plugins+=( "$teleid" )
|
||
|
||
# Full or light load?
|
||
[[ $mode == light ]] && ZINIT_REGISTERED_STATES[$uspl2]=1 || ZINIT_REGISTERED_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="${ZINIT_ICE[id-as]:-$id_as}"
|
||
|
||
# Remove leading whitespace and trailing /
|
||
id_as="${${id_as#"${id_as%%[! $'\t']*}"}%/}"
|
||
|
||
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 {
|
||
local_dir=${${${(M)id_as#%}:+${id_as#%}}:-${ZINIT[PLUGINS_DIR]}/${id_as//\//---}}
|
||
[[ $id_as == _local/* && -d $local_dir && ! -d $local_dir/._zinit ]] && command mkdir -p "$local_dir"/._zinit
|
||
}
|
||
|
||
[[ -e $local_dir/${dirname:+$dirname/}._zinit || \
|
||
-e $local_dir/${dirname:+$dirname/}._zplugin ]] && exists=1
|
||
|
||
reply=( "$local_dir" "$dirname" "$exists" )
|
||
|
||
return $(( 1 - exists ))
|
||
}
|
||
# ]]]
|
||
# FUNCTION: @zinit-substitute [[[
|
||
@zinit-substitute() {
|
||
emulate -LR zsh
|
||
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 ${ZINIT_ICE[param]} && ${ZINIT[SUBST_DONE_FOR]} != ${ZINIT_ICE[param]} ]] {
|
||
ZINIT[SUBST_DONE_FOR]=${ZINIT_ICE[param]}
|
||
ZINIT[PARAM_SUBST]=
|
||
local -a ___params
|
||
___params=( ${(s.;.)ZINIT_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=( "${ZINIT_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-z-annex [[[
|
||
# Registers the z-annex inside Zinit – i.e. an Zinit extension
|
||
@zinit-register-annex() {
|
||
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}"
|
||
ZINIT_EXTS[ice-mods]="${ZINIT_EXTS[ice-mods]}${icemods:+|}$icemods"
|
||
}
|
||
# ]]]
|
||
# FUNCTION: @zsh-plugin-run-on-update [[[
|
||
# The Plugin Standard required mechanism, see:
|
||
# http://zdharma.org/Zsh-100-Commits-Club/Zsh-Plugin-Standard.html
|
||
@zsh-plugin-run-on-unload() {
|
||
ZINIT_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() {
|
||
ZINIT_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 2>/dev/null -p $ZPFX/bin
|
||
}
|
||
[[ ! -d ${ZINIT[PLUGINS_DIR]}/_local---zinit ]] && {
|
||
command rm -rf "${ZINIT[PLUGINS_DIR]:-/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 2>/dev/null -p $ZPFX/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 2>/dev/null -p $ZPFX/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 2>/dev/null -p $ZPFX/bin
|
||
}
|
||
} # ]]]
|
||
# 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" ___rst=0 ___retval=0 ___key
|
||
.zinit-any-to-user-plugin "$1" "$2"
|
||
local ___user="${reply[-2]}" ___plugin="${reply[-1]}" ___id_as="${ZINIT_ICE[id-as]:-${reply[-2]}${${reply[-2]:#(%|/)*}:+/}${reply[-1]}}"
|
||
ZINIT_ICE[teleid]="${ZINIT_ICE[teleid]:-$___user${${___user:#(%|/)*}:+/}$___plugin}"
|
||
|
||
local ___m_bkp="${functions[m]}"
|
||
functions[m]="${functions[+zinit-message]}"
|
||
|
||
local -a ___arr
|
||
reply=( "${(@on)ZINIT_EXTS[(I)z-annex hook:preinit <->]}" )
|
||
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//\//---}}" preinit || \
|
||
return $(( 10 - $? ))
|
||
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 (( ${+ZINIT_ICE[pack]} )) {
|
||
if ! .zinit-get-package "$___user" "$___plugin" "$___id_as" \
|
||
"${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}" \
|
||
"${ZINIT_ICE[pack]:-default}"
|
||
then
|
||
zle && { print; zle .reset-prompt; }
|
||
return 1
|
||
fi
|
||
___id_as="${ZINIT_ICE[id-as]:-${___user}${${___user:#(%|/)*}:+/}$___plugin}"
|
||
}
|
||
___user="${reply[-2]}" ___plugin="${reply[-1]}"
|
||
ZINIT_ICE[teleid]="$___user${${___user:#(%|/)*}:+/}$___plugin"
|
||
[[ $REPLY = snippet ]] && {
|
||
ZINIT_ICE[id-as]="${ZINIT_ICE[id-as]:-$___id_as}"
|
||
.zinit-load-snippet $___plugin && return
|
||
zle && { print; zle .reset-prompt; }
|
||
return 1
|
||
}
|
||
if ! .zinit-setup-plugin-dir "$___user" "$___plugin" "$___id_as" "$REPLY"; then
|
||
zle && { print; zle .reset-prompt; }
|
||
return 1
|
||
fi
|
||
zle && ___rst=1
|
||
}
|
||
|
||
ZINIT_SICE[$___id_as]=
|
||
.zinit-pack-ice "$___id_as"
|
||
|
||
(( ${+ZINIT_ICE[cloneonly]} )) && return 0
|
||
|
||
.zinit-register-plugin "$___id_as" "$___mode" "${ZINIT_ICE[teleid]}"
|
||
|
||
# Set up param'' objects (parameters)
|
||
if [[ -n ${ZINIT_ICE[param]} ]] {
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-setup-params && local ${(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
|
||
|
||
[[ ${+ZINIT_ICE[atinit]} = 1 && $ZINIT_ICE[atinit] != '!'* ]] && { local ___oldcd="$PWD"; (( ${+ZINIT_ICE[nocd]} == 0 )) && { () { setopt localoptions noautopushd; builtin cd -q "${${${(M)___user:#%}:+$___plugin}:-${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}}"; } && eval "${ZINIT_ICE[atinit]}"; ((1)); } || eval "${ZINIT_ICE[atinit]}"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; }
|
||
|
||
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"; ___retval=$?
|
||
(( ${+ZINIT_ICE[notify]} == 1 )) && { [[ $___retval -eq 0 || -n ${(M)ZINIT_ICE[notify]#\!} ]] && { local msg; eval "msg=\"${ZINIT_ICE[notify]#\!}\""; +zinit-deploy-message @msg "$msg" } || +zinit-deploy-message @msg "notify: Plugin not loaded / loaded with problem, the return code: $___retval"; }
|
||
(( ${+ZINIT_ICE[reset-prompt]} == 1 )) && +zinit-deploy-message @___rst
|
||
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" ___correct=0 ___retval=0
|
||
# Hide arguments from sourced scripts. Without this calls our "$@" are visible as "$@"
|
||
# within scripts that we `source`.
|
||
set --
|
||
ZINIT[CUR_USR]="$___user" ZINIT[CUR_PLUGIN]="$___plugin" ZINIT[CUR_USPL2]="$___id_as"
|
||
[[ -o ksharrays ]] && ___correct=1
|
||
|
||
[[ -n ${ZINIT_ICE[(i)(\!|)(sh|bash|ksh|csh)]}${ZINIT_ICE[opts]} ]] && {
|
||
local -a ___precm
|
||
___precm=(
|
||
emulate
|
||
${${(M)${ZINIT_ICE[(i)(\!|)(sh|bash|ksh|csh)]}#\!}:+-R}
|
||
${${${ZINIT_ICE[(i)(\!|)(sh|bash|ksh|csh)]}#\!}:-zsh}
|
||
${${ZINIT_ICE[(i)(\!|)bash]}:+-${(s: :):-o noshglob -o braceexpand -o kshglob}}
|
||
${(s: :):-${${:-${(@s: :):--o}" "${(s: :)^ZINIT_ICE[opts]}}:#-o }}
|
||
-c
|
||
)
|
||
}
|
||
|
||
[[ -z ${ZINIT_ICE[subst]} ]] && local ___builtin=builtin
|
||
|
||
[[ ${ZINIT_ICE[as]} = null ]] && \
|
||
ZINIT_ICE[pick]="${ZINIT_ICE[pick]:-/dev/null}"
|
||
|
||
local ___pbase="${${___plugin:t}%(.plugin.zsh|.zsh|.git)}"
|
||
[[ $___user = % ]] && local ___pdir_path="$___plugin" || local ___pdir_path="${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}"
|
||
local ___pdir_orig="$___pdir_path" ___key
|
||
|
||
if [[ -n ${ZINIT_ICE[autoload]} ]] {
|
||
:zinit-shade-autoload -Uz \
|
||
${(s: :)${${(s.;.)ZINIT_ICE[autoload]#\!}//(#b)((*)->(*)|(*))/${match[2]:+$match[2] -S $match[3]}${match[4]:+${match[4]} -S ${match[4]}}}} \
|
||
${${(M)ZINIT_ICE[autoload]:#*->*}:+-C} ${${(M)ZINIT_ICE[autoload]#\!}:+-C}
|
||
}
|
||
|
||
if [[ ${ZINIT_ICE[as]} = command ]]; then
|
||
[[ ${+ZINIT_ICE[pick]} = 1 && -z ${ZINIT_ICE[pick]} ]] && \
|
||
ZINIT_ICE[pick]="${___id_as:t}"
|
||
reply=()
|
||
if [[ -n ${ZINIT_ICE[pick]} && ${ZINIT_ICE[pick]} != /dev/null ]]; then
|
||
reply=( ${(M)~ZINIT_ICE[pick]##/*}(DN) $___pdir_path/${~ZINIT_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[@]}
|
||
|
||
[[ ${ZINIT_ICE[atinit]} = '!'* || -n ${ZINIT_ICE[src]} || -n ${ZINIT_ICE[multisrc]} || ${ZINIT_ICE[atload][1]} = "!" ]] && {
|
||
if [[ ${ZINIT[SHADOWING]} = inactive ]]; then
|
||
(( ${+functions[compdef]} )) && ZINIT[bkp-compdef]="${functions[compdef]}" || builtin unset "ZINIT[bkp-compdef]"
|
||
functions[compdef]=':zinit-shade-compdef "$@";'
|
||
ZINIT[SHADOWING]=1
|
||
else
|
||
(( ++ ZINIT[SHADOWING] ))
|
||
fi
|
||
}
|
||
|
||
local ZERO
|
||
[[ $ZINIT_ICE[atinit] = '!'* ]] && { local ___oldcd="$PWD"; (( ${+ZINIT_ICE[nocd]} == 0 )) && { () { setopt localoptions noautopushd; builtin cd -q "${${${(M)___user:#%}:+$___plugin}:-${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}}"; } && eval "${ZINIT_ICE[atinit#!]}"; ((1)); } || eval "${ZINIT_ICE[atinit]#!}"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; }
|
||
[[ -n ${ZINIT_ICE[src]} ]] && { ZERO="${${(M)ZINIT_ICE[src]##/*}:-$___pdir_orig/${ZINIT_ICE[src]}}"; (( ${+ZINIT_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 ${ZINIT_ICE[multisrc]} ]] && { local ___oldcd="$PWD"; () { setopt localoptions noautopushd; builtin cd -q "$___pdir_orig"; }; eval "reply=(${ZINIT_ICE[multisrc]})"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; local ___fname; for ___fname in "${reply[@]}"; do ZERO="${${(M)___fname:#/*}:-$___pdir_orig/$___fname}"; (( ${+ZINIT_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 ${ZINIT_ICE[wrap-track]} ]] {
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-wrap-track-functions "$___user" "$___plugin" "$___id_as"
|
||
}
|
||
|
||
[[ ${ZINIT_ICE[atload][1]} = "!" ]] && { .zinit-add-report "$___id_as" "Note: Starting to track the atload'!…' ice…"; ZERO="$___pdir_orig/-atload-"; local ___oldcd="$PWD"; (( ${+ZINIT_ICE[nocd]} == 0 )) && { () { setopt localoptions noautopushd; builtin cd -q "$___pdir_orig"; } && builtin eval "${ZINIT_ICE[atload]#\!}"; } || eval "${ZINIT_ICE[atload]#\!}"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; }
|
||
|
||
[[ -n ${ZINIT_ICE[src]} || -n ${ZINIT_ICE[multisrc]} || ${ZINIT_ICE[atload][1]} = "!" ]] && {
|
||
(( -- ZINIT[SHADOWING] == 0 )) && { ZINIT[SHADOWING]=inactive; builtin setopt noaliases; (( ${+ZINIT[bkp-compdef]} )) && functions[compdef]="${ZINIT[bkp-compdef]}" || unfunction compdef; (( ZINIT[ALIASES_OPT] )) && builtin setopt aliases; }
|
||
}
|
||
elif [[ ${ZINIT_ICE[as]} = completion ]]; then
|
||
((1))
|
||
else
|
||
if [[ -n ${ZINIT_ICE[pick]} ]]; then
|
||
[[ ${ZINIT_ICE[pick]} = /dev/null ]] && reply=( /dev/null ) || reply=( ${(M)~ZINIT_ICE[pick]##/*}(DN) $___pdir_path/${~ZINIT_ICE[pick]}(DN) )
|
||
elif [[ -e $___pdir_path/$___pbase.plugin.zsh ]]; then
|
||
reply=( "$___pdir_path/$___pbase".plugin.zsh )
|
||
else
|
||
.zinit-find-other-matches "$___pdir_path" "$___pbase"
|
||
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 shadeing
|
||
[[ $___mode != light(|-b) ]] && .zinit-diff "${ZINIT[CUR_USPL2]}" begin
|
||
|
||
.zinit-shade-on "${___mode:-load}"
|
||
|
||
# We need some state, but ___user wants his for his plugins
|
||
(( ${+ZINIT_ICE[blockf]} )) && { local -a fpath_bkp; fpath_bkp=( "${fpath[@]}" ); }
|
||
local ZERO="$___pdir_path/$___fname"
|
||
(( ${+ZINIT_ICE[aliases]} )) || builtin setopt noaliases
|
||
[[ $ZINIT_ICE[atinit] = '!'* ]] && { local ___oldcd="$PWD"; (( ${+ZINIT_ICE[nocd]} == 0 )) && { () { setopt localoptions noautopushd; builtin cd -q "${${${(M)___user:#%}:+$___plugin}:-${ZINIT[PLUGINS_DIR]}/${___id_as//\//---}}"; } && eval "${ZINIT_ICE[atinit]#!}"; ((1)); } || eval "${ZINIT_ICE[atinit]#1}"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; }
|
||
(( ${+ZINIT_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 ${ZINIT_ICE[src]} ]] && { ZERO="${${(M)ZINIT_ICE[src]##/*}:-$___pdir_orig/${ZINIT_ICE[src]}}"; (( ${+ZINIT_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 ${ZINIT_ICE[multisrc]} ]] && { local ___oldcd="$PWD"; () { setopt localoptions noautopushd; builtin cd -q "$___pdir_orig"; }; eval "reply=(${ZINIT_ICE[multisrc]})"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; for ___fname in "${reply[@]}"; do ZERO="${${(M)___fname:#/*}:-$___pdir_orig/$___fname}"; (( ${+ZINIT_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 ${ZINIT_ICE[wrap-track]} ]] {
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-wrap-track-functions "$___user" "$___plugin" "$___id_as"
|
||
}
|
||
|
||
[[ ${ZINIT_ICE[atload][1]} = "!" ]] && { .zinit-add-report "$___id_as" "Note: Starting to track the atload'!…' ice…"; ZERO="$___pdir_orig/-atload-"; local ___oldcd="$PWD"; (( ${+ZINIT_ICE[nocd]} == 0 )) && { () { setopt localoptions noautopushd; builtin cd -q "$___pdir_orig"; } && builtin eval "${ZINIT_ICE[atload]#\!}"; ((1)); } || eval "${ZINIT_ICE[atload]#\!}"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; }
|
||
(( ZINIT[ALIASES_OPT] )) && builtin setopt aliases
|
||
(( ${+ZINIT_ICE[blockf]} )) && { fpath=( "${fpath_bkp[@]}" ); }
|
||
|
||
.zinit-shade-off "${___mode:-load}"
|
||
|
||
[[ $___mode != light(|-b) ]] && .zinit-diff "${ZINIT[CUR_USPL2]}" end
|
||
fi
|
||
|
||
[[ ${+ZINIT_ICE[atload]} = 1 && ${ZINIT_ICE[atload][1]} != "!" ]] && { ZERO="$___pdir_orig/-atload-"; local ___oldcd="$PWD"; (( ${+ZINIT_ICE[nocd]} == 0 )) && { () { setopt localoptions noautopushd; builtin cd -q "$___pdir_orig"; } && builtin eval "${ZINIT_ICE[atload]}"; ((1)); } || eval "${ZINIT_ICE[atload]}"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; }
|
||
|
||
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
|
||
|
||
# Mark no load is in progress
|
||
ZINIT[CUR_USR]= ZINIT[CUR_PLUGIN]= ZINIT[CUR_USPL2]=
|
||
|
||
(( ___rst )) && { print; zle .reset-prompt; }
|
||
|
||
if [[ -n $___m_bkp ]] {
|
||
functions[m]="$___m_bkp"
|
||
} else {
|
||
noglob unset functions[m]
|
||
}
|
||
|
||
return $___retval
|
||
} # ]]]
|
||
# 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 || { +zinit-message "[error]Error:[rst] Incorrect options (accepted ones: -f, --command)"; return 1; }
|
||
local url="$1"
|
||
# Hide arguments from sourced scripts. Without this calls our "$@" are visible as "$@"
|
||
# within scripts that we `source`.
|
||
set --
|
||
integer correct retval exists
|
||
[[ -o ksharrays ]] && correct=1
|
||
|
||
[[ -n ${ZINIT_ICE[(i)(\!|)(sh|bash|ksh|csh)]}${ZINIT_ICE[opts]} ]] && {
|
||
local -a precm
|
||
precm=(
|
||
emulate
|
||
${${(M)${ZINIT_ICE[(i)(\!|)(sh|bash|ksh|csh)]}#\!}:+-R}
|
||
${${${ZINIT_ICE[(i)(\!|)(sh|bash|ksh|csh)]}#\!}:-zsh}
|
||
${${ZINIT_ICE[(i)(\!|)bash]}:+-${(s: :):-o noshglob -o braceexpand -o kshglob}}
|
||
${(s: :):-${${:-${(@s: :):--o}" "${(s: :)^ZINIT_ICE[opts]}}:#-o }}
|
||
-c
|
||
)
|
||
}
|
||
# Remove leading whitespace and trailing /
|
||
url="${${url#"${url%%[! $'\t']*}"}%/}"
|
||
ZINIT_ICE[teleid]="$url"
|
||
[[ ${ZINIT_ICE[as]} = null ]] && \
|
||
ZINIT_ICE[pick]="${ZINIT_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="${ZINIT_ICE[id-as]:-$url}"
|
||
|
||
local ___m_bkp="${functions[m]}"
|
||
functions[m]="${functions[+zinit-message]}"
|
||
|
||
# Set up param'' objects (parameters)
|
||
if [[ -n ${ZINIT_ICE[param]} ]] {
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-setup-params && local ${(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_EXTS[(I)z-annex hook:preinit <->]}" )
|
||
for key in "${reply[@]}"; do
|
||
arr=( "${(Q)${(z@)ZINIT_EXTS[$key]}[@]}" )
|
||
"${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" preinit || \
|
||
return $(( 10 - $? ))
|
||
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=$?
|
||
}
|
||
|
||
(( ${+ZINIT_ICE[cloneonly]} || retval )) && return 0
|
||
|
||
ZINIT_SNIPPETS[$id_as]="$id_as <${${ZINIT_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
|
||
|
||
(( ${+ZINIT_ICE[atinit]} )) && { local ___oldcd="$PWD"; (( ${+ZINIT_ICE[nocd]} == 0 )) && { () { setopt localoptions noautopushd; builtin cd -q "$local_dir/$dirname"; } && eval "${ZINIT_ICE[atinit]}"; ((1)); } || eval "${ZINIT_ICE[atinit]}"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; }
|
||
|
||
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 ${ZINIT_ICE[as]} || ${ZINIT_ICE[as]} = null ) ]]; then
|
||
# Source the file with compdef shadeing
|
||
if [[ ${ZINIT[SHADOWING]} = inactive ]]; then
|
||
# Shadowing code is inlined from .zinit-shade-on
|
||
(( ${+functions[compdef]} )) && ZINIT[bkp-compdef]="${functions[compdef]}" || builtin unset "ZINIT[bkp-compdef]"
|
||
functions[compdef]=':zinit-shade-compdef "$@";'
|
||
ZINIT[SHADOWING]=1
|
||
else
|
||
(( ++ ZINIT[SHADOWING] ))
|
||
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 (( ${+ZINIT_ICE[svn]} == 0 )) {
|
||
[[ ${+ZINIT_ICE[pick]} = 0 ]] && list=( "$local_dir/$dirname/$filename" )
|
||
[[ -n ${ZINIT_ICE[pick]} ]] && list=( ${(M)~ZINIT_ICE[pick]##/*}(DN) $local_dir/$dirname/${~ZINIT_ICE[pick]}(DN) )
|
||
} else {
|
||
if [[ -n ${ZINIT_ICE[pick]} ]]; then
|
||
list=( ${(M)~ZINIT_ICE[pick]##/*}(DN) $local_dir/$dirname/${~ZINIT_ICE[pick]}(DN) )
|
||
elif (( ${+ZINIT_ICE[pick]} == 0 )); then
|
||
.zinit-find-other-matches "$local_dir/$dirname" "$filename"
|
||
list=( ${reply[@]} )
|
||
fi
|
||
}
|
||
|
||
if [[ -f ${list[1-correct]} ]] {
|
||
ZERO="${list[1-correct]}"
|
||
(( ${+ZINIT_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 { [[ ${+ZINIT_ICE[pick]} = 1 && -z ${ZINIT_ICE[pick]} || ${ZINIT_ICE[pick]} = /dev/null ]] || { +zinit-message "Snippet not loaded ([info2]${id_as}[rst])"; retval=1; } }
|
||
|
||
[[ -n ${ZINIT_ICE[src]} ]] && { ZERO="${${(M)ZINIT_ICE[src]##/*}:-$local_dir/$dirname/${ZINIT_ICE[src]}}"; (( ${+ZINIT_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 ${ZINIT_ICE[multisrc]} ]] && { local ___oldcd="$PWD"; () { setopt localoptions noautopushd; builtin cd -q "$local_dir/$dirname"; }; eval "reply=(${ZINIT_ICE[multisrc]})"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; local fname; for fname in "${reply[@]}"; do ZERO="${${(M)fname:#/*}:-$local_dir/$dirname/$fname}"; (( ${+ZINIT_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 ${ZINIT_ICE[wrap-track]} ]] {
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-wrap-track-functions "$save_url" "" "$id_as"
|
||
}
|
||
|
||
[[ ${ZINIT_ICE[atload][1]} = "!" ]] && { .zinit-add-report "$id_as" "Note: Starting to track the atload'!…' ice…"; ZERO="$local_dir/$dirname/-atload-"; local ___oldcd="$PWD"; (( ${+ZINIT_ICE[nocd]} == 0 )) && { () { setopt localoptions noautopushd; builtin cd -q "$local_dir/$dirname"; } && builtin eval "${ZINIT_ICE[atload]#\!}"; ((1)); } || eval "${ZINIT_ICE[atload]#\!}"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; }
|
||
|
||
(( -- ZINIT[SHADOWING] == 0 )) && { ZINIT[SHADOWING]=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]} || ${ZINIT_ICE[as]} = command ]]; then
|
||
[[ ${+ZINIT_ICE[pick]} = 1 && -z ${ZINIT_ICE[pick]} ]] && \
|
||
ZINIT_ICE[pick]="${id_as:t}"
|
||
# Subversion - directory and multiple files possible
|
||
if (( ${+ZINIT_ICE[svn]} )); then
|
||
if [[ -n ${ZINIT_ICE[pick]} ]]; then
|
||
list=( ${(M)~ZINIT_ICE[pick]##/*}(DN) $local_dir/$dirname/${~ZINIT_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 ${ZINIT_ICE[pick]} ]] && {
|
||
list=( ${(M)~ZINIT_ICE[pick]##/*}(DN) $local_dir/$dirname/${~ZINIT_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 ${ZINIT_ICE[src]} || -n ${ZINIT_ICE[multisrc]} || ${ZINIT_ICE[atload][1]} = "!" ]] && {
|
||
if [[ ${ZINIT[SHADOWING]} = inactive ]]; then
|
||
# Shadowing code is inlined from .zinit-shade-on
|
||
(( ${+functions[compdef]} )) && ZINIT[bkp-compdef]="${functions[compdef]}" || builtin unset "ZINIT[bkp-compdef]"
|
||
functions[compdef]=':zinit-shade-compdef "$@";'
|
||
ZINIT[SHADOWING]=1
|
||
else
|
||
(( ++ ZINIT[SHADOWING] ))
|
||
fi
|
||
}
|
||
|
||
if [[ -n ${ZINIT_ICE[src]} ]]; then
|
||
ZERO="${${(M)ZINIT_ICE[src]##/*}:-$local_dir/$dirname/${ZINIT_ICE[src]}}"
|
||
(( ${+ZINIT_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 ${ZINIT_ICE[multisrc]} ]] && { local ___oldcd="$PWD"; () { setopt localoptions noautopushd; builtin cd -q "$local_dir/$dirname"; }; eval "reply=(${ZINIT_ICE[multisrc]})"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; local fname; for fname in "${reply[@]}"; do ZERO="${${(M)fname:#/*}:-$local_dir/$dirname/$fname}"; (( ${+ZINIT_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 ${ZINIT_ICE[wrap-track]} ]] {
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-wrap-track-functions "$save_url" "" "$id_as"
|
||
}
|
||
|
||
[[ ${ZINIT_ICE[atload][1]} = "!" ]] && { .zinit-add-report "$id_as" "Note: Starting to track the atload'!…' ice…"; ZERO="$local_dir/$dirname/-atload-"; local ___oldcd="$PWD"; (( ${+ZINIT_ICE[nocd]} == 0 )) && { () { setopt localoptions noautopushd; builtin cd -q "$local_dir/$dirname"; } && builtin eval "${ZINIT_ICE[atload]#\!}"; ((1)); } || eval "${ZINIT_ICE[atload]#\!}"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; }
|
||
|
||
[[ -n ${ZINIT_ICE[src]} || -n ${ZINIT_ICE[multisrc]} || ${ZINIT_ICE[atload][1]} = "!" ]] && {
|
||
(( -- ZINIT[SHADOWING] == 0 )) && { ZINIT[SHADOWING]=inactive; builtin setopt noaliases; (( ${+ZINIT[bkp-compdef]} )) && functions[compdef]="${ZINIT[bkp-compdef]}" || unfunction compdef; (( ZINIT[ALIASES_OPT] )) && builtin setopt aliases; }
|
||
}
|
||
elif [[ ${ZINIT_ICE[as]} = completion ]]; then
|
||
((1))
|
||
fi
|
||
|
||
(( ${+ZINIT_ICE[atload]} )) && [[ ${ZINIT_ICE[atload][1]} != "!" ]] && { ZERO="$local_dir/$dirname/-atload-"; local ___oldcd="$PWD"; (( ${+ZINIT_ICE[nocd]} == 0 )) && { () { setopt localoptions noautopushd; builtin cd -q "$local_dir/$dirname"; } && builtin eval "${ZINIT_ICE[atload]}"; ((1)); } || eval "${ZINIT_ICE[atload]}"; () { setopt localoptions noautopushd; builtin cd -q "$___oldcd"; }; }
|
||
|
||
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
|
||
|
||
(( ${+ZINIT_ICE[notify]} == 1 )) && { [[ $retval -eq 0 || -n ${(M)ZINIT_ICE[notify]#\!} ]] && { local msg; eval "msg=\"${ZINIT_ICE[notify]#\!}\""; +zinit-deploy-message @msg "$msg" } || +zinit-deploy-message @msg "notify: Plugin not loaded / loaded with problem, the return code: $retval"; }
|
||
(( ${+ZINIT_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
|
||
|
||
if [[ -n $___m_bkp ]] {
|
||
functions[m]="$___m_bkp"
|
||
} else {
|
||
noglob unset functions[m]
|
||
}
|
||
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
|
||
+zinit-message "Compinit isn't loaded, cannot do compdef replay"
|
||
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 ]] || +zinit-message "Running compdef: [obj]${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 ]] || +zinit-message "Compdef-replay cleared (had [obj]${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]}"
|
||
(( front )) && \
|
||
fpath[1,0]=${${${(M)user:#%}:+$plugin}:-${ZINIT[PLUGINS_DIR]}/${id_as//\//---}}${add_dir:+/$add_dir} || \
|
||
fpath+=(
|
||
${${${(M)user:#%}:+$plugin}:-${ZINIT[PLUGINS_DIR]}/${id_as//\//---}}${add_dir:+/$add_dir}
|
||
)
|
||
}
|
||
# ]]]
|
||
# FUNCTION: .zinit-run [[[
|
||
# Run code inside plugin's folder
|
||
# It uses the `correct' parameter from upper's 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 ]] && { +zinit-message "[error]Error: No last plugin available, please specify as the first argument.[rst]"; return 1; }
|
||
else
|
||
integer ___nolast=1
|
||
fi
|
||
.zinit-any-to-user-plugin "$1" ""
|
||
local ___id_as="$1" ___user="${reply[-2]}" ___plugin="${reply[-1]}" ___oldpwd="$PWD"
|
||
() {
|
||
emulate -LR zsh
|
||
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[-3]}/${reply[-2]}
|
||
}
|
||
}
|
||
if (( $? == 0 )); then
|
||
(( ___nolast )) && { print -r "$1" >! ${ZINIT[BIN_DIR]}/last-run-object.txt; }
|
||
ZINIT[last-run-plugin]="$1"
|
||
eval "${@[2-correct,-1]}"
|
||
() { setopt localoptions noautopushd; builtin cd -q "$___oldpwd"; }
|
||
else
|
||
+zinit-message "[error]Error: no such plugin or snippet.[rst]"
|
||
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's after
|
||
# it, otherwise substitute 0
|
||
exec {THEFD} < <(LANG=C sleep $(( 0.01 + ${${${(M)1#@sleep:}:+${1#@sleep:}}:-0} )); print -r -- ${1:#(@msg|@sleep:*)} "${@[2,-1]}"; )
|
||
command true # workaround a Zsh bug, see: http://www.zsh.org/mla/workers/2018/msg00966.html
|
||
builtin zle -F "$THEFD" +zinit-deploy-message
|
||
}
|
||
# ]]]
|
||
# FUNCTION: +zinit-message [[[
|
||
+zinit-message() {
|
||
builtin emulate -LR zsh -o extendedglob
|
||
[[ $1 = -* ]] && { local opt=$1; shift }
|
||
local msg=${(j: :)${@//(#b)\[([^\]]##)\]/${ZINIT[col-$match[1]]-\[$match[1]\]}}}
|
||
builtin print -Pr $opt -- $msg
|
||
}
|
||
# ]]]
|
||
|
||
#
|
||
# Ice support
|
||
#
|
||
|
||
# FUNCTION: .zinit-ice [[[
|
||
# Parses ICE specification, puts the result into ZINIT_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="${~ZINIT_EXTS[ice-mods]//\'\'/}"
|
||
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%/}}"
|
||
return $retval
|
||
} # ]]]
|
||
# FUNCTION: .zinit-pack-ice [[[
|
||
# Remembers all ice-mods, assigns them to concrete plugin. Ice spec
|
||
# is in general forgotten for second-next command (that's why it's
|
||
# called "ice" - it melts), 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)ZINIT_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]}
|
||
${(@us.|.)${ZINIT_EXTS[ice-mods]//\'\'/}}
|
||
)
|
||
___path="${ZINIT[PLUGINS_DIR]}/${id_as//\//---}"/._zinit
|
||
# TODO snippet's dir computation…
|
||
if [[ ! -d $___path ]] {
|
||
if ! .zinit-get-object-path snippet "${id_as//\//---}"; then
|
||
return 1
|
||
fi
|
||
___path="${reply[-3]%/}/${reply[-2]}"/._zinit
|
||
}
|
||
for ___key ( "${ice_order[@]}" ) {
|
||
(( ${+ZINIT_ICE[$___key]} )) && [[ ${ZINIT_ICE[$___key]} != +* ]] && continue
|
||
[[ -e $___path/$___key ]] && ZINIT_ICE[$___key]="$(<$___path/$___key)"
|
||
}
|
||
[[ -n ${ZINIT_ICE[on-update-of]} ]] && ZINIT_ICE[subscribe]="${ZINIT_ICE[subscribe]:-${ZINIT_ICE[on-update-of]}}"
|
||
[[ ${ZINIT_ICE[as]} = program ]] && ZINIT_ICE[as]=command
|
||
[[ -n ${ZINIT_ICE[pick]} ]] && ZINIT_ICE[pick]="${ZINIT_ICE[pick]//\$ZPFX/${ZPFX%/}}"
|
||
|
||
return 0
|
||
}
|
||
# ]]]
|
||
|
||
#
|
||
# 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 - the pass number, either 1st or 2nd pass
|
||
# $2 - the time assigned to the task
|
||
# $3 - type: plugin, snippet, service plugin, service snippet
|
||
# $4 - task's index in the ZINIT[WAIT_ICE_...] fields
|
||
# $5 - mode: load or light
|
||
# $6 - the plugin-spec or snippet URL or alias name (from id-as'')
|
||
.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 ZINIT_ICE
|
||
ZINIT_ICE=( "${(@Q)${(z@)ZINIT[WAIT_ICE_${___idx}]}}" )
|
||
|
||
local ___id_as=${ZINIT_ICE[id-as]:-$___id}
|
||
|
||
if [[ $___pass = 1 && ${${ZINIT_ICE[wait]#\!}%%[^0-9]([^0-9]|)([^0-9]|)([^0-9]|)} = <-> ]]; then
|
||
___action="${(M)ZINIT_ICE[wait]#\!}load"
|
||
elif [[ $___pass = 1 && -n ${ZINIT_ICE[wait]#\!} ]] && { eval "${ZINIT_ICE[wait]#\!}" || [[ $(( ___s=0 )) = 1 ]]; }; then
|
||
___action="${(M)ZINIT_ICE[wait]#\!}load"
|
||
elif [[ -n ${ZINIT_ICE[load]#\!} && -n $(( ___s=0 )) && $___pass = 3 && -z ${ZINIT_REGISTERED_PLUGINS[(r)$___id_as]} ]] && eval "${ZINIT_ICE[load]#\!}"; then
|
||
___action="${(M)ZINIT_ICE[load]#\!}load"
|
||
elif [[ -n ${ZINIT_ICE[unload]#\!} && -n $(( ___s=0 )) && $___pass = 2 && -n ${ZINIT_REGISTERED_PLUGINS[(r)$___id_as]} ]] && eval "${ZINIT_ICE[unload]#\!}"; then
|
||
___action="${(M)ZINIT_ICE[unload]#\!}remove"
|
||
elif [[ -n ${ZINIT_ICE[subscribe]#\!} && -n $(( ___s=0 )) && $___pass = 3 ]] && \
|
||
{ local -a fts_arr
|
||
eval "fts_arr=( ${ZINIT_ICE[subscribe]}(DNms-$(( EPOCHSECONDS -
|
||
ZINIT[fts-${ZINIT_ICE[subscribe]}] ))) ); (( \${#fts_arr} ))" && \
|
||
{ ZINIT[fts-${ZINIT_ICE[subscribe]}]="$EPOCHSECONDS"; ___s=${+ZINIT_ICE[once]}; } || \
|
||
(( 0 ))
|
||
}
|
||
then
|
||
___action="${(M)ZINIT_ICE[subscribe]#\!}load"
|
||
fi
|
||
|
||
if [[ $___action = *load ]]; then
|
||
if [[ $___tpe = p ]]; then
|
||
.zinit-load "$___id" "" "$___mode"; (( ___retval += $? ))
|
||
elif [[ $___tpe = s ]]; then
|
||
.zinit-load-snippet $___opt "${(@)=___id}"; (( ___retval += $? ))
|
||
elif [[ $___tpe = p1 || $___tpe = s1 ]]; then
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
zpty -b "${___id//\//:} / ${ZINIT_ICE[service]}" '.zinit-service '"${(M)___tpe#?}"' "$___mode" "$___id"'
|
||
fi
|
||
(( ${+ZINIT_ICE[silent]} == 0 && ${+ZINIT_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
|
||
(( ${+ZINIT_ICE[silent]} == 0 && ${+ZINIT_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, so that
|
||
# @zinit-scheduler can run (load, unload) this as a task.
|
||
.zinit-submit-turbo() {
|
||
local tpe="$1" mode="$2" opt_uspl2="$3" opt_plugin="$4"
|
||
|
||
ZINIT_ICE[wait]="${ZINIT_ICE[wait]%%.[0-9]##}"
|
||
ZINIT[WAIT_IDX]=$(( ${ZINIT[WAIT_IDX]:-0} + 1 ))
|
||
ZINIT[WAIT_ICE_${ZINIT[WAIT_IDX]}]="${(j: :)${(qkv)ZINIT_ICE[@]}}"
|
||
ZINIT[fts-${ZINIT_ICE[subscribe]}]="${ZINIT_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 [[ ${${ZINIT_ICE[wait]}%%[^0-9]([^0-9]|)([^0-9]|)([^0-9]|)} = (\!|.|)<-> ]]; then
|
||
ZINIT_TASKS+=( "$EPOCHSECONDS+${${ZINIT_ICE[wait]#(\!|.)}%%[^0-9]([^0-9]|)([^0-9]|)([^0-9]|)}+${${${(M)ZINIT_ICE[wait]%a}:+1}:-${${${(M)ZINIT_ICE[wait]%b}:+2}:-${${${(M)ZINIT_ICE[wait]%c}:+3}:-1}}} $tpe ${ZINIT[WAIT_IDX]} ${mode:-_} ${(q)id} ${opt_plugin:+${(q)opt_uspl2}}" )
|
||
elif [[ -n ${ZINIT_ICE[wait]}${ZINIT_ICE[load]}${ZINIT_ICE[unload]}${ZINIT_ICE[subscribe]} ]]; then
|
||
ZINIT_TASKS+=( "${${ZINIT_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. There's 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 REPLY AFD
|
||
|
||
[[ -o ksharrays ]] && correct=1
|
||
|
||
if [[ -n $1 ]] {
|
||
if [[ ${#ZINIT_RUN} -le 1 || $1 = following ]] {
|
||
() {
|
||
builtin emulate -L zsh
|
||
builtin setopt extendedglob
|
||
# Example entry:
|
||
# 1531252764+2+1 p 18 light zdharma/zsh-diff-so-fancy
|
||
#
|
||
# This either doesn't 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
|
||
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]}} )
|
||
}
|
||
# There's 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 it's 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: http://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 [[[
|
||
# Main function directly exposed to user, obtains subcommand and its
|
||
# arguments, has completion.
|
||
zinit() {
|
||
local -A ZINIT_ICE
|
||
ZINIT_ICE=( "${(kv)ZINIT_ICES[@]}" )
|
||
ZINIT_ICES=()
|
||
|
||
integer ___retval=0 ___correct=0
|
||
local -a match mbegin mend reply
|
||
local MATCH REPLY ___q="\`" ___q2="'"; integer MBEGIN MEND
|
||
|
||
|
||
[[ -o ksharrays ]] && ___correct=1
|
||
|
||
local -A ___opt_map ICE_OPTS
|
||
___opt_map=(
|
||
-q opt_-q,--quiet
|
||
--quiet opt_-q,--quiet
|
||
-r opt_-r,--reset
|
||
--reset opt_-r,--reset
|
||
--all opt_--all
|
||
--clean opt_--clean
|
||
--yes opt_-y,--yes
|
||
-y opt_-y,--yes
|
||
-f opt_-f,--force
|
||
--force opt_-f,--force
|
||
-p opt_-p,--parallel
|
||
--parallel opt_-p,--parallel
|
||
)
|
||
|
||
|
||
reply=( ${ZINIT_EXTS[(I)z-annex subcommand:*]} )
|
||
|
||
[[ $1 != (-h|--help|help|man|self-update|times|zstatus|load|light|unload|snippet|ls|ice|\
|
||
update|status|report|delete|loaded|list|cd|create|edit|glance|stress|changes|recently|clist|\
|
||
completions|cclear|cdisable|cenable|creinstall|cuninstall|csearch|compinit|dtrace|dstart|dstop|\
|
||
dunload|dreport|dclear|compile|uncompile|compiled|cdlist|cdreplay|cdclear|srv|recall|\
|
||
env-whitelist|bindkeys|module|add-fpath|fpath|run${reply:+|${(~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
|
||
() {
|
||
setopt localoptions extendedglob
|
||
: ${@[@]//(#b)([ $'\t']##|(#s))(-b|--command|-f)([ $'\t']##|(#e))/${ICE_OPTS[${match[2]}]::=1}}
|
||
} "$@"
|
||
set -- "${@[@]:#(-b|--command|-f)}"
|
||
[[ $1 = light && -z ${ICE_OPTS[(I)-b]} ]] && ZINIT_ICE[light-mode]=
|
||
[[ $1 = snippet ]] && ZINIT_ICE[is-snippet]= || ___is_snippet=-1
|
||
shift
|
||
|
||
ZINIT_ICES=( "${(kv)ZINIT_ICE[@]}" )
|
||
ZINIT_ICE=()
|
||
1="${1:+@}${1#@}${2:+/$2}"
|
||
(( $# > 1 )) && { shift -p $(( $# - 1 )); }
|
||
[[ -z $1 ]] && {
|
||
+zinit-message "Argument needed, try: [obj]help[rst]."
|
||
return 1
|
||
}
|
||
} else {
|
||
.zinit-ice "$@"
|
||
integer ___retval=$?
|
||
local ___last_ice=${@[___retval]}
|
||
shift $___retval
|
||
if [[ $# -gt 0 && $1 != for ]] {
|
||
+zinit-message "[error]Unknown command or ice: ${___q}[obj]${1}[error]'" \
|
||
"(use ${___q}[info2]help[error]' to get usage information).[rst]"
|
||
return 1
|
||
} elif (( $# == 0 )) {
|
||
___error=1
|
||
} else {
|
||
shift
|
||
}
|
||
}
|
||
integer ___retval ___had_wait
|
||
if (( $# )) {
|
||
local -a ___ices
|
||
___ices=( "${(kv)ZINIT_ICES[@]}" )
|
||
ZINIT_ICES=()
|
||
while (( $# )) {
|
||
.zinit-ice "$@"
|
||
integer ___retval=$?
|
||
local ___last_ice=${@[___retval]}
|
||
shift $___retval
|
||
[[ -z ${ZINIT_ICES[subscribe]} ]] && unset 'ZINIT_ICES[subscribe]'
|
||
if [[ -n $1 ]] {
|
||
ZINIT_ICE=( "${___ices[@]}" "${(kv)ZINIT_ICES[@]}" )
|
||
ZINIT_ICES=()
|
||
|
||
(( ${+ZINIT_ICE[pack]} )) && {
|
||
___had_wait=${+ZINIT_ICE[wait]}
|
||
.zinit-load-ices "${1#@}"
|
||
[[ -z ${ZINIT_ICE[wait]} && $___had_wait == 0 ]] && \
|
||
unset 'ZINIT_ICE[wait]'
|
||
}
|
||
|
||
[[ ${ZINIT_ICE[id-as]} = (auto|) && ${+ZINIT_ICE[id-as]} == 1 ]] && ZINIT_ICE[id-as]="${1:t}"
|
||
|
||
integer ___is_snippet=${${(M)___is_snippet:#-1}:-0}
|
||
() {
|
||
setopt localoptions extendedglob
|
||
if [[ $___is_snippet -ge 0 && ( -n ${ZINIT_ICE[is-snippet]+1} || ${1#@} = ((#i)(http(s|)|ftp(s|)):/|(${(~kj.|.)ZINIT_1MAP}))* ) ]] {
|
||
___is_snippet=1
|
||
}
|
||
} "$@"
|
||
|
||
integer ___action_load=0 ___turbo=0
|
||
if [[ -n ${(M)${+ZINIT_ICE[wait]}:#1}${ZINIT_ICE[load]}${ZINIT_ICE[unload]}${ZINIT_ICE[service]}${ZINIT_ICE[subscribe]} ]] {
|
||
___turbo=1
|
||
}
|
||
|
||
if [[ -n ${ZINIT_ICE[trigger-load]} || \
|
||
( ${+ZINIT_ICE[wait]} == 1 &&
|
||
${ZINIT_ICE[wait]} = (\!|)(<->(a|b|c|)|) )
|
||
]] && (( !ZINIT[OPTIMIZE_OUT_DISK_ACCESSES]
|
||
)) {
|
||
if (( ___is_snippet > 0 )) {
|
||
.zinit-get-object-path snippet "${${1#@}%%(///|//|/)}"
|
||
} else {
|
||
.zinit-get-object-path plugin "${${${1#@}#https://github.com/}%%(///|//|/)}"
|
||
}
|
||
(( $? )) && { ___action_load=1; }
|
||
local ___object_path="${reply[-3]}"
|
||
} elif (( ! ___turbo )) {
|
||
___action_load=1
|
||
reply=( 1 )
|
||
} else {
|
||
reply=( 1 )
|
||
}
|
||
|
||
if [[ ${reply[-1]} -eq 1 && -n ${ZINIT_ICE[trigger-load]} ]] {
|
||
() {
|
||
setopt localoptions extendedglob
|
||
local ___mode
|
||
(( ___is_snippet > 0 )) && ___mode=snippet || ___mode="${${${ZINIT_ICE[light-mode]+light}}:-load}"
|
||
for MATCH ( ${(s.;.)ZINIT_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@)ZINIT_ICE[(I)^(trigger-load|wait|light-mode)]}} ) {
|
||
ices+=( \"\$a\$b\" )
|
||
}
|
||
zinit ice \${ices[@]}; zinit $___mode ${(qqq)${1#@}}
|
||
${${(M)MATCH#!}:+# Forward the call
|
||
eval ${MATCH#!} \$@}
|
||
}"
|
||
}
|
||
} "$@"
|
||
___retval+=$?
|
||
(( $# )) && shift
|
||
continue
|
||
}
|
||
|
||
(( ${+ZINIT_ICE[if]} )) && { eval "${ZINIT_ICE[if]}" || { (( $# )) && shift; continue; }; }
|
||
(( ${+ZINIT_ICE[has]} )) && { (( ${+commands[${ZINIT_ICE[has]}]} )) || { (( $# )) && shift; continue; }; }
|
||
|
||
ZINIT_ICE[wait]="${${(M)${+ZINIT_ICE[wait]}:#1}:+${(M)ZINIT_ICE[wait]#!}${${ZINIT_ICE[wait]#!}:-0}}"
|
||
if (( ___turbo && ZINIT[HAVE_SCHEDULER] )) {
|
||
ZINIT_ICE[wait]="${ZINIT_ICE[wait]:-${ZINIT_ICE[service]:+0}}"
|
||
if (( ___is_snippet > 0 )); then
|
||
ZINIT_SICE[${${1#@}%%(///|//|/)}]=
|
||
.zinit-submit-turbo s${ZINIT_ICE[service]:+1} "" \
|
||
"${${1#@}%%(///|//|/)}" \
|
||
"${(k)ICE_OPTS[*]}"
|
||
else
|
||
ZINIT_SICE[${${${1#@}#https://github.com/}%%(///|//|/)}]=
|
||
.zinit-submit-turbo p${ZINIT_ICE[service]:+1} \
|
||
"${${${ZINIT_ICE[light-mode]+light}}:-load}" \
|
||
"${${${1#@}#https://github.com/}%%(///|//|/)}" ""
|
||
fi
|
||
___retval+=$?
|
||
}
|
||
if (( ___action_load || !ZINIT[HAVE_SCHEDULER] )) {
|
||
if (( ___turbo )) {
|
||
ZINIT_ICE[cloneonly]=""
|
||
}
|
||
if (( ___is_snippet > 0 )); then
|
||
.zinit-load-snippet ${(k)ICE_OPTS[@]} "${${1#@}%%(///|//|/)}"
|
||
else
|
||
.zinit-load "${${${1#@}#https://github.com/}%%(///|//|/)}" "" \
|
||
"${${ZINIT_ICE[light-mode]+light}:-${ICE_OPTS[(I)-b]:+light-b}}"
|
||
fi
|
||
___retval+=$? ___is_snippet=0
|
||
if (( ___turbo )) {
|
||
command rm -f $___object_path/._zinit/cloneonly
|
||
}
|
||
}
|
||
} else {
|
||
___error=1
|
||
}
|
||
(( $# )) && shift
|
||
}
|
||
} else {
|
||
___error=1
|
||
}
|
||
|
||
if (( ___error )) {
|
||
() {
|
||
emulate -LR zsh -o extendedglob
|
||
+zinit-message -n "[error]Error: No plugin or snippet ID given"
|
||
if [[ -n $___last_ice ]] {
|
||
+zinit-message "(the last recognized ice was: [obj]"\
|
||
"${___last_ice/(#m)(${~ZINIT[ice-list]})/[obj]$MATCH${___q2}[file]}[obj]'[error]).
|
||
You can try to prepend ${___q}[obj]@[error]' if the last ice is in fact a plugin.[rst]
|
||
[info2]Note:[rst]The \`ice' subcommand is now again required if not using the
|
||
for-syntax."
|
||
} else {
|
||
+zinit-message ".[rst]"
|
||
}
|
||
}
|
||
return 2
|
||
} elif (( ! $# )) {
|
||
return 0
|
||
}
|
||
}
|
||
|
||
case "$1" in
|
||
(ice)
|
||
shift
|
||
.zinit-ice "$@"
|
||
;;
|
||
(cdreplay)
|
||
.zinit-compdef-replay "$2"; ___retval=$?
|
||
;;
|
||
(cdclear)
|
||
.zinit-compdef-clear "$2"
|
||
;;
|
||
(add-fpath|fpath)
|
||
.zinit-add-fpath "${@[2-correct,-1]}"
|
||
;;
|
||
(run)
|
||
.zinit-run "${@[2-correct,-1]}"
|
||
;;
|
||
(dstart|dtrace)
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-debug-start
|
||
;;
|
||
(dstop)
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-debug-stop
|
||
;;
|
||
(man)
|
||
man "${ZINIT[BIN_DIR]}/doc/zinit.1"
|
||
;;
|
||
(env-whitelist)
|
||
shift
|
||
[[ $1 = -v ]] && { shift; local ___verbose=1; }
|
||
[[ $1 = -h ]] && { shift; +zinit-message "[info2]Usage:[rst] zinit env-whitelist [-v] VAR1 ...\nSaves names (also patterns) of parameters left unchanged during an unload. -v - ___verbose."; }
|
||
(( $# == 0 )) && {
|
||
ZINIT[ENV-WHITELIST]=
|
||
(( ___verbose )) && +zinit-message "Cleared parameter whitelist"
|
||
} || {
|
||
ZINIT[ENV-WHITELIST]+="${(j: :)${(q-kv)@}} "
|
||
(( ___verbose )) && +zinit-message "Extended parameter whitelist"
|
||
}
|
||
;;
|
||
(*)
|
||
# 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 $?; } || \
|
||
{ +zinit-message "([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
|
||
;;
|
||
(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
|
||
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)
|
||
(( ${+ZINIT_ICE[if]} )) && { eval "${ZINIT_ICE[if]}" || return 1; }
|
||
(( ${+ZINIT_ICE[has]} )) && { (( ${+commands[${ZINIT_ICE[has]}]} )) || return 1; }
|
||
() {
|
||
setopt localoptions extendedglob
|
||
: ${@[@]//(#b)([ $'\t']##|(#s))(-q|--quiet|-r|--reset|-f|--force|-p|--parallel)([ $'\t']##|(#e))/${ICE_OPTS[${___opt_map[${match[2]}]}]::=1}}
|
||
} "$@"
|
||
set -- "${@[@]:#(--quiet|-q|--reset|-r|-f|--force|-p|--parallel)}"
|
||
if [[ $2 = --all || ${ICE_OPTS[opt_-p,--parallel]} = 1 || ( -z $2 && -z $3 && -z ${ZINIT_ICE[teleid]} && -z ${ZINIT_ICE[id-as]} ) ]]; then
|
||
[[ -z $2 && ${ICE_OPTS[opt_-p,--parallel]} != 1 ]] && { print -r -- "Assuming --all is passed"; sleep 2; }
|
||
[[ ${ICE_OPTS[opt_-p,--parallel]} = 1 ]] && \
|
||
ICE_OPTS[value]=${${${${${(M)2:#--all}:+$3}:-$2}:#--all}:-15}
|
||
.zinit-update-or-status-all update; ___retval=$?
|
||
else
|
||
.zinit-update-or-status update "${${2%%(///|//|/)}:-${ZINIT_ICE[id-as]:-$ZINIT_ICE[teleid]}}" "${3%%(///|//|/)}"; ___retval=$?
|
||
fi
|
||
;;
|
||
(status)
|
||
if [[ $2 = --all || ( -z $2 && -z $3 ) ]]; then
|
||
[[ -z $2 ]] && { print -r -- "Assuming --all is passed"; sleep 2; }
|
||
.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 ]] && { print -r -- "Assuming --all is passed"; sleep 3; }
|
||
.zinit-show-all-reports
|
||
else
|
||
.zinit-show-report "${2%%(///|//|/)}" "${3%%(///|//|/)}"; ___retval=$?
|
||
fi
|
||
;;
|
||
(loaded|list)
|
||
# Show list of loaded plugins
|
||
.zinit-show-registered-plugins "$2"
|
||
;;
|
||
(clist|completions)
|
||
# Show installed, enabled or disabled, completions
|
||
# Detect stray and improper ones
|
||
.zinit-show-completions "$2"
|
||
;;
|
||
(cclear)
|
||
# Delete stray and improper completions
|
||
.zinit-clear-completions
|
||
;;
|
||
(cdisable)
|
||
if [[ -z $2 ]]; then
|
||
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"
|
||
print "Initializing completion system (compinit)..."
|
||
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
|
||
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"
|
||
print "Initializing completion system (compinit)..."
|
||
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's 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]} ]] && print "Initializing completion (compinit)..."
|
||
builtin autoload -Uz compinit
|
||
compinit -d ${ZINIT[ZCOMPDUMP_PATH]:-${ZDOTDIR:-$HOME}/.zcompdump} "${(Q@)${(z@)ZINIT[COMPINIT_OPTS]}}"
|
||
;;
|
||
(cuninstall)
|
||
if [[ -z $2 && -z $3 ]]; then
|
||
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=$?
|
||
print "Initializing completion (compinit)..."
|
||
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=$?
|
||
;;
|
||
(dreport)
|
||
.zinit-show-debug-report
|
||
;;
|
||
(dclear)
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-clear-debug-report
|
||
;;
|
||
(dunload)
|
||
(( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
|
||
.zinit-debug-unload
|
||
;;
|
||
(compile)
|
||
(( ${+functions[.zinit-compile-plugin]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-install.zsh" || return 1
|
||
if [[ $2 = --all || ( -z $2 && -z $3 ) ]]; then
|
||
[[ -z $2 ]] && { print -r -- "Assuming --all is passed"; sleep 2; }
|
||
.zinit-compile-uncompile-all 1; ___retval=$?
|
||
else
|
||
.zinit-compile-plugin "${2%%(///|//|/)}" "${3%%(///|//|/)}"; ___retval=$?
|
||
fi
|
||
;;
|
||
(uncompile)
|
||
if [[ $2 = --all || ( -z $2 && -z $3 ) ]]; then
|
||
[[ -z $2 ]] && { print -r -- "Assuming --all is passed"; sleep 2; }
|
||
.zinit-compile-uncompile-all 0; ___retval=$?
|
||
else
|
||
.zinit-uncompile-plugin "${2%%(///|//|/)}" "${3%%(///|//|/)}"; ___retval=$?
|
||
fi
|
||
;;
|
||
(compiled)
|
||
.zinit-compiled
|
||
;;
|
||
(cdlist)
|
||
.zinit-list-compdef-replay
|
||
;;
|
||
(cd|delete|recall|edit|glance|changes|create|stress)
|
||
.zinit-"$1" "${@[2-correct,-1]%%(///|//|/)}"; ___retval=$?
|
||
;;
|
||
(recently)
|
||
shift
|
||
.zinit-recently "$@"; ___retval=$?
|
||
;;
|
||
(-h|--help|help)
|
||
.zinit-help
|
||
;;
|
||
(ls)
|
||
shift
|
||
.zinit-ls "$@"
|
||
;;
|
||
(srv)
|
||
() { setopt localoptions extendedglob warncreateglobal
|
||
[[ ! -e ${ZINIT[SERVICES_DIR]}/"$2".fifo ]] && { print "No such service: $2"; } ||
|
||
{ [[ $3 = (#i)(next|stop|quit|restart) ]] &&
|
||
{ print "${(U)3}" >>! ${ZINIT[SERVICES_DIR]}/"$2".fifo || print "Service $2 inactive"; ___retval=1; } ||
|
||
{ [[ $3 = (#i)start ]] && rm -f ${ZINIT[SERVICES_DIR]}/"$2".stop ||
|
||
{ print "Unknown service-command: $3"; ___retval=1; }
|
||
}
|
||
}
|
||
} "$@"
|
||
;;
|
||
(module)
|
||
.zinit-module "${@[2-correct,-1]}"; ___retval=$?
|
||
;;
|
||
(*)
|
||
+zinit-message "[error]Unknown command ${___q}[obj]${1}[error]'" \
|
||
"(use ${___q}[obj]help[error]' to get usage information).[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)@}}" ); }
|
||
# ]]]
|
||
|
||
# Compatibility functions [[[
|
||
zplugin() { zinit "$@"; }
|
||
zpcdreplay() { .zinit-compdef-replay -q; }
|
||
zpcdclear() { .zinit-compdef-clear -q; }
|
||
zpcompinit() { autoload -Uz compinit; compinit -d ${ZINIT[ZCOMPDUMP_PATH]:-${ZDOTDIR:-$HOME}/.zcompdump} "${(Q@)${(z@)ZINIT[COMPINIT_OPTS]}}"; }
|
||
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 [[[
|
||
builtin alias zpl=zinit zplg=zinit zi=zinit zini=zinit
|
||
|
||
.zinit-prepare-home
|
||
|
||
# Remember source's 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
|
||
# This will allow to cuninstall of its completion
|
||
ZINIT_REGISTERED_PLUGINS=( _local/zinit "${(u)ZINIT_REGISTERED_PLUGINS[@]:#_local/zinit}" )
|
||
ZINIT_REGISTERED_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} ]] {
|
||
+zinit-message "[error]WARNING:[rst][msg1]A [obj]recompilation[rst]" \
|
||
"of the Zinit module has been requested… [obj]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
|
||
+zinit-message "[pre]Build successful![rst]"
|
||
else
|
||
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"
|
||
}
|
||
}
|
||
}
|
||
# ]]]
|
||
|
||
# vim:ft=zsh:sw=4:sts=4:et:foldmarker=[[[,]]]:foldmethod=marker
|