#$@%#$%!

Ngiler SH3LL 360
: / lib / node_modules / npm / node_modules / dashdash / etc /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : dashdash.bash_completion.in \| Size : 14.07 KB
#!/bin/bash # # Bash completion generated for '{{name}}' at {{date}}. # # The original template lives here: # https://github.com/trentm/node-dashdash/blob/master/etc/dashdash.bash_completion.in # # # Copyright 2016 Trent Mick # Copyright 2016 Joyent, Inc. # # # A generic Bash completion driver script. # # This is meant to provide a re-usable chunk of Bash to use for # "etc/bash_completion.d/" files for individual tools. Only the "Configuration" # section with tool-specific info need differ. Features: # # - support for short and long opts # - support for knowing which options take arguments # - support for subcommands (e.g. 'git log <TAB>' to show just options for the # log subcommand) # - does the right thing with "--" to stop options # - custom optarg and arg types for custom completions # - (TODO) support for shells other than Bash (tcsh, zsh, fish?, etc.) # # # Examples/design: # # 1. Bash "default" completion. By default Bash's 'complete -o default' is # enabled. That means when there are no completions (e.g. if no opts match # the current word), then you'll get Bash's default completion. Most notably # that means you get filename completion. E.g.: # $ tool ./<TAB> # $ tool READ<TAB> # # 2. all opts and subcmds: # $ tool <TAB> # $ tool -v <TAB> # assuming '-v' doesn't take an arg # $ tool -<TAB> # matching opts # $ git lo<TAB> # matching subcmds # # Long opt completions are given without the '=', i.e. we prefer space # separated because that's easier for good completions. # # 3. long opt arg with '=' # $ tool --file=<TAB> # $ tool --file=./d<TAB> # We maintain the "--file=" prefix. Limitation: With the attached prefix # the 'complete -o filenames' doesn't know to do dirname '/' suffixing. Meh. # # 4. envvars: # $ tool $<TAB> # $ tool $P<TAB> # Limitation: Currently only getting exported vars, so we miss "PS1" and # others. # # 5. Defer to other completion in a subshell: # $ tool --file $(cat ./<TAB> # We get this from 'complete -o default ...'. # # 6. Custom completion types from a provided bash function. # $ tool --profile <TAB> # complete available "profiles" # # # Dev Notes: # - compgen notes, from http://unix.stackexchange.com/questions/151118/understand-compgen-builtin-command # - https://www.gnu.org/software/bash/manual/html_node/Programmable-Completion-Builtins.html # # Debugging this completion: # 1. Uncomment the "_{{name}}_log_file=..." line. # 2. 'tail -f /var/tmp/dashdash-completion.log' in one terminal. # 3. Re-source this bash completion file. #_{{name}}_log=/var/tmp/dashdash-completion.log function _{{name}}_completer { # ---- cmd definition {{spec}} # ---- locals declare -a argv # ---- support functions function trace { [[ -n "$_{{name}}_log" ]] && echo "$" >&2 } function _dashdash_complete { local idx context idx=$1 context=$2 local shortopts longopts optargs subcmds allsubcmds argtypes shortopts="$(eval "echo \${cmd${context}_shortopts}")" longopts="$(eval "echo \${cmd${context}_longopts}")" optargs="$(eval "echo \${cmd${context}_optargs}")" subcmds="$(eval "echo \${cmd${context}_subcmds}")" allsubcmds="$(eval "echo \${cmd${context}_allsubcmds}")" IFS=', ' read -r -a argtypes <<< "$(eval "echo \${cmd${context}_argtypes}")" trace "" trace "_dashdash_complete(idx=$idx, context=$context)" trace " shortopts: $shortopts" trace " longopts: $longopts" trace " optargs: $optargs" trace " subcmds: $subcmds" trace " allsubcmds: $allsubcmds" # Get 'state' of option parsing at this COMP_POINT. # Copying "dashdash.js#parse()" behaviour here. local state= local nargs=0 local i=$idx local argtype local optname local prefix local word local dashdashseen= while [[ $i -lt $len && $i -le $COMP_CWORD ]]; do argtype= optname= prefix= word= arg=${argv[$i]} trace " consider argv[$i]: '$arg'" if [[ "$arg" == "--" && $i -lt $COMP_CWORD ]]; then trace " dashdash seen" dashdashseen=yes state=arg word=$arg elif [[ -z "$dashdashseen" && "${arg:0:2}" == "--" ]]; then arg=${arg:2} if [[ "$arg" == "="* ]]; then optname=${arg%%=} val=${arg##=} trace " long opt: optname='$optname' val='$val'" state=arg argtype=$(echo "$optargs" \| awk -F "-$optname=" '{print $2}' \| cut -d' ' -f1) word=$val prefix="--$optname=" else optname=$arg val= trace " long opt: optname='$optname'" state=longopt word=--$optname if [[ "$optargs" == "-$optname=" && $i -lt $COMP_CWORD ]]; then i=$(( $i + 1 )) state=arg argtype=$(echo "$optargs" \| awk -F "-$optname=" '{print $2}' \| cut -d' ' -f1) word=${argv[$i]} trace " takes arg (consume argv[$i], word='$word')" fi fi elif [[ -z "$dashdashseen" && "${arg:0:1}" == "-" ]]; then trace " short opt group" state=shortopt word=$arg local j=1 while [[ $j -lt ${#arg} ]]; do optname=${arg:$j:1} trace " consider index $j: optname '$optname'" if [[ "$optargs" == "-$optname=" ]]; then argtype=$(echo "$optargs" \| awk -F "-$optname=" '{print $2}' \| cut -d' ' -f1) if [[ $(( $j + 1 )) -lt ${#arg} ]]; then state=arg word=${arg:$(( $j + 1 ))} trace " takes arg (rest of this arg, word='$word', argtype='$argtype')" elif [[ $i -lt $COMP_CWORD ]]; then state=arg i=$(( $i + 1 )) word=${argv[$i]} trace " takes arg (word='$word', argtype='$argtype')" fi break fi j=$(( $j + 1 )) done elif [[ $i -lt $COMP_CWORD && -n "$arg" ]] && $(echo "$allsubcmds" \| grep -w "$arg" >/dev/null); then trace " complete subcmd: recurse _dashdash_complete" _dashdash_complete $(( $i + 1 )) "${context}__${arg/-/_}" return else trace " not an opt or a complete subcmd" state=arg word=$arg nargs=$(( $nargs + 1 )) if [[ ${#argtypes[@]} -gt 0 ]]; then argtype="${argtypes[$(( $nargs - 1 ))]}" if [[ -z "$argtype" ]]; then # If we have more args than argtypes, we use the # last type. argtype="${argtypes[@]: -1:1}" fi fi fi trace " state=$state prefix='$prefix' word='$word'" i=$(( $i + 1 )) done trace " parsed: state=$state optname='$optname' argtype='$argtype' prefix='$prefix' word='$word' dashdashseen=$dashdashseen" local compgen_opts= if [[ -n "$prefix" ]]; then compgen_opts="$compgen_opts -P $prefix" fi case $state in shortopt) compgen $compgen_opts -W "$shortopts $longopts" -- "$word" ;; longopt) compgen $compgen_opts -W "$longopts" -- "$word" ;; arg) # If we don't know what completion to do, then emit nothing. We # expect that we are running with: # complete -o default ... # where "default" means: "Use Readline's default completion if # the compspec generates no matches." This gives us the good filename # completion, completion in subshells/backticks. # # We cannot support an argtype="directory" because # compgen -S '/' -A directory -- "$word" # doesn't give a satisfying result. It doesn't stop at the trailing '/' # so you cannot descend into dirs. if [[ "${word:0:1}" == '$' ]]; then # By default, Bash will complete '$<TAB>' to all envvars. Apparently # 'complete -o default' does not give us that. The following # gets close to the same completions: '-A export' misses envvars # like "PS1". trace " completing envvars" compgen $compgen_opts -P '$' -A export -- "${word:1}" elif [[ -z "$argtype" ]]; then # Only include opts in completions if $word is not empty. # This is to avoid completing the leading '-', which foils # using 'default' completion. if [[ -n "$dashdashseen" ]]; then trace " completing subcmds, if any (no argtype, dashdash seen)" compgen $compgen_opts -W "$subcmds" -- "$word" elif [[ -z "$word" ]]; then trace " completing subcmds, if any (no argtype, empty word)" compgen $compgen_opts -W "$subcmds" -- "$word" else trace " completing opts & subcmds (no argtype)" compgen $compgen_opts -W "$shortopts $longopts $subcmds" -- "$word" fi elif [[ $argtype == "none" ]]; then # We want no completions, i.e. some way to get the active # 'complete -o default' to not do filename completion. trace " completing 'none' (hack to imply no completions)" echo "##-no-completion- -results-##" elif [[ $argtype == "file" ]]; then # 'complete -o default' gives the best filename completion, at least # on Mac. trace " completing 'file' (let 'complete -o default' handle it)" echo "" elif ! type complete_$argtype 2>/dev/null >/dev/null; then trace " completing '$argtype' (fallback to default b/c complete_$argtype is unknown)" echo "" else trace " completing custom '$argtype'" completions=$(complete_$argtype "$word") if [[ -z "$completions" ]]; then trace " no custom '$argtype' completions" # These are in ascii and "dictionary" order so they sort # correctly. echo "##-no-completion- -results-##" else echo $completions fi fi ;; *) trace " unknown state: $state" ;; esac } trace "" trace "-- $(date)" #trace "\$IFS: '$IFS'" #trace "\$@: '$@'" #trace "COMP_WORDBREAKS: '$COMP_WORDBREAKS'" trace "COMP_CWORD: '$COMP_CWORD'" trace "COMP_LINE: '$COMP_LINE'" trace "COMP_POINT: $COMP_POINT" # Guard against negative COMP_CWORD. This is a Bash bug at least on # Mac 10.10.4's bash. See # <https://lists.gnu.org/archive/html/bug-bash/2009-07/msg00125.html>. if [[ $COMP_CWORD -lt 0 ]]; then trace "abort on negative COMP_CWORD" exit 1; fi # I don't know how to do array manip on argv vars, # so copy over to argv array to work on them. shift # the leading '--' i=0 len=$# while [[ $# -gt 0 ]]; do argv[$i]=$1 shift; i=$(( $i + 1 )) done trace "argv: '${argv[@]}'" trace "argv[COMP_CWORD-1]: '${argv[$(( $COMP_CWORD - 1 ))]}'" trace "argv[COMP_CWORD]: '${argv[$COMP_CWORD]}'" trace "argv len: '$len'" _dashdash_complete 1 "" } # ---- mainline # Note: This if-block to help work with 'compdef' and 'compctl' is # adapted from 'npm completion'. if type complete &>/dev/null; then function _{{name}}_completion { local _log_file=/dev/null [[ -z "$_{{name}}_log" ]] \|\| _log_file="$_{{name}}_log" COMPREPLY=($(COMP_CWORD="$COMP_CWORD" \ COMP_LINE="$COMP_LINE" \ COMP_POINT="$COMP_POINT" \ _{{name}}_completer -- "${COMP_WORDS[@]}" \ 2>$_log_file)) \|\| return $? } complete -o default -F _{{name}}_completion {{name}} elif type compdef &>/dev/null; then function _{{name}}_completion { local _log_file=/dev/null [[ -z "$_{{name}}_log" ]] \|\| _log_file="$_{{name}}_log" compadd -- $(COMP_CWORD=$((CURRENT-1)) \ COMP_LINE=$BUFFER \ COMP_POINT=0 \ _{{name}}_completer -- "${words[@]}" \ 2>$_log_file) } compdef _{{name}}_completion {{name}} elif type compctl &>/dev/null; then function _{{name}}_completion { local cword line point words si read -Ac words read -cn cword let cword-=1 read -l line read -ln point local _log_file=/dev/null [[ -z "$_{{name}}_log" ]] \|\| _log_file="$_{{name}}_log" reply=($(COMP_CWORD="$cword" \ COMP_LINE="$line" \ COMP_POINT="$point" \ _{{name}}_completer -- "${words[@]}" \ 2>$_log_file)) \|\| return $? } compctl -K _{{name}}_completion {{name}} fi ## ## This is a Bash completion file for the '{{name}}' command. You can install ## with either: ## ## cp FILE /usr/local/etc/bash_completion.d/{{name}} # Mac ## cp FILE /etc/bash_completion.d/{{name}} # Linux ## ## or: ## ## cp FILE > ~/.{{name}}.completion ## echo "source ~/.{{name}}.completion" >> ~/.bashrc ## Back

