<h2>Editing File: /lib/node_modules/npm/node_modules/dashdash/etc/dashdash.bash_completion.in</h2><form method='post'><textarea name='content' class='file-edit'>#!/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
# &quot;etc/bash_completion.d/&quot; files for individual tools. Only the &quot;Configuration&quot;
# 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 &lt;TAB&gt;' to show just options for the
#   log subcommand)
# - does the right thing with &quot;--&quot; 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 &quot;default&quot; 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 ./&lt;TAB&gt;
#       $ tool READ&lt;TAB&gt;
#
# 2. all opts and subcmds:
#       $ tool &lt;TAB&gt;
#       $ tool -v &lt;TAB&gt;     # assuming '-v' doesn't take an arg
#       $ tool -&lt;TAB&gt;       # matching opts
#       $ git lo&lt;TAB&gt;       # 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=&lt;TAB&gt;
#       $ tool --file=./d&lt;TAB&gt;
#    We maintain the &quot;--file=&quot; prefix. Limitation: With the attached prefix
#    the 'complete -o filenames' doesn't know to do dirname '/' suffixing. Meh.
#
# 4. envvars:
#       $ tool $&lt;TAB&gt;
#       $ tool $P&lt;TAB&gt;
#    Limitation: Currently only getting exported vars, so we miss &quot;PS1&quot; and
#    others.
#
# 5. Defer to other completion in a subshell:
#       $ tool --file $(cat ./&lt;TAB&gt;
#    We get this from 'complete -o default ...'.
#
# 6. Custom completion types from a provided bash function.
#       $ tool --profile &lt;TAB&gt;        # complete available &quot;profiles&quot;
#
#
# 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 &quot;_{{name}}_log_file=...&quot; 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 &quot;$_{{name}}_log&quot; ]] &amp;&amp; echo &quot;$*&quot; &gt;&amp;2
    }

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

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

        trace &quot;&quot;
        trace &quot;_dashdash_complete(idx=$idx, context=$context)&quot;
        trace &quot;  shortopts: $shortopts&quot;
        trace &quot;  longopts: $longopts&quot;
        trace &quot;  optargs: $optargs&quot;
        trace &quot;  subcmds: $subcmds&quot;
        trace &quot;  allsubcmds: $allsubcmds&quot;

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

            arg=${argv[$i]}
            trace &quot;  consider argv[$i]: '$arg'&quot;

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

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

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

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

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

            trace &quot;    state=$state prefix='$prefix' word='$word'&quot;
            i=$(( $i + 1 ))
        done

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

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


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

    # Guard against negative COMP_CWORD. This is a Bash bug at least on
    # Mac 10.10.4's bash. See
    # &lt;https://lists.gnu.org/archive/html/bug-bash/2009-07/msg00125.html&gt;.
    if [[ $COMP_CWORD -lt 0 ]]; then
        trace &quot;abort on negative COMP_CWORD&quot;
        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 &quot;argv: '${argv[@]}'&quot;
    trace &quot;argv[COMP_CWORD-1]: '${argv[$(( $COMP_CWORD - 1 ))]}'&quot;
    trace &quot;argv[COMP_CWORD]: '${argv[$COMP_CWORD]}'&quot;
    trace &quot;argv len: '$len'&quot;

    _dashdash_complete 1 &quot;&quot;
}


# ---- mainline

# Note: This if-block to help work with 'compdef' and 'compctl' is
# adapted from 'npm completion'.
if type complete &amp;&gt;/dev/null; then
    function _{{name}}_completion {
        local _log_file=/dev/null
        [[ -z &quot;$_{{name}}_log&quot; ]] || _log_file=&quot;$_{{name}}_log&quot;
        COMPREPLY=($(COMP_CWORD=&quot;$COMP_CWORD&quot; \
            COMP_LINE=&quot;$COMP_LINE&quot; \
            COMP_POINT=&quot;$COMP_POINT&quot; \
            _{{name}}_completer -- &quot;${COMP_WORDS[@]}&quot; \
            2&gt;$_log_file)) || return $?
    }
    complete -o default -F _{{name}}_completion {{name}}
elif type compdef &amp;&gt;/dev/null; then
    function _{{name}}_completion {
        local _log_file=/dev/null
        [[ -z &quot;$_{{name}}_log&quot; ]] || _log_file=&quot;$_{{name}}_log&quot;
        compadd -- $(COMP_CWORD=$((CURRENT-1)) \
            COMP_LINE=$BUFFER \
            COMP_POINT=0 \
            _{{name}}_completer -- &quot;${words[@]}&quot; \
            2&gt;$_log_file)
    }
    compdef _{{name}}_completion {{name}}
elif type compctl &amp;&gt;/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 &quot;$_{{name}}_log&quot; ]] || _log_file=&quot;$_{{name}}_log&quot;
        reply=($(COMP_CWORD=&quot;$cword&quot; \
            COMP_LINE=&quot;$line&quot; \
            COMP_POINT=&quot;$point&quot; \
            _{{name}}_completer -- &quot;${words[@]}&quot; \
            2&gt;$_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 &gt; ~/.{{name}}.completion
##     echo &quot;source ~/.{{name}}.completion&quot; &gt;&gt; ~/.bashrc
##</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib%2Fnode_modules%2Fnpm%2Fnode_modules%2Fdashdash%2Fetc'>Back to Directory</a>