feat: init
This commit is contained in:
798
node_modules/@bomb.sh/tab/dist/t-DYl0qC9V.js
generated
vendored
Normal file
798
node_modules/@bomb.sh/tab/dist/t-DYl0qC9V.js
generated
vendored
Normal file
@@ -0,0 +1,798 @@
|
||||
import e from"node:assert";function t(e,t){return`#compdef ${e}
|
||||
compdef _${e} ${e}
|
||||
|
||||
# zsh completion for ${e} -*- shell-script -*-
|
||||
|
||||
__${e}_debug() {
|
||||
local file="$BASH_COMP_DEBUG_FILE"
|
||||
if [[ -n \${file} ]]; then
|
||||
echo "$*" >> "\${file}"
|
||||
fi
|
||||
}
|
||||
|
||||
_${e}() {
|
||||
local shellCompDirectiveError=${a.ShellCompDirectiveError}
|
||||
local shellCompDirectiveNoSpace=${a.ShellCompDirectiveNoSpace}
|
||||
local shellCompDirectiveNoFileComp=${a.ShellCompDirectiveNoFileComp}
|
||||
local shellCompDirectiveFilterFileExt=${a.ShellCompDirectiveFilterFileExt}
|
||||
local shellCompDirectiveFilterDirs=${a.ShellCompDirectiveFilterDirs}
|
||||
local shellCompDirectiveKeepOrder=${a.ShellCompDirectiveKeepOrder}
|
||||
|
||||
local lastParam lastChar flagPrefix requestComp out directive comp lastComp noSpace keepOrder
|
||||
local -a completions
|
||||
|
||||
__${e}_debug "\\n========= starting completion logic =========="
|
||||
__${e}_debug "CURRENT: \${CURRENT}, words[*]: \${words[*]}"
|
||||
|
||||
# The user could have moved the cursor backwards on the command-line.
|
||||
# We need to trigger completion from the $CURRENT location, so we need
|
||||
# to truncate the command-line ($words) up to the $CURRENT location.
|
||||
# (We cannot use $CURSOR as its value does not work when a command is an alias.)
|
||||
words=( "\${=words[1,CURRENT]}" )
|
||||
__${e}_debug "Truncated words[*]: \${words[*]},"
|
||||
|
||||
lastParam=\${words[-1]}
|
||||
lastChar=\${lastParam[-1]}
|
||||
__${e}_debug "lastParam: \${lastParam}, lastChar: \${lastChar}"
|
||||
|
||||
# For zsh, when completing a flag with an = (e.g., ${e} -n=<TAB>)
|
||||
# completions must be prefixed with the flag
|
||||
setopt local_options BASH_REMATCH
|
||||
if [[ "\${lastParam}" =~ '-.*=' ]]; then
|
||||
# We are dealing with a flag with an =
|
||||
flagPrefix="-P \${BASH_REMATCH}"
|
||||
fi
|
||||
|
||||
# Prepare the command to obtain completions, ensuring arguments are quoted for eval
|
||||
local -a args_to_quote=("\${(@)words[2,-1]}")
|
||||
if [ "\${lastChar}" = "" ]; then
|
||||
# If the last parameter is complete (there is a space following it)
|
||||
# We add an extra empty parameter so we can indicate this to the go completion code.
|
||||
__${e}_debug "Adding extra empty parameter"
|
||||
args_to_quote+=("")
|
||||
fi
|
||||
|
||||
# Use Zsh's (q) flag to quote each argument safely for eval
|
||||
local quoted_args=("\${(@q)args_to_quote}")
|
||||
|
||||
# Join the main command and the quoted arguments into a single string for eval
|
||||
requestComp="${t} complete -- \${quoted_args[*]}"
|
||||
|
||||
__${e}_debug "About to call: eval \${requestComp}"
|
||||
|
||||
# Use eval to handle any environment variables and such
|
||||
out=$(eval \${requestComp} 2>/dev/null)
|
||||
__${e}_debug "completion output: \${out}"
|
||||
|
||||
# Extract the directive integer following a : from the last line
|
||||
local lastLine
|
||||
while IFS='\n' read -r line; do
|
||||
lastLine=\${line}
|
||||
done < <(printf "%s\n" "\${out[@]}")
|
||||
__${e}_debug "last line: \${lastLine}"
|
||||
|
||||
if [ "\${lastLine[1]}" = : ]; then
|
||||
directive=\${lastLine[2,-1]}
|
||||
# Remove the directive including the : and the newline
|
||||
local suffix
|
||||
(( suffix=\${#lastLine}+2))
|
||||
out=\${out[1,-$suffix]}
|
||||
else
|
||||
# There is no directive specified. Leave $out as is.
|
||||
__${e}_debug "No directive found. Setting to default"
|
||||
directive=0
|
||||
fi
|
||||
|
||||
__${e}_debug "directive: \${directive}"
|
||||
__${e}_debug "completions: \${out}"
|
||||
__${e}_debug "flagPrefix: \${flagPrefix}"
|
||||
|
||||
if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
|
||||
__${e}_debug "Completion received error. Ignoring completions."
|
||||
return
|
||||
fi
|
||||
|
||||
local activeHelpMarker="%"
|
||||
local endIndex=\${#activeHelpMarker}
|
||||
local startIndex=$((\${#activeHelpMarker}+1))
|
||||
local hasActiveHelp=0
|
||||
while IFS='\n' read -r comp; do
|
||||
# Check if this is an activeHelp statement (i.e., prefixed with $activeHelpMarker)
|
||||
if [ "\${comp[1,$endIndex]}" = "$activeHelpMarker" ];then
|
||||
__${e}_debug "ActiveHelp found: $comp"
|
||||
comp="\${comp[$startIndex,-1]}"
|
||||
if [ -n "$comp" ]; then
|
||||
compadd -x "\${comp}"
|
||||
__${e}_debug "ActiveHelp will need delimiter"
|
||||
hasActiveHelp=1
|
||||
fi
|
||||
continue
|
||||
fi
|
||||
|
||||
if [ -n "$comp" ]; then
|
||||
# If requested, completions are returned with a description.
|
||||
# The description is preceded by a TAB character.
|
||||
# For zsh's _describe, we need to use a : instead of a TAB.
|
||||
# We first need to escape any : as part of the completion itself.
|
||||
comp=\${comp//:/\\:}
|
||||
|
||||
local tab="$(printf '\\t')"
|
||||
comp=\${comp//$tab/:}
|
||||
|
||||
__${e}_debug "Adding completion: \${comp}"
|
||||
completions+=\${comp}
|
||||
lastComp=$comp
|
||||
fi
|
||||
done < <(printf "%s\n" "\${out[@]}")
|
||||
|
||||
# Add a delimiter after the activeHelp statements, but only if:
|
||||
# - there are completions following the activeHelp statements, or
|
||||
# - file completion will be performed (so there will be choices after the activeHelp)
|
||||
if [ $hasActiveHelp -eq 1 ]; then
|
||||
if [ \${#completions} -ne 0 ] || [ $((directive & shellCompDirectiveNoFileComp)) -eq 0 ]; then
|
||||
__${e}_debug "Adding activeHelp delimiter"
|
||||
compadd -x "--"
|
||||
hasActiveHelp=0
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
|
||||
__${e}_debug "Activating nospace."
|
||||
noSpace="-S ''"
|
||||
fi
|
||||
|
||||
if [ $((directive & shellCompDirectiveKeepOrder)) -ne 0 ]; then
|
||||
__${e}_debug "Activating keep order."
|
||||
keepOrder="-V"
|
||||
fi
|
||||
|
||||
if [ $((directive & shellCompDirectiveFilterFileExt)) -ne 0 ]; then
|
||||
# File extension filtering
|
||||
local filteringCmd
|
||||
filteringCmd='_files'
|
||||
for filter in \${completions[@]}; do
|
||||
if [ \${filter[1]} != '*' ]; then
|
||||
# zsh requires a glob pattern to do file filtering
|
||||
filter="\\*.$filter"
|
||||
fi
|
||||
filteringCmd+=" -g $filter"
|
||||
done
|
||||
filteringCmd+=" \${flagPrefix}"
|
||||
|
||||
__${e}_debug "File filtering command: $filteringCmd"
|
||||
_arguments '*:filename:'"$filteringCmd"
|
||||
elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then
|
||||
# File completion for directories only
|
||||
local subdir
|
||||
subdir="\${completions[1]}"
|
||||
if [ -n "$subdir" ]; then
|
||||
__${e}_debug "Listing directories in $subdir"
|
||||
pushd "\${subdir}" >/dev/null 2>&1
|
||||
else
|
||||
__${e}_debug "Listing directories in ."
|
||||
fi
|
||||
|
||||
local result
|
||||
_arguments '*:dirname:_files -/'" \${flagPrefix}"
|
||||
result=$?
|
||||
if [ -n "$subdir" ]; then
|
||||
popd >/dev/null 2>&1
|
||||
fi
|
||||
return $result
|
||||
else
|
||||
__${e}_debug "Calling _describe"
|
||||
if eval _describe $keepOrder "completions" completions -Q \${flagPrefix} \${noSpace}; then
|
||||
__${e}_debug "_describe found some completions"
|
||||
|
||||
# Return the success of having called _describe
|
||||
return 0
|
||||
else
|
||||
__${e}_debug "_describe did not find completions."
|
||||
__${e}_debug "Checking if we should do file completion."
|
||||
if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
|
||||
__${e}_debug "deactivating file completion"
|
||||
|
||||
# Return 0 to indicate completion is finished and prevent zsh from
|
||||
# trying other completion algorithms (which could cause hanging).
|
||||
# We use NoFileComp directive to explicitly disable file completion.
|
||||
return 0
|
||||
else
|
||||
# Perform file completion
|
||||
__${e}_debug "Activating file completion"
|
||||
|
||||
# We must return the result of this command, so it must be the
|
||||
# last command, or else we must store its result to return it.
|
||||
_arguments '*:filename:_files'" \${flagPrefix}"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
# don't run the completion function when being sourced or eval-ed
|
||||
if [ "\${funcstack[1]}" = "_${e}" ]; then
|
||||
_${e}
|
||||
fi
|
||||
`}function n(e,t){let n=e.replace(/[-:]/g,`_`);return`# bash completion for ${e}
|
||||
|
||||
# Define shell completion directives
|
||||
readonly ShellCompDirectiveError=${a.ShellCompDirectiveError}
|
||||
readonly ShellCompDirectiveNoSpace=${a.ShellCompDirectiveNoSpace}
|
||||
readonly ShellCompDirectiveNoFileComp=${a.ShellCompDirectiveNoFileComp}
|
||||
readonly ShellCompDirectiveFilterFileExt=${a.ShellCompDirectiveFilterFileExt}
|
||||
readonly ShellCompDirectiveFilterDirs=${a.ShellCompDirectiveFilterDirs}
|
||||
readonly ShellCompDirectiveKeepOrder=${a.ShellCompDirectiveKeepOrder}
|
||||
|
||||
# Function to debug completion
|
||||
__${n}_debug() {
|
||||
if [[ -n \${BASH_COMP_DEBUG_FILE:-} ]]; then
|
||||
echo "$*" >> "\${BASH_COMP_DEBUG_FILE}"
|
||||
fi
|
||||
}
|
||||
|
||||
# Function to handle completions
|
||||
__${n}_complete() {
|
||||
local cur prev words cword
|
||||
_get_comp_words_by_ref -n "=:" cur prev words cword
|
||||
|
||||
local requestComp out directive
|
||||
|
||||
# Build the command to get completions
|
||||
requestComp="${t} complete -- \${words[@]:1}"
|
||||
|
||||
# Add an empty parameter if the last parameter is complete
|
||||
if [[ -z "$cur" ]]; then
|
||||
requestComp="$requestComp ''"
|
||||
fi
|
||||
|
||||
# Get completions from the program
|
||||
out=$(eval "$requestComp" 2>/dev/null)
|
||||
|
||||
# Extract directive if present
|
||||
directive=0
|
||||
if [[ "$out" == *:* ]]; then
|
||||
directive=\${out##*:}
|
||||
out=\${out%:*}
|
||||
fi
|
||||
|
||||
# Process completions based on directive
|
||||
if [[ $((directive & $ShellCompDirectiveError)) -ne 0 ]]; then
|
||||
# Error, no completion
|
||||
return
|
||||
fi
|
||||
|
||||
# Apply directives
|
||||
if [[ $((directive & $ShellCompDirectiveNoSpace)) -ne 0 ]]; then
|
||||
compopt -o nospace
|
||||
fi
|
||||
if [[ $((directive & $ShellCompDirectiveKeepOrder)) -ne 0 ]]; then
|
||||
compopt -o nosort
|
||||
fi
|
||||
if [[ $((directive & $ShellCompDirectiveNoFileComp)) -ne 0 ]]; then
|
||||
compopt +o default
|
||||
fi
|
||||
|
||||
# Handle file extension filtering
|
||||
if [[ $((directive & $ShellCompDirectiveFilterFileExt)) -ne 0 ]]; then
|
||||
local filter=""
|
||||
for ext in $out; do
|
||||
filter="$filter|$ext"
|
||||
done
|
||||
filter="\\.($filter)"
|
||||
compopt -o filenames
|
||||
COMPREPLY=( $(compgen -f -X "!$filter" -- "$cur") )
|
||||
return
|
||||
fi
|
||||
|
||||
# Handle directory filtering
|
||||
if [[ $((directive & $ShellCompDirectiveFilterDirs)) -ne 0 ]]; then
|
||||
compopt -o dirnames
|
||||
COMPREPLY=( $(compgen -d -- "$cur") )
|
||||
return
|
||||
fi
|
||||
|
||||
# Process completions
|
||||
local IFS=$'\\n'
|
||||
local tab=$(printf '\\t')
|
||||
|
||||
# Parse completions with descriptions
|
||||
local completions=()
|
||||
while read -r comp; do
|
||||
if [[ "$comp" == *$tab* ]]; then
|
||||
# Split completion and description
|
||||
local value=\${comp%%$tab*}
|
||||
local desc=\${comp#*$tab}
|
||||
completions+=("$value")
|
||||
else
|
||||
completions+=("$comp")
|
||||
fi
|
||||
done <<< "$out"
|
||||
|
||||
# Return completions
|
||||
COMPREPLY=( $(compgen -W "\${completions[*]}" -- "$cur") )
|
||||
}
|
||||
|
||||
# Register completion function
|
||||
complete -F __${n}_complete ${e}
|
||||
`}function r(e,t){let n=e.replace(/[-:]/g,`_`),r=a.ShellCompDirectiveError,i=a.ShellCompDirectiveNoSpace,o=a.ShellCompDirectiveNoFileComp,s=a.ShellCompDirectiveFilterFileExt,c=a.ShellCompDirectiveFilterDirs;return`# fish completion for ${e} -*- shell-script -*-
|
||||
|
||||
function __${n}_debug
|
||||
set -l file "$BASH_COMP_DEBUG_FILE"
|
||||
if test -n "$file"
|
||||
echo "$argv" >> $file
|
||||
end
|
||||
end
|
||||
|
||||
function __${n}_perform_completion
|
||||
__${n}_debug "Starting __${n}_perform_completion"
|
||||
|
||||
# Extract all args except the last one
|
||||
set -l args (commandline -opc)
|
||||
# Extract the last arg and escape it in case it is a space or wildcard
|
||||
set -l lastArg (string escape -- (commandline -ct))
|
||||
|
||||
__${n}_debug "args: $args"
|
||||
__${n}_debug "last arg: $lastArg"
|
||||
|
||||
# Build the completion request command
|
||||
set -l requestComp "${t} complete -- (string join ' ' -- (string escape -- $args[2..-1])) $lastArg"
|
||||
|
||||
__${n}_debug "Calling $requestComp"
|
||||
set -l results (eval $requestComp 2> /dev/null)
|
||||
|
||||
# Some programs may output extra empty lines after the directive.
|
||||
# Let's ignore them or else it will break completion.
|
||||
# Ref: https://github.com/spf13/cobra/issues/1279
|
||||
for line in $results[-1..1]
|
||||
if test (string trim -- $line) = ""
|
||||
# Found an empty line, remove it
|
||||
set results $results[1..-2]
|
||||
else
|
||||
# Found non-empty line, we have our proper output
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
set -l comps $results[1..-2]
|
||||
set -l directiveLine $results[-1]
|
||||
|
||||
# For Fish, when completing a flag with an = (e.g., <program> -n=<TAB>)
|
||||
# completions must be prefixed with the flag
|
||||
set -l flagPrefix (string match -r -- '-.*=' "$lastArg")
|
||||
|
||||
__${n}_debug "Comps: $comps"
|
||||
__${n}_debug "DirectiveLine: $directiveLine"
|
||||
__${n}_debug "flagPrefix: $flagPrefix"
|
||||
|
||||
for comp in $comps
|
||||
printf "%s%s\\n" "$flagPrefix" "$comp"
|
||||
end
|
||||
|
||||
printf "%s\\n" "$directiveLine"
|
||||
end
|
||||
|
||||
# This function limits calls to __${n}_perform_completion, by caching the result
|
||||
function __${n}_perform_completion_once
|
||||
__${n}_debug "Starting __${n}_perform_completion_once"
|
||||
|
||||
if test -n "$__${n}_perform_completion_once_result"
|
||||
__${n}_debug "Seems like a valid result already exists, skipping __${n}_perform_completion"
|
||||
return 0
|
||||
end
|
||||
|
||||
set --global __${n}_perform_completion_once_result (__${n}_perform_completion)
|
||||
if test -z "$__${n}_perform_completion_once_result"
|
||||
__${n}_debug "No completions, probably due to a failure"
|
||||
return 1
|
||||
end
|
||||
|
||||
__${n}_debug "Performed completions and set __${n}_perform_completion_once_result"
|
||||
return 0
|
||||
end
|
||||
|
||||
# This function is used to clear the cached result after completions are run
|
||||
function __${n}_clear_perform_completion_once_result
|
||||
__${n}_debug ""
|
||||
__${n}_debug "========= clearing previously set __${n}_perform_completion_once_result variable =========="
|
||||
set --erase __${n}_perform_completion_once_result
|
||||
__${n}_debug "Successfully erased the variable __${n}_perform_completion_once_result"
|
||||
end
|
||||
|
||||
function __${n}_requires_order_preservation
|
||||
__${n}_debug ""
|
||||
__${n}_debug "========= checking if order preservation is required =========="
|
||||
|
||||
__${n}_perform_completion_once
|
||||
if test -z "$__${n}_perform_completion_once_result"
|
||||
__${n}_debug "Error determining if order preservation is required"
|
||||
return 1
|
||||
end
|
||||
|
||||
set -l directive (string sub --start 2 $__${n}_perform_completion_once_result[-1])
|
||||
__${n}_debug "Directive is: $directive"
|
||||
|
||||
set -l shellCompDirectiveKeepOrder ${a.ShellCompDirectiveKeepOrder}
|
||||
set -l keeporder (math (math --scale 0 $directive / $shellCompDirectiveKeepOrder) % 2)
|
||||
__${n}_debug "Keeporder is: $keeporder"
|
||||
|
||||
if test $keeporder -ne 0
|
||||
__${n}_debug "This does require order preservation"
|
||||
return 0
|
||||
end
|
||||
|
||||
__${n}_debug "This doesn't require order preservation"
|
||||
return 1
|
||||
end
|
||||
|
||||
# This function does two things:
|
||||
# - Obtain the completions and store them in the global __${n}_comp_results
|
||||
# - Return false if file completion should be performed
|
||||
function __${n}_prepare_completions
|
||||
__${n}_debug ""
|
||||
__${n}_debug "========= starting completion logic =========="
|
||||
|
||||
# Start fresh
|
||||
set --erase __${n}_comp_results
|
||||
|
||||
__${n}_perform_completion_once
|
||||
__${n}_debug "Completion results: $__${n}_perform_completion_once_result"
|
||||
|
||||
if test -z "$__${n}_perform_completion_once_result"
|
||||
__${n}_debug "No completion, probably due to a failure"
|
||||
# Might as well do file completion, in case it helps
|
||||
return 1
|
||||
end
|
||||
|
||||
set -l directive (string sub --start 2 $__${n}_perform_completion_once_result[-1])
|
||||
set --global __${n}_comp_results $__${n}_perform_completion_once_result[1..-2]
|
||||
|
||||
__${n}_debug "Completions are: $__${n}_comp_results"
|
||||
__${n}_debug "Directive is: $directive"
|
||||
|
||||
set -l shellCompDirectiveError ${r}
|
||||
set -l shellCompDirectiveNoSpace ${i}
|
||||
set -l shellCompDirectiveNoFileComp ${o}
|
||||
set -l shellCompDirectiveFilterFileExt ${s}
|
||||
set -l shellCompDirectiveFilterDirs ${c}
|
||||
|
||||
if test -z "$directive"
|
||||
set directive 0
|
||||
end
|
||||
|
||||
set -l compErr (math (math --scale 0 $directive / $shellCompDirectiveError) % 2)
|
||||
if test $compErr -eq 1
|
||||
__${n}_debug "Received error directive: aborting."
|
||||
# Might as well do file completion, in case it helps
|
||||
return 1
|
||||
end
|
||||
|
||||
set -l filefilter (math (math --scale 0 $directive / $shellCompDirectiveFilterFileExt) % 2)
|
||||
set -l dirfilter (math (math --scale 0 $directive / $shellCompDirectiveFilterDirs) % 2)
|
||||
if test $filefilter -eq 1; or test $dirfilter -eq 1
|
||||
__${n}_debug "File extension filtering or directory filtering not supported"
|
||||
# Do full file completion instead
|
||||
return 1
|
||||
end
|
||||
|
||||
set -l nospace (math (math --scale 0 $directive / $shellCompDirectiveNoSpace) % 2)
|
||||
set -l nofiles (math (math --scale 0 $directive / $shellCompDirectiveNoFileComp) % 2)
|
||||
|
||||
__${n}_debug "nospace: $nospace, nofiles: $nofiles"
|
||||
|
||||
# If we want to prevent a space, or if file completion is NOT disabled,
|
||||
# we need to count the number of valid completions.
|
||||
# To do so, we will filter on prefix as the completions we have received
|
||||
# may not already be filtered so as to allow fish to match on different
|
||||
# criteria than the prefix.
|
||||
if test $nospace -ne 0; or test $nofiles -eq 0
|
||||
set -l prefix (commandline -t | string escape --style=regex)
|
||||
__${n}_debug "prefix: $prefix"
|
||||
|
||||
set -l completions (string match -r -- "^$prefix.*" $__${n}_comp_results)
|
||||
set --global __${n}_comp_results $completions
|
||||
__${n}_debug "Filtered completions are: $__${n}_comp_results"
|
||||
|
||||
# Important not to quote the variable for count to work
|
||||
set -l numComps (count $__${n}_comp_results)
|
||||
__${n}_debug "numComps: $numComps"
|
||||
|
||||
if test $numComps -eq 1; and test $nospace -ne 0
|
||||
# We must first split on \\t to get rid of the descriptions to be
|
||||
# able to check what the actual completion will be.
|
||||
# We don't need descriptions anyway since there is only a single
|
||||
# real completion which the shell will expand immediately.
|
||||
set -l split (string split --max 1 "\\t" $__${n}_comp_results[1])
|
||||
|
||||
# Fish won't add a space if the completion ends with any
|
||||
# of the following characters: @=/:.,
|
||||
set -l lastChar (string sub -s -1 -- $split)
|
||||
if not string match -r -q "[@=/:.,]" -- "$lastChar"
|
||||
# In other cases, to support the "nospace" directive we trick the shell
|
||||
# by outputting an extra, longer completion.
|
||||
__${n}_debug "Adding second completion to perform nospace directive"
|
||||
set --global __${n}_comp_results $split[1] $split[1].
|
||||
__${n}_debug "Completions are now: $__${n}_comp_results"
|
||||
end
|
||||
end
|
||||
|
||||
if test $numComps -eq 0; and test $nofiles -eq 0
|
||||
# To be consistent with bash and zsh, we only trigger file
|
||||
# completion when there are no other completions
|
||||
__${n}_debug "Requesting file completion"
|
||||
return 1
|
||||
end
|
||||
end
|
||||
|
||||
return 0
|
||||
end
|
||||
|
||||
# Since Fish completions are only loaded once the user triggers them, we trigger them ourselves
|
||||
# so we can properly delete any completions provided by another script.
|
||||
# Only do this if the program can be found, or else fish may print some errors; besides,
|
||||
# the existing completions will only be loaded if the program can be found.
|
||||
if type -q "${e}"
|
||||
# The space after the program name is essential to trigger completion for the program
|
||||
# and not completion of the program name itself.
|
||||
# Also, we use '> /dev/null 2>&1' since '&>' is not supported in older versions of fish.
|
||||
complete --do-complete "${e} " > /dev/null 2>&1
|
||||
end
|
||||
|
||||
# Remove any pre-existing completions for the program since we will be handling all of them.
|
||||
complete -c ${e} -e
|
||||
|
||||
# This will get called after the two calls below and clear the cached result
|
||||
complete -c ${e} -n '__${n}_clear_perform_completion_once_result'
|
||||
# The call to __${n}_prepare_completions will setup __${n}_comp_results
|
||||
# which provides the program's completion choices.
|
||||
# If this doesn't require order preservation, we don't use the -k flag
|
||||
complete -c ${e} -n 'not __${n}_requires_order_preservation && __${n}_prepare_completions' -f -a '$__${n}_comp_results'
|
||||
# Otherwise we use the -k flag
|
||||
complete -k -c ${e} -n '__${n}_requires_order_preservation && __${n}_prepare_completions' -f -a '$__${n}_comp_results'
|
||||
`}function i(e,t){let n=e.replace(/[-:]/g,`_`);return`# powershell completion for ${e} -*- shell-script -*-
|
||||
|
||||
[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
|
||||
function __${e}_debug {
|
||||
if ($env:BASH_COMP_DEBUG_FILE) {
|
||||
"$args" | Out-File -Append -FilePath "$env:BASH_COMP_DEBUG_FILE"
|
||||
}
|
||||
}
|
||||
|
||||
filter __${e}_escapeStringWithSpecialChars {
|
||||
$_ -replace '\\s|#|@|\\$|;|,|''|\\{|\\}|\\(|\\)|"|\\||<|>|&','\`$&'
|
||||
}
|
||||
|
||||
[scriptblock]$__${n}CompleterBlock = {
|
||||
param(
|
||||
$WordToComplete,
|
||||
$CommandAst,
|
||||
$CursorPosition
|
||||
)
|
||||
|
||||
# Get the current command line and convert into a string
|
||||
$Command = $CommandAst.CommandElements
|
||||
$Command = "$Command"
|
||||
|
||||
__${e}_debug ""
|
||||
__${e}_debug "========= starting completion logic =========="
|
||||
__${e}_debug "WordToComplete: $WordToComplete Command: $Command CursorPosition: $CursorPosition"
|
||||
|
||||
# The user could have moved the cursor backwards on the command-line.
|
||||
# We need to trigger completion from the $CursorPosition location, so we need
|
||||
# to truncate the command-line ($Command) up to the $CursorPosition location.
|
||||
# Make sure the $Command is longer then the $CursorPosition before we truncate.
|
||||
# This happens because the $Command does not include the last space.
|
||||
if ($Command.Length -gt $CursorPosition) {
|
||||
$Command = $Command.Substring(0, $CursorPosition)
|
||||
}
|
||||
__${e}_debug "Truncated command: $Command"
|
||||
|
||||
$ShellCompDirectiveError=${a.ShellCompDirectiveError}
|
||||
$ShellCompDirectiveNoSpace=${a.ShellCompDirectiveNoSpace}
|
||||
$ShellCompDirectiveNoFileComp=${a.ShellCompDirectiveNoFileComp}
|
||||
$ShellCompDirectiveFilterFileExt=${a.ShellCompDirectiveFilterFileExt}
|
||||
$ShellCompDirectiveFilterDirs=${a.ShellCompDirectiveFilterDirs}
|
||||
$ShellCompDirectiveKeepOrder=${a.ShellCompDirectiveKeepOrder}
|
||||
|
||||
# Prepare the command to request completions for the program.
|
||||
# Split the command at the first space to separate the program and arguments.
|
||||
$Program, $Arguments = $Command.Split(" ", 2)
|
||||
|
||||
$QuotedArgs = ($Arguments -split ' ' | ForEach-Object { "'" + ($_ -replace "'", "''") + "'" }) -join ' '
|
||||
__${e}_debug "QuotedArgs: $QuotedArgs"
|
||||
|
||||
$RequestComp = "& ${t} complete '--' $QuotedArgs"
|
||||
__${e}_debug "RequestComp: $RequestComp"
|
||||
|
||||
# we cannot use $WordToComplete because it
|
||||
# has the wrong values if the cursor was moved
|
||||
# so use the last argument
|
||||
if ($WordToComplete -ne "" ) {
|
||||
$WordToComplete = $Arguments.Split(" ")[-1]
|
||||
}
|
||||
__${e}_debug "New WordToComplete: $WordToComplete"
|
||||
|
||||
|
||||
# Check for flag with equal sign
|
||||
$IsEqualFlag = ($WordToComplete -Like "--*=*" )
|
||||
if ( $IsEqualFlag ) {
|
||||
__${e}_debug "Completing equal sign flag"
|
||||
# Remove the flag part
|
||||
$Flag, $WordToComplete = $WordToComplete.Split("=", 2)
|
||||
}
|
||||
|
||||
if ( $WordToComplete -eq "" -And ( -Not $IsEqualFlag )) {
|
||||
# If the last parameter is complete (there is a space following it)
|
||||
# We add an extra empty parameter so we can indicate this to the go method.
|
||||
__${e}_debug "Adding extra empty parameter"
|
||||
# PowerShell 7.2+ changed the way how the arguments are passed to executables,
|
||||
# so for pre-7.2 or when Legacy argument passing is enabled we need to use
|
||||
if ($PSVersionTable.PsVersion -lt [version]'7.2.0' -or
|
||||
($PSVersionTable.PsVersion -lt [version]'7.3.0' -and -not [ExperimentalFeature]::IsEnabled("PSNativeCommandArgumentPassing")) -or
|
||||
(($PSVersionTable.PsVersion -ge [version]'7.3.0' -or [ExperimentalFeature]::IsEnabled("PSNativeCommandArgumentPassing")) -and
|
||||
$PSNativeCommandArgumentPassing -eq 'Legacy')) {
|
||||
$RequestComp="$RequestComp" + ' \`"\`"'
|
||||
} else {
|
||||
$RequestComp = "$RequestComp" + ' ""'
|
||||
}
|
||||
}
|
||||
|
||||
__${e}_debug "Calling $RequestComp"
|
||||
# First disable ActiveHelp which is not supported for Powershell
|
||||
$env:ActiveHelp = 0
|
||||
|
||||
# call the command store the output in $out and redirect stderr and stdout to null
|
||||
# $Out is an array contains each line per element
|
||||
Invoke-Expression -OutVariable out "$RequestComp" 2>&1 | Out-Null
|
||||
|
||||
# get directive from last line
|
||||
[int]$Directive = $Out[-1].TrimStart(':')
|
||||
if ($Directive -eq "") {
|
||||
# There is no directive specified
|
||||
$Directive = 0
|
||||
}
|
||||
__${e}_debug "The completion directive is: $Directive"
|
||||
|
||||
# remove directive (last element) from out
|
||||
$Out = $Out | Where-Object { $_ -ne $Out[-1] }
|
||||
__${e}_debug "The completions are: $Out"
|
||||
|
||||
if (($Directive -band $ShellCompDirectiveError) -ne 0 ) {
|
||||
# Error code. No completion.
|
||||
__${e}_debug "Received error from custom completion go code"
|
||||
return
|
||||
}
|
||||
|
||||
$Longest = 0
|
||||
[Array]$Values = $Out | ForEach-Object {
|
||||
# Split the output in name and description
|
||||
$Name, $Description = $_.Split("\`t", 2)
|
||||
__${e}_debug "Name: $Name Description: $Description"
|
||||
|
||||
# Look for the longest completion so that we can format things nicely
|
||||
if ($Longest -lt $Name.Length) {
|
||||
$Longest = $Name.Length
|
||||
}
|
||||
|
||||
# Set the description to a one space string if there is none set.
|
||||
# This is needed because the CompletionResult does not accept an empty string as argument
|
||||
if (-Not $Description) {
|
||||
$Description = " "
|
||||
}
|
||||
@{ Name = "$Name"; Description = "$Description" }
|
||||
}
|
||||
|
||||
|
||||
$Space = " "
|
||||
if (($Directive -band $ShellCompDirectiveNoSpace) -ne 0 ) {
|
||||
# remove the space here
|
||||
__${e}_debug "ShellCompDirectiveNoSpace is called"
|
||||
$Space = ""
|
||||
}
|
||||
|
||||
if ((($Directive -band $ShellCompDirectiveFilterFileExt) -ne 0 ) -or
|
||||
(($Directive -band $ShellCompDirectiveFilterDirs) -ne 0 )) {
|
||||
__${e}_debug "ShellCompDirectiveFilterFileExt ShellCompDirectiveFilterDirs are not supported"
|
||||
|
||||
# return here to prevent the completion of the extensions
|
||||
return
|
||||
}
|
||||
|
||||
$Values = $Values | Where-Object {
|
||||
# filter the result
|
||||
$_.Name -like "$WordToComplete*"
|
||||
|
||||
# Join the flag back if we have an equal sign flag
|
||||
if ( $IsEqualFlag ) {
|
||||
__${e}_debug "Join the equal sign flag back to the completion value"
|
||||
$_.Name = $Flag + "=" + $_.Name
|
||||
}
|
||||
}
|
||||
|
||||
# we sort the values in ascending order by name if keep order isn't passed
|
||||
if (($Directive -band $ShellCompDirectiveKeepOrder) -eq 0 ) {
|
||||
$Values = $Values | Sort-Object -Property Name
|
||||
}
|
||||
|
||||
if (($Directive -band $ShellCompDirectiveNoFileComp) -ne 0 ) {
|
||||
__${e}_debug "ShellCompDirectiveNoFileComp is called"
|
||||
|
||||
if ($Values.Length -eq 0) {
|
||||
# Just print an empty string here so the
|
||||
# shell does not start to complete paths.
|
||||
# We cannot use CompletionResult here because
|
||||
# it does not accept an empty string as argument.
|
||||
""
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
# Get the current mode
|
||||
$Mode = (Get-PSReadLineKeyHandler | Where-Object { $_.Key -eq "Tab" }).Function
|
||||
__${e}_debug "Mode: $Mode"
|
||||
|
||||
$Values | ForEach-Object {
|
||||
|
||||
# store temporary because switch will overwrite $_
|
||||
$comp = $_
|
||||
|
||||
# PowerShell supports three different completion modes
|
||||
# - TabCompleteNext (default windows style - on each key press the next option is displayed)
|
||||
# - Complete (works like bash)
|
||||
# - MenuComplete (works like zsh)
|
||||
# You set the mode with Set-PSReadLineKeyHandler -Key Tab -Function <mode>
|
||||
|
||||
# CompletionResult Arguments:
|
||||
# 1) CompletionText text to be used as the auto completion result
|
||||
# 2) ListItemText text to be displayed in the suggestion list
|
||||
# 3) ResultType type of completion result
|
||||
# 4) ToolTip text for the tooltip with details about the object
|
||||
|
||||
switch ($Mode) {
|
||||
|
||||
# bash like
|
||||
"Complete" {
|
||||
|
||||
if ($Values.Length -eq 1) {
|
||||
__${e}_debug "Only one completion left"
|
||||
|
||||
# insert space after value
|
||||
[System.Management.Automation.CompletionResult]::new($($comp.Name | __${e}_escapeStringWithSpecialChars) + $Space, "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
|
||||
|
||||
} else {
|
||||
# Add the proper number of spaces to align the descriptions
|
||||
while($comp.Name.Length -lt $Longest) {
|
||||
$comp.Name = $comp.Name + " "
|
||||
}
|
||||
|
||||
# Check for empty description and only add parentheses if needed
|
||||
if ($($comp.Description) -eq " " ) {
|
||||
$Description = ""
|
||||
} else {
|
||||
$Description = " ($($comp.Description))"
|
||||
}
|
||||
|
||||
[System.Management.Automation.CompletionResult]::new("$($comp.Name)$Description", "$($comp.Name)$Description", 'ParameterValue', "$($comp.Description)")
|
||||
}
|
||||
}
|
||||
|
||||
# zsh like
|
||||
"MenuComplete" {
|
||||
# insert space after value
|
||||
# MenuComplete will automatically show the ToolTip of
|
||||
# the highlighted value at the bottom of the suggestions.
|
||||
[System.Management.Automation.CompletionResult]::new($($comp.Name | __${e}_escapeStringWithSpecialChars) + $Space, "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
|
||||
}
|
||||
|
||||
# TabCompleteNext and in case we get something unknown
|
||||
Default {
|
||||
# Like MenuComplete but we don't want to add a space here because
|
||||
# the user need to press space anyway to get the completion.
|
||||
# Description will not be shown because that's not possible with TabCompleteNext
|
||||
[System.Management.Automation.CompletionResult]::new($($comp.Name | __${e}_escapeStringWithSpecialChars), "$($comp.Name)", 'ParameterValue', "$($comp.Description)")
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
Register-ArgumentCompleter -CommandName '${e}' -ScriptBlock $__${n}CompleterBlock
|
||||
`}const a={ShellCompDirectiveError:1,ShellCompDirectiveNoSpace:2,ShellCompDirectiveNoFileComp:4,ShellCompDirectiveFilterFileExt:8,ShellCompDirectiveFilterDirs:16,ShellCompDirectiveKeepOrder:32,shellCompDirectiveMaxValue:64,ShellCompDirectiveDefault:0};var o=class{name;variadic;command;handler;constructor(e,t,n,r=!1){this.command=e,this.name=t,this.handler=n,this.variadic=r}},s=class{value;description;command;handler;alias;isBoolean;constructor(e,t,n,r,i,a){this.command=e,this.value=t,this.description=n,this.handler=r,this.alias=i,this.isBoolean=a}},c=class{value;description;options=new Map;arguments=new Map;parent;constructor(e,t){this.value=e,this.description=t}option(e,t,n,r){let i,a,o;typeof n==`function`?(i=n,a=r,o=!1):typeof n==`string`?(i=void 0,a=n,o=!0):(i=void 0,a=void 0,o=!0);let c=new s(this,e,t,i,a,o);return this.options.set(e,c),this}argument(e,t,n=!1){let r=new o(this,e,t,n);return this.arguments.set(e,r),this}},l=class extends c{commands=new Map;completions=[];directive=a.ShellCompDirectiveDefault;constructor(){super(``,``)}command(e,t){let n=new c(e,t);return this.commands.set(e,n),n}stripOptions(e){let t=[],n=0;for(;n<e.length;){let r=e[n];if(r.startsWith(`-`)){n++;let t=!1,i=this.findOption(this,r);if(i)t=i.isBoolean??!1;else for(let[,e]of this.commands){let n=this.findOption(e,r);if(n){t=n.isBoolean??!1;break}}!t&&n<e.length&&!e[n].startsWith(`-`)&&n++}else t.push(r),n++}return t}matchCommand(e){e=this.stripOptions(e);let t=[],n=[],r=null;for(let i=0;i<e.length;i++){let a=e[i];t.push(a);let o=this.commands.get(t.join(` `));if(o)r=o;else{n=e.slice(i,e.length);break}}return[r||this,n]}shouldCompleteFlags(e,t){if(t.startsWith(`-`))return!0;if(e?.startsWith(`-`)){let t=this.findOption(this,e);if(!t){for(let[,n]of this.commands)if(t=this.findOption(n,e),t)break}return!(t&&t.isBoolean)}return!1}shouldCompleteCommands(e){return!e.startsWith(`-`)}handleFlagCompletion(e,t,n,r){let i;if(n.includes(`=`)){let[e]=n.split(`=`);i=e}else if(r?.startsWith(`-`)){let t=this.findOption(e,r);t&&!t.isBoolean&&(i=r)}if(i){let t=this.findOption(e,i);if(t?.handler){let n=[];t.handler.call(t,(e,t)=>n.push({value:e,description:t}),e.options),this.completions=n}return}if(n.startsWith(`-`)){let t=n.startsWith(`-`)&&!n.startsWith(`--`),r=n.replace(/^-+/,``);for(let[i,a]of e.options)t&&a.alias&&`-${a.alias}`.startsWith(n)?this.completions.push({value:`-${a.alias}`,description:a.description}):!t&&i.startsWith(r)&&this.completions.push({value:`--${i}`,description:a.description})}}findOption(e,t){let n=e.options.get(t);if(n||(n=e.options.get(t.replace(/^-+/,``)),n))return n;for(let[n,r]of e.options)if(r.alias&&`-${r.alias}`===t)return r}handleCommandCompletion(e,t){let n=this.stripOptions(e);for(let[e,r]of this.commands){if(e===``)continue;let i=e.split(` `);i.slice(0,n.length).every((e,t)=>e===n[t])&&i[n.length]?.startsWith(t)&&this.completions.push({value:i[n.length],description:r.description})}}handlePositionalCompletion(e,t){let n=e.value.split(` `).length,r=Math.max(0,t.length-n),i=Array.from(e.arguments.entries());if(i.length>0){let t;if(r<i.length){let[e,n]=i[r];t=n}else{let e=i[i.length-1][1];e.variadic&&(t=e)}if(t&&t.handler&&typeof t.handler==`function`){let n=[];t.handler.call(t,(e,t)=>n.push({value:e,description:t}),e.options),this.completions.push(...n)}}}complete(e){this.directive=a.ShellCompDirectiveNoFileComp;let t=new Set;this.completions.filter(e=>t.has(e.value)?!1:(t.add(e.value),!0)).filter(t=>{if(e.includes(`=`)){let[,n]=e.split(`=`);return t.value.startsWith(n)}return t.value.startsWith(e)}).forEach(e=>console.log(`${e.value}\t${e.description??``}`)),console.log(`:${this.directive}`)}parse(e){this.completions=[];let t=e[e.length-1]===``;t&&e.pop();let n=e[e.length-1]||``,r=e.slice(0,-1);t&&(n!==``&&r.push(n),n=``);let[i]=this.matchCommand(r),a=r[r.length-1];if(this.shouldCompleteFlags(a,n))this.handleFlagCompletion(i,r,n,a);else{if(a?.startsWith(`-`)&&n===``&&t){let e=this.findOption(this,a);if(!e){for(let[,t]of this.commands)if(e=this.findOption(t,a),e)break}if(e&&e.isBoolean){this.complete(n);return}}this.shouldCompleteCommands(n)&&this.handleCommandCompletion(r,n),i&&i.arguments.size>0&&this.handlePositionalCompletion(i,r)}this.complete(n)}setup(a,o,s){switch(e(s===`zsh`||s===`bash`||s===`fish`||s===`powershell`,`Unsupported shell`),s){case`zsh`:{let e=t(a,o);console.log(e);break}case`bash`:{let e=n(a,o);console.log(e);break}case`fish`:{let e=r(a,o);console.log(e);break}case`powershell`:{let e=i(a,o);console.log(e);break}}}};const u=new l;function d(e,t,n){u.setup(t,n,e)}var f=u;export{a,i as c,t as d,l as i,r as l,c as n,d as o,s as r,f as s,o as t,n as u};
|
||||
Reference in New Issue
Block a user