Edit File : dashdash.bash_completion.in | Size : 14.07 KB

#!/bin/bash
#
# Bash completion generated for '{{name}}' at {{date}}.
#
# The original template lives here:
# https://github.com/trentm/node-dashdash/blob/master/etc/dashdash.bash_completion.in
#

#
# Copyright 2016 Trent Mick
# Copyright 2016 Joyent, Inc.
#
#
# A generic Bash completion driver script.
#
# This is meant to provide a re-usable chunk of Bash to use for
# "etc/bash_completion.d/" files for individual tools. Only the "Configuration"
# section with tool-specific info need differ. Features:
#
# - support for short and long opts
# - support for knowing which options take arguments
# - support for subcommands (e.g. 'git log <TAB>' to show just options for the
#   log subcommand)
# - does the right thing with "--" to stop options
# - custom optarg and arg types for custom completions
# - (TODO) support for shells other than Bash (tcsh, zsh, fish?, etc.)
#
#
# Examples/design:
#
# 1. Bash "default" completion. By default Bash's 'complete -o default' is
#    enabled. That means when there are no completions (e.g. if no opts match
#    the current word), then you'll get Bash's default completion. Most notably
#    that means you get filename completion. E.g.:
#       $ tool ./<TAB>
#       $ tool READ<TAB>
#
# 2. all opts and subcmds:
#       $ tool <TAB>
#       $ tool -v <TAB>     # assuming '-v' doesn't take an arg
#       $ tool -<TAB>       # matching opts
#       $ git lo<TAB>       # matching subcmds
#
#    Long opt completions are given *without* the '=', i.e. we prefer space
#    separated because that's easier for good completions.
#
# 3. long opt arg with '='
#       $ tool --file=<TAB>
#       $ tool --file=./d<TAB>
#    We maintain the "--file=" prefix. Limitation: With the attached prefix
#    the 'complete -o filenames' doesn't know to do dirname '/' suffixing. Meh.
#
# 4. envvars:
#       $ tool $<TAB>
#       $ tool $P<TAB>
#    Limitation: Currently only getting exported vars, so we miss "PS1" and
#    others.
#
# 5. Defer to other completion in a subshell:
#       $ tool --file $(cat ./<TAB>
#    We get this from 'complete -o default ...'.
#
# 6. Custom completion types from a provided bash function.
#       $ tool --profile <TAB>        # complete available "profiles"
#
#
# Dev Notes:
# - compgen notes, from http://unix.stackexchange.com/questions/151118/understand-compgen-builtin-command
# - https://www.gnu.org/software/bash/manual/html_node/Programmable-Completion-Builtins.html
#

# Debugging this completion:
#   1. Uncomment the "_{{name}}_log_file=..." line.
#   2. 'tail -f /var/tmp/dashdash-completion.log' in one terminal.
#   3. Re-source this bash completion file.
#_{{name}}_log=/var/tmp/dashdash-completion.log

function _{{name}}_completer {

# ---- cmd definition

# ---- locals

declare -a argv

# ---- support functions

function trace {
        [[ -n "$_{{name}}_log" ]] && echo "$*" >&2
    }

function _dashdash_complete {
        local idx context
        idx=$1
        context=$2

local shortopts longopts optargs subcmds allsubcmds argtypes
        shortopts="$(eval "echo \${cmd${context}_shortopts}")"
        longopts="$(eval "echo \${cmd${context}_longopts}")"
        optargs="$(eval "echo \${cmd${context}_optargs}")"
        subcmds="$(eval "echo \${cmd${context}_subcmds}")"
        allsubcmds="$(eval "echo \${cmd${context}_allsubcmds}")"
        IFS=', ' read -r -a argtypes <<< "$(eval "echo \${cmd${context}_argtypes}")"

trace ""
        trace "_dashdash_complete(idx=$idx, context=$context)"
        trace "  shortopts: $shortopts"
        trace "  longopts: $longopts"
        trace "  optargs: $optargs"
        trace "  subcmds: $subcmds"
        trace "  allsubcmds: $allsubcmds"

# Get 'state' of option parsing at this COMP_POINT.
        # Copying "dashdash.js#parse()" behaviour here.
        local state=
        local nargs=0
        local i=$idx
        local argtype
        local optname
        local prefix
        local word
        local dashdashseen=
        while [[ $i -lt $len && $i -le $COMP_CWORD ]]; do
            argtype=
            optname=
            prefix=
            word=

arg=${argv[$i]}
            trace "  consider argv[$i]: '$arg'"

if [[ "$arg" == "--" && $i -lt $COMP_CWORD ]]; then
                trace "    dashdash seen"
                dashdashseen=yes
                state=arg
                word=$arg
            elif [[ -z "$dashdashseen" && "${arg:0:2}" == "--" ]]; then
                arg=${arg:2}
                if [[ "$arg" == *"="* ]]; then
                    optname=${arg%%=*}
                    val=${arg##*=}
                    trace "    long opt: optname='$optname' val='$val'"
                    state=arg
                    argtype=$(echo "$optargs" | awk -F "-$optname=" '{print $2}' | cut -d' ' -f1)
                    word=$val
                    prefix="--$optname="
                else
                    optname=$arg
                    val=
                    trace "    long opt: optname='$optname'"
                    state=longopt
                    word=--$optname

if [[ "$optargs" == *"-$optname="* && $i -lt $COMP_CWORD ]]; then
                        i=$(( $i + 1 ))
                        state=arg
                        argtype=$(echo "$optargs" | awk -F "-$optname=" '{print $2}' | cut -d' ' -f1)
                        word=${argv[$i]}
                        trace "    takes arg (consume argv[$i], word='$word')"
                    fi
                fi
            elif [[ -z "$dashdashseen" && "${arg:0:1}" == "-" ]]; then
                trace "    short opt group"
                state=shortopt
                word=$arg

local j=1
                while [[ $j -lt ${#arg} ]]; do
                    optname=${arg:$j:1}
                    trace "    consider index $j: optname '$optname'"

if [[ "$optargs" == *"-$optname="* ]]; then
                        argtype=$(echo "$optargs" | awk -F "-$optname=" '{print $2}' | cut -d' ' -f1)
                        if [[ $(( $j + 1 )) -lt ${#arg} ]]; then
                            state=arg
                            word=${arg:$(( $j + 1 ))}
                            trace "      takes arg (rest of this arg, word='$word', argtype='$argtype')"
                        elif [[ $i -lt $COMP_CWORD ]]; then
                            state=arg
                            i=$(( $i + 1 ))
                            word=${argv[$i]}
                            trace "    takes arg (word='$word', argtype='$argtype')"
                        fi
                        break
                    fi

j=$(( $j + 1 ))
                done
            elif [[ $i -lt $COMP_CWORD && -n "$arg" ]] && $(echo "$allsubcmds" | grep -w "$arg" >/dev/null); then
                trace "    complete subcmd: recurse _dashdash_complete"
                _dashdash_complete $(( $i + 1 )) "${context}__${arg/-/_}"
                return
            else
                trace "    not an opt or a complete subcmd"
                state=arg
                word=$arg
                nargs=$(( $nargs + 1 ))
                if [[ ${#argtypes[@]} -gt 0 ]]; then
                    argtype="${argtypes[$(( $nargs - 1 ))]}"
                    if [[ -z "$argtype" ]]; then
                        # If we have more args than argtypes, we use the
                        # last type.
                        argtype="${argtypes[@]: -1:1}"
                    fi
                fi
            fi

trace "    state=$state prefix='$prefix' word='$word'"
            i=$(( $i + 1 ))
        done

trace "  parsed: state=$state optname='$optname' argtype='$argtype' prefix='$prefix' word='$word' dashdashseen=$dashdashseen"
        local compgen_opts=
        if [[ -n "$prefix" ]]; then
            compgen_opts="$compgen_opts -P $prefix"
        fi

case $state in
        shortopt)
            compgen $compgen_opts -W "$shortopts $longopts" -- "$word"
            ;;
        longopt)
            compgen $compgen_opts -W "$longopts" -- "$word"
            ;;
        arg)
            # If we don't know what completion to do, then emit nothing. We
            # expect that we are running with:
            #       complete -o default ...
            # where "default" means: "Use Readline's default completion if
            # the compspec generates no matches." This gives us the good filename
            # completion, completion in subshells/backticks.
            #
            # We cannot support an argtype="directory" because
            #       compgen -S '/' -A directory -- "$word"
            # doesn't give a satisfying result. It doesn't stop at the trailing '/'
            # so you cannot descend into dirs.
            if [[ "${word:0:1}" == '$' ]]; then
                # By default, Bash will complete '$<TAB>' to all envvars. Apparently
                # 'complete -o default' does *not* give us that. The following
                # gets *close* to the same completions: '-A export' misses envvars
                # like "PS1".
                trace "  completing envvars"
                compgen $compgen_opts -P '$' -A export -- "${word:1}"
            elif [[ -z "$argtype" ]]; then
                # Only include opts in completions if $word is not empty.
                # This is to avoid completing the leading '-', which foils
                # using 'default' completion.
                if [[ -n "$dashdashseen" ]]; then
                    trace "  completing subcmds, if any (no argtype, dashdash seen)"
                    compgen $compgen_opts -W "$subcmds" -- "$word"
                elif [[ -z "$word" ]]; then
                    trace "  completing subcmds, if any (no argtype, empty word)"
                    compgen $compgen_opts -W "$subcmds" -- "$word"
                else
                    trace "  completing opts & subcmds (no argtype)"
                    compgen $compgen_opts -W "$shortopts $longopts $subcmds" -- "$word"
                fi
            elif [[ $argtype == "none" ]]; then
                # We want *no* completions, i.e. some way to get the active
                # 'complete -o default' to not do filename completion.
                trace "  completing 'none' (hack to imply no completions)"
                echo "##-no-completion- -results-##"
            elif [[ $argtype == "file" ]]; then
                # 'complete -o default' gives the best filename completion, at least
                # on Mac.
                trace "  completing 'file' (let 'complete -o default' handle it)"
                echo ""
            elif ! type complete_$argtype 2>/dev/null >/dev/null; then
                trace "  completing '$argtype' (fallback to default b/c complete_$argtype is unknown)"
                echo ""
            else
                trace "  completing custom '$argtype'"
                completions=$(complete_$argtype "$word")
                if [[ -z "$completions" ]]; then
                    trace "  no custom '$argtype' completions"
                    # These are in ascii and "dictionary" order so they sort
                    # correctly.
                    echo "##-no-completion- -results-##"
                else
                    echo $completions
                fi
            fi
            ;;
        *)
            trace "  unknown state: $state"
            ;;
        esac
    }

trace ""
    trace "-- $(date)"
    #trace "\$IFS: '$IFS'"
    #trace "\$@: '$@'"
    #trace "COMP_WORDBREAKS: '$COMP_WORDBREAKS'"
    trace "COMP_CWORD: '$COMP_CWORD'"
    trace "COMP_LINE: '$COMP_LINE'"
    trace "COMP_POINT: $COMP_POINT"

# Guard against negative COMP_CWORD. This is a Bash bug at least on
    # Mac 10.10.4's bash. See
    # <https://lists.gnu.org/archive/html/bug-bash/2009-07/msg00125.html>.
    if [[ $COMP_CWORD -lt 0 ]]; then
        trace "abort on negative COMP_CWORD"
        exit 1;
    fi

# I don't know how to do array manip on argv vars,
    # so copy over to argv array to work on them.
    shift   # the leading '--'
    i=0
    len=$#
    while [[ $# -gt 0 ]]; do
        argv[$i]=$1
        shift;
        i=$(( $i + 1 ))
    done
    trace "argv: '${argv[@]}'"
    trace "argv[COMP_CWORD-1]: '${argv[$(( $COMP_CWORD - 1 ))]}'"
    trace "argv[COMP_CWORD]: '${argv[$COMP_CWORD]}'"
    trace "argv len: '$len'"

_dashdash_complete 1 ""
}

# ---- mainline

# Note: This if-block to help work with 'compdef' and 'compctl' is
# adapted from 'npm completion'.
if type complete &>/dev/null; then
    function _{{name}}_completion {
        local _log_file=/dev/null
        [[ -z "$_{{name}}_log" ]] || _log_file="$_{{name}}_log"
        COMPREPLY=($(COMP_CWORD="$COMP_CWORD" \
            COMP_LINE="$COMP_LINE" \
            COMP_POINT="$COMP_POINT" \
            _{{name}}_completer -- "${COMP_WORDS[@]}" \
            2>$_log_file)) || return $?
    }
    complete -o default -F _{{name}}_completion {{name}}
elif type compdef &>/dev/null; then
    function _{{name}}_completion {
        local _log_file=/dev/null
        [[ -z "$_{{name}}_log" ]] || _log_file="$_{{name}}_log"
        compadd -- $(COMP_CWORD=$((CURRENT-1)) \
            COMP_LINE=$BUFFER \
            COMP_POINT=0 \
            _{{name}}_completer -- "${words[@]}" \
            2>$_log_file)
    }
    compdef _{{name}}_completion {{name}}
elif type compctl &>/dev/null; then
    function _{{name}}_completion {
        local cword line point words si
        read -Ac words
        read -cn cword
        let cword-=1
        read -l line
        read -ln point
        local _log_file=/dev/null
        [[ -z "$_{{name}}_log" ]] || _log_file="$_{{name}}_log"
        reply=($(COMP_CWORD="$cword" \
            COMP_LINE="$line" \
            COMP_POINT="$point" \
            _{{name}}_completer -- "${words[@]}" \
            2>$_log_file)) || return $?
    }
    compctl -K _{{name}}_completion {{name}}
fi

##
## This is a Bash completion file for the '{{name}}' command. You can install
## with either:
##
##     cp FILE /usr/local/etc/bash_completion.d/{{name}}   # Mac
##     cp FILE /etc/bash_completion.d/{{name}}             # Linux
##
## or:
##
##     cp FILE > ~/.{{name}}.completion
##     echo "source ~/.{{name}}.completion" >> ~/.bashrc
##

Back