2017-07-30 11:42:35 +03:00
|
|
|
package cobra
|
|
|
|
|
|
|
|
import (
|
2020-06-29 22:52:14 +03:00
|
|
|
"bytes"
|
2017-07-30 11:42:35 +03:00
|
|
|
"fmt"
|
|
|
|
"io"
|
2017-09-05 19:32:32 +03:00
|
|
|
"os"
|
2018-03-23 13:09:56 +03:00
|
|
|
)
|
|
|
|
|
2020-06-29 22:52:14 +03:00
|
|
|
// GenZshCompletionFile generates zsh completion file including descriptions.
|
2017-09-05 20:20:51 +03:00
|
|
|
func (c *Command) GenZshCompletionFile(filename string) error {
|
2020-06-29 22:52:14 +03:00
|
|
|
return c.genZshCompletionFile(filename, true)
|
2017-09-05 19:32:32 +03:00
|
|
|
}
|
|
|
|
|
2020-06-29 22:52:14 +03:00
|
|
|
// GenZshCompletion generates zsh completion file including descriptions
|
|
|
|
// and writes it to the passed writer.
|
2017-09-05 20:20:51 +03:00
|
|
|
func (c *Command) GenZshCompletion(w io.Writer) error {
|
2020-06-29 22:52:14 +03:00
|
|
|
return c.genZshCompletion(w, true)
|
2018-03-23 13:09:56 +03:00
|
|
|
}
|
|
|
|
|
2020-06-29 22:52:14 +03:00
|
|
|
// GenZshCompletionFileNoDesc generates zsh completion file without descriptions.
|
|
|
|
func (c *Command) GenZshCompletionFileNoDesc(filename string) error {
|
|
|
|
return c.genZshCompletionFile(filename, false)
|
2018-03-23 13:09:56 +03:00
|
|
|
}
|
|
|
|
|
2020-06-29 22:52:14 +03:00
|
|
|
// GenZshCompletionNoDesc generates zsh completion file without descriptions
|
|
|
|
// and writes it to the passed writer.
|
|
|
|
func (c *Command) GenZshCompletionNoDesc(w io.Writer) error {
|
|
|
|
return c.genZshCompletion(w, false)
|
2018-03-23 13:09:56 +03:00
|
|
|
}
|
|
|
|
|
2020-06-29 22:52:14 +03:00
|
|
|
// MarkZshCompPositionalArgumentFile only worked for zsh and its behavior was
|
|
|
|
// not consistent with Bash completion. It has therefore been disabled.
|
|
|
|
// Instead, when no other completion is specified, file completion is done by
|
|
|
|
// default for every argument. One can disable file completion on a per-argument
|
|
|
|
// basis by using ValidArgsFunction and ShellCompDirectiveNoFileComp.
|
|
|
|
// To achieve file extension filtering, one can use ValidArgsFunction and
|
|
|
|
// ShellCompDirectiveFilterFileExt.
|
|
|
|
//
|
|
|
|
// Deprecated
|
|
|
|
func (c *Command) MarkZshCompPositionalArgumentFile(argPosition int, patterns ...string) error {
|
2018-03-23 13:09:56 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-06-29 22:52:14 +03:00
|
|
|
// MarkZshCompPositionalArgumentWords only worked for zsh. It has therefore
|
|
|
|
// been disabled.
|
|
|
|
// To achieve the same behavior across all shells, one can use
|
|
|
|
// ValidArgs (for the first argument only) or ValidArgsFunction for
|
|
|
|
// any argument (can include the first one also).
|
|
|
|
//
|
|
|
|
// Deprecated
|
|
|
|
func (c *Command) MarkZshCompPositionalArgumentWords(argPosition int, words ...string) error {
|
|
|
|
return nil
|
2018-02-28 18:04:17 +03:00
|
|
|
}
|
|
|
|
|
2020-06-29 22:52:14 +03:00
|
|
|
func (c *Command) genZshCompletionFile(filename string, includeDesc bool) error {
|
|
|
|
outFile, err := os.Create(filename)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2018-02-28 18:04:17 +03:00
|
|
|
}
|
2020-06-29 22:52:14 +03:00
|
|
|
defer outFile.Close()
|
2018-02-28 18:04:17 +03:00
|
|
|
|
2020-06-29 22:52:14 +03:00
|
|
|
return c.genZshCompletion(outFile, includeDesc)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Command) genZshCompletion(w io.Writer, includeDesc bool) error {
|
|
|
|
buf := new(bytes.Buffer)
|
|
|
|
genZshComp(buf, c.Name(), includeDesc)
|
|
|
|
_, err := buf.WriteTo(w)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-02-08 03:08:50 +03:00
|
|
|
func genZshComp(buf io.StringWriter, name string, includeDesc bool) {
|
2020-06-29 22:52:14 +03:00
|
|
|
compCmd := ShellCompRequestCmd
|
|
|
|
if !includeDesc {
|
|
|
|
compCmd = ShellCompNoDescRequestCmd
|
|
|
|
}
|
2022-06-05 22:45:59 +03:00
|
|
|
WriteStringAndCheck(buf, fmt.Sprintf(`#compdef %[1]s
|
2020-06-29 22:52:14 +03:00
|
|
|
|
|
|
|
# zsh completion for %-36[1]s -*- shell-script -*-
|
|
|
|
|
|
|
|
__%[1]s_debug()
|
|
|
|
{
|
|
|
|
local file="$BASH_COMP_DEBUG_FILE"
|
|
|
|
if [[ -n ${file} ]]; then
|
|
|
|
echo "$*" >> "${file}"
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
|
|
|
_%[1]s()
|
|
|
|
{
|
|
|
|
local shellCompDirectiveError=%[3]d
|
|
|
|
local shellCompDirectiveNoSpace=%[4]d
|
|
|
|
local shellCompDirectiveNoFileComp=%[5]d
|
|
|
|
local shellCompDirectiveFilterFileExt=%[6]d
|
|
|
|
local shellCompDirectiveFilterDirs=%[7]d
|
|
|
|
|
Fix zsh for DirectiveNoSpace and DirectiveNoFileComp (#1213)
Fixes #1211
When handling ShellCompDirectiveNoSpace we must still properly handle
descriptions. To do so we cannot simply use 'compadd', but must use
zsh's '_describe' function.
Also, when handling ShellCompDirectiveNoSpace we cannot assume that
only a single completion will be given to the script. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix. Therefore, we cannot use the
number of completions received in the completion script to determine
if we should activate the "no space" directive. Instead, we can leave
it all to the '_describe' function.
Fixes #1212
When handling ShellCompDirectiveNoFileComp we cannot base ourself on
the script receiving no valid completion. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix at all. Therefore, we cannot use
the number of completions received by the completion script to determine
if we should activate the "no file comp" directive. Instead, we can
check if the '_describe' function has found any completions.
Finally, it is important for the script to return the return code of the
called zsh functions (_describe, _arguments). This tells zsh if
completions were found or not, which if not, will trigger different
matching attempts, such as matching what the user typed with the the
content of possible completions (instead of just as the prefix).
Signed-off-by: Marc Khouzam <marc.khouzam@montreal.ca>
2021-05-03 19:54:00 +03:00
|
|
|
local lastParam lastChar flagPrefix requestComp out directive comp lastComp noSpace
|
2020-06-29 22:52:14 +03:00
|
|
|
local -a completions
|
|
|
|
|
|
|
|
__%[1]s_debug "\n========= starting completion logic =========="
|
|
|
|
__%[1]s_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]}")
|
|
|
|
__%[1]s_debug "Truncated words[*]: ${words[*]},"
|
|
|
|
|
|
|
|
lastParam=${words[-1]}
|
|
|
|
lastChar=${lastParam[-1]}
|
|
|
|
__%[1]s_debug "lastParam: ${lastParam}, lastChar: ${lastChar}"
|
|
|
|
|
|
|
|
# For zsh, when completing a flag with an = (e.g., %[1]s -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
|
|
|
|
requestComp="${words[1]} %[2]s ${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.
|
|
|
|
__%[1]s_debug "Adding extra empty parameter"
|
|
|
|
requestComp="${requestComp} \"\""
|
|
|
|
fi
|
|
|
|
|
|
|
|
__%[1]s_debug "About to call: eval ${requestComp}"
|
|
|
|
|
|
|
|
# Use eval to handle any environment variables and such
|
|
|
|
out=$(eval ${requestComp} 2>/dev/null)
|
|
|
|
__%[1]s_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[@]}")
|
|
|
|
__%[1]s_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.
|
|
|
|
__%[1]s_debug "No directive found. Setting do default"
|
|
|
|
directive=0
|
|
|
|
fi
|
|
|
|
|
|
|
|
__%[1]s_debug "directive: ${directive}"
|
|
|
|
__%[1]s_debug "completions: ${out}"
|
|
|
|
__%[1]s_debug "flagPrefix: ${flagPrefix}"
|
|
|
|
|
|
|
|
if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
|
|
|
|
__%[1]s_debug "Completion received error. Ignoring completions."
|
|
|
|
return
|
|
|
|
fi
|
|
|
|
|
2022-06-16 03:08:16 +03:00
|
|
|
local activeHelpMarker="%[8]s"
|
|
|
|
local endIndex=${#activeHelpMarker}
|
|
|
|
local startIndex=$((${#activeHelpMarker}+1))
|
|
|
|
local hasActiveHelp=0
|
2020-06-29 22:52:14 +03:00
|
|
|
while IFS='\n' read -r comp; do
|
2022-06-16 03:08:16 +03:00
|
|
|
# Check if this is an activeHelp statement (i.e., prefixed with $activeHelpMarker)
|
|
|
|
if [ "${comp[1,$endIndex]}" = "$activeHelpMarker" ];then
|
|
|
|
__%[1]s_debug "ActiveHelp found: $comp"
|
|
|
|
comp="${comp[$startIndex,-1]}"
|
|
|
|
if [ -n "$comp" ]; then
|
|
|
|
compadd -x "${comp}"
|
|
|
|
__%[1]s_debug "ActiveHelp will need delimiter"
|
|
|
|
hasActiveHelp=1
|
|
|
|
fi
|
|
|
|
|
|
|
|
continue
|
|
|
|
fi
|
|
|
|
|
2020-06-29 22:52:14 +03:00
|
|
|
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//:/\\:}
|
|
|
|
|
2022-04-14 07:30:27 +03:00
|
|
|
local tab="$(printf '\t')"
|
2020-06-29 22:52:14 +03:00
|
|
|
comp=${comp//$tab/:}
|
|
|
|
|
|
|
|
__%[1]s_debug "Adding completion: ${comp}"
|
|
|
|
completions+=${comp}
|
|
|
|
lastComp=$comp
|
|
|
|
fi
|
|
|
|
done < <(printf "%%s\n" "${out[@]}")
|
|
|
|
|
2022-06-16 03:08:16 +03:00
|
|
|
# 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
|
|
|
|
__%[1]s_debug "Adding activeHelp delimiter"
|
|
|
|
compadd -x "--"
|
|
|
|
hasActiveHelp=0
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
Fix zsh for DirectiveNoSpace and DirectiveNoFileComp (#1213)
Fixes #1211
When handling ShellCompDirectiveNoSpace we must still properly handle
descriptions. To do so we cannot simply use 'compadd', but must use
zsh's '_describe' function.
Also, when handling ShellCompDirectiveNoSpace we cannot assume that
only a single completion will be given to the script. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix. Therefore, we cannot use the
number of completions received in the completion script to determine
if we should activate the "no space" directive. Instead, we can leave
it all to the '_describe' function.
Fixes #1212
When handling ShellCompDirectiveNoFileComp we cannot base ourself on
the script receiving no valid completion. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix at all. Therefore, we cannot use
the number of completions received by the completion script to determine
if we should activate the "no file comp" directive. Instead, we can
check if the '_describe' function has found any completions.
Finally, it is important for the script to return the return code of the
called zsh functions (_describe, _arguments). This tells zsh if
completions were found or not, which if not, will trigger different
matching attempts, such as matching what the user typed with the the
content of possible completions (instead of just as the prefix).
Signed-off-by: Marc Khouzam <marc.khouzam@montreal.ca>
2021-05-03 19:54:00 +03:00
|
|
|
if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
|
|
|
|
__%[1]s_debug "Activating nospace."
|
|
|
|
noSpace="-S ''"
|
|
|
|
fi
|
|
|
|
|
2020-06-29 22:52:14 +03:00
|
|
|
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}"
|
|
|
|
|
|
|
|
__%[1]s_debug "File filtering command: $filteringCmd"
|
|
|
|
_arguments '*:filename:'"$filteringCmd"
|
|
|
|
elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then
|
|
|
|
# File completion for directories only
|
2021-12-08 01:53:38 +03:00
|
|
|
local subdir
|
2020-06-29 22:52:14 +03:00
|
|
|
subdir="${completions[1]}"
|
|
|
|
if [ -n "$subdir" ]; then
|
|
|
|
__%[1]s_debug "Listing directories in $subdir"
|
|
|
|
pushd "${subdir}" >/dev/null 2>&1
|
|
|
|
else
|
|
|
|
__%[1]s_debug "Listing directories in ."
|
|
|
|
fi
|
|
|
|
|
Fix zsh for DirectiveNoSpace and DirectiveNoFileComp (#1213)
Fixes #1211
When handling ShellCompDirectiveNoSpace we must still properly handle
descriptions. To do so we cannot simply use 'compadd', but must use
zsh's '_describe' function.
Also, when handling ShellCompDirectiveNoSpace we cannot assume that
only a single completion will be given to the script. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix. Therefore, we cannot use the
number of completions received in the completion script to determine
if we should activate the "no space" directive. Instead, we can leave
it all to the '_describe' function.
Fixes #1212
When handling ShellCompDirectiveNoFileComp we cannot base ourself on
the script receiving no valid completion. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix at all. Therefore, we cannot use
the number of completions received by the completion script to determine
if we should activate the "no file comp" directive. Instead, we can
check if the '_describe' function has found any completions.
Finally, it is important for the script to return the return code of the
called zsh functions (_describe, _arguments). This tells zsh if
completions were found or not, which if not, will trigger different
matching attempts, such as matching what the user typed with the the
content of possible completions (instead of just as the prefix).
Signed-off-by: Marc Khouzam <marc.khouzam@montreal.ca>
2021-05-03 19:54:00 +03:00
|
|
|
local result
|
2020-06-29 22:52:14 +03:00
|
|
|
_arguments '*:dirname:_files -/'" ${flagPrefix}"
|
Fix zsh for DirectiveNoSpace and DirectiveNoFileComp (#1213)
Fixes #1211
When handling ShellCompDirectiveNoSpace we must still properly handle
descriptions. To do so we cannot simply use 'compadd', but must use
zsh's '_describe' function.
Also, when handling ShellCompDirectiveNoSpace we cannot assume that
only a single completion will be given to the script. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix. Therefore, we cannot use the
number of completions received in the completion script to determine
if we should activate the "no space" directive. Instead, we can leave
it all to the '_describe' function.
Fixes #1212
When handling ShellCompDirectiveNoFileComp we cannot base ourself on
the script receiving no valid completion. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix at all. Therefore, we cannot use
the number of completions received by the completion script to determine
if we should activate the "no file comp" directive. Instead, we can
check if the '_describe' function has found any completions.
Finally, it is important for the script to return the return code of the
called zsh functions (_describe, _arguments). This tells zsh if
completions were found or not, which if not, will trigger different
matching attempts, such as matching what the user typed with the the
content of possible completions (instead of just as the prefix).
Signed-off-by: Marc Khouzam <marc.khouzam@montreal.ca>
2021-05-03 19:54:00 +03:00
|
|
|
result=$?
|
2020-06-29 22:52:14 +03:00
|
|
|
if [ -n "$subdir" ]; then
|
|
|
|
popd >/dev/null 2>&1
|
|
|
|
fi
|
Fix zsh for DirectiveNoSpace and DirectiveNoFileComp (#1213)
Fixes #1211
When handling ShellCompDirectiveNoSpace we must still properly handle
descriptions. To do so we cannot simply use 'compadd', but must use
zsh's '_describe' function.
Also, when handling ShellCompDirectiveNoSpace we cannot assume that
only a single completion will be given to the script. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix. Therefore, we cannot use the
number of completions received in the completion script to determine
if we should activate the "no space" directive. Instead, we can leave
it all to the '_describe' function.
Fixes #1212
When handling ShellCompDirectiveNoFileComp we cannot base ourself on
the script receiving no valid completion. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix at all. Therefore, we cannot use
the number of completions received by the completion script to determine
if we should activate the "no file comp" directive. Instead, we can
check if the '_describe' function has found any completions.
Finally, it is important for the script to return the return code of the
called zsh functions (_describe, _arguments). This tells zsh if
completions were found or not, which if not, will trigger different
matching attempts, such as matching what the user typed with the the
content of possible completions (instead of just as the prefix).
Signed-off-by: Marc Khouzam <marc.khouzam@montreal.ca>
2021-05-03 19:54:00 +03:00
|
|
|
return $result
|
|
|
|
else
|
|
|
|
__%[1]s_debug "Calling _describe"
|
|
|
|
if eval _describe "completions" completions $flagPrefix $noSpace; then
|
|
|
|
__%[1]s_debug "_describe found some completions"
|
|
|
|
|
|
|
|
# Return the success of having called _describe
|
|
|
|
return 0
|
2020-06-29 22:52:14 +03:00
|
|
|
else
|
Fix zsh for DirectiveNoSpace and DirectiveNoFileComp (#1213)
Fixes #1211
When handling ShellCompDirectiveNoSpace we must still properly handle
descriptions. To do so we cannot simply use 'compadd', but must use
zsh's '_describe' function.
Also, when handling ShellCompDirectiveNoSpace we cannot assume that
only a single completion will be given to the script. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix. Therefore, we cannot use the
number of completions received in the completion script to determine
if we should activate the "no space" directive. Instead, we can leave
it all to the '_describe' function.
Fixes #1212
When handling ShellCompDirectiveNoFileComp we cannot base ourself on
the script receiving no valid completion. In fact,
ValidArgsFunction can return multiple completions, even if they don't
match the 'toComplete' argument prefix at all. Therefore, we cannot use
the number of completions received by the completion script to determine
if we should activate the "no file comp" directive. Instead, we can
check if the '_describe' function has found any completions.
Finally, it is important for the script to return the return code of the
called zsh functions (_describe, _arguments). This tells zsh if
completions were found or not, which if not, will trigger different
matching attempts, such as matching what the user typed with the the
content of possible completions (instead of just as the prefix).
Signed-off-by: Marc Khouzam <marc.khouzam@montreal.ca>
2021-05-03 19:54:00 +03:00
|
|
|
__%[1]s_debug "_describe did not find completions."
|
|
|
|
__%[1]s_debug "Checking if we should do file completion."
|
|
|
|
if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
|
|
|
|
__%[1]s_debug "deactivating file completion"
|
|
|
|
|
|
|
|
# We must return an error code here to let zsh know that there were no
|
|
|
|
# completions found by _describe; this is what will trigger other
|
|
|
|
# matching algorithms to attempt to find completions.
|
|
|
|
# For example zsh can match letters in the middle of words.
|
|
|
|
return 1
|
|
|
|
else
|
|
|
|
# Perform file completion
|
|
|
|
__%[1]s_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
|
2020-06-29 22:52:14 +03:00
|
|
|
fi
|
|
|
|
fi
|
|
|
|
}
|
2020-10-04 04:25:07 +03:00
|
|
|
|
|
|
|
# don't run the completion function when being source-ed or eval-ed
|
|
|
|
if [ "$funcstack[1]" = "_%[1]s" ]; then
|
2021-12-08 01:57:57 +03:00
|
|
|
_%[1]s
|
2020-10-04 04:25:07 +03:00
|
|
|
fi
|
2020-06-29 22:52:14 +03:00
|
|
|
`, name, compCmd,
|
|
|
|
ShellCompDirectiveError, ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp,
|
2022-06-16 03:08:16 +03:00
|
|
|
ShellCompDirectiveFilterFileExt, ShellCompDirectiveFilterDirs,
|
|
|
|
activeHelpMarker))
|
2018-03-17 21:55:27 +03:00
|
|
|
}
|