www.aleph1.co.uk Git - yaffs-website/blob - node_modules/dashdash/etc/dashdash.bash_completion.in

   1 #!/bin/bash
   2 #
   3 # Bash completion generated for '{{name}}' at {{date}}.
   4 #
   5 # The original template lives here:
   6 # https://github.com/trentm/node-dashdash/blob/master/etc/dashdash.bash_completion.in
   7 #
   8
   9 #
  10 # Copyright 2016 Trent Mick
  11 # Copyright 2016 Joyent, Inc.
  12 #
  13 #
  14 # A generic Bash completion driver script.
  15 #
  16 # This is meant to provide a re-usable chunk of Bash to use for
  17 # "etc/bash_completion.d/" files for individual tools. Only the "Configuration"
  18 # section with tool-specific info need differ. Features:
  19 #
  20 # - support for short and long opts
  21 # - support for knowing which options take arguments
  22 # - support for subcommands (e.g. 'git log <TAB>' to show just options for the
  23 #   log subcommand)
  24 # - does the right thing with "--" to stop options
  25 # - custom optarg and arg types for custom completions
  26 # - (TODO) support for shells other than Bash (tcsh, zsh, fish?, etc.)
  27 #
  28 #
  29 # Examples/design:
  30 #
  31 # 1. Bash "default" completion. By default Bash's 'complete -o default' is
  32 #    enabled. That means when there are no completions (e.g. if no opts match
  33 #    the current word), then you'll get Bash's default completion. Most notably
  34 #    that means you get filename completion. E.g.:
  35 #       $ tool ./<TAB>
  36 #       $ tool READ<TAB>
  37 #
  38 # 2. all opts and subcmds:
  39 #       $ tool <TAB>
  40 #       $ tool -v <TAB>     # assuming '-v' doesn't take an arg
  41 #       $ tool -<TAB>       # matching opts
  42 #       $ git lo<TAB>       # matching subcmds
  43 #
  44 #    Long opt completions are given *without* the '=', i.e. we prefer space
  45 #    separated because that's easier for good completions.
  46 #
  47 # 3. long opt arg with '='
  48 #       $ tool --file=<TAB>
  49 #       $ tool --file=./d<TAB>
  50 #    We maintain the "--file=" prefix. Limitation: With the attached prefix
  51 #    the 'complete -o filenames' doesn't know to do dirname '/' suffixing. Meh.
  52 #
  53 # 4. envvars:
  54 #       $ tool $<TAB>
  55 #       $ tool $P<TAB>
  56 #    Limitation: Currently only getting exported vars, so we miss "PS1" and
  57 #    others.
  58 #
  59 # 5. Defer to other completion in a subshell:
  60 #       $ tool --file $(cat ./<TAB>
  61 #    We get this from 'complete -o default ...'.
  62 #
  63 # 6. Custom completion types from a provided bash function.
  64 #       $ tool --profile <TAB>        # complete available "profiles"
  65 #
  66 #
  67 # Dev Notes:
  68 # - compgen notes, from http://unix.stackexchange.com/questions/151118/understand-compgen-builtin-command
  69 # - https://www.gnu.org/software/bash/manual/html_node/Programmable-Completion-Builtins.html
  70 #
  71
  72
  73 # Debugging this completion:
  74 #   1. Uncomment the "_{{name}}_log_file=..." line.
  75 #   2. 'tail -f /var/tmp/dashdash-completion.log' in one terminal.
  76 #   3. Re-source this bash completion file.
  77 #_{{name}}_log=/var/tmp/dashdash-completion.log
  78
  79 function _{{name}}_completer {
  80
  81     # ---- cmd definition
  82
  83     {{spec}}
  84
  85
  86     # ---- locals
  87
  88     declare -a argv
  89
  90
  91     # ---- support functions
  92
  93     function trace {
  94         [[ -n "$_{{name}}_log" ]] && echo "$*" >&2
  95     }
  96
  97     function _dashdash_complete {
  98         local idx context
  99         idx=$1
 100         context=$2
 101
 102         local shortopts longopts optargs subcmds allsubcmds argtypes
 103         shortopts="$(eval "echo \${cmd${context}_shortopts}")"
 104         longopts="$(eval "echo \${cmd${context}_longopts}")"
 105         optargs="$(eval "echo \${cmd${context}_optargs}")"
 106         subcmds="$(eval "echo \${cmd${context}_subcmds}")"
 107         allsubcmds="$(eval "echo \${cmd${context}_allsubcmds}")"
 108         IFS=', ' read -r -a argtypes <<< "$(eval "echo \${cmd${context}_argtypes}")"
 109
 110         trace ""
 111         trace "_dashdash_complete(idx=$idx, context=$context)"
 112         trace "  shortopts: $shortopts"
 113         trace "  longopts: $longopts"
 114         trace "  optargs: $optargs"
 115         trace "  subcmds: $subcmds"
 116         trace "  allsubcmds: $allsubcmds"
 117
 118         # Get 'state' of option parsing at this COMP_POINT.
 119         # Copying "dashdash.js#parse()" behaviour here.
 120         local state=
 121         local nargs=0
 122         local i=$idx
 123         local argtype
 124         local optname
 125         local prefix
 126         local word
 127         local dashdashseen=
 128         while [[ $i -lt $len && $i -le $COMP_CWORD ]]; do
 129             argtype=
 130             optname=
 131             prefix=
 132             word=
 133
 134             arg=${argv[$i]}
 135             trace "  consider argv[$i]: '$arg'"
 136
 137             if [[ "$arg" == "--" && $i -lt $COMP_CWORD ]]; then
 138                 trace "    dashdash seen"
 139                 dashdashseen=yes
 140                 state=arg
 141                 word=$arg
 142             elif [[ -z "$dashdashseen" && "${arg:0:2}" == "--" ]]; then
 143                 arg=${arg:2}
 144                 if [[ "$arg" == *"="* ]]; then
 145                     optname=${arg%%=*}
 146                     val=${arg##*=}
 147                     trace "    long opt: optname='$optname' val='$val'"
 148                     state=arg
 149                     argtype=$(echo "$optargs" | awk -F "-$optname=" '{print $2}' | cut -d' ' -f1)
 150                     word=$val
 151                     prefix="--$optname="
 152                 else
 153                     optname=$arg
 154                     val=
 155                     trace "    long opt: optname='$optname'"
 156                     state=longopt
 157                     word=--$optname
 158
 159                     if [[ "$optargs" == *"-$optname="* && $i -lt $COMP_CWORD ]]; then
 160                         i=$(( $i + 1 ))
 161                         state=arg
 162                         argtype=$(echo "$optargs" | awk -F "-$optname=" '{print $2}' | cut -d' ' -f1)
 163                         word=${argv[$i]}
 164                         trace "    takes arg (consume argv[$i], word='$word')"
 165                     fi
 166                 fi
 167             elif [[ -z "$dashdashseen" && "${arg:0:1}" == "-" ]]; then
 168                 trace "    short opt group"
 169                 state=shortopt
 170                 word=$arg
 171
 172                 local j=1
 173                 while [[ $j -lt ${#arg} ]]; do
 174                     optname=${arg:$j:1}
 175                     trace "    consider index $j: optname '$optname'"
 176
 177                     if [[ "$optargs" == *"-$optname="* ]]; then
 178                         argtype=$(echo "$optargs" | awk -F "-$optname=" '{print $2}' | cut -d' ' -f1)
 179                         if [[ $(( $j + 1 )) -lt ${#arg} ]]; then
 180                             state=arg
 181                             word=${arg:$(( $j + 1 ))}
 182                             trace "      takes arg (rest of this arg, word='$word', argtype='$argtype')"
 183                         elif [[ $i -lt $COMP_CWORD ]]; then
 184                             state=arg
 185                             i=$(( $i + 1 ))
 186                             word=${argv[$i]}
 187                             trace "    takes arg (word='$word', argtype='$argtype')"
 188                         fi
 189                         break
 190                     fi
 191
 192                     j=$(( $j + 1 ))
 193                 done
 194             elif [[ $i -lt $COMP_CWORD && -n "$arg" ]] && $(echo "$allsubcmds" | grep -w "$arg" >/dev/null); then
 195                 trace "    complete subcmd: recurse _dashdash_complete"
 196                 _dashdash_complete $(( $i + 1 )) "${context}__${arg/-/_}"
 197                 return
 198             else
 199                 trace "    not an opt or a complete subcmd"
 200                 state=arg
 201                 word=$arg
 202                 nargs=$(( $nargs + 1 ))
 203                 if [[ ${#argtypes[@]} -gt 0 ]]; then
 204                     argtype="${argtypes[$(( $nargs - 1 ))]}"
 205                     if [[ -z "$argtype" ]]; then
 206                         # If we have more args than argtypes, we use the
 207                         # last type.
 208                         argtype="${argtypes[@]: -1:1}"
 209                     fi
 210                 fi
 211             fi
 212
 213             trace "    state=$state prefix='$prefix' word='$word'"
 214             i=$(( $i + 1 ))
 215         done
 216
 217         trace "  parsed: state=$state optname='$optname' argtype='$argtype' prefix='$prefix' word='$word' dashdashseen=$dashdashseen"
 218         local compgen_opts=
 219         if [[ -n "$prefix" ]]; then
 220             compgen_opts="$compgen_opts -P $prefix"
 221         fi
 222
 223         case $state in
 224         shortopt)
 225             compgen $compgen_opts -W "$shortopts $longopts" -- "$word"
 226             ;;
 227         longopt)
 228             compgen $compgen_opts -W "$longopts" -- "$word"
 229             ;;
 230         arg)
 231             # If we don't know what completion to do, then emit nothing. We
 232             # expect that we are running with:
 233             #       complete -o default ...
 234             # where "default" means: "Use Readline's default completion if
 235             # the compspec generates no matches." This gives us the good filename
 236             # completion, completion in subshells/backticks.
 237             #
 238             # We cannot support an argtype="directory" because
 239             #       compgen -S '/' -A directory -- "$word"
 240             # doesn't give a satisfying result. It doesn't stop at the trailing '/'
 241             # so you cannot descend into dirs.
 242             if [[ "${word:0:1}" == '$' ]]; then
 243                 # By default, Bash will complete '$<TAB>' to all envvars. Apparently
 244                 # 'complete -o default' does *not* give us that. The following
 245                 # gets *close* to the same completions: '-A export' misses envvars
 246                 # like "PS1".
 247                 trace "  completing envvars"
 248                 compgen $compgen_opts -P '$' -A export -- "${word:1}"
 249             elif [[ -z "$argtype" ]]; then
 250                 # Only include opts in completions if $word is not empty.
 251                 # This is to avoid completing the leading '-', which foils
 252                 # using 'default' completion.
 253                 if [[ -n "$dashdashseen" ]]; then
 254                     trace "  completing subcmds, if any (no argtype, dashdash seen)"
 255                     compgen $compgen_opts -W "$subcmds" -- "$word"
 256                 elif [[ -z "$word" ]]; then
 257                     trace "  completing subcmds, if any (no argtype, empty word)"
 258                     compgen $compgen_opts -W "$subcmds" -- "$word"
 259                 else
 260                     trace "  completing opts & subcmds (no argtype)"
 261                     compgen $compgen_opts -W "$shortopts $longopts $subcmds" -- "$word"
 262                 fi
 263             elif [[ $argtype == "none" ]]; then
 264                 # We want *no* completions, i.e. some way to get the active
 265                 # 'complete -o default' to not do filename completion.
 266                 trace "  completing 'none' (hack to imply no completions)"
 267                 echo "##-no-completion- -results-##"
 268             elif [[ $argtype == "file" ]]; then
 269                 # 'complete -o default' gives the best filename completion, at least
 270                 # on Mac.
 271                 trace "  completing 'file' (let 'complete -o default' handle it)"
 272                 echo ""
 273             elif ! type complete_$argtype 2>/dev/null >/dev/null; then
 274                 trace "  completing '$argtype' (fallback to default b/c complete_$argtype is unknown)"
 275                 echo ""
 276             else
 277                 trace "  completing custom '$argtype'"
 278                 completions=$(complete_$argtype "$word")
 279                 if [[ -z "$completions" ]]; then
 280                     trace "  no custom '$argtype' completions"
 281                     # These are in ascii and "dictionary" order so they sort
 282                     # correctly.
 283                     echo "##-no-completion- -results-##"
 284                 else
 285                     echo $completions
 286                 fi
 287             fi
 288             ;;
 289         *)
 290             trace "  unknown state: $state"
 291             ;;
 292         esac
 293     }
 294
 295
 296     trace ""
 297     trace "-- $(date)"
 298     #trace "\$IFS: '$IFS'"
 299     #trace "\$@: '$@'"
 300     #trace "COMP_WORDBREAKS: '$COMP_WORDBREAKS'"
 301     trace "COMP_CWORD: '$COMP_CWORD'"
 302     trace "COMP_LINE: '$COMP_LINE'"
 303     trace "COMP_POINT: $COMP_POINT"
 304
 305     # Guard against negative COMP_CWORD. This is a Bash bug at least on
 306     # Mac 10.10.4's bash. See
 307     # <https://lists.gnu.org/archive/html/bug-bash/2009-07/msg00125.html>.
 308     if [[ $COMP_CWORD -lt 0 ]]; then
 309         trace "abort on negative COMP_CWORD"
 310         exit 1;
 311     fi
 312
 313     # I don't know how to do array manip on argv vars,
 314     # so copy over to argv array to work on them.
 315     shift   # the leading '--'
 316     i=0
 317     len=$#
 318     while [[ $# -gt 0 ]]; do
 319         argv[$i]=$1
 320         shift;
 321         i=$(( $i + 1 ))
 322     done
 323     trace "argv: '${argv[@]}'"
 324     trace "argv[COMP_CWORD-1]: '${argv[$(( $COMP_CWORD - 1 ))]}'"
 325     trace "argv[COMP_CWORD]: '${argv[$COMP_CWORD]}'"
 326     trace "argv len: '$len'"
 327
 328     _dashdash_complete 1 ""
 329 }
 330
 331
 332 # ---- mainline
 333
 334 # Note: This if-block to help work with 'compdef' and 'compctl' is
 335 # adapted from 'npm completion'.
 336 if type complete &>/dev/null; then
 337     function _{{name}}_completion {
 338         local _log_file=/dev/null
 339         [[ -z "$_{{name}}_log" ]] || _log_file="$_{{name}}_log"
 340         COMPREPLY=($(COMP_CWORD="$COMP_CWORD" \
 341             COMP_LINE="$COMP_LINE" \
 342             COMP_POINT="$COMP_POINT" \
 343             _{{name}}_completer -- "${COMP_WORDS[@]}" \
 344             2>$_log_file)) || return $?
 345     }
 346     complete -o default -F _{{name}}_completion {{name}}
 347 elif type compdef &>/dev/null; then
 348     function _{{name}}_completion {
 349         local _log_file=/dev/null
 350         [[ -z "$_{{name}}_log" ]] || _log_file="$_{{name}}_log"
 351         compadd -- $(COMP_CWORD=$((CURRENT-1)) \
 352             COMP_LINE=$BUFFER \
 353             COMP_POINT=0 \
 354             _{{name}}_completer -- "${words[@]}" \
 355             2>$_log_file)
 356     }
 357     compdef _{{name}}_completion {{name}}
 358 elif type compctl &>/dev/null; then
 359     function _{{name}}_completion {
 360         local cword line point words si
 361         read -Ac words
 362         read -cn cword
 363         let cword-=1
 364         read -l line
 365         read -ln point
 366         local _log_file=/dev/null
 367         [[ -z "$_{{name}}_log" ]] || _log_file="$_{{name}}_log"
 368         reply=($(COMP_CWORD="$cword" \
 369             COMP_LINE="$line" \
 370             COMP_POINT="$point" \
 371             _{{name}}_completer -- "${words[@]}" \
 372             2>$_log_file)) || return $?
 373     }
 374     compctl -K _{{name}}_completion {{name}}
 375 fi
 376
 377
 378 ##
 379 ## This is a Bash completion file for the '{{name}}' command. You can install
 380 ## with either:
 381 ##
 382 ##     cp FILE /usr/local/etc/bash_completion.d/{{name}}   # Mac
 383 ##     cp FILE /etc/bash_completion.d/{{name}}             # Linux
 384 ##
 385 ## or:
 386 ##
 387 ##     cp FILE > ~/.{{name}}.completion
 388 ##     echo "source ~/.{{name}}.completion" >> ~/.bashrc
 389 ##