From: Jannik Zander Date: Sun, 1 May 2016 07:28:41 +0000 (+0200) Subject: Add bash files X-Git-Url: https://git.zndr.dk/?a=commitdiff_plain;h=62c788ef2c18a6ebc6885fd8283ff2d424151338;p=dotfiles.git Add bash files --- diff --git a/.bash/aliases b/.bash/aliases new file mode 100644 index 0000000..d2600d3 --- /dev/null +++ b/.bash/aliases @@ -0,0 +1,110 @@ +# Easier navigation: .., ..., ...., ....., ~ and - +alias ..="cd .." +alias ...="cd ../.." +alias ....="cd ../../.." +alias .....="cd ../../../.." +alias ~="cd ~" # `cd` is probably faster to type though +alias -- -="cd -" +alias cd=cd_func +alias -- --="cd --" +alias -- -0="cd -0" +alias -- -1="cd -1" +alias -- -2="cd -2" +alias -- -3="cd -3" +alias -- -4="cd -4" +alias -- -5="cd -5" +alias -- -6="cd -6" +alias -- -7="cd -7" +alias -- -8="cd -8" +alias -- -9="cd -9" +# alias ++ pushd +# alias -- popd + +# Secure settings +alias rm='rm -i' +alias cp='cp -i' +alias mv='mv -i' + + +alias info='info --vi-keys' +#alias less='less -rX' # raw control characters, don't clear the screen after quitting +alias whence='type -a' # where, of a sort +alias grep='grep --color' # show differences in color +alias egrep='egrep --color=auto' # show differences in color +alias fgrep='fgrep --color=auto' # show differences in color + +# Shortcuts +alias d="cd ~/Documents" +alias dl="cd ~/Downloads" +alias dt="cd ~/Desktop" +alias w="cd ~/work" +alias g="git" +alias h="history" +alias j="jobs" + + +LS_COMMON="-hF" +#LS_COMMON="$LS_COMMON -I NTUSER.\* -I ntuser.\*" + +# Detect which `ls` flavor is in use +if whence dircolors > /dev/null 2>&1; then # GNU `ls` + eval $(dircolors -b $HOME/.bash/dircolors) + colorflag="--color" +else # OS X `ls` + #eval $(gdircolors $HOME/.bash/dircolors) + export CLICOLOR=1 + colorflag="-G" +fi + +# Always list colorized +LS_COMMON="$LS_COMMON $colorflag" +alias ls="command ls $LS_COMMON" + +# List all files excl. dotfiles +alias l="ls" + +# List all files in long format excl. dotfiles +alias ll="ls -l" + +# List all files in long format, incl. dotfiles +alias la="ls -la" + +# List only directories +alias lsd="ls -l | grep --color=never '^d'" + +# List only dotfiles +alias l.="ls -d .*" + +# Enable aliases to be sudo'ed +alias sudo='sudo ' + +# Get week number +alias week='date +%V' + +# Stopwatch +alias timer='echo "Timer started. Stop with Ctrl-D." && date && time cat && date' + +# Intuitive map function +# For example, to list all directories that contain a certain file: +# find . -name .gitattributes | map dirname +alias map="xargs -n1" + +for method in GET HEAD POST PUT DELETE TRACE OPTIONS; do + alias "$method"="lwp-request -m '$method'" +done + +# Reload the shell (i.e. invoke as a login shell) +alias reload="exec $SHELL -l" + +# Update dotfiles +alias pull.='pushd ~/.dotfiles && git pull && stow -vR * && popd' +alias push.='pushd ~/.dotfiles && git commit -a && git push && popd' + +# alias bashhere='chere -il -t mintty -s bash' +alias newterm='mintty /bin/env CHERE_INVOKING=1 /bin/bash -l &' +alias gtypist='gtypist -wi' +alias startxwin='run /usr/bin/bash.exe -l -c "/usr/bin/startxwin -- -nolock -unixkill"' +alias sumatra='startSumatra.sh' +alias lynx='lynx -use_mouse' +alias startvnc='vncserver -geometry 1870x980 -depth 24' +alias startvnc4='vnc4server -geometry 1870x980 -depth 24' diff --git a/.bash/bash_completion b/.bash/bash_completion new file mode 100644 index 0000000..5441277 --- /dev/null +++ b/.bash/bash_completion @@ -0,0 +1,1690 @@ +# +# bash_completion - programmable completion functions for bash 3.2+ +# +# Copyright © 2006-2008, Ian Macdonald +# © 2009-2011, Bash Completion Maintainers +# +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The latest version of this software can be obtained here: +# +# http://bash-completion.alioth.debian.org/ +# +# RELEASE: 1.3 + +if [[ $- == *v* ]]; then + BASH_COMPLETION_ORIGINAL_V_VALUE="-v" +else + BASH_COMPLETION_ORIGINAL_V_VALUE="+v" +fi + +if [[ -n $BASH_COMPLETION_DEBUG ]]; then + set -v +else + set +v +fi + +# Alter the following to reflect the location of this file. +# +[ -n "$BASH_COMPLETION" ] || BASH_COMPLETION=$HOME/.bash/bash_completion +[ -n "$BASH_COMPLETION_DIR" ] || BASH_COMPLETION_DIR=$HOME/.bash/bash_completion.d +[ -n "$BASH_COMPLETION_COMPAT_DIR" ] || BASH_COMPLETION_COMPAT_DIR=$HOME/.bash/bash_completion.d +readonly BASH_COMPLETION BASH_COMPLETION_DIR BASH_COMPLETION_COMPAT_DIR + +# Set a couple of useful vars +# +UNAME=$( uname -s ) +# strip OS type and version under Cygwin (e.g. CYGWIN_NT-5.1 => Cygwin) +UNAME=${UNAME/CYGWIN_*/Cygwin} + +case ${UNAME} in + Linux|GNU|GNU/*) USERLAND=GNU ;; + *) USERLAND=${UNAME} ;; +esac + +# Turn on extended globbing and programmable completion +shopt -s extglob progcomp + +# A lot of the following one-liners were taken directly from the +# completion examples provided with the bash 2.04 source distribution + +# Make directory commands see only directories +complete -d pushd + +# The following section lists completions that are redefined later +# Do NOT break these over multiple lines. +# +# START exclude -- do NOT remove this line +# bzcmp, bzdiff, bz*grep, bzless, bzmore intentionally not here, see Debian: #455510 +complete -f -X '!*.?(t)bz?(2)' bunzip2 bzcat pbunzip2 pbzcat +complete -f -X '!*.@(zip|[ejw]ar|exe|pk3|wsz|zargo|xpi|sxw|o[tx]t|od[fgpst]|epub|apk)' unzip zipinfo +complete -f -X '*.Z' compress znew +# zcmp, zdiff, z*grep, zless, zmore intentionally not here, see Debian: #455510 +complete -f -X '!*.@(Z|[gGd]z|t[ag]z)' gunzip zcat unpigz +complete -f -X '!*.Z' uncompress +# lzcmp, lzdiff intentionally not here, see Debian: #455510 +complete -f -X '!*.@(tlz|lzma)' lzcat lzegrep lzfgrep lzgrep lzless lzmore unlzma +complete -f -X '!*.@(?(t)xz|tlz|lzma)' unxz xzcat +complete -f -X '!*.lrz' lrunzip +complete -f -X '!*.@(gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx)' ee +complete -f -X '!*.@(gif|jp?(e)g|tif?(f)|png|p[bgp]m|bmp|x[bp]m|rle|rgb|pcx|fits|pm)' xv qiv +complete -f -X '!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ|.bz2|.BZ2|.Z))' gv ggv kghostview +complete -f -X '!*.@(dvi|DVI)?(.@(gz|Z|bz2))' xdvi kdvi +complete -f -X '!*.dvi' dvips dviselect dvitype dvipdf advi dvipdfm dvipdfmx +complete -f -X '!*.[pf]df' acroread gpdf xpdf +complete -f -X '!*.@(?(e)ps|pdf)' kpdf +complete -f -X '!*.@(@(?(e)ps|?(E)PS|[pf]df|[PF]DF|dvi|DVI)?(.gz|.GZ|.bz2|.BZ2)|cb[rz]|djv?(u)|gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|fdf)' evince +complete -f -X '!*.@(okular|@(?(e|x)ps|?(E|X)PS|pdf|PDF|dvi|DVI|cb[rz]|CB[RZ]|djv?(u)|DJV?(U)|dvi|DVI|gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX|epub|EPUB|odt|ODT|fb?(2)|FB?(2)|mobi|MOBI|g3|G3|chm|CHM|fdf|FDF)?(.?(gz|GZ|bz2|BZ2)))' okular +complete -f -X '!*.@(?(e)ps|pdf)' ps2pdf ps2pdf12 ps2pdf13 ps2pdf14 ps2pdfwr +complete -f -X '!*.texi*' makeinfo texi2html +complete -f -X '!*.@(?(la)tex|texi|dtx|ins|ltx)' tex latex slitex jadetex pdfjadetex pdftex pdflatex texi2dvi +complete -f -X '!*.mp3' mpg123 mpg321 madplay +complete -f -X '!*@(.@(mp?(e)g|MP?(E)G|wma|avi|AVI|asf|vob|VOB|bin|dat|divx|DIVX|vcd|ps|pes|fli|flv|FLV|fxm|FXM|viv|rm|ram|yuv|mov|MOV|qt|QT|wmv|mp[234]|MP[234]|m4[pv]|M4[PV]|mkv|MKV|og[gmv]|OG[GMV]|t[ps]|T[PS]|m2t?(s)|M2T?(S)|wav|WAV|flac|FLAC|asx|ASX|mng|MNG|srt|m[eo]d|M[EO]D|s[3t]m|S[3T]M|it|IT|xm|XM)|+([0-9]).@(vdr|VDR))?(.part)' xine aaxine fbxine +complete -f -X '!*@(.@(mp?(e)g|MP?(E)G|wma|avi|AVI|asf|vob|VOB|bin|dat|divx|DIVX|vcd|ps|pes|fli|flv|FLV|fxm|FXM|viv|rm|ram|yuv|mov|MOV|qt|QT|wmv|mp[234]|MP[234]|m4[pv]|M4[PV]|mkv|MKV|og[gmv]|OG[GMV]|t[ps]|T[PS]|m2t?(s)|M2T?(S)|wav|WAV|flac|FLAC|asx|ASX|mng|MNG|srt|m[eo]d|M[EO]D|s[3t]m|S[3T]M|it|IT|xm|XM|iso|ISO)|+([0-9]).@(vdr|VDR))?(.part)' kaffeine dragon +complete -f -X '!*.@(avi|asf|wmv)' aviplay +complete -f -X '!*.@(rm?(j)|ra?(m)|smi?(l))' realplay +complete -f -X '!*.@(mpg|mpeg|avi|mov|qt)' xanim +complete -f -X '!*.@(ogg|m3u|flac|spx)' ogg123 +complete -f -X '!*.@(mp3|ogg|pls|m3u)' gqmpeg freeamp +complete -f -X '!*.fig' xfig +complete -f -X '!*.@(mid?(i)|cmf)' playmidi +complete -f -X '!*.@(mid?(i)|rmi|rcp|[gr]36|g18|mod|xm|it|x3m|s[3t]m|kar)' timidity +complete -f -X '!*.@(m[eo]d|s[3t]m|xm|it)' modplugplay modplug123 +complete -f -X '*.@(o|so|so.!(conf)|a|[rs]pm|gif|jp?(e)g|mp3|mp?(e)g|avi|asf|ogg|class)' vi vim gvim rvim view rview rgvim rgview gview emacs xemacs sxemacs kate kwrite +complete -f -X '!*.@([eE][xX][eE]?(.[sS][oO])|[cC][oO][mM]|[sS][cC][rR])' wine +complete -f -X '!*.@(zip|z|gz|tgz)' bzme +# konqueror not here on purpose, it's more than a web/html browser +complete -f -X '!*.@(?([xX]|[sS])[hH][tT][mM]?([lL]))' netscape mozilla lynx opera galeon dillo elinks amaya firefox mozilla-firefox iceweasel google-chrome chromium-browser epiphany +complete -f -X '!*.@(sxw|stw|sxg|sgl|doc?([mx])|dot?([mx])|rtf|txt|htm|html|odt|ott|odm)' oowriter +complete -f -X '!*.@(sxi|sti|pps?(x)|ppt?([mx])|pot?([mx])|odp|otp)' ooimpress +complete -f -X '!*.@(sxc|stc|xls?([bmx])|xlw|xlt?([mx])|[ct]sv|ods|ots)' oocalc +complete -f -X '!*.@(sxd|std|sda|sdd|odg|otg)' oodraw +complete -f -X '!*.@(sxm|smf|mml|odf)' oomath +complete -f -X '!*.odb' oobase +complete -f -X '!*.[rs]pm' rpm2cpio +complete -f -X '!*.aux' bibtex +complete -f -X '!*.po' poedit gtranslator kbabel lokalize +complete -f -X '!*.@([Pp][Rr][Gg]|[Cc][Ll][Pp])' harbour gharbour hbpp +complete -f -X '!*.[Hh][Rr][Bb]' hbrun +complete -f -X '!*.ly' lilypond ly2dvi +complete -f -X '!*.@(dif?(f)|?(d)patch)?(.@([gx]z|bz2|lzma))' cdiff +complete -f -X '!*.lyx' lyx +complete -f -X '!@(*.@(ks|jks|jceks|p12|pfx|bks|ubr|gkr|cer|crt|cert|p7b|pkipath|pem|p10|csr|crl)|cacerts)' portecle +complete -f -X '!*.@(mp[234c]|og[ag]|@(fl|a)ac|m4[abp]|spx|tta|w?(a)v|wma|aif?(f)|asf|ape)' kid3 kid3-qt +# FINISH exclude -- do not remove this line + +# start of section containing compspecs that can be handled within bash + +# user commands see only users +complete -u su write chfn groups slay w sux runuser + +# bg completes with stopped jobs +complete -A stopped -P '"%' -S '"' bg + +# other job commands +complete -j -P '"%' -S '"' fg jobs disown + +# readonly and unset complete with shell variables +complete -v readonly unset + +# set completes with set options +complete -A setopt set + +# shopt completes with shopt options +complete -A shopt shopt + +# helptopics +complete -A helptopic help + +# unalias completes with aliases +complete -a unalias + +# bind completes with readline bindings (make this more intelligent) +complete -A binding bind + +# type and which complete on commands +complete -c command type which + +# builtin completes on builtins +complete -b builtin + +# start of section containing completion functions called by other functions + +# This function checks whether we have a given program on the system. +# No need for bulky functions in memory if we don't. +# +have() +{ + unset -v have + # Completions for system administrator commands are installed as well in + # case completion is attempted via `sudo command ...'. + PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin type $1 &>/dev/null && + have="yes" +} + +# This function checks whether a given readline variable +# is `on'. +# +_rl_enabled() +{ + [[ "$( bind -v )" = *$1+([[:space:]])on* ]] +} + +# This function shell-quotes the argument +quote() +{ + echo \'${1//\'/\'\\\'\'}\' #'# Help vim syntax highlighting +} + +# @see _quote_readline_by_ref() +quote_readline() +{ + local quoted + _quote_readline_by_ref "$1" ret + printf %s "$ret" +} # quote_readline() + + +# This function shell-dequotes the argument +dequote() +{ + eval echo "$1" 2> /dev/null +} + + +# Assign variable one scope above the caller +# Usage: local "$1" && _upvar $1 "value(s)" +# Param: $1 Variable name to assign value to +# Param: $* Value(s) to assign. If multiple values, an array is +# assigned, otherwise a single value is assigned. +# NOTE: For assigning multiple variables, use '_upvars'. Do NOT +# use multiple '_upvar' calls, since one '_upvar' call might +# reassign a variable to be used by another '_upvar' call. +# See: http://fvue.nl/wiki/Bash:_Passing_variables_by_reference +_upvar() { + if unset -v "$1"; then # Unset & validate varname + if (( $# == 2 )); then + eval $1=\"\$2\" # Return single value + else + eval $1=\(\"\${@:2}\"\) # Return array + fi + fi +} + + +# Assign variables one scope above the caller +# Usage: local varname [varname ...] && +# _upvars [-v varname value] | [-aN varname [value ...]] ... +# Available OPTIONS: +# -aN Assign next N values to varname as array +# -v Assign single value to varname +# Return: 1 if error occurs +# See: http://fvue.nl/wiki/Bash:_Passing_variables_by_reference +_upvars() { + if ! (( $# )); then + echo "${FUNCNAME[0]}: usage: ${FUNCNAME[0]} [-v varname"\ + "value] | [-aN varname [value ...]] ..." 1>&2 + return 2 + fi + while (( $# )); do + case $1 in + -a*) + # Error checking + [[ ${1#-a} ]] || { echo "bash: ${FUNCNAME[0]}: \`$1': missing"\ + "number specifier" 1>&2; return 1; } + printf %d "${1#-a}" &> /dev/null || { echo "bash:"\ + "${FUNCNAME[0]}: \`$1': invalid number specifier" 1>&2 + return 1; } + # Assign array of -aN elements + [[ "$2" ]] && unset -v "$2" && eval $2=\(\"\${@:3:${1#-a}}\"\) && + shift $((${1#-a} + 2)) || { echo "bash: ${FUNCNAME[0]}:"\ + "\`$1${2+ }$2': missing argument(s)" 1>&2; return 1; } + ;; + -v) + # Assign single value + [[ "$2" ]] && unset -v "$2" && eval $2=\"\$3\" && + shift 3 || { echo "bash: ${FUNCNAME[0]}: $1: missing"\ + "argument(s)" 1>&2; return 1; } + ;; + *) + echo "bash: ${FUNCNAME[0]}: $1: invalid option" 1>&2 + return 1 ;; + esac + done +} + + +# Reassemble command line words, excluding specified characters from the +# list of word completion separators (COMP_WORDBREAKS). +# @param $1 chars Characters out of $COMP_WORDBREAKS which should +# NOT be considered word breaks. This is useful for things like scp where +# we want to return host:path and not only path, so we would pass the +# colon (:) as $1 here. +# @param $2 words Name of variable to return words to +# @param $3 cword Name of variable to return cword to +# +__reassemble_comp_words_by_ref() { + local exclude i j ref + # Exclude word separator characters? + if [[ $1 ]]; then + # Yes, exclude word separator characters; + # Exclude only those characters, which were really included + exclude="${1//[^$COMP_WORDBREAKS]}" + fi + + # Default to cword unchanged + eval $3=$COMP_CWORD + # Are characters excluded which were former included? + if [[ $exclude ]]; then + # Yes, list of word completion separators has shrunk; + # Re-assemble words to complete + for (( i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do + # Is current word not word 0 (the command itself) and is word not + # empty and is word made up of just word separator characters to be + # excluded? + while [[ $i -gt 0 && ${COMP_WORDS[$i]} && + ${COMP_WORDS[$i]//[^$exclude]} == ${COMP_WORDS[$i]} + ]]; do + [ $j -ge 2 ] && ((j--)) + # Append word separator to current word + ref="$2[$j]" + eval $2[$j]=\${!ref}\${COMP_WORDS[i]} + # Indicate new cword + [ $i = $COMP_CWORD ] && eval $3=$j + # Indicate next word if available, else end *both* while and for loop + (( $i < ${#COMP_WORDS[@]} - 1)) && ((i++)) || break 2 + done + # Append word to current word + ref="$2[$j]" + eval $2[$j]=\${!ref}\${COMP_WORDS[i]} + # Indicate new cword + [[ $i == $COMP_CWORD ]] && eval $3=$j + done + else + # No, list of word completions separators hasn't changed; + eval $2=\( \"\${COMP_WORDS[@]}\" \) + fi +} # __reassemble_comp_words_by_ref() + + +# @param $1 exclude Characters out of $COMP_WORDBREAKS which should NOT be +# considered word breaks. This is useful for things like scp where +# we want to return host:path and not only path, so we would pass the +# colon (:) as $1 in this case. Bash-3 doesn't do word splitting, so this +# ensures we get the same word on both bash-3 and bash-4. +# @param $2 words Name of variable to return words to +# @param $3 cword Name of variable to return cword to +# @param $4 cur Name of variable to return current word to complete to +# @see ___get_cword_at_cursor_by_ref() +__get_cword_at_cursor_by_ref() { + local cword words=() + __reassemble_comp_words_by_ref "$1" words cword + + local i cur2 + local cur="$COMP_LINE" + local index="$COMP_POINT" + for (( i = 0; i <= cword; ++i )); do + while [[ + # Current word fits in $cur? + "${#cur}" -ge ${#words[i]} && + # $cur doesn't match cword? + "${cur:0:${#words[i]}}" != "${words[i]}" + ]]; do + # Strip first character + cur="${cur:1}" + # Decrease cursor position + ((index--)) + done + + # Does found word matches cword? + if [[ "$i" -lt "$cword" ]]; then + # No, cword lies further; + local old_size="${#cur}" + cur="${cur#${words[i]}}" + local new_size="${#cur}" + index=$(( index - old_size + new_size )) + fi + done + + if [[ "${words[cword]:0:${#cur}}" != "$cur" ]]; then + # We messed up. At least return the whole word so things keep working + cur2=${words[cword]} + else + cur2=${cur:0:$index} + fi + + local "$2" "$3" "$4" && + _upvars -a${#words[@]} $2 "${words[@]}" -v $3 "$cword" -v $4 "$cur2" +} + + +# Get the word to complete and optional previous words. +# This is nicer than ${COMP_WORDS[$COMP_CWORD]}, since it handles cases +# where the user is completing in the middle of a word. +# (For example, if the line is "ls foobar", +# and the cursor is here --------> ^ +# Also one is able to cross over possible wordbreak characters. +# Usage: _get_comp_words_by_ref [OPTIONS] [VARNAMES] +# Available VARNAMES: +# cur Return cur via $cur +# prev Return prev via $prev +# words Return words via $words +# cword Return cword via $cword +# +# Available OPTIONS: +# -n EXCLUDE Characters out of $COMP_WORDBREAKS which should NOT be +# considered word breaks. This is useful for things like scp +# where we want to return host:path and not only path, so we +# would pass the colon (:) as -n option in this case. Bash-3 +# doesn't do word splitting, so this ensures we get the same +# word on both bash-3 and bash-4. +# -c VARNAME Return cur via $VARNAME +# -p VARNAME Return prev via $VARNAME +# -w VARNAME Return words via $VARNAME +# -i VARNAME Return cword via $VARNAME +# +# Example usage: +# +# $ _get_comp_words_by_ref -n : cur prev +# +_get_comp_words_by_ref() +{ + local exclude flag i OPTIND=1 + local cur cword words=() + local upargs=() upvars=() vcur vcword vprev vwords + + while getopts "c:i:n:p:w:" flag "$@"; do + case $flag in + c) vcur=$OPTARG ;; + i) vcword=$OPTARG ;; + n) exclude=$OPTARG ;; + p) vprev=$OPTARG ;; + w) vwords=$OPTARG ;; + esac + done + while [[ $# -ge $OPTIND ]]; do + case ${!OPTIND} in + cur) vcur=cur ;; + prev) vprev=prev ;; + cword) vcword=cword ;; + words) vwords=words ;; + *) echo "bash: $FUNCNAME(): \`${!OPTIND}': unknown argument" \ + 1>&2; return 1 + esac + let "OPTIND += 1" + done + + __get_cword_at_cursor_by_ref "$exclude" words cword cur + + [[ $vcur ]] && { upvars+=("$vcur" ); upargs+=(-v $vcur "$cur" ); } + [[ $vcword ]] && { upvars+=("$vcword"); upargs+=(-v $vcword "$cword"); } + [[ $vprev ]] && { upvars+=("$vprev" ); upargs+=(-v $vprev + "${words[cword - 1]}"); } + [[ $vwords ]] && { upvars+=("$vwords"); upargs+=(-a${#words[@]} $vwords + "${words[@]}"); } + + (( ${#upvars[@]} )) && local "${upvars[@]}" && _upvars "${upargs[@]}" +} + + +# Get the word to complete. +# This is nicer than ${COMP_WORDS[$COMP_CWORD]}, since it handles cases +# where the user is completing in the middle of a word. +# (For example, if the line is "ls foobar", +# and the cursor is here --------> ^ +# @param $1 string Characters out of $COMP_WORDBREAKS which should NOT be +# considered word breaks. This is useful for things like scp where +# we want to return host:path and not only path, so we would pass the +# colon (:) as $1 in this case. Bash-3 doesn't do word splitting, so this +# ensures we get the same word on both bash-3 and bash-4. +# @param $2 integer Index number of word to return, negatively offset to the +# current word (default is 0, previous is 1), respecting the exclusions +# given at $1. For example, `_get_cword "=:" 1' returns the word left of +# the current word, respecting the exclusions "=:". +# @deprecated Use `_get_comp_words_by_ref cur' instead +# @see _get_comp_words_by_ref() +_get_cword() +{ + local LC_CTYPE=C + local cword words + __reassemble_comp_words_by_ref "$1" words cword + + # return previous word offset by $2 + if [[ ${2//[^0-9]/} ]]; then + printf "%s" "${words[cword-$2]}" + elif [[ "${#words[cword]}" -eq 0 || "$COMP_POINT" == "${#COMP_LINE}" ]]; then + printf "%s" "${words[cword]}" + else + local i + local cur="$COMP_LINE" + local index="$COMP_POINT" + for (( i = 0; i <= cword; ++i )); do + while [[ + # Current word fits in $cur? + "${#cur}" -ge ${#words[i]} && + # $cur doesn't match cword? + "${cur:0:${#words[i]}}" != "${words[i]}" + ]]; do + # Strip first character + cur="${cur:1}" + # Decrease cursor position + ((index--)) + done + + # Does found word matches cword? + if [[ "$i" -lt "$cword" ]]; then + # No, cword lies further; + local old_size="${#cur}" + cur="${cur#${words[i]}}" + local new_size="${#cur}" + index=$(( index - old_size + new_size )) + fi + done + + if [[ "${words[cword]:0:${#cur}}" != "$cur" ]]; then + # We messed up! At least return the whole word so things + # keep working + printf "%s" "${words[cword]}" + else + printf "%s" "${cur:0:$index}" + fi + fi +} # _get_cword() + + +# Get word previous to the current word. +# This is a good alternative to `prev=${COMP_WORDS[COMP_CWORD-1]}' because bash4 +# will properly return the previous word with respect to any given exclusions to +# COMP_WORDBREAKS. +# @deprecated Use `_get_comp_words_by_ref cur prev' instead +# @see _get_comp_words_by_ref() +# +_get_pword() +{ + if [ $COMP_CWORD -ge 1 ]; then + _get_cword "${@:-}" 1; + fi +} + + +# If the word-to-complete contains a colon (:), left-trim COMPREPLY items with +# word-to-complete. +# On bash-3, and bash-4 with a colon in COMP_WORDBREAKS, words containing +# colons are always completed as entire words if the word to complete contains +# a colon. This function fixes this, by removing the colon-containing-prefix +# from COMPREPLY items. +# The preferred solution is to remove the colon (:) from COMP_WORDBREAKS in +# your .bashrc: +# +# # Remove colon (:) from list of word completion separators +# COMP_WORDBREAKS=${COMP_WORDBREAKS//:} +# +# See also: Bash FAQ - E13) Why does filename completion misbehave if a colon +# appears in the filename? - http://tiswww.case.edu/php/chet/bash/FAQ +# @param $1 current word to complete (cur) +# @modifies global array $COMPREPLY +# +__ltrim_colon_completions() { + # If word-to-complete contains a colon, + # and bash-version < 4, + # or bash-version >= 4 and COMP_WORDBREAKS contains a colon + if [[ + "$1" == *:* && ( + ${BASH_VERSINFO[0]} -lt 4 || + (${BASH_VERSINFO[0]} -ge 4 && "$COMP_WORDBREAKS" == *:*) + ) + ]]; then + # Remove colon-word prefix from COMPREPLY items + local colon_word=${1%${1##*:}} + local i=${#COMPREPLY[*]} + while [ $((--i)) -ge 0 ]; do + COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"} + done + fi +} # __ltrim_colon_completions() + + +# This function quotes the argument in a way so that readline dequoting +# results in the original argument. This is necessary for at least +# `compgen' which requires its arguments quoted/escaped: +# +# $ ls "a'b/" +# c +# $ compgen -f "a'b/" # Wrong, doesn't return output +# $ compgen -f "a\'b/" # Good (bash-4) +# a\'b/c +# $ compgen -f "a\\\\\'b/" # Good (bash-3) +# a\'b/c +# +# On bash-3, special characters need to be escaped extra. This is +# unless the first character is a single quote ('). If the single +# quote appears further down the string, bash default completion also +# fails, e.g.: +# +# $ ls 'a&b/' +# f +# $ foo 'a&b/ # Becomes: foo 'a&b/f' +# $ foo a'&b/ # Nothing happens +# +# See also: +# - http://lists.gnu.org/archive/html/bug-bash/2009-03/msg00155.html +# - http://www.mail-archive.com/bash-completion-devel@lists.alioth.\ +# debian.org/msg01944.html +# @param $1 Argument to quote +# @param $2 Name of variable to return result to +_quote_readline_by_ref() +{ + if [[ ${1:0:1} == "'" ]]; then + if [[ ${BASH_VERSINFO[0]} -ge 4 ]]; then + # Leave out first character + printf -v $2 %s "${1:1}" + else + # Quote word, leaving out first character + printf -v $2 %q "${1:1}" + # Double-quote word (bash-3) + printf -v $2 %q ${!2} + fi + elif [[ ${BASH_VERSINFO[0]} -le 3 && ${1:0:1} == '"' ]]; then + printf -v $2 %q "${1:1}" + else + printf -v $2 %q "$1" + fi + + # If result becomes quoted like this: $'string', re-evaluate in order to + # drop the additional quoting. See also: http://www.mail-archive.com/ + # bash-completion-devel@lists.alioth.debian.org/msg01942.html + [[ ${!2:0:1} == '$' ]] && eval $2=${!2} +} # _quote_readline_by_ref() + + +# This function turns on "-o filenames" behavior dynamically. It is present +# for bash < 4 reasons. See http://bugs.debian.org/272660#64 for info about +# the bash < 4 compgen hack. +_compopt_o_filenames() +{ + # We test for compopt availability first because directly invoking it on + # bash < 4 at this point may cause terminal echo to be turned off for some + # reason, see https://bugzilla.redhat.com/653669 for more info. + type compopt &>/dev/null && compopt -o filenames 2>/dev/null || \ + compgen -f /non-existing-dir/ >/dev/null +} + + +# This function performs file and directory completion. It's better than +# simply using 'compgen -f', because it honours spaces in filenames. +# @param $1 If `-d', complete only on directories. Otherwise filter/pick only +# completions with `.$1' and the uppercase version of it as file +# extension. +# +_filedir() +{ + local i IFS=$'\n' xspec + + _tilde "$cur" || return 0 + + local -a toks + local quoted tmp + + _quote_readline_by_ref "$cur" quoted + toks=( ${toks[@]-} $( + compgen -d -- "$quoted" | { + while read -r tmp; do + # TODO: I have removed a "[ -n $tmp ] &&" before 'printf ..', + # and everything works again. If this bug suddenly + # appears again (i.e. "cd /b" becomes "cd /"), + # remember to check for other similar conditionals (here + # and _filedir_xspec()). --David + printf '%s\n' $tmp + done + } + )) + + if [[ "$1" != -d ]]; then + # Munge xspec to contain uppercase version too + [[ ${BASH_VERSINFO[0]} -ge 4 ]] && \ + xspec=${1:+"!*.@($1|${1^^})"} || \ + xspec=${1:+"!*.@($1|$(printf %s $1 | tr '[:lower:]' '[:upper:]'))"} + toks=( ${toks[@]-} $( compgen -f -X "$xspec" -- $quoted) ) + fi + [ ${#toks[@]} -ne 0 ] && _compopt_o_filenames + + COMPREPLY=( "${COMPREPLY[@]}" "${toks[@]}" ) +} # _filedir() + + +# This function splits $cur=--foo=bar into $prev=--foo, $cur=bar, making it +# easier to support both "--foo bar" and "--foo=bar" style completions. +# Returns 0 if current option was split, 1 otherwise. +# +_split_longopt() +{ + if [[ "$cur" == --?*=* ]]; then + # Cut also backslash before '=' in case it ended up there + # for some reason. + prev="${cur%%?(\\)=*}" + cur="${cur#*=}" + return 0 + fi + + return 1 +} + +# This function tries to parse the help output of the given command. +# @param $1 command +# @param $2 command options (default: --help) +# +_parse_help() { + $1 ${2:---help} 2>&1 | sed -e '/^[[:space:]]*-/!d' -e 's|[,/]| |g' | \ + awk '{ print $1; if ($2 ~ /^-/) { print $2 } }' | sed -e 's|[<=].*||' +} + +# This function completes on signal names +# +_signals() +{ + local i + + # standard signal completion is rather braindead, so we need + # to hack around to get what we want here, which is to + # complete on a dash, followed by the signal name minus + # the SIG prefix + COMPREPLY=( $( compgen -A signal SIG${cur#-} )) + for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do + COMPREPLY[i]=-${COMPREPLY[i]#SIG} + done +} + +# This function completes on known mac addresses +# +_mac_addresses() +{ + local re='\([A-Fa-f0-9]\{2\}:\)\{5\}[A-Fa-f0-9]\{2\}' + local PATH="$PATH:/sbin:/usr/sbin" + + # Local interfaces (Linux only?) + COMPREPLY=( "${COMPREPLY[@]}" $( ifconfig -a 2>/dev/null | sed -ne \ + "s/.*[[:space:]]HWaddr[[:space:]]\{1,\}\($re\)[[:space:]]*$/\1/p" ) ) + + # ARP cache + COMPREPLY=( "${COMPREPLY[@]}" $( arp -an 2>/dev/null | sed -ne \ + "s/.*[[:space:]]\($re\)[[:space:]].*/\1/p" -ne \ + "s/.*[[:space:]]\($re\)[[:space:]]*$/\1/p" ) ) + + # /etc/ethers + COMPREPLY=( "${COMPREPLY[@]}" $( sed -ne \ + "s/^[[:space:]]*\($re\)[[:space:]].*/\1/p" /etc/ethers 2>/dev/null ) ) + + COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- "$cur" ) ) + __ltrim_colon_completions "$cur" +} + +# This function completes on configured network interfaces +# +_configured_interfaces() +{ + if [ -f /etc/debian_version ]; then + # Debian system + COMPREPLY=( $( compgen -W "$( sed -ne 's|^iface \([^ ]\{1,\}\).*$|\1|p'\ + /etc/network/interfaces )" -- "$cur" ) ) + elif [ -f /etc/SuSE-release ]; then + # SuSE system + COMPREPLY=( $( compgen -W "$( printf '%s\n' \ + /etc/sysconfig/network/ifcfg-* | \ + sed -ne 's|.*ifcfg-\(.*\)|\1|p' )" -- "$cur" ) ) + elif [ -f /etc/pld-release ]; then + # PLD Linux + COMPREPLY=( $( compgen -W "$( command ls -B \ + /etc/sysconfig/interfaces | \ + sed -ne 's|.*ifcfg-\(.*\)|\1|p' )" -- "$cur" ) ) + else + # Assume Red Hat + COMPREPLY=( $( compgen -W "$( printf '%s\n' \ + /etc/sysconfig/network-scripts/ifcfg-* | \ + sed -ne 's|.*ifcfg-\(.*\)|\1|p' )" -- "$cur" ) ) + fi +} + +# This function completes on available kernels +# +_kernel_versions() +{ + COMPREPLY=( $( compgen -W '$( command ls /lib/modules )' -- "$cur" ) ) +} + +# This function completes on all available network interfaces +# -a: restrict to active interfaces only +# -w: restrict to wireless interfaces only +# +_available_interfaces() +{ + local cmd + + if [ "${1:-}" = -w ]; then + cmd="iwconfig" + elif [ "${1:-}" = -a ]; then + cmd="ifconfig" + else + cmd="ifconfig -a" + fi + + COMPREPLY=( $( eval PATH="$PATH:/sbin" $cmd 2>/dev/null | \ + awk '/^[^ \t]/ { print $1 }' ) ) + COMPREPLY=( $( compgen -W '${COMPREPLY[@]/%[[:punct:]]/}' -- "$cur" ) ) +} + + +# Perform tilde (~) completion +# @return True (0) if completion needs further processing, +# False (> 0) if tilde is followed by a valid username, completions +# are put in COMPREPLY and no further processing is necessary. +_tilde() { + local result=0 + # Does $1 start with tilde (~) and doesn't contain slash (/)? + if [[ ${1:0:1} == "~" && $1 == ${1//\/} ]]; then + _compopt_o_filenames + # Try generate username completions + COMPREPLY=( $( compgen -P '~' -u "${1#\~}" ) ) + result=${#COMPREPLY[@]} + fi + return $result +} + + +# Expand variable starting with tilde (~) +# We want to expand ~foo/... to /home/foo/... to avoid problems when +# word-to-complete starting with a tilde is fed to commands and ending up +# quoted instead of expanded. +# Only the first portion of the variable from the tilde up to the first slash +# (~../) is expanded. The remainder of the variable, containing for example +# a dollar sign variable ($) or asterisk (*) is not expanded. +# Example usage: +# +# $ v="~"; __expand_tilde_by_ref v; echo "$v" +# +# Example output: +# +# v output +# -------- ---------------- +# ~ /home/user +# ~foo/bar /home/foo/bar +# ~foo/$HOME /home/foo/$HOME +# ~foo/a b /home/foo/a b +# ~foo/* /home/foo/* +# +# @param $1 Name of variable (not the value of the variable) to expand +__expand_tilde_by_ref() { + # Does $1 start with tilde (~)? + if [ "${!1:0:1}" = "~" ]; then + # Does $1 contain slash (/)? + if [ "${!1}" != "${!1//\/}" ]; then + # Yes, $1 contains slash; + # 1: Remove * including and after first slash (/), i.e. "~a/b" + # becomes "~a". Double quotes allow eval. + # 2: Remove * before the first slash (/), i.e. "~a/b" + # becomes "b". Single quotes prevent eval. + # +-----1----+ +---2----+ + eval $1="${!1/%\/*}"/'${!1#*/}' + else + # No, $1 doesn't contain slash + eval $1="${!1}" + fi + fi +} # __expand_tilde_by_ref() + + +# This function expands tildes in pathnames +# +_expand() +{ + # FIXME: Why was this here? + #[ "$cur" != "${cur%\\}" ] && cur="$cur\\" + + # Expand ~username type directory specifications. We want to expand + # ~foo/... to /home/foo/... to avoid problems when $cur starting with + # a tilde is fed to commands and ending up quoted instead of expanded. + + if [[ "$cur" == \~*/* ]]; then + eval cur=$cur + elif [[ "$cur" == \~* ]]; then + cur=${cur#\~} + COMPREPLY=( $( compgen -P '~' -u "$cur" ) ) + [ ${#COMPREPLY[@]} -eq 1 ] && eval COMPREPLY[0]=${COMPREPLY[0]} + return ${#COMPREPLY[@]} + fi +} + +# This function completes on process IDs. +# AIX and Solaris ps prefers X/Open syntax. +[[ $UNAME == SunOS || $UNAME == AIX ]] && +_pids() +{ + COMPREPLY=( $( compgen -W '$( command ps -efo pid | sed 1d )' -- "$cur" )) +} || +_pids() +{ + COMPREPLY=( $( compgen -W '$( command ps axo pid= )' -- "$cur" ) ) +} + +# This function completes on process group IDs. +# AIX and SunOS prefer X/Open, all else should be BSD. +[[ $UNAME == SunOS || $UNAME == AIX ]] && +_pgids() +{ + COMPREPLY=( $( compgen -W '$( command ps -efo pgid | sed 1d )' -- "$cur" )) +} || +_pgids() +{ + COMPREPLY=( $( compgen -W '$( command ps axo pgid= )' -- "$cur" )) +} + +# This function completes on process names. +# AIX and SunOS prefer X/Open, all else should be BSD. +[[ $UNAME == SunOS || $UNAME == AIX ]] && +_pnames() +{ + COMPREPLY=( $( compgen -X '' -W '$( command ps -efo comm | \ + sed -e 1d -e "s:.*/::" -e "s/^-//" | sort -u )' -- "$cur" ) ) +} || +_pnames() +{ + # FIXME: completes "[kblockd/0]" to "0". Previously it was completed + # to "kblockd" which isn't correct either. "kblockd/0" would be + # arguably most correct, but killall from psmisc 22 treats arguments + # containing "/" specially unless -r is given so that wouldn't quite + # work either. Perhaps it'd be best to not complete these to anything + # for now. + # Not using "ps axo comm" because under some Linux kernels, it + # truncates command names (see e.g. http://bugs.debian.org/497540#19) + COMPREPLY=( $( compgen -X '' -W '$( command ps axo command= | \ + sed -e "s/ .*//" -e "s:.*/::" -e "s/:$//" -e "s/^[[(-]//" \ + -e "s/[])]$//" | sort -u )' -- "$cur" ) ) +} + +# This function completes on user IDs +# +_uids() +{ + if type getent &>/dev/null; then + COMPREPLY=( $( compgen -W '$( getent passwd | cut -d: -f3 )' -- "$cur" ) ) + elif type perl &>/dev/null; then + COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($uid) = (getpwent)[2]) { print $uid . "\n" }'"'"' )' -- "$cur" ) ) + else + # make do with /etc/passwd + COMPREPLY=( $( compgen -W '$( cut -d: -f3 /etc/passwd )' -- "$cur" ) ) + fi +} + +# This function completes on group IDs +# +_gids() +{ + if type getent &>/dev/null; then + COMPREPLY=( $( compgen -W '$( getent group | cut -d: -f3 )' \ + -- "$cur" ) ) + elif type perl &>/dev/null; then + COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($gid) = (getgrent)[2]) { print $gid . "\n" }'"'"' )' -- "$cur" ) ) + else + # make do with /etc/group + COMPREPLY=( $( compgen -W '$( cut -d: -f3 /etc/group )' -- "$cur" ) ) + fi +} + +# This function completes on services +# +_services() +{ + local sysvdir famdir + [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d || sysvdir=/etc/init.d + famdir=/etc/xinetd.d + COMPREPLY=( $( printf '%s\n' \ + $sysvdir/!(*.rpm@(orig|new|save)|*~|functions) ) ) + + if [ -d $famdir ]; then + COMPREPLY=( "${COMPREPLY[@]}" $( printf '%s\n' \ + $famdir/!(*.rpm@(orig|new|save)|*~) ) ) + fi + + COMPREPLY=( $( compgen -W '${COMPREPLY[@]#@($sysvdir|$famdir)/}' -- "$cur" ) ) +} + +# This function completes on modules +# +_modules() +{ + local modpath + modpath=/lib/modules/$1 + COMPREPLY=( $( compgen -W "$( command ls -R $modpath | \ + sed -ne 's/^\(.*\)\.k\{0,1\}o\(\.gz\)\{0,1\}$/\1/p' )" -- "$cur" ) ) +} + +# This function completes on installed modules +# +_installed_modules() +{ + COMPREPLY=( $( compgen -W "$( PATH="$PATH:/sbin" lsmod | \ + awk '{if (NR != 1) print $1}' )" -- "$1" ) ) +} + +# This function completes on user or user:group format; as for chown and cpio. +# +# The : must be added manually; it will only complete usernames initially. +# The legacy user.group format is not supported. +# +# @param $1 If -u, only return users/groups the user has access to in +# context of current completion. +_usergroup() +{ + if [[ $cur = *\\\\* || $cur = *:*:* ]]; then + # Give up early on if something seems horribly wrong. + return + elif [[ $cur = *\\:* ]]; then + # Completing group after 'user\:gr'. + # Reply with a list of groups prefixed with 'user:', readline will + # escape to the colon. + local prefix + prefix=${cur%%*([^:])} + prefix=${prefix//\\} + local mycur="${cur#*[:]}" + if [[ $1 == -u ]]; then + _allowed_groups "$mycur" + else + local IFS=$'\n' + COMPREPLY=( $( compgen -g -- "$mycur" ) ) + fi + COMPREPLY=( $( compgen -P "$prefix" -W "${COMPREPLY[@]}" ) ) + elif [[ $cur = *:* ]]; then + # Completing group after 'user:gr'. + # Reply with a list of unprefixed groups since readline with split on : + # and only replace the 'gr' part + local mycur="${cur#*:}" + if [[ $1 == -u ]]; then + _allowed_groups "$mycur" + else + local IFS=$'\n' + COMPREPLY=( $( compgen -g -- "$mycur" ) ) + fi + else + # Completing a partial 'usernam'. + # + # Don't suffix with a : because readline will escape it and add a + # slash. It's better to complete into 'chown username ' than 'chown + # username\:'. + if [[ $1 == -u ]]; then + _allowed_users "$cur" + else + local IFS=$'\n' + COMPREPLY=( $( compgen -u -- "$cur" ) ) + fi + fi +} + +_allowed_users() +{ + if _complete_as_root; then + local IFS=$'\n' + COMPREPLY=( $( compgen -u -- "${1:-$cur}" ) ) + else + local IFS=$'\n ' + COMPREPLY=( $( compgen -W \ + "$( id -un 2>/dev/null || whoami 2>/dev/null )" -- "${1:-$cur}" ) ) + fi +} + +_allowed_groups() +{ + if _complete_as_root; then + local IFS=$'\n' + COMPREPLY=( $( compgen -g -- "$1" ) ) + else + local IFS=$'\n ' + COMPREPLY=( $( compgen -W \ + "$( id -Gn 2>/dev/null || groups 2>/dev/null )" -- "$1" ) ) + fi +} + +# This function completes on valid shells +# +_shells() +{ + COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W \ + '$( command grep "^[[:space:]]*/" /etc/shells 2>/dev/null )' \ + -- "$cur" ) ) +} + +# This function completes on valid filesystem types +# +_fstypes() +{ + local fss + + if [ -e /proc/filesystems ] ; then + # Linux + fss="$( cut -d$'\t' -f2 /proc/filesystems ) + $( awk '! /\*/ { print $NF }' /etc/filesystems 2>/dev/null )" + else + # Generic + fss="$( awk '/^[ \t]*[^#]/ { print $3 }' /etc/fstab 2>/dev/null ) + $( awk '/^[ \t]*[^#]/ { print $3 }' /etc/mnttab 2>/dev/null ) + $( awk '/^[ \t]*[^#]/ { print $4 }' /etc/vfstab 2>/dev/null ) + $( awk '{ print $1 }' /etc/dfs/fstypes 2>/dev/null ) + $( [ -d /etc/fs ] && command ls /etc/fs )" + fi + + [ -n "$fss" ] && \ + COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W "$fss" -- "$cur" ) ) +} + +# Get real command. +# - arg: $1 Command +# - stdout: Filename of command in PATH with possible symbolic links resolved. +# Empty string if command not found. +# - return: True (0) if command found, False (> 0) if not. +_realcommand() +{ + type -P "$1" > /dev/null && { + if type -p realpath > /dev/null; then + realpath "$(type -P "$1")" + elif type -p readlink > /dev/null; then + readlink -f "$(type -P "$1")" + else + type -P "$1" + fi + } +} + +# This function returns the first arugment, excluding options +# @param $1 chars Characters out of $COMP_WORDBREAKS which should +# NOT be considered word breaks. See __reassemble_comp_words_by_ref. +_get_first_arg() +{ + local i + + arg= + for (( i=1; i < COMP_CWORD; i++ )); do + if [[ "${COMP_WORDS[i]}" != -* ]]; then + arg=${COMP_WORDS[i]} + break + fi + done +} + + +# This function counts the number of args, excluding options +# @param $1 chars Characters out of $COMP_WORDBREAKS which should +# NOT be considered word breaks. See __reassemble_comp_words_by_ref. +_count_args() +{ + local i cword words + __reassemble_comp_words_by_ref "$1" words cword + + args=1 + for i in "${words[@]:1:cword-1}"; do + [[ "$i" != -* ]] && args=$(($args+1)) + done +} + +# This function completes on PCI IDs +# +_pci_ids() +{ + COMPREPLY=( ${COMPREPLY[@]:-} $( compgen -W \ + "$( PATH="$PATH:/sbin" lspci -n | awk '{print $3}')" -- "$cur" ) ) +} + +# This function completes on USB IDs +# +_usb_ids() +{ + COMPREPLY=( ${COMPREPLY[@]:-} $( compgen -W \ + "$( PATH="$PATH:/sbin" lsusb | awk '{print $6}' )" -- "$cur" ) ) +} + +# CD device names +_cd_devices() +{ + COMPREPLY=( "${COMPREPLY[@]}" + $( compgen -f -d -X "!*/?([amrs])cd*" -- "${cur:-/dev/}" ) ) +} + +# DVD device names +_dvd_devices() +{ + COMPREPLY=( "${COMPREPLY[@]}" + $( compgen -f -d -X "!*/?(r)dvd*" -- "${cur:-/dev/}" ) ) +} + +# start of section containing completion functions for external programs + +# a little help for FreeBSD ports users +[ $UNAME = FreeBSD ] && complete -W 'index search fetch fetch-list extract \ + patch configure build install reinstall deinstall clean clean-depends \ + kernel buildworld' make + +# This function provides simple user@host completion +# +_user_at_host() { + local cur + + COMPREPLY=() + _get_comp_words_by_ref -n : cur + + if [[ $cur == *@* ]]; then + _known_hosts_real "$cur" + else + COMPREPLY=( $( compgen -u -- "$cur" ) ) + fi + + return 0 +} +shopt -u hostcomplete && complete -F _user_at_host -o nospace talk ytalk finger + +# NOTE: Using this function as a helper function is deprecated. Use +# `_known_hosts_real' instead. +_known_hosts() +{ + local options + COMPREPLY=() + + # NOTE: Using `_known_hosts' as a helper function and passing options + # to `_known_hosts' is deprecated: Use `_known_hosts_real' instead. + [[ "$1" == -a || "$2" == -a ]] && options=-a + [[ "$1" == -c || "$2" == -c ]] && options="$options -c" + _known_hosts_real $options "$(_get_cword :)" +} # _known_hosts() + +# Helper function for completing _known_hosts. +# This function performs host completion based on ssh's config and known_hosts +# files, as well as hostnames reported by avahi-browse if +# COMP_KNOWN_HOSTS_WITH_AVAHI is set to a non-empty value. Also hosts from +# HOSTFILE (compgen -A hostname) are added, unless +# COMP_KNOWN_HOSTS_WITH_HOSTFILE is set to an empty value. +# Usage: _known_hosts_real [OPTIONS] CWORD +# Options: -a Use aliases +# -c Use `:' suffix +# -F configfile Use `configfile' for configuration settings +# -p PREFIX Use PREFIX +# Return: Completions, starting with CWORD, are added to COMPREPLY[] +_known_hosts_real() +{ + local configfile flag prefix + local cur curd awkcur user suffix aliases i host + local -a kh khd config + + local OPTIND=1 + while getopts "acF:p:" flag "$@"; do + case $flag in + a) aliases='yes' ;; + c) suffix=':' ;; + F) configfile=$OPTARG ;; + p) prefix=$OPTARG ;; + esac + done + [ $# -lt $OPTIND ] && echo "error: $FUNCNAME: missing mandatory argument CWORD" + cur=${!OPTIND}; let "OPTIND += 1" + [ $# -ge $OPTIND ] && echo "error: $FUNCNAME("$@"): unprocessed arguments:"\ + $(while [ $# -ge $OPTIND ]; do printf '%s\n' ${!OPTIND}; shift; done) + + [[ $cur == *@* ]] && user=${cur%@*}@ && cur=${cur#*@} + kh=() + + # ssh config files + if [ -n "$configfile" ]; then + [ -r "$configfile" ] && + config=( "${config[@]}" "$configfile" ) + else + for i in /etc/ssh/ssh_config "${HOME}/.ssh/config" \ + "${HOME}/.ssh2/config"; do + [ -r $i ] && config=( "${config[@]}" "$i" ) + done + fi + + # Known hosts files from configs + if [ ${#config[@]} -gt 0 ]; then + local OIFS=$IFS IFS=$'\n' + local -a tmpkh + # expand paths (if present) to global and user known hosts files + # TODO(?): try to make known hosts files with more than one consecutive + # spaces in their name work (watch out for ~ expansion + # breakage! Alioth#311595) + tmpkh=( $( awk 'sub("^[ \t]*([Gg][Ll][Oo][Bb][Aa][Ll]|[Uu][Ss][Ee][Rr])[Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee][ \t]+", "") { print $0 }' "${config[@]}" | sort -u ) ) + for i in "${tmpkh[@]}"; do + # Remove possible quotes + i=${i//\"} + # Eval/expand possible `~' or `~user' + __expand_tilde_by_ref i + [ -r "$i" ] && kh=( "${kh[@]}" "$i" ) + done + IFS=$OIFS + fi + + if [ -z "$configfile" ]; then + # Global and user known_hosts files + for i in /etc/ssh/ssh_known_hosts /etc/ssh/ssh_known_hosts2 \ + /etc/known_hosts /etc/known_hosts2 ~/.ssh/known_hosts \ + ~/.ssh/known_hosts2; do + [ -r $i ] && kh=( "${kh[@]}" $i ) + done + for i in /etc/ssh2/knownhosts ~/.ssh2/hostkeys; do + [ -d $i ] && khd=( "${khd[@]}" $i/*pub ) + done + fi + + # If we have known_hosts files to use + if [[ ${#kh[@]} -gt 0 || ${#khd[@]} -gt 0 ]]; then + # Escape slashes and dots in paths for awk + awkcur=${cur//\//\\\/} + awkcur=${awkcur//\./\\\.} + curd=$awkcur + + if [[ "$awkcur" == [0-9]*[.:]* ]]; then + # Digits followed by a dot or a colon - just search for that + awkcur="^$awkcur[.:]*" + elif [[ "$awkcur" == [0-9]* ]]; then + # Digits followed by no dot or colon - search for digits followed + # by a dot or a colon + awkcur="^$awkcur.*[.:]" + elif [ -z "$awkcur" ]; then + # A blank - search for a dot, a colon, or an alpha character + awkcur="[a-z.:]" + else + awkcur="^$awkcur" + fi + + if [ ${#kh[@]} -gt 0 ]; then + # FS needs to look for a comma separated list + COMPREPLY=( "${COMPREPLY[@]}" $( awk 'BEGIN {FS=","} + /^\s*[^|\#]/ {for (i=1; i<=2; ++i) { \ + sub(" .*$", "", $i); \ + sub("^\\[", "", $i); sub("\\](:[0-9]+)?$", "", $i); \ + if ($i ~ /'"$awkcur"'/) {print $i} \ + }}' "${kh[@]}" 2>/dev/null ) ) + fi + if [ ${#khd[@]} -gt 0 ]; then + # Needs to look for files called + # .../.ssh2/key_22_.pub + # dont fork any processes, because in a cluster environment, + # there can be hundreds of hostkeys + for i in "${khd[@]}" ; do + if [[ "$i" == *key_22_$curd*.pub && -r "$i" ]]; then + host=${i/#*key_22_/} + host=${host/%.pub/} + COMPREPLY=( "${COMPREPLY[@]}" $host ) + fi + done + fi + + # apply suffix and prefix + for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do + COMPREPLY[i]=$prefix$user${COMPREPLY[i]}$suffix + done + fi + + # append any available aliases from config files + if [[ ${#config[@]} -gt 0 && -n "$aliases" ]]; then + local hosts=$( sed -ne 's/^[ \t]*[Hh][Oo][Ss][Tt]\([Nn][Aa][Mm][Ee]\)\{0,1\}['"$'\t '"']\{1,\}\([^#*?]*\)\(#.*\)\{0,1\}$/\2/p' "${config[@]}" ) + COMPREPLY=( "${COMPREPLY[@]}" $( compgen -P "$prefix$user" \ + -S "$suffix" -W "$hosts" -- "$cur" ) ) + fi + + # Add hosts reported by avahi-browse, if desired and it's available. + if [[ ${COMP_KNOWN_HOSTS_WITH_AVAHI:-} ]] && \ + type avahi-browse &>/dev/null; then + # The original call to avahi-browse also had "-k", to avoid lookups + # into avahi's services DB. We don't need the name of the service, and + # if it contains ";", it may mistify the result. But on Gentoo (at + # least), -k wasn't available (even if mentioned in the manpage) some + # time ago, so... + COMPREPLY=( "${COMPREPLY[@]}" $( \ + compgen -P "$prefix$user" -S "$suffix" -W \ + "$( avahi-browse -cpr _workstation._tcp 2>/dev/null | \ + awk -F';' '/^=/ { print $7 }' | sort -u )" -- "$cur" ) ) + fi + + # Add results of normal hostname completion, unless + # `COMP_KNOWN_HOSTS_WITH_HOSTFILE' is set to an empty value. + if [ -n "${COMP_KNOWN_HOSTS_WITH_HOSTFILE-1}" ]; then + COMPREPLY=( "${COMPREPLY[@]}" + $( compgen -A hostname -P "$prefix$user" -S "$suffix" -- "$cur" ) ) + fi + + __ltrim_colon_completions "$prefix$user$cur" + + return 0 +} # _known_hosts_real() +complete -F _known_hosts traceroute traceroute6 tracepath tracepath6 ping \ + ping6 fping fping6 telnet host nslookup rsh rlogin ftp dig mtr \ + ssh-installkeys showmount + +# This meta-cd function observes the CDPATH variable, so that cd additionally +# completes on directories under those specified in CDPATH. +# +_cd() +{ + local cur IFS=$'\n' i j k + _get_comp_words_by_ref cur + + # try to allow variable completion + if [[ "$cur" == ?(\\)\$* ]]; then + COMPREPLY=( $( compgen -v -P '$' -- "${cur#?(\\)$}" ) ) + return 0 + fi + + _compopt_o_filenames + + # Use standard dir completion if no CDPATH or parameter starts with /, + # ./ or ../ + if [[ -z "${CDPATH:-}" || "$cur" == ?(.)?(.)/* ]]; then + _filedir -d + return 0 + fi + + local -r mark_dirs=$(_rl_enabled mark-directories && echo y) + local -r mark_symdirs=$(_rl_enabled mark-symlinked-directories && echo y) + + # we have a CDPATH, so loop on its contents + for i in ${CDPATH//:/$'\n'}; do + # create an array of matched subdirs + k="${#COMPREPLY[@]}" + for j in $( compgen -d $i/$cur ); do + if [[ ( $mark_symdirs && -h $j || $mark_dirs && ! -h $j ) && ! -d ${j#$i/} ]]; then + j="${j}/" + fi + COMPREPLY[k++]=${j#$i/} + done + done + + _filedir -d + + if [[ ${#COMPREPLY[@]} -eq 1 ]]; then + i=${COMPREPLY[0]} + if [[ "$i" == "$cur" && $i != "*/" ]]; then + COMPREPLY[0]="${i}/" + fi + fi + + return 0 +} +if shopt -q cdable_vars; then + complete -v -F _cd -o nospace cd +else + complete -F _cd -o nospace cd +fi + +# a wrapper method for the next one, when the offset is unknown +_command() +{ + local offset i + + # find actual offset, as position of the first non-option + offset=1 + for (( i=1; i <= COMP_CWORD; i++ )); do + if [[ "${COMP_WORDS[i]}" != -* ]]; then + offset=$i + break + fi + done + _command_offset $offset +} + +# A meta-command completion function for commands like sudo(8), which need to +# first complete on a command, then complete according to that command's own +# completion definition - currently not quite foolproof (e.g. mount and umount +# don't work properly), but still quite useful. +# +_command_offset() +{ + local cur func cline cspec noglob cmd i char_offset word_offset \ + _COMMAND_FUNC _COMMAND_FUNC_ARGS + + word_offset=$1 + + # rewrite current completion context before invoking + # actual command completion + + # find new first word position, then + # rewrite COMP_LINE and adjust COMP_POINT + local first_word=${COMP_WORDS[$word_offset]} + for (( i=0; i <= ${#COMP_LINE}; i++ )); do + if [[ "${COMP_LINE:$i:${#first_word}}" == "$first_word" ]]; then + char_offset=$i + break + fi + done + COMP_LINE=${COMP_LINE:$char_offset} + COMP_POINT=$(( COMP_POINT - $char_offset )) + + # shift COMP_WORDS elements and adjust COMP_CWORD + for (( i=0; i <= COMP_CWORD - $word_offset; i++ )); do + COMP_WORDS[i]=${COMP_WORDS[i+$word_offset]} + done + for (( i; i <= COMP_CWORD; i++ )); do + unset COMP_WORDS[i]; + done + COMP_CWORD=$(( $COMP_CWORD - $word_offset )) + + COMPREPLY=() + _get_comp_words_by_ref cur + + if [[ $COMP_CWORD -eq 0 ]]; then + _compopt_o_filenames + COMPREPLY=( $( compgen -c -- "$cur" ) ) + else + cmd=${COMP_WORDS[0]} + if complete -p ${cmd##*/} &>/dev/null; then + cspec=$( complete -p ${cmd##*/} ) + if [ "${cspec#* -F }" != "$cspec" ]; then + # complete -F + + # get function name + func=${cspec#*-F } + func=${func%% *} + + if [[ ${#COMP_WORDS[@]} -ge 2 ]]; then + $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}" "${COMP_WORDS[${#COMP_WORDS[@]}-2]}" + else + $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}" + fi + + # remove any \: generated by a command that doesn't + # default to filenames or dirnames (e.g. sudo chown) + # FIXME: I'm pretty sure this does not work! + if [ "${cspec#*-o }" != "$cspec" ]; then + cspec=${cspec#*-o } + cspec=${cspec%% *} + if [[ "$cspec" != @(dir|file)names ]]; then + COMPREPLY=("${COMPREPLY[@]//\\\\:/:}") + else + _compopt_o_filenames + fi + fi + elif [ -n "$cspec" ]; then + cspec=${cspec#complete}; + cspec=${cspec%%${cmd##*/}}; + COMPREPLY=( $( eval compgen "$cspec" -- "$cur" ) ); + fi + elif [ ${#COMPREPLY[@]} -eq 0 ]; then + _filedir + fi + fi +} +complete -F _command aoss command do else eval exec ltrace nice nohup padsp \ + then time tsocks vsound xargs + +_root_command() +{ + local PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin + local root_command=$1 + _command $1 $2 $3 +} +complete -F _root_command fakeroot gksu gksudo kdesudo really sudo + +# Return true if the completion should be treated as running as root +_complete_as_root() +{ + [[ $EUID -eq 0 || ${root_command:-} ]] +} + +_longopt() +{ + local cur prev split=false + _get_comp_words_by_ref -n = cur prev + + _split_longopt && split=true + + case "$prev" in + --*[Dd][Ii][Rr]*) + _filedir -d + return 0 + ;; + --*[Ff][Ii][Ll][Ee]*|--*[Pp][Aa][Tt][Hh]*) + _filedir + return 0 + ;; + esac + + $split && return 0 + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W "$( $1 --help 2>&1 | \ + sed -ne 's/.*\(--[-A-Za-z0-9]\{1,\}\).*/\1/p' | sort -u )" \ + -- "$cur" ) ) + elif [[ "$1" == @(mk|rm)dir ]]; then + _filedir -d + else + _filedir + fi +} +# makeinfo and texi2dvi are defined elsewhere. +for i in a2ps awk bash bc bison cat colordiff cp csplit \ + curl cut date df diff dir du enscript env expand fmt fold gperf gprof \ + grep grub head indent irb ld ldd less ln ls m4 md5sum mkdir mkfifo mknod \ + mv netstat nl nm objcopy objdump od paste patch pr ptx readelf rm rmdir \ + sed seq sha{,1,224,256,384,512}sum shar sort split strip tac tail tee \ + texindex touch tr uname unexpand uniq units vdir wc wget who; do + have $i && complete -F _longopt -o default $i +done +unset i + +_filedir_xspec() +{ + local IFS cur xspec + + IFS=$'\n' + COMPREPLY=() + _get_comp_words_by_ref cur + + _expand || return 0 + + # get first exclusion compspec that matches this command + xspec=$( awk "/^complete[ \t]+.*[ \t]${1##*/}([ \t]|\$)/ { print \$0; exit }" \ + "$BASH_COMPLETION" ) + # prune to leave nothing but the -X spec + xspec=${xspec#*-X } + xspec=${xspec%% *} + + local -a toks + local tmp + + toks=( ${toks[@]-} $( + compgen -d -- "$(quote_readline "$cur")" | { + while read -r tmp; do + # see long TODO comment in _filedir() --David + printf '%s\n' $tmp + done + } + )) + + # Munge xspec to contain uppercase version too + eval xspec="${xspec}" + local matchop=! + if [[ $xspec == !* ]]; then + xspec=${xspec#!} + matchop=@ + fi + [[ ${BASH_VERSINFO[0]} -ge 4 ]] && \ + xspec="$matchop($xspec|${xspec^^})" || \ + xspec="$matchop($xspec|$(printf %s $xspec | tr '[:lower:]' '[:upper:]'))" + + toks=( ${toks[@]-} $( + eval compgen -f -X "!$xspec" -- "\$(quote_readline "\$cur")" | { + while read -r tmp; do + [ -n $tmp ] && printf '%s\n' $tmp + done + } + )) + + [ ${#toks[@]} -ne 0 ] && _compopt_o_filenames + COMPREPLY=( "${toks[@]}" ) +} +list=( $( sed -ne '/^# START exclude/,/^# FINISH exclude/p' "$BASH_COMPLETION" | \ + # read exclusion compspecs + ( + while read line + do + # ignore compspecs that are commented out + if [ "${line#\#}" != "$line" ]; then continue; fi + line=${line%# START exclude*} + line=${line%# FINISH exclude*} + line=${line##*\'} + list=( "${list[@]}" $line ) + done + printf '%s ' "${list[@]}" + ) + ) ) +# remove previous compspecs +if [ ${#list[@]} -gt 0 ]; then + eval complete -r ${list[@]} + # install new compspecs + eval complete -F _filedir_xspec "${list[@]}" +fi +unset list + +# source completion directory definitions +if [[ -d $BASH_COMPLETION_COMPAT_DIR && -r $BASH_COMPLETION_COMPAT_DIR && \ + -x $BASH_COMPLETION_COMPAT_DIR ]]; then + for i in $(LC_ALL=C command ls "$BASH_COMPLETION_COMPAT_DIR"); do + i=$BASH_COMPLETION_COMPAT_DIR/$i + [[ ${i##*/} != @(*~|*.bak|*.swp|\#*\#|*.dpkg*|*.rpm@(orig|new|save)|Makefile*) \ + && -f $i && -r $i ]] && . "$i" + done +fi +if [[ $BASH_COMPLETION_DIR != $BASH_COMPLETION_COMPAT_DIR && \ + -d $BASH_COMPLETION_DIR && -r $BASH_COMPLETION_DIR && \ + -x $BASH_COMPLETION_DIR ]]; then + for i in $(LC_ALL=C command ls "$BASH_COMPLETION_DIR"); do + i=$BASH_COMPLETION_DIR/$i + [[ ${i##*/} != @(*~|*.bak|*.swp|\#*\#|*.dpkg*|*.rpm@(orig|new|save)|Makefile*) \ + && -f $i && -r $i ]] && . "$i" + done +fi +unset i + +# source user completion file +[[ $BASH_COMPLETION != ~/.bash_completion && -r ~/.bash_completion ]] \ + && . ~/.bash_completion +unset -f have +unset UNAME USERLAND have + +set $BASH_COMPLETION_ORIGINAL_V_VALUE +unset BASH_COMPLETION_ORIGINAL_V_VALUE + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/abook b/.bash/bash_completion.d/abook new file mode 100644 index 0000000..f09c8b5 --- /dev/null +++ b/.bash/bash_completion.d/abook @@ -0,0 +1,62 @@ +# abook(1) completion + +have abook && +_abook() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + # abook only takes options, tabbing after command name adds a single + # dash (bash4) + [[ ${BASH_VERSINFO[0]} -ge 4 && $COMP_CWORD -eq 1 && -z "$cur" ]] && + { + compopt -o nospace + COMPREPLY=( "-" ) + return 0 + } + + case $cur in + -*) + _longopt abook + return 0 + ;; + esac + + case $prev in + --informat) + COMPREPLY=( $( compgen -W "$(abook --formats | \ + sed -n -e 's/^\t\([a-z]*\).*/\1/p' -e '/^$/q')" -- "$cur" ) ) + return 0 + ;; + --outformat) + COMPREPLY=( $( compgen -W "$(abook --formats | \ + sed -n -e '/^$/,$s/^\t\([a-z]*\).*/\1/p')" -- "$cur" ) ) + return 0 + ;; + --infile) + COMPREPLY=( $( compgen -W stdin -- "$cur" ) ) + _filedir + return 0 + ;; + --outfile) + COMPREPLY=( $( compgen -W stdout -- "$cur" ) ) + _filedir + return 0 + ;; + --config|--datafile) + _filedir + return 0 + ;; + esac +} && +complete -F _abook abook + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/ant b/.bash/bash_completion.d/ant new file mode 100644 index 0000000..132c439 --- /dev/null +++ b/.bash/bash_completion.d/ant @@ -0,0 +1,70 @@ +# bash completion for ant + +have ant && +{ +_ant() +{ + local cur prev buildfile i + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -buildfile|-file|-f) + _filedir 'xml' + return 0 + ;; + -logfile|-l) + _filedir + return 0 + ;; + -propertyfile) + _filedir properties + return 0 + ;; + -nice) + COMPREPLY=( $( compgen -W '1 2 3 4 5 6 7 8 9 10' -- "$cur" ) ) + return 0 + ;; + -lib|-logger|-listener|-D|-inputhandler|-main) + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-help -projecthelp -version -diagnostics \ + -quiet -verbose -debug -emacs -lib -logfile -logger -listener \ + -noinput -buildfile -D -keep-going -propertyfile -inputhandler \ + -find -s -nice -nouserlib -noclasspath -autoproxy -main' \ + -- "$cur" ) ) + else + # available targets completion + # find which buildfile to use + buildfile=build.xml + for (( i=1; i < COMP_CWORD; i++ )); do + if [[ "${COMP_WORDS[i]}" == -@(?(build)file|f) ]]; then + buildfile=${COMP_WORDS[i+1]} + break + fi + done + [ ! -f $buildfile ] && return 0 + + # parse buildfile for targets + # some versions of sed complain if there's no trailing linefeed, + # hence the 2>/dev/null + COMPREPLY=( $( compgen -W "$( cat $buildfile | tr "'\t\n>" "\" \n" | \ + sed -ne 's/.*/dev/null )" \ + -- "$cur" ) ) + fi +} +have complete-ant-cmd.pl && \ + complete -C complete-ant-cmd.pl -F _ant ant || complete -F _ant ant +} + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/apache2ctl b/.bash/bash_completion.d/apache2ctl new file mode 100644 index 0000000..287443a --- /dev/null +++ b/.bash/bash_completion.d/apache2ctl @@ -0,0 +1,24 @@ +# apache2ctl(1) completion + +have apache2ctl && { +_apache2ctl() { + local APWORDS cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + APWORDS=$(apache2ctl 2>&1 >/dev/null | awk 'NR<2 { print $3; exit }' | \ + tr "|" " ") + + COMPREPLY=( $( compgen -W "$APWORDS" -- "$cur" ) ) +} +complete -F _apache2ctl apache2ctl +} + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/apt b/.bash/bash_completion.d/apt new file mode 100644 index 0000000..84811ae --- /dev/null +++ b/.bash/bash_completion.d/apt @@ -0,0 +1,157 @@ +# Debian apt-get(8) completion. + +have apt-get && +_apt_get() +{ + local cur prev special i + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do + if [[ ${COMP_WORDS[i]} == @(install|remove|autoremove|purge|source|build-dep) ]]; then + special=${COMP_WORDS[i]} + fi + done + + if [ -n "$special" ]; then + case $special in + remove|autoremove|purge) + if [ -f /etc/debian_version ]; then + # Debian system + COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) ) + else + # assume RPM based + _rpm_installed_packages + fi + return 0 + ;; + source) + COMPREPLY=( $( apt-cache --no-generate pkgnames "$cur" \ + 2> /dev/null ) $( apt-cache dumpavail | \ + command grep "^Source: $cur" | sort -u | cut -f2 -d" " ) ) + return 0 + ;; + *) + COMPREPLY=( $( apt-cache --no-generate pkgnames "$cur" \ + 2> /dev/null ) ) + return 0 + ;; + esac + fi + + case $prev in + -c|--config-file) + _filedir + return 0 + ;; + -t|--target-release|--default-release) + COMPREPLY=( $( apt-cache policy | \ + command grep "release.o=Debian,a=$cur" | \ + sed -e "s/.*a=\(\w*\).*/\1/" | uniq 2> /dev/null) ) + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-d -f -h -v -m -q -s -y -u -t -b -c -o \ + --download-only --fix-broken --help --version --ignore-missing \ + --fix-missing --no-download --quiet --simulate --just-print \ + --dry-run --recon --no-act --yes --assume-yes --show-upgraded \ + --only-source --compile --build --ignore-hold --target-release \ + --no-upgrade --force-yes --print-uris --purge --reinstall \ + --list-cleanup --default-release --trivial-only --no-remove \ + --diff-only --no-install-recommends --tar-only --config-file \ + --option --auto-remove' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W 'update upgrade dselect-upgrade \ + dist-upgrade install remove purge source build-dep \ + check clean autoclean autoremove' -- "$cur" ) ) + fi + + return 0 +} && +complete -F _apt_get apt-get + +# Debian apt-cache(8) completion. +# +have apt-cache && +_apt_cache() +{ + local cur prev special i + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + if [ "$cur" != show ]; then + for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do + if [[ ${COMP_WORDS[i]} == @(add|depends|dotty|madison|policy|rdepends|show?(pkg|src|)) ]]; then + special=${COMP_WORDS[i]} + fi + done + fi + + + if [ -n "$special" ]; then + case $special in + add) + _filedir + return 0 + ;; + + showsrc) + COMPREPLY=( $( apt-cache dumpavail | \ + command grep "^Source: $cur" | sort -u | cut -f2 -d" " ) ) + return 0 + ;; + + *) + COMPREPLY=( $( apt-cache --no-generate pkgnames "$cur" 2> /dev/null ) ) + return 0 + ;; + + esac + fi + + + case $prev in + -c|-p|-s|--config-file|--pkg-cache|--src-cache) + _filedir + return 0 + ;; + search) + if [[ "$cur" != -* ]]; then + return 0 + fi + ;; + esac + + if [[ "$cur" == -* ]]; then + + COMPREPLY=( $( compgen -W '-h -v -p -s -q -i -f -a -g -c \ + -o --help --version --pkg-cache --src-cache \ + --quiet --important --full --all-versions \ + --no-all-versions --generate --no-generate \ + --names-only --all-names --recurse \ + --config-file --option --installed' -- "$cur" ) ) + else + + COMPREPLY=( $( compgen -W 'add gencaches show showpkg showsrc \ + stats dump dumpavail unmet search search \ + depends rdepends pkgnames dotty xvcg \ + policy madison' -- "$cur" ) ) + + fi + + + return 0 +} && +complete -F _apt_cache apt-cache + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/apt-build b/.bash/bash_completion.d/apt-build new file mode 100644 index 0000000..d875a98 --- /dev/null +++ b/.bash/bash_completion.d/apt-build @@ -0,0 +1,66 @@ +# Debian apt-build(1) completion. + +have apt-build && +_apt_build() +{ + local cur prev special i + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do + if [[ ${COMP_WORDS[i]} == @(install|remove|source|info|clean) ]]; then + special=${COMP_WORDS[i]} + fi + done + + if [ -n "$special" ]; then + case $special in + install|source|info) + COMPREPLY=( $( apt-cache pkgnames "$cur" 2> /dev/null ) ) + return 0 + ;; + remove) + COMPREPLY=( $( _comp_dpkg_installed_packages "$cur" ) ) + return 0 + ;; + *) + return 0 + ;; + esac + fi + + case $prev in + --patch|--build-dir|--repository-dir) + _filedir + return 0 + ;; + -h|--help) + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--help --show-upgraded -u --build-dir \ + --repository-dir --build-only --build-command --reinstall \ + --rebuild --remove-builddep --no-wrapper --purge --patch \ + --patch-strip -p --yes -y --version -v --no-source' -- "$cur" ) ) + + else + COMPREPLY=( $( compgen -W 'update upgrade install remove source \ + dist-upgrade world clean info clean-build update-repository' \ + -- "$cur" ) ) + fi + + + return 0 +} && +complete -F _apt_build apt-build + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/aptitude b/.bash/bash_completion.d/aptitude new file mode 100644 index 0000000..c00ad40 --- /dev/null +++ b/.bash/bash_completion.d/aptitude @@ -0,0 +1,98 @@ +# Debian aptitude(1) completion + +have aptitude && { +have grep-status && { +_comp_dpkg_hold_packages() +{ + grep-status -P -e "^$1" -a -FStatus 'hold' -n -s Package +} +} || { +_comp_dpkg_hold_packages() +{ + command grep -B 2 'hold' /var/lib/dpkg/status | \ + command grep "Package: $1" | cut -d\ -f2 +} +} + +_aptitude() +{ + local cur dashoptions prev special i + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + dashoptions='-S -u -i -h --help --version -s --simulate -d \ + --download-only -P --prompt -y --assume-yes -F \ + --display-format -O --sort -w --width -f -r -g \ + --with-recommends -R -G --without-recommends -t \ + --target-release -V --show-versions -D --show-deps\ + -Z -v --verbose --purge-unused --schedule-only' + + for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do + if [[ ${COMP_WORDS[i]} == @(@(|re)install|@(|un)hold|@(|un)markauto|@(dist|full)-upgrade|download|show|forbid-version|purge|remove|changelog|why@(|-not)|keep@(|-all)|build-dep|@(add|remove)-user-tag) ]]; then + special=${COMP_WORDS[i]} + fi + #exclude some mutually exclusive options + [[ ${COMP_WORDS[i]} == '-u' ]] && dashoptions=${dashoptions/-i} + [[ ${COMP_WORDS[i]} == '-i' ]] && dashoptions=${dashoptions/-u} + done + + if [[ -n "$special" ]]; then + case $special in + install|hold|markauto|unmarkauto|dist-upgrade|full-upgrade| \ + download|show|changelog|why|why-not|build-dep|add-user-tag| \ + remove-user-tag) + COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) ) + return 0 + ;; + purge|remove|reinstall|forbid-version) + COMPREPLY=( $( _comp_dpkg_installed_packages "$cur" ) ) + return 0 + ;; + unhold) + COMPREPLY=( $( _comp_dpkg_hold_packages "$cur" ) ) + return 0 + ;; + esac + fi + + case $prev in + # don't complete anything if these options are found + autoclean|clean|forget-new|search|safe-upgrade|upgrade|update|keep-all) + return 0 + ;; + -S) + _filedir + return 0 + ;; + -t|--target-release|--default-release) + COMPREPLY=( $( apt-cache policy | \ + command grep "release.o=Debian,a=$cur" | \ + sed -e "s/.*a=\(\w*\).*/\1/" | uniq 2> /dev/null ) ) + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W "$dashoptions" -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W 'update upgrade safe-upgrade forget-new \ + clean autoclean install reinstall remove \ + hold unhold purge markauto unmarkauto why why-not \ + dist-upgrade full-upgrade download search show \ + forbid-version changelog keep-all build-dep \ + add-user-tag remove-user-tag' -- "$cur" ) ) + fi + + return 0 +} +complete -F _aptitude -o default aptitude +} + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/aspell b/.bash/bash_completion.d/aspell new file mode 100644 index 0000000..5254eee --- /dev/null +++ b/.bash/bash_completion.d/aspell @@ -0,0 +1,96 @@ +# bash completion for aspell + +have aspell && { +_aspell_dictionary() +{ + local datadir + datadir=$( aspell config data-dir 2>/dev/null || echo /usr/lib/aspell ) + # First, get aliases (dicts dump does not list them) + COMPREPLY=( $( command ls $datadir/*.alias 2>/dev/null ) ) + COMPREPLY=( ${COMPREPLY[@]%.alias} ) + COMPREPLY=( ${COMPREPLY[@]#$datadir/} ) + # Then, add the canonical dicts + COMPREPLY=( "${COMPREPLY[@]}" $( aspell dicts 2>/dev/null ) ) + COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- "$cur" ) ) +} + +_aspell() +{ + local cur prev split=false + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + _split_longopt && split=true + + case $prev in + -c|-p|check|--conf|--personal|--repl|--per-conf) + _filedir + return 0 + ;; + --conf-dir|--data-dir|--dict-dir|--home-dir|--local-data-dir|--prefix) + _filedir -d + return 0 + ;; + dump|create|merge) + COMPREPLY=( $( compgen -W 'master personal repl' -- "$cur" ) ) + return 0 + ;; + --mode) + COMPREPLY=( $( compgen -W 'none url email sgml tex' -- "$cur" ) ) + return 0 + ;; + --sug-mode) + COMPREPLY=( $( compgen -W 'ultra fast normal bad-speller' -- "$cur" ) ) + return 0 + ;; + --keymapping) + COMPREPLY=( $( compgen -W 'aspell ispell' -- "$cur" ) ) + return 0 + ;; + -d|--master) + _aspell_dictionary + return 0 + ;; + esac + + $split && return 0 + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--conf --conf-dir --data-dir --dict-dir \ + --encoding --add-filter --rem-filter --mode \ + --add-extra-dicts --rem-extra-dicts \ + --home-dir --ignore --ignore-accents \ + --dont-ignore-accents --ignore-case --dont-ignore-case \ + --ignore-repl --dont-ignore-repl --jargon --keyboard \ + --lang --language-tag --local-data-dir --master \ + --module --add-module-search-order \ + --rem-module-search-order --per-conf --personal \ + --prefix --repl --run-together --dont-run-together \ + --run-together-limit --run-together-min --save-repl \ + --dont-save-repl --set-prefix --dont-set-prefix --size \ + --spelling --strip-accents --dont-strip-accents \ + --sug-mode --add-word-list-path --rem-word-list-path \ + --backup --dont-backup --reverse --dont-reverse \ + --time --dont-time --keymapping --add-email-quote \ + --rem-email-quote --email-margin --add-tex-command \ + --rem-tex-command --tex-check-comments \ + --dont-tex-check-comments --add-tex-extension \ + --rem-tex-extension --add-sgml-check --rem-sgml-check \ + --add-sgml-extension --rem-sgml-extension' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W 'usage help check pipe list \ + config soundslike filter version dump create merge' -- "$cur" ) ) + fi + +} +complete -F _aspell aspell +} + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/autoconf b/.bash/bash_completion.d/autoconf new file mode 100644 index 0000000..c8f1b19 --- /dev/null +++ b/.bash/bash_completion.d/autoconf @@ -0,0 +1,124 @@ +# Completions for autoconf tools + +have autoconf && +_autoconf() +{ + COMPREPLY=() + local cur prev split=false + _get_comp_words_by_ref cur prev + + _split_longopt && split=true + + case "$prev" in + --help|-h|--version|-V|--trace|-t) + return 0 + ;; + --output|-o) + _filedir + return 0 + ;; + --warnings|-W) + local cats=( cross obsolete syntax ) + COMPREPLY=( $( compgen -W \ + '${cats[@]} ${cats[@]/#/no-} all none error' -- "$cur" ) ) + return 0 + ;; + --prepend-include|-B|--include|-I) + _filedir -d + return 0 + ;; + esac + + $split && return 0 + + if [[ "$cur" == -* ]]; then + _longopt $1 + return + fi + + _filedir '@(ac|in)' +} && +complete -F _autoconf autoconf + +have autoreconf || have autoheader && +_autoreconf() +{ + COMPREPLY=() + local cur prev split=false + _get_comp_words_by_ref cur prev + + _split_longopt && split=true + + case "$prev" in + --help|-h|--version|-V) + return 0 + ;; + --warnings|-W) + local cats=( cross gnu obsolete override portability syntax \ + unsupported ) + COMPREPLY=( $( compgen -W \ + '${cats[@]} ${cats[@]/#/no-} all none error' -- "$cur" ) ) + return 0 + ;; + --prepend-include|-B|--include|-I) + _filedir -d + return 0 + ;; + esac + + $split && return 0 + + if [[ "$cur" == -* ]]; then + _longopt $1 + return 0 + fi + + if [[ $1 == autoheader ]] ; then + _filedir '@(ac|in)' + else + _filedir -d + fi +} && +complete -F _autoreconf autoreconf autoheader + +have autoscan || have autoupdate && +_autoscan() +{ + COMPREPLY=() + local cur prev split=false + _get_comp_words_by_ref cur prev + + _split_longopt && split=true + + case "$prev" in + --help|-h|--version|-V) + return 0 + ;; + --prepend-include|-B|--include|-I) + _filedir -d + return 0 + ;; + esac + + $split && return 0 + + if [[ "$cur" == -* ]]; then + _longopt $1 + return 0 + fi + + if [[ $1 == autoupdate ]] ; then + _filedir '@(ac|in)' + else + _filedir -d + fi +} && +complete -F _autoscan autoscan autoupdate + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/automake b/.bash/bash_completion.d/automake new file mode 100644 index 0000000..7ed8745 --- /dev/null +++ b/.bash/bash_completion.d/automake @@ -0,0 +1,80 @@ +# Completions for automake tools + +have automake && +_automake() +{ + COMPREPLY=() + local cur prev split=false + _get_comp_words_by_ref cur prev + + _split_longopt && split=true + + case "$prev" in + --help|--version) + return 0 + ;; + --warnings|-W) + local cats=( gnu obsolete override portability syntax unsupported ) + COMPREPLY=( $( compgen -W \ + '${cats[@]} ${cats[@]/#/no-} all none error' -- "$cur" ) ) + return 0 + ;; + --libdir) + _filedir -d + return 0 + ;; + esac + + $split && return 0 + + if [[ "$cur" == -* ]]; then + _longopt $1 + return + fi + + _filedir +} && +complete -F _automake automake automake-1.11 + +have aclocal && +_aclocal() +{ + COMPREPLY=() + local cur prev split=false + _get_comp_words_by_ref cur prev + + _split_longopt && split=true + + case "$prev" in + --help|--print-ac-dir|--version) + return 0 + ;; + --acdir|-I) + _filedir -d + return 0 + ;; + --output) + _filedir + return 0 + ;; + --warnings|-W) + local cats=( syntax unsupported ) + COMPREPLY=( $( compgen -W \ + '${cats[@]} ${cats[@]/#/no-} all none error' -- "$cur" ) ) + return 0 + ;; + esac + + $split && return 0 + + _longopt $1 +} && +complete -F _aclocal aclocal aclocal-1.11 + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/autorpm b/.bash/bash_completion.d/autorpm new file mode 100644 index 0000000..6a5f762 --- /dev/null +++ b/.bash/bash_completion.d/autorpm @@ -0,0 +1,23 @@ +# autorpm(8) completion + +have autorpm && +_autorpm() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + COMPREPLY=( $( compgen -W '--notty --debug --help --version auto add \ + fullinfo info help install list remove set' -- "$cur" ) ) + +} && +complete -F _autorpm autorpm + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/bash-builtins b/.bash/bash_completion.d/bash-builtins new file mode 100644 index 0000000..3eba8a1 --- /dev/null +++ b/.bash/bash_completion.d/bash-builtins @@ -0,0 +1,128 @@ +# bash alias completion +# +_alias() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + case $COMP_LINE in + *[^=]) + COMPREPLY=( $( compgen -A alias -- "$cur" ) ) + ;; + *=) + COMPREPLY=( "$( alias ${cur%=} 2>/dev/null | sed \ + -e 's|^alias '"$cur"'\(.*\)$|\1|' )" ) + ;; + esac +} +complete -F _alias -o nospace alias + +# bash export completion +# +_export() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + case $COMP_LINE in + *=\$*) + COMPREPLY=( $( compgen -v -P '$' -- "${cur#*=\$}" ) ) + ;; + *[^=]) + COMPREPLY=( $( compgen -v -S '=' -- "$cur" ) ) + ;; + *=) + COMPREPLY=( "$( eval echo -n \"$`echo ${cur%=}`\" | + ( echo -n \' + sed -e 's/'\''/'\''\\\'\'''\''/g' + echo -n \' ) )" ) + ;; + esac +} +complete -F _export -o default -o nospace export + +# bash shell function completion +# +_function() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + if [[ $1 == @(declare|typeset) ]]; then + if [ "$prev" = -f ]; then + COMPREPLY=( $( compgen -A function -- "$cur" ) ) + elif [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-a -f -F -i -r -x -p' -- "$cur" ) ) + fi + elif [ $COMP_CWORD -eq 1 ]; then + COMPREPLY=( $( compgen -A function -- "$cur" ) ) + else + COMPREPLY=( "() $( type -- ${COMP_WORDS[1]} | sed -e 1,2d )" ) + fi +} +complete -F _function function declare typeset + +# bash complete completion +# +_complete() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -o) + COMPREPLY=( $( compgen -W 'bashdefault default dirnames filenames \ + nospace plusdirs' -- "$cur" ) ) + return 0 + ;; + + -A) + COMPREPLY=( $( compgen -W 'alias arrayvar binding builtin command \ + directory disabled enabled export file function group \ + helptopic hostname job keyword running service setopt shopt \ + signal stopped user variable' -- "$cur" ) ) + return 0 + ;; + + -C) + COMPREPLY=( $( compgen -A command -- "$cur" ) ) + return 0 + ;; + -F) + COMPREPLY=( $( compgen -A function -- "$cur" ) ) + return 0 + ;; + -p|-r) + COMPREPLY=( $( complete -p | sed -e 's|.* ||' ) ) + COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- "$cur" ) ) + return 0 + ;; + + esac + + if [[ "$cur" == -* ]]; then + # relevant options completion + local opts="-a -b -c -d -e -f -g -j -k -o -s -u -v -A -G -W -P -S -X" + [[ $1 != compgen ]] && opts="$opts -F -C" + COMPREPLY=( $( compgen -W "$opts" -- "$cur" ) ) + else + COMPREPLY=( $( compgen -A command -- "$cur" ) ) + fi +} +complete -F _complete compgen complete + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/bind-utils b/.bash/bash_completion.d/bind-utils new file mode 100644 index 0000000..040d197 --- /dev/null +++ b/.bash/bash_completion.d/bind-utils @@ -0,0 +1,23 @@ +# bash completion for nslookup + +have nslookup && +_nslookup() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + COMPREPLY=( $( compgen -P '-' -W 'all class= debug d2 domain= srchlist= \ + defname search port= querytype= type= recurse retry root timeout vc \ + ignoretc' -- "$cur" ) ) +} && +complete -F _nslookup nslookup + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/bitkeeper b/.bash/bash_completion.d/bitkeeper new file mode 100644 index 0000000..4c312a1 --- /dev/null +++ b/.bash/bash_completion.d/bitkeeper @@ -0,0 +1,26 @@ +# BitKeeper completion adapted from code by Bart Trojanowski + +have bk && +_bk() { + local BKCMDS + + COMPREPLY=() + _get_comp_words_by_ref cur + + BKCMDS="$( bk help topics | awk '/^ bk/ { print $4 }' | \ + xargs printf '%s ' )" + + COMPREPLY=( $( compgen -W "$BKCMDS" -- "$cur" ) ) + _filedir + + return 0 +} && +complete -F _bk bk + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/bittorrent b/.bash/bash_completion.d/bittorrent new file mode 100644 index 0000000..761d083 --- /dev/null +++ b/.bash/bash_completion.d/bittorrent @@ -0,0 +1,41 @@ +# btdownloadheadless(1) completion + +have btdownloadheadless.py || have btdownloadcurses.py || \ +have btdownloadgui.py && +_btdownload() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + --responsefile|--saveas) + _filedir + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--max_uploads --keepalive_interval \ + --download_slice_size --request_backlog --max_message_length \ + --ip --minport --maxport --responsefile --url --saveas --timeout \ + --timeout_check_interval --max_slice_length --max_rate_period \ + --bind --upload_rate_fudge --display_interval --rerequest_interval \ + --min_peers --http_timeout --max_initiate --max_allow_in \ + --check_hashes --max_upload_rate --snub_time --spew \ + --rarest_first_cutoff --min_uploads --report_hash_failures' \ + -- "$cur" ) ) + else + _filedir + fi +} && +complete -F _btdownload btdownloadheadless.py btdownloadcurses.py btdownloadgui.py + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/bluez b/.bash/bash_completion.d/bluez new file mode 100644 index 0000000..7a2b1e5 --- /dev/null +++ b/.bash/bash_completion.d/bluez @@ -0,0 +1,432 @@ +# bash completion for bluez utils + +have hcitool && { +_bluetooth_adresses() +{ + if [ -n "${COMP_BLUETOOTH_SCAN:-}" ]; then + COMPREPLY=( ${COMPREPLY[@]:-} $( compgen -W "$( hcitool scan | \ + awk '/^\t/{print $1}' )" -- "$cur" ) ) + fi +} + +_bluetooth_devices() +{ + COMPREPLY=( ${COMPREPLY[@]:-} $( compgen -W "$( hcitool dev | \ + awk '/^\t/{print $1}' )" -- "$cur" ) ) +} + +_bluetooth_services() +{ + COMPREPLY=( $( compgen -W 'DID SP DUN LAN FAX OPUSH FTP HS HF HFAG \ + SAP NAP GN PANU HCRP HID CIP A2SRC A2SNK AVRCT AVRTG UDIUE \ + UDITE SYNCML' -- "$cur" ) ) +} + +_bluetooth_packet_types() +{ + COMPREPLY=( $( compgen -W 'DM1 DM3 DM5 DH1 DH3 DH5 HV1 HV2 HV3' \ + -- "$cur" ) ) +} + +_hcitool() +{ + local cur prev split=false arg + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + _split_longopt && split=true + + case $prev in + -i) + _bluetooth_devices + return 0; + ;; + --role) + COMPREPLY=( $( compgen -W 'm s' -- "$cur" ) ) + return 0; + ;; + --pkt-type) + _bluetooth_packet_types + return 0; + ;; + esac + + $split && return 0 + + _get_first_arg + if [ -z $arg ]; then + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--help -i' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W 'dev inq scan name info \ + spinq epinq cmd con cc dc sr cpt rssi lq tpl \ + afh lst auth enc key clkoff clock' -- "$cur" ) ) + fi + else + case $arg in + name|info|dc|rssi|lq|afh|auth|key|clkoff|lst) + _count_args + if [ $args -eq 2 ]; then + _bluetooth_adresses + fi + ;; + cc) + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--role --pkt-type' -- "$cur" ) ) + else + _count_args + if [ $args -eq 2 ]; then + _bluetooth_adresses + fi + fi + ;; + sr) + _count_args + if [ $args -eq 2 ]; then + _bluetooth_adresses + else + COMPREPLY=( $( compgen -W 'master slave' -- "$cur" ) ) + fi + ;; + cpt) + _count_args + if [ $args -eq 2 ]; then + _bluetooth_adresses + else + _bluetooth_packet_types + fi + ;; + tpl|enc|clock) + _count_args + if [ $args -eq 2 ]; then + _bluetooth_adresses + else + COMPREPLY=( $( compgen -W '0 1' -- "$cur" ) ) + fi + ;; + esac + fi +} +complete -F _hcitool hcitool + +_sdptool() +{ + local cur prev split=false + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + _split_longopt && split=true + + case $prev in + --bdaddr) + _bluetooth_adresses + return 0; + ;; + esac + + $split && return 0 + + _get_first_arg + if [ -z $arg ]; then + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--help' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W 'search browse records add \ + del get setattr setseq' -- "$cur" ) ) + fi + else + case $arg in + search) + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--bdaddr \ + --tree --raw --xml' -- "$cur" ) ) + else + _bluetooth_services + fi + ;; + browse|records) + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--tree --raw --xml' -- "$cur" ) ) + else + _bluetooth_adresses + fi + ;; + add) + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--handle --channel' -- "$cur" ) ) + else + _bluetooth_services + fi + ;; + get) + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--bdaddr \ + --tree --raw --xml' -- "$cur" ) ) + fi + ;; + esac + fi +} +complete -F _sdptool sdptool + +_l2ping() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -i) + _bluetooth_devices + return 0; + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-i -s -c -t -f -r' -- "$cur" ) ) + else + _bluetooth_adresses + fi + +} +complete -F _l2ping l2ping + +_rfcomm() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -f|--config) + _filedir + return 0; + ;; + -i) + _bluetooth_devices + _bluetooth_adresses + return 0; + ;; + esac + + _get_first_arg + if [ -z $arg ]; then + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--help -a --raw \ + --config -i --auth --encrypt --secure --master' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W 'show connect listen watch \ + bind release' -- "$cur" ) ) + fi + else + _count_args + if [ $args -eq 2 ]; then + _bluetooth_devices + else + case $arg in + connect|bind) + if [ $args -eq 3 ]; then + _bluetooth_adresses + fi + ;; + esac + fi + fi +} +complete -F _rfcomm rfcomm + +_ciptool() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -i) + _bluetooth_devices + _bluetooth_adresses + return 0; + ;; + esac + + _get_first_arg + if [ -z $arg ]; then + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--help -i' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W 'show search connect release \ + loopback' -- "$cur" ) ) + fi + else + case $arg in + connect|release|loopback) + _count_args + if [ $args -eq 2 ]; then + _bluetooth_adresses + fi + ;; + esac + fi +} +complete -F _ciptool ciptool + +_dfutool() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -d|--device) + _bluetooth_devices + return 0; + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--help --device' -- "$cur" ) ) + else + _count_args + case $args in + 1) + COMPREPLY=( $( compgen -W 'verify modify \ + upgrade archive' -- "$cur" ) ) + ;; + 2) + _filedir + ;; + esac + fi +} +complete -F _dfutool dfutool + +_hciconfig() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + _get_first_arg + if [ -z $arg ]; then + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--help --all' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W 'up down reset rstat auth \ + noauth encrypt noencrypt secmgr nosecmgr \ + piscan noscan iscan pscan ptype name class \ + voice iac inqmode inqdata inqtype inqparams \ + pageparms pageto afhmode aclmtu scomtu putkey \ + delkey commands features version revision lm' \ + -- "$cur" ) ) + fi + else + case $arg in + putkey|delkey) + _count_args + if [ $args -eq 2 ]; then + _bluetooth_adresses + fi + ;; + lm) + _count_args + if [ $args -eq 2 ]; then + COMPREPLY=( $( compgen -W 'MASTER \ + SLAVE NONE ACCEPT' -- "$cur" ) ) + fi + ;; + ptype) + _count_args + if [ $args -eq 2 ]; then + _bluetooth_packet_types + fi + ;; + esac + fi +} +complete -F _hciconfig hciconfig + +_hciattach() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-n -p -t -b -s -l' -- "$cur" ) ) + else + _count_args + case $args in + 1) + COMPREPLY=( $( printf '%s\n' /dev/tty* ) ) + COMPREPLY=( $( compgen -W '${COMPREPLY[@]} \ + ${COMPREPLY[@]#/dev/}' -- "$cur" ) ) + ;; + 2) + COMPREPLY=( $( compgen -W 'any ericsson digi \ + xircom csr bboxes swave bcsp 0x0105 \ + 0x080a 0x0160 0x0002' -- "$cur" ) ) + ;; + 3) + COMPREPLY=( $( compgen -W '9600 19200 38400 \ + 57600 115200 230400 460800 921600' -- "$cur" ) ) + ;; + 4) + COMPREPLY=( $( compgen -W 'flow noflow' -- "$cur" ) ) + ;; + 5) + _bluetooth_adresses + ;; + esac + fi + +} +complete -F _hciattach hciattach + +_hid2hci() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--help --quiet -0 --tohci -1 \ + --tohid' -- "$cur" ) ) + fi +} +complete -F _hid2hci hid2hci + +_avctrl() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--help --quiet' -- "$cur" ) ) + else + _count_args + if [ $args -eq 1 ]; then + COMPREPLY=( $( compgen -W 'discover switch' -- "$cur" ) ) + fi + fi +} +complete -F _avctrl avctrl +} + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/brctl b/.bash/bash_completion.d/brctl new file mode 100644 index 0000000..1be86af --- /dev/null +++ b/.bash/bash_completion.d/brctl @@ -0,0 +1,48 @@ +# bash completion for brctl + +have brctl && +_brctl() +{ + local cur command + + COMPREPLY=() + _get_comp_words_by_ref cur + command=${COMP_WORDS[1]} + + case $COMP_CWORD in + 1) + COMPREPLY=( $( compgen -W "addbr delbr addif delif \ + setageing setbridgeprio setfd sethello \ + setmaxage setpathcost setportprio show \ + showmacs showstp stp" -- "$cur" ) ) + ;; + 2) + case $command in + show) + ;; + *) + COMPREPLY=( $( compgen -W "$(brctl show | \ + awk 'NR>1 {print $1}' )" -- "$cur" ) ) + esac + ;; + 3) + case $command in + addif|delif) + _configured_interfaces + ;; + stp) + COMPREPLY=( $( compgen -W 'on off' -- "$cur" ) ) + ;; + esac + ;; + esac +} && +complete -F _brctl -o default brctl + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/bzip2 b/.bash/bash_completion.d/bzip2 new file mode 100644 index 0000000..7e2f9fd --- /dev/null +++ b/.bash/bash_completion.d/bzip2 @@ -0,0 +1,51 @@ +# bash completion for bzip2 + +have bzip2 || have pbzip2 && +_bzip2() +{ + local cur prev xspec helpopts + + COMPREPLY=() + _get_comp_words_by_ref cur prev + helpopts=`_parse_help ${COMP_WORDS[0]}` + + case $prev in + -b|-h|--help|-p) + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W "${helpopts//#/} -2 -3 -4 -5 -6 -7 -8 -9" \ + -- "$cur" ) ) + return 0 + fi + + local IFS=$'\n' + + xspec="*.bz2" + if [[ "$prev" == --* ]]; then + [[ "$prev" == --decompress || \ + "$prev" == --list || \ + "$prev" == --test ]] && xspec="!"$xspec + [[ "$prev" == --compress ]] && xspec= + elif [[ "$prev" == -* ]]; then + [[ "$prev" == -*[dt]* ]] && xspec="!"$xspec + [[ "$prev" == -*z* ]] && xspec= + fi + + _expand || return 0 + + _compopt_o_filenames + COMPREPLY=( $( compgen -f -X "$xspec" -- "$cur" ) \ + $( compgen -d -- "$cur" ) ) +} && +complete -F _bzip2 bzip2 pbzip2 + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/cardctl b/.bash/bash_completion.d/cardctl new file mode 100644 index 0000000..1af7491 --- /dev/null +++ b/.bash/bash_completion.d/cardctl @@ -0,0 +1,24 @@ +# Linux cardctl(8) completion + +have cardctl || have pccardctl && +_cardctl() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + if [ $COMP_CWORD -eq 1 ]; then + COMPREPLY=( $( compgen -W 'status config ident suspend \ + resume reset eject insert scheme' -- "$cur" ) ) + fi +} && +complete -F _cardctl cardctl pccardctl + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/cfengine b/.bash/bash_completion.d/cfengine new file mode 100644 index 0000000..50a1384 --- /dev/null +++ b/.bash/bash_completion.d/cfengine @@ -0,0 +1,88 @@ +# bash completion for cfengine + +have cfagent && { +_cfagent_options() +{ + COMPREPLY=( $( compgen -W '--sysadm --force-net-copy --no-check-files \ + --no-check-mounts --debug --define --no-edits --enforce-links --file \ + --help --no-hard-classes --no-ifconfig --inform --no-copy --no-lock \ + --traverse-links --delete-stale-links --no-mount --no-modules \ + --dry-run --negate --parse-only --no-processes --no-splay \ + --no-commands --silent --no-tidy --use-env --underscore-classes \ + --verbose --version --no-preconf --no-links --quiet' -- "$cur" ) ) +} + +_cfagent() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -f|--file) + _filedir + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + _cfagent_options + fi +} +complete -F _cfagent cfagent + +_cfrun() +{ + local i section cfinputs cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + section=1 + for (( i=1; i < COMP_CWORD; i++ )); do + if [[ "${COMP_WORDS[i]}" == -- ]]; then + section=$((section + 1)) + fi + done + + case $section in + 1) + case $prev in + -f) + _filedir + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-f -h -d -S -T -v' -- $cur ) ) + else + hostfile=${CFINPUTS:-/var/lib/cfengine/inputs}/cfrun.hosts + for (( i=1; i < COMP_CWORD; i++ )); do + if [[ "${COMP_WORDS[i]}" == -f ]]; then + hostfile=${COMP_WORDS[i+1]} + break + fi + done + [ ! -f $hostfile ] && return 0 + + COMPREPLY=( $(compgen -W "$( command grep -v \ + -E '(=|^$|^#)' $hostfile )" -- "$cur" ) ) + fi + ;; + 2) + _cfagent_options + ;; + esac +} +complete -F _cfrun cfrun +} + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/chkconfig b/.bash/bash_completion.d/chkconfig new file mode 100644 index 0000000..2d02e56 --- /dev/null +++ b/.bash/bash_completion.d/chkconfig @@ -0,0 +1,44 @@ +# chkconfig(8) completion + +have chkconfig && +_chkconfig() +{ + local cur prev split=false + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + _split_longopt && split=true + + case $prev in + --level=[1-6]|[1-6]|--list|--add|--del|--override) + _services + return 0 + ;; + --level) + COMPREPLY=( $( compgen -W '1 2 3 4 5 6' -- "$cur" ) ) + return 0 + ;; + esac + + $split && return 0 + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--list --add --del --override --level' -- "$cur" ) ) + else + if [[ $COMP_CWORD -eq 2 || $COMP_CWORD -eq 4 ]]; then + COMPREPLY=( $( compgen -W 'on off reset resetpriorities' -- "$cur" ) ) + else + _services + fi + fi +} && +complete -F _chkconfig chkconfig + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/chsh b/.bash/bash_completion.d/chsh new file mode 100644 index 0000000..1af3630 --- /dev/null +++ b/.bash/bash_completion.d/chsh @@ -0,0 +1,37 @@ +# chsh(1) completion + +_chsh() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + --list-shells|--help|-v|--version) + return 0 + ;; + -s|--shell) + _shells + return 0 + ;; + esac + + if [[ "$cur" == -* && "$( uname -s )" == @(Linux|GNU|GNU/*) ]]; then + COMPREPLY=( $( compgen -W '--shell --list-shells --help --version' \ + -- "$cur" ) ) + else + COMPREPLY=( $( compgen -u -- "$cur" ) ) + fi + + return 0 +} +complete -F _chsh chsh + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/cksfv b/.bash/bash_completion.d/cksfv new file mode 100644 index 0000000..1f83824 --- /dev/null +++ b/.bash/bash_completion.d/cksfv @@ -0,0 +1,38 @@ +# cksfv completion by Chris + +have cksfv && +_cksfv() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + if [ $COMP_CWORD -eq 1 ]; then + COMPREPLY=( $( compgen -W '-C -f -i -q -v' -- "$cur" ) ) + return 0 + fi + + case "$prev" in + -C) + _filedir -d + return 0 + ;; + -f) + _filedir 'sfv' + return 0 + ;; + esac + + _filedir + return 0 +} && +complete -F _cksfv cksfv + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/clisp b/.bash/bash_completion.d/clisp new file mode 100644 index 0000000..074f692 --- /dev/null +++ b/.bash/bash_completion.d/clisp @@ -0,0 +1,31 @@ +# bash brogrammable completion for various Common Lisp implementations by +# Nikodemus Siivola + +have clisp && +_clisp() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + # completing an option (may or may not be separated by a space) + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-h --help --version --license -B -K \ + -M -m -L -N -E -q --quiet --silent -w -I -ansi \ + -traditional -p -C -norc -i -c -l -o -x ' -- "$cur" ) ) + else + _filedir + fi + + return 0 +} && +complete -F _clisp -o default clisp + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/configure b/.bash/bash_completion.d/configure new file mode 100644 index 0000000..1b20769 --- /dev/null +++ b/.bash/bash_completion.d/configure @@ -0,0 +1,44 @@ +# bash completion for configure + +_configure() +{ + local cur prev split=false + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + _split_longopt && split=true + + case $prev in + --*prefix|--*dir) + _filedir -d + ;; + esac + + $split && return 0 + + # if $COMP_CONFIGURE_HINTS is not null, then completions of the form + # --option=SETTING will include 'SETTING' as a contextual hint + [[ "$cur" != -* ]] && return 0 + + if [ -n "$COMP_CONFIGURE_HINTS" ]; then + COMPREPLY=( $( compgen -W "$( $1 --help 2>&1 | \ + awk '/^ --[A-Za-z]/ { print $1; \ + if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,].*//g' )" \ + -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W "$( $1 --help 2>&1 | \ + awk '/^ --[A-Za-z]/ { print $1; \ + if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,=].*//g' )" \ + -- "$cur" ) ) + fi +} +complete -F _configure configure + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/coreutils b/.bash/bash_completion.d/coreutils new file mode 100644 index 0000000..33d58cf --- /dev/null +++ b/.bash/bash_completion.d/coreutils @@ -0,0 +1,149 @@ +# Completions for various core utilities + +# chown(1) completion +# +have chown && +_chown() +{ + local cur prev split=false + + # Get cur and prev words; but don't treat user:group as separate words. + _get_comp_words_by_ref -n : cur prev + + _split_longopt && split=true + + case "$prev" in + --from) + _usergroup + return 0 + ;; + --reference) + _filedir + return 0 + ;; + esac + + $split && return 0 + + if [[ "$cur" == -* ]]; then + # Complete -options + local w opts + for w in "${COMP_WORDS[@]}" ; do + [[ "$w" == -@(R|-recursive) ]] && opts="-H -L -P" && break + done + COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes --dereference \ + --no-dereference --from --silent --quiet --reference --recursive \ + --verbose --help --version $opts' -- "$cur" ) ) + else + local args + + # The first argument is an usergroup; the rest are filedir. + _count_args : + + if [[ $args == 1 ]]; then + _usergroup -u + else + _filedir + fi + fi +} && +complete -F _chown chown + + +# chgrp(1) completion +# +have chgrp && +_chgrp() +{ + local cur prev split=false + + COMPREPLY=() + _get_comp_words_by_ref cur prev + cur=${cur//\\\\/} + + _split_longopt && split=true + + if [[ "$prev" == --reference ]]; then + _filedir + return 0 + fi + + $split && return 0 + + # options completion + if [[ "$cur" == -* ]]; then + local w opts + for w in "${COMP_WORDS[@]}" ; do + [[ "$w" == -@(R|-recursive) ]] && opts="-H -L -P" && break + done + COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes --dereference \ + --no-dereference --silent --quiet --reference --recursive \ + --verbose --help --version $opts' -- "$cur" ) ) + return 0 + fi + + # first parameter on line or first since an option? + if [[ $COMP_CWORD -eq 1 && "$cur" != -* || "$prev" == -* ]]; then + _allowed_groups + else + _filedir || return 0 + fi + + return 0 +} && +complete -F _chgrp chgrp + +# id(1) completion +# +have id && +_id() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-a -g --group -G --groups -n --name\ + -r --real -u --user --help --version' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -u "$cur" ) ) + fi +} && +complete -F _id id + +# mktemp(1) completion +# +have mktemp && +_mktemp() +{ + COMPREPLY=() + local cur prev split=false + _get_comp_words_by_ref cur prev + + _split_longopt && split=true + + case "$prev" in + --help|--version|--suffix) + return 0 + ;; + --tmpdir|-p) + _filedir -d + return 0 + ;; + esac + + $split && return 0 + + [[ "$cur" == -* ]] && \ + COMPREPLY=( $( compgen -W '-d -u -q -p -t' -- "$cur" ) ) +} && +complete -F _mktemp mktemp + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/cowsay b/.bash/bash_completion.d/cowsay new file mode 100644 index 0000000..c6d797a --- /dev/null +++ b/.bash/bash_completion.d/cowsay @@ -0,0 +1,31 @@ +# bash completion for cowsay + +have cowsay && +_cowsay() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -f) + COMPREPLY=( $( compgen -W '$( cowsay -l | tail -n +2)' -- "$cur" ) ) + return 0 + ;; + esac + + # relevant options completion + COMPREPLY=( $( compgen -W '-b -d -g -p -s -t -w -y -e -f -h -l -n -T -W' \ + -- "$cur" ) ) + +} && +complete -F _cowsay -o default cowsay cowthink + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/cpan2dist b/.bash/bash_completion.d/cpan2dist new file mode 100644 index 0000000..13f568a --- /dev/null +++ b/.bash/bash_completion.d/cpan2dist @@ -0,0 +1,52 @@ +# bash completion for cpan2dist + +have cpan2dist && +_cpan2dist() +{ + local cur prev packagelist cpandirs + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + --format) + # should remove ":" from COMP_WORDBREAKS, but doesn't work (?) + COMPREPLY=( $( compgen -W '$(perl -MCPANPLUS::Dist -e \ + "print map { \"\$_\n\" } CPANPLUS::Dist->dist_types")' \ + -- "$cur" ) ) + return 0 + ;; + --banlist|--ignorelist|--modulelist|--logfile) + _filedir + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--help --skiptest --force --install \ + --verbose --keepsource --makefile --buildprereq \ + --archive --flushcache --defaults --edit-metafile \ + --format --ban --banlist --ignore --ignorelist \ + --modulelist --logfile --timeout --set-config \ + --set-program --dist-opts --default-banlist \ + --default-ignorelist' -- $cur ) ) + else + cpandirs=( "$HOME/.cpanplus/" "$HOME/.cpan/source/modules/" ) + for dir in ${cpandirs[@]}; do + [[ -d "$dir" && -r "$dir/02packages.details.txt.gz" ]] && \ + packagelist="$dir/02packages.details.txt.gz" + done + COMPREPLY=( $( zgrep "^${cur//-/::}" \ + $packagelist 2>/dev/null \ + | awk '{print $1}' | sed -e 's/::/-/g' ) ) + fi +} && +complete -F _cpan2dist -o default cpan2dist + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/cpio b/.bash/bash_completion.d/cpio new file mode 100644 index 0000000..5ead018 --- /dev/null +++ b/.bash/bash_completion.d/cpio @@ -0,0 +1,103 @@ +# bash completion for cpio + +have cpio && { +_cpio_format() +{ + COMPREPLY=( $( compgen -W 'bin odc newc crc tar ustar hpbin hpodc' -- "$cur" ) ) +} + +_cpio() +{ + local cur prev split=false + + COMPREPLY=() + _get_comp_words_by_ref -n : cur prev + + _split_longopt && split=true + + # --name value style option + case $prev in + -H|--format) + _cpio_format + return 0 + ;; + -E|-F|-I|--file|--pattern-file) + _filedir + return 0 + ;; + -R|--owner) + _usergroup + return 0 + ;; + --rsh-command) + _compopt_o_filenames + COMPREPLY=( $( compgen -c -- "$cur" ) ) + return 0 + ;; + esac + + $split && return 0 + + if [ $COMP_CWORD -eq 1 ]; then + COMPREPLY=( $( compgen -W '-o --create -i --extract -p --pass-through \ + -? --help --license --usage --version' -- "$cur" ) ) + else + case ${COMP_WORDS[1]} in + -o|--create) + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-0 -a -c -v -A -B\ + -L -V -C -H -M -O -F --file --format\ + --message --null --reset-access-time\ + --verbose --dot --append --block-size\ + --dereference --io-size --quiet\ + --force-local --rsh-command --help\ + --version' -- "$cur" ) ) + fi + ;; + -i|--extract) + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-b -c -d -f -m -n -r\ + -t -s -u -v -B -S -V -C -E -H -M -R -I\ + -F --file --make-directories\ + --nonmatching\ + --preserve-modification-time\ + --numeric-uid-gid --rename -t --list\ + --swap-bytes --swap --dot\ + --unconditional --verbose --block-size\ + --swap-halfwords --io-size\ + --pattern-file --format --owner\ + --no-preserve-owner --message\ + --force-local --no-absolute-filenames\ + --sparse --only-verify-crc --quiet\ + --rsh-command --help\ + --to-stdout \ + --version' -- "$cur" ) ) + fi + ;; + -p|--pass-through) + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-0 -a -d -l -m -u -v\ + -L -V -R --null --reset-access-time\ + --make-directories --link --quiet\ + --preserve-modification-time\ + --unconditional --verbose --dot\ + --dereference --owner\ + --no-preserve-owner --sparse --help\ + --version' -- "$cur" ) ) + else + _filedir -d + fi + ;; + esac + fi +} +complete -F _cpio cpio +} + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/crontab b/.bash/bash_completion.d/crontab new file mode 100644 index 0000000..d2ee23a --- /dev/null +++ b/.bash/bash_completion.d/crontab @@ -0,0 +1,60 @@ +# crontab(1) completion + +have crontab && +_crontab() +{ + local cur prev + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -u) + _allowed_users + return 0 + ;; + esac + + local i opts=" -u -l -r -e" # leading space at start is significant... + [ "$(uname -s)" = Linux ] && opts="$opts -i" + [ -e /etc/selinux ] && opts="$opts -s" + for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do + case "${COMP_WORDS[i]}" in + -l) + opts=${opts// -l -r -e/} + opts=${opts// -i/} + opts=${opts// -s/} + ;; + -e) + opts=${opts// -l -r -e/} + opts=${opts// -i/} + ;; + -r) + opts=${opts// -l -r -e/} + ;; + -u) + opts=${opts// -u/} + opts=${opts// -i/} + ;; + -i|-s) + opts=${opts// ${COMP_WORDS[i]}/} + ;; + esac + done + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '$opts' -- "$cur" ) ) + return 0 + fi + + # do filenames only if we did not have -l, -r, or -e + [[ "${COMP_LINE}" == *\ -@(l|r|e)* ]] || _filedir +} && +complete -F _crontab crontab + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/cryptsetup b/.bash/bash_completion.d/cryptsetup new file mode 100644 index 0000000..5e88de3 --- /dev/null +++ b/.bash/bash_completion.d/cryptsetup @@ -0,0 +1,113 @@ +# bash completion for cryptsetup + +_cryptsetup_name() +{ + COMPREPLY=( $( compgen -X control -W '$( command ls /dev/mapper )' \ + -- "$cur" ) ) +} + +_cryptsetup_device() +{ + cur=${cur:=/dev/} + _filedir +} + +have cryptsetup && +_cryptsetup() +{ + local cur prev arg + COMPREPLY=() + cur=`_get_cword` + prev=`_get_pword` + + case $prev in + --key-file|--master-key-file|--header-backup-file|-d) + _filedir + return 0; + ;; + esac + + _get_first_arg + if [ -z $arg ]; then + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--hash --cipher --verify-passphrase \ + --key-file --master-key-file --key-slot --key-size --size \ + --offset --skip --readonly --iter-time --batch-mode --timeout \ + --tries --align-payload --version' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W 'create remove status resize luksFormat \ + luksOpen luksClose luksSuspend luksResume luksAddKey \ + luksRemoveKey luksKillSlot luksDelKey luksUUID isLuks \ + luksDump luksHeaderBackup luksHeaderRestore' -- "$cur" ) ) + fi + else + _count_args + case $arg in + create) + case $args in + 2) + _cryptsetup_name + ;; + 3) + _cryptsetup_device + ;; + esac + ;; + remove|status|resize|luksClose|luksSuspend|luksResume) + case $args in + 2) + _cryptsetup_name + ;; + esac + ;; + luksFormat|luksAddKey|luksRemoveKey) + case $args in + 2) + _cryptsetup_device + ;; + 3) + _filedir + ;; + esac + ;; + luksOpen) + case $args in + 2) + _cryptsetup_device + ;; + 3) + _cryptsetup_name + ;; + esac + ;; + luksKillSlot|luksDelKey|luksUUID|isLuks|luksDump) + case $args in + 2) + _cryptsetup_device + ;; + esac + ;; + luksHeaderBackup|luksHeaderRestore) + case $args in + 2) + _cryptsetup_device + ;; + 3) + COMPREPLY=( '--header-backup-file' ) + ;; + esac + ;; + esac + fi + + return 0 +} && +complete -F _cryptsetup cryptsetup + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/cups b/.bash/bash_completion.d/cups new file mode 100644 index 0000000..2848c95 --- /dev/null +++ b/.bash/bash_completion.d/cups @@ -0,0 +1,21 @@ +# bash completion for cups + +have cancel && +_cancel() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + COMPREPLY=( $( compgen -W "$( lpstat | cut -d' ' -f1 )" -- "$cur" ) ) +} && +complete -F _cancel cancel + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/cvs b/.bash/bash_completion.d/cvs new file mode 100644 index 0000000..be3b1be --- /dev/null +++ b/.bash/bash_completion.d/cvs @@ -0,0 +1,392 @@ +# cvs(1) completion + +have cvs && { +set_prefix() +{ + [ -z ${prefix:-} ] || prefix=${cur%/*}/ + [ -r ${prefix:-}CVS/Entries ] || prefix="" +} + +get_entries() +{ + local IFS=$'\n' + [ -r ${prefix:-}CVS/Entries ] && \ + entries=$(cut -d/ -f2 -s ${prefix:-}CVS/Entries) +} + +get_modules() +{ + if [ -n "$prefix" ]; then + COMPREPLY=( $( command ls -d ${cvsroot}/${prefix}/!(CVSROOT) ) ) + else + COMPREPLY=( $( command ls -d ${cvsroot}/!(CVSROOT) ) ) + fi +} + +_cvs_commands() +{ + cvs --help-commands 2>&1 | awk '/^( *|\t)/ { print $1 }' +} + +_cvs_options() +{ + cvs --help-options 2>&1 | awk '/^( *|\t)-/ { print $1 }' +} + +_cvs_command_options() +{ + cvs --help $1 2>&1 | sed -ne 's/^[[:space:]]*\(-[^[:space:]=[]*\).*/\1/p' +} + +_cvs_kflags() +{ + COMPREPLY=( $( compgen -W 'kv kvl k o b v' -- "$cur" ) ) +} + +_cvs_roots() +{ + local -a cvsroots + cvsroots=( $CVSROOT ) + [ -r ~/.cvspass ] && \ + cvsroots=( "${cvsroots[@]}" $( awk '{ print $2 }' ~/.cvspass ) ) + [ -r CVS/Root ] && cvsroots=( "${cvsroots[@]}" $(cat CVS/Root) ) + COMPREPLY=( $( compgen -W '${cvsroots[@]}' -- "$cur" ) ) + __ltrim_colon_completions "$cur" +} + +_cvs() +{ + local cur prev count mode i cvsroot cvsroots pwd + local -a flags miss files entries changed newremoved + + COMPREPLY=() + _get_comp_words_by_ref -n : cur prev + + count=0 + for i in "${COMP_WORDS[@]}"; do + [ $count -eq $COMP_CWORD ] && break + # Last parameter was the CVSROOT, now go back to mode selection + if [[ "${COMP_WORDS[((count))]}" == "$cvsroot" && "$mode" == cvsroot ]]; then + mode="" + fi + if [ -z "$mode" ]; then + case $i in + -H|--help) + COMPREPLY=( $( compgen -W "$( _cvs_commands )" -- "$cur" ) ) + return 0 + ;; + -d) + mode=cvsroot + cvsroot=${COMP_WORDS[((count+1))]} + ;; + ad|add|new) + mode=add + ;; + adm|admin|rcs) + mode=admin + ;; + ann|annotate) + mode=annotate + ;; + checkout|co|get) + mode=checkout + ;; + com|commit|ci) + mode=commit + ;; + di|dif|diff) + mode=diff + ;; + ex|exp|export) + mode=export + ;; + edit|unedit) + mode=$i + ;; + hi|his|history) + mode=history + ;; + im|imp|import) + mode=import + ;; + re|rel|release) + mode=release + ;; + log|rlog) + mode=log + ;; + rdiff|patch) + mode=rdiff + ;; + remove|rm|delete) + mode=remove + ;; + rtag|rfreeze) + mode=rtag + ;; + st|stat|status) + mode=status + ;; + tag|freeze) + mode=tag + ;; + up|upd|update) + mode=update + ;; + esac + elif [[ "$i" = -* ]]; then + flags=( "${flags[@]}" $i ) + fi + count=$((++count)) + done + + case $mode in + add) + case $prev in + -m) + return 0 + ;; + -k) + _cvs_kflags + return 0 + ;; + esac + + if [[ "$cur" != -* ]]; then + set_prefix + if [[ $COMP_CWORD -gt 1 && -r ${prefix:-}CVS/Entries ]]; then + get_entries + [ -z "$cur" ] && \ + files=$( command ls -Ad !(CVS) ) || \ + files=$( command ls -d ${cur}* 2>/dev/null ) + for i in "${entries[@]}"; do + files=( ${files[@]/#$i//} ) + done + COMPREPLY=( $( compgen -X '*~' -W '${files[@]}' -- $cur ) ) + fi + else + COMPREPLY=( $( compgen -W "$( _cvs_command_options $mode )" \ + -- "$cur" ) ) + fi + ;; + admin) + case $prev in + -a|-A|-b|-c|-e|-l|-m|-n|-N|-o|-s|-t-|-u) + return 0 + ;; + -t) + _filedir + return 0 + ;; + -k) + _cvs_kflags + return 0 + ;; + esac + + if [[ "$cur" = -* ]]; then + COMPREPLY=( $( compgen -W "$( _cvs_command_options $mode )" \ + -- "$cur" ) ) + fi + ;; + annotate) + [[ "$prev" == -@(r|D) ]] && return 0 + + if [[ "$cur" = -* ]]; then + COMPREPLY=( $( compgen -W "$( _cvs_command_options $mode )" \ + -- "$cur" ) ) + else + get_entries + COMPREPLY=( $( compgen -W '${entries[@]}' -- "$cur" ) ) + fi + ;; + checkout) + case $prev in + -r|-D|j) + return 0 + ;; + -d) + _filedir -d + return 0 + ;; + -k) + _cvs_kflags + return 0 + ;; + esac + + if [[ "$cur" != -* ]]; then + [ -z "$cvsroot" ] && cvsroot=$CVSROOT + COMPREPLY=( $( cvs -d "$cvsroot" co -c 2> /dev/null | \ + awk '{print $1}' ) ) + COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W "$( _cvs_command_options $mode )" \ + -- "$cur" ) ) + fi + ;; + commit) + case $prev in + -m|-r) + return 0 + ;; + -F) + _filedir + return 0 + ;; + esac + + set_prefix + + if [[ "$cur" != -* && -r ${prefix:-}CVS/Entries ]]; then + # if $COMP_CVS_REMOTE is not null, 'cvs commit' will + # complete on remotely checked-out files (requires + # passwordless access to the remote repository + if [ -n "${COMP_CVS_REMOTE:-}" ]; then + # this is the least computationally intensive + # way found so far, but other changes + # (something other than changed/removed/new) + # may be missing + changed=( $( cvs -q diff --brief 2>&1 | \ + sed -ne 's/^Files [^ ]* and \([^ ]*\) differ$/\1/p' ) ) + newremoved=( $( cvs -q diff --brief 2>&1 | \ + sed -ne 's/^cvs diff: \([^ ]*\) .*, no comparison available$/\1/p' ) ) + COMPREPLY=( $( compgen -W '${changed[@]:-} \ + ${newremoved[@]:-}' -- "$cur" ) ) + else + COMPREPLY=( $(compgen -o default -- "$cur") ) + fi + else + COMPREPLY=( $( compgen -W "$( _cvs_command_options $mode )" \ + -- "$cur" ) ) + fi + ;; + cvsroot) + # TODO: works poorly because of the colons and -o default, + # could we drop -o default? works ok without it in cvsps + _cvs_roots + ;; + export) + case $prev in + -r|-D) + return 0 + ;; + -d) + _filedir -d + return 0 + ;; + -k) + _cvs_kflags + return 0 + ;; + esac + + if [[ "$cur" != -* ]]; then + [ -z "$cvsroot" ] && cvsroot=$CVSROOT + COMPREPLY=( $( cvs -d "$cvsroot" co -c | awk '{print $1}' ) ) + COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W "$( _cvs_command_options $mode )" \ + -- "$cur" ) ) + fi + ;; + diff) + if [[ "$cur" == -* ]]; then + _longopt diff + else + get_entries + COMPREPLY=( $( compgen -W '${entries[@]:-}' -- "$cur" ) ) + fi + ;; + remove) + if [[ "$cur" != -* ]]; then + set_prefix + if [[ $COMP_CWORD -gt 1 && -r ${prefix:-}CVS/Entries ]]; then + get_entries + # find out what files are missing + for i in "${entries[@]}"; do + [ ! -r "$i" ] && miss=( "${miss[@]}" $i ) + done + COMPREPLY=( $(compgen -W '${miss[@]:-}' -- "$cur") ) + fi + else + COMPREPLY=( $( compgen -W "$( _cvs_command_options $mode )" \ + -- "$cur" ) ) + fi + ;; + import) + case $prev in + -I|-b|-m|-W) + return 0 + ;; + -k) + _cvs_kflags + return 0 + ;; + esac + + if [[ "$cur" != -* ]]; then + # starts with same algorithm as checkout + [ -z "$cvsroot" ] && cvsroot=$CVSROOT + prefix=${cur%/*} + if [ -r ${cvsroot}/${prefix} ]; then + get_modules + COMPREPLY=( ${COMPREPLY[@]#$cvsroot} ) + COMPREPLY=( ${COMPREPLY[@]#\/} ) + fi + pwd=$( pwd ) + pwd=${pwd##*/} + COMPREPLY=( $( compgen -W '${COMPREPLY[@]} $pwd' -- $cur ) ) + else + COMPREPLY=( $( compgen -W "$( _cvs_command_options $mode )" \ + -- "$cur" ) ) + fi + ;; + update) + case $prev in + -r|-D|-j|-I|-W) + return 0 + ;; + -k) + _cvs_kflags + return 0 + ;; + esac + + if [[ "$cur" = -* ]]; then + COMPREPLY=( $( compgen -W "$( _cvs_command_options $mode )" \ + -- "$cur" ) ) + fi + ;; + "") + case $prev in + -T) + _filedir -d + return 0 + ;; + -e|-s) + return 0 + ;; + -z) + COMPREPLY=( $( compgen -W '1 2 3 4 5 6 7 8 9' -- "$cur" ) ) + return 0 + ;; + esac + + COMPREPLY=( $( compgen -W '$( _cvs_commands ) $( _cvs_options ) \ + --help --help-commands --help-options --version' -- "$cur" ) ) + ;; + esac + + return 0 +} +complete -F _cvs -o default cvs +} + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/cvsps b/.bash/bash_completion.d/cvsps new file mode 100644 index 0000000..257437b --- /dev/null +++ b/.bash/bash_completion.d/cvsps @@ -0,0 +1,69 @@ +# bash completion for cvsps + +have cvsps && +_cvsps() +{ + COMPREPLY=() + local cur prev + _get_comp_words_by_ref -n : cur prev + + case $prev in + -h|-z|-f|-d|-l|--diff-opts|--debuglvl) + return 0 + ;; + -s) + COMPREPLY=( $( compgen -W "$( cvsps 2>/dev/null | + awk '/^PatchSet:?[ \t]/ { print $2 }' )" -- "$cur" ) ) + return 0 + ;; + -a) + COMPREPLY=( $( compgen -W "$( cvsps 2>/dev/null | + awk '/^Author:[ \t]/ { print $2 }' )" -- "$cur" ) ) + return 0 + ;; + -b) + COMPREPLY=( $( compgen -W "$( cvsps 2>/dev/null | + awk '/^Branch:[ \t]/ { print $2 }' )" -- "$cur" ) ) + return 0 + ;; + -r) + COMPREPLY=( $( compgen -W "$( cvsps 2>/dev/null | + awk '/^Tag:[ \t]+[^(]/ { print $2 }' )" -- "$cur" ) ) + return 0 + ;; + -p) + _filedir -d + return 0 + ;; + --test-log) + _filedir + return 0 + ;; + -Z) + COMPREPLY=( $( compgen -W '1 2 3 4 5 6 7 8 9' -- "$cur" ) ) + return 0 + ;; + --root) + type _cvs_roots &>/dev/null && _cvs_roots + return 0 + ;; + esac + + if [[ "$cur" == -* ]] ; then + COMPREPLY=( $( compgen -W '-h -x -u -z -g -s -a -f -d -b -l -r -p -v \ + -t --norc --summary-first --test-log --diff-opts --bkcvs --no-rlog \ + --cvs-direct --no-cvs-direct --debuglvl -Z --root -q -A' \ + -- "$cur" ) ) + else + type _cvs_roots &>/dev/null && _cvs_roots + fi +} && +complete -F _cvsps cvsps + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/dd b/.bash/bash_completion.d/dd new file mode 100644 index 0000000..7b9b3ac --- /dev/null +++ b/.bash/bash_completion.d/dd @@ -0,0 +1,39 @@ +# bash completion for dd + +have dd && +_dd() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref -n = cur + + case $cur in + if=*|of=*) + cur=${cur#*=} + _filedir + return 0 + ;; + conv=*) + cur=${cur#*=} + COMPREPLY=( $( compgen -W 'ascii ebcdic ibm block unblock lcase + notrunc ucase swab noerror sync' -- "$cur" ) ) + return 0 + ;; + esac + + _expand || return 0 + + COMPREPLY=( $( compgen -W '--help --version' -- "$cur" ) \ + $( compgen -W 'bs cbs conv count ibs if obs of seek skip' \ + -S '=' -- "$cur" ) ) +} && +complete -F _dd -o nospace dd + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/dhclient b/.bash/bash_completion.d/dhclient new file mode 100644 index 0000000..3d7e1e1 --- /dev/null +++ b/.bash/bash_completion.d/dhclient @@ -0,0 +1,36 @@ +# bash completion for dhclient + +have dhclient && _dhclient() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -cf|-lf|-pf|-sf) + _filedir + return 0 + ;; + -s) + _known_hosts_real "$cur" + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-p -d -q -1 -r -lf -pf \ + -cf -sf -s -g -n -nw -w' -- "$cur" ) ) + else + _available_interfaces + fi +} && +complete -F _dhclient dhclient + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/dict b/.bash/bash_completion.d/dict new file mode 100644 index 0000000..4cfdf98 --- /dev/null +++ b/.bash/bash_completion.d/dict @@ -0,0 +1,77 @@ +# dict(1) completion + +{ have dict || have rdict; } && { +_dictdata() +{ + dict $host $port $1 2>/dev/null | sed -ne \ + 's/^['$'\t '']['$'\t '']*\([^'$'\t '']*\).*$/\1/p' +} + +_dict() +{ + local cur prev host port db dictfile + + COMPREPLY=() + _get_comp_words_by_ref cur prev + dictfile=/usr/share/dict/words + + for (( i=1; i < COMP_CWORD; i++ )); do + case ${COMP_WORDS[i]} in + -h|--host) + host=${COMP_WORDS[i+1]} + [ -n "$host" ] && host="-h $host" + i=$((++i)) + ;; + -p|--port) + port=${COMP_WORDS[i+1]} + [ -n "$port" ] && port="-p $port" + i=$((++i)) + ;; + -d|--database) + db=${COMP_WORDS[i+1]} + [ -n "$db" ] && host="-d $db" + i=$((++i)) + ;; + *) + ;; + esac + done + + if [[ "$cur" = -* ]]; then + COMPREPLY=( $( compgen -W '--host --port --database \ + --match --strategy --config \ + --nocorrect --dbs --strats \ + --serverhelp --info --serverinfo \ + --noauth --user --key --version \ + --license --help --verbose --raw \ + --pager --debug --html --pipesize --client' \ + -- "$cur" ) ) + return 0 + fi + + case $prev in + -d|--database|-i|-info) + COMPREPLY=( $( compgen -W '$( _dictdata -D )' -- "$cur" ) ) + return 0 + ;; + -s|--strategy) + COMPREPLY=( $( compgen -W '$( _dictdata -S )' -- "$cur" ) ) + return 0 + ;; + *) + ;; + esac + + [ -r $dictfile ] && \ + COMPREPLY=( $( compgen -W '$( cat $dictfile )' -- "$cur" ) ) +} +complete -F _dict -o default dict rdict +} + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/dpkg b/.bash/bash_completion.d/dpkg new file mode 100644 index 0000000..0556f3d --- /dev/null +++ b/.bash/bash_completion.d/dpkg @@ -0,0 +1,244 @@ +# This function is required by _dpkg() and _dpkg-reconfigure() +have dpkg && { +have grep-status && { +_comp_dpkg_installed_packages() +{ + grep-status -P -e "^$1" -a -FStatus 'install ok installed' -n -s Package +} +} || { +_comp_dpkg_installed_packages() +{ + command grep -A 1 "Package: $1" /var/lib/dpkg/status | \ + command grep -B 1 -Ee "ok installed|half-installed|unpacked| \ + half-configured|config-files" \ + -Ee "^Essential: yes" | \ + command grep "Package: $1" | cut -d\ -f2 +} +} + +# Debian dpkg(8) completion +# +_dpkg() +{ + local cur prev i + + COMPREPLY=() + _get_comp_words_by_ref cur prev + i=$COMP_CWORD + + _expand || return 0 + + _split_longopt + + # find the last option flag + if [[ $cur != -* ]]; then + while [[ $prev != -* && $i != 1 ]]; do + i=$((i-1)) + prev=${COMP_WORDS[i-1]} + done + fi + + case $prev in + -c|-i|-A|-I|-f|-e|-x|-X|-W|--install|--unpack|--record-avail| \ + --contents|--info|--fsys-tarfile|--field|--control|--extract| \ + --show) + _filedir '?(u)deb' + return 0 + ;; + -b|--build) + _filedir -d + return 0 + ;; + -s|-p|-l|--status|--print-avail|--list) + COMPREPLY=( $( apt-cache pkgnames "$cur" 2>/dev/null ) ) + return 0 + ;; + -S|--search) + _filedir + return 0 + ;; + -r|-L|-P|--remove|--purge|--listfiles) + COMPREPLY=( $( _comp_dpkg_installed_packages "$cur" ) ) + return 0 + ;; + *) + COMPREPLY=( $( compgen -W '-i --install --unpack -A --record-avail \ + --configure -r --remove -P --purge --get-selections \ + --set-selections --update-avail --merge-avail \ + --clear-avail --command-fd --forget-old-unavail -s \ + --status -p --print-avail -L --listfiles -l --list \ + -S --search -C --audit --print-architecture \ + --print-gnu-build-architecture \ + --print-installation-architecture \ + --compare-versions --help --version --force-help \ + --force-all --force-auto-select --force-downgrade \ + --force-configure-any --force-hold --force-bad-path \ + --force-not-root --force-overwrite \ + --force-overwrite-diverted --force-bad-verify \ + --force-depends-version --force-depends \ + --force-confnew --force-confold --force-confdef \ + --force-confmiss --force-conflicts --force-architecture\ + --force-overwrite-dir --force-remove-reinstreq \ + --force-remove-essential -Dh \ + --debug=help --licence --admindir --root --instdir \ + -O --selected-only -E --skip-same-version \ + -G --refuse-downgrade -B --auto-deconfigure \ + --no-debsig --no-act -D --debug --status-fd \ + -b --build -I --info -f --field -c --contents \ + -x --extract -X --vextract --fsys-tarfile -e --control \ + --ignore-depends --abort-after' -- "$cur" ) ) + ;; + esac + + +} +complete -F _dpkg dpkg dpkg-deb +} + +# Debian GNU dpkg-reconfigure(8) completion +# +have dpkg-reconfigure && +_dpkg_reconfigure() +{ + local cur prev opt + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -f|--frontend) + opt=( $( printf '%s\n' /usr/share/perl5/Debconf/FrontEnd/* ) ) + opt=( ${opt[@]##*/} ) + opt=( ${opt[@]%.pm} ) + COMPREPLY=( $( compgen -W '${opt[@]}' -- "$cur" ) ) + return 0 + ;; + -p|--priority) + COMPREPLY=( $( compgen -W 'low medium high critical' -- "$cur" ) ) + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $(compgen -W '--frontend --priority --all --unseen-only \ + --help --showold --force --terse' -- "$cur" ) ) + else + COMPREPLY=( $( _comp_dpkg_installed_packages "$cur" ) ) + fi +} && +complete -F _dpkg_reconfigure -o default dpkg-reconfigure + +# Debian dpkg-source completion +# +have dpkg-source && +_dpkg_source() +{ + local cur prev options work i action packopts unpackopts fields + + packopts="-c -l -F -V -T -D -U -W -E -sa -i -I -sk -sr -ss -sA -sK -sP \ + -sU -sR" + unpackopts="-sp -sn -su" + options="-x -b $packopts $unpackopts" + fields="Format Source Version Binary Maintainer Uploader Architecture \ + Standards-Version Build-Depends Files" + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + action="options" + for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do + if [[ ${COMP_WORDS[$i]} == "-x" ]]; then + action=unpack + elif [[ ${COMP_WORDS[$i]} == "-b" ]]; then + action=pack + elif [[ ${COMP_WORDS[$i]} == "-h" ]]; then + action=help + fi + done + + case $action in + unpack) + case $prev in + -x) + _filedir -d + _filedir 'dsc' + return 0 + ;; + *) + COMPREPLY=( $( compgen -W "$unpackopts" -- "$cur" ) ) + _filedir -d + _filedir + return 0 + ;; + esac + return 0 + ;; + pack) + case $prev in + -b) + _filedir -d + return 0 + ;; + -c|-l|-T|-i|-I) + # -c: get controlfile + # -l: get per-version info from this file + # -T: read variables here, not debian/substvars + # -i: filter out files to ignore diffs of. + # -I: filter out files when building tarballs. + # return directory names and file names + _filedir -d + _filedir + return 0 + ;; + -F) + # -F: force change log format + COMPREPLY=( $( command ls /usr/lib/dpkg/parsechangelog ) ) + return 0 + ;; + -V|-D) + # -V: set a substitution variable + # we don't know anything about possible variables or values + # so we don't try to suggest any completion. + COMPREPLY=() + return 0 + ;; + -D) + # -D: override or add a .dsc field and value + # if $cur doesn't contain a = yet, suggest variable names + if [[ "$cur" == *=* ]]; then + # $cur contains a "=" + COMPREPLY=() + return 0 + else + COMPREPLY=( $( compgen -W "$fields" -- "$cur" ) ) + return 0 + fi + ;; + -U) + # -U: remove a field + # Suggest possible fieldnames + COMPREPLY=( $( compgen -W "$fields" -- "$cur" ) ) + return 0 + ;; + *) + COMPREPLY=( $( compgen -W "$packopts $unpackopts" -- "$cur" ) ) + return 0 + ;; + esac + return 0 + ;; + *) + COMPREPLY=( $( compgen -W "$options" -- "$cur" ) ) + return 0 + ;; + esac +} && +complete -F _dpkg_source dpkg-source + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/dselect b/.bash/bash_completion.d/dselect new file mode 100644 index 0000000..3042a8d --- /dev/null +++ b/.bash/bash_completion.d/dselect @@ -0,0 +1,40 @@ +# Debian Linux dselect(8) completion. + +have dselect && +_dselect() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + --admindir) + _filedir -d + return 0 + ;; + -D|-debug) + _filedir + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '--admindir --help --version --licence \ + --license --expert --debug' -- "$cur" ) ) + else + COMPREPLY=( $( compgen -W 'access update select install config \ + remove quit' -- "$cur" ) ) + fi + + return 0 +} && +complete -F _dselect dselect + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/dsniff b/.bash/bash_completion.d/dsniff new file mode 100644 index 0000000..1d3b303 --- /dev/null +++ b/.bash/bash_completion.d/dsniff @@ -0,0 +1,256 @@ +# dsniff util completion + +have arpspoof && +_arpspoof() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -i) + _available_interfaces + return 0 + ;; + -t) + _known_hosts_real "$cur" + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-i -t' -- "$cur" ) ) + else + _known_hosts_real "$cur" + fi + +} && +complete -F _arpspoof arpspoof + +have dnsspoof && +_dnsspoof() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -i) + _interfaces + return 0 + ;; + -f) + _filedir + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-i -f' -- "$cur" ) ) + fi + +} && +complete -F _dnsspoof dnsspoof + +have dsniff && +_dsniff() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -r|-w|-f) + _filedir + return 0 + ;; + -i) + _interfaces + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-c -d -m -n -i -s -f -t -r -w' -- "$cur" ) ) + fi + +} && +complete -F _dsniff dsniff + +have filesnarf || have mailsnarf || have msgsnarf && +_snarf() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -i) + _interfaces + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-i -v' -- "$cur" ) ) + fi + +} && +complete -F _snarf filesnarf mailsnarf msgsnarf + +have macof && +_macof() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -i) + _interfaces + return 0 + ;; + esac + + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-i -s -d -e -x -y -n' -- "$cur" ) ) + fi + +} && +complete -F _macof macof + +have sshmitm && +_sshmitm() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-d -I -p' -- "$cur" ) ) + else + _known_hosts_real "$cur" + fi + +} && +complete -F _sshmitm sshmitm + +have sshow && +_sshow() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -i) + _interfaces + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-d -i' -- "$cur" ) ) + fi + +} && +complete -F _sshow sshow + +have tcpkill && +_tcpkill() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -i) + _interfaces + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-i -1 -2 -3 -4 -5 -6 -7 -8 -9' -- "$cur" ) ) + fi + +} && +complete -F _tcpkill tcpkill + +have tcpnice && +_tcpnice() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -i) + _interfaces + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-A -I -M -i' -- "$cur" ) ) + fi + +} && +complete -F _tcpnice tcpnice + +have urlsnarf && +_urlsnarf() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -i) + _interfaces + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-n -i -v' -- "$cur" ) ) + fi + +} && +complete -F _urlsnarf urlsnarf + +have webmitm && +_webmitm() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-d' -- "$cur" ) ) + else + _known_hosts_real "$cur" + fi + +} && +complete -F _webmitm webmitm + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/dvd+rw-tools b/.bash/bash_completion.d/dvd+rw-tools new file mode 100644 index 0000000..f37781e --- /dev/null +++ b/.bash/bash_completion.d/dvd+rw-tools @@ -0,0 +1,47 @@ +# dvd+rw-tools completions + +have growisofs && +_growisofs() +{ + COMPREPLY=() + local cur prev + _get_comp_words_by_ref cur prev + + case $prev in + -version|-speed) + return 0 + ;; + -Z|-M) + compopt -o nospace &>/dev/null + _dvd_devices + return 0 + ;; + /?(r)dev/*) + if [[ $cur == =* ]] ; then + # e.g. /dev/dvd=foo.iso, /dev/dvdrw=/dev/zero + cur="${cur#=}" + _filedir + return 0 + fi + ;; + esac + + if [[ "$cur" == -* ]]; then + # TODO: mkisofs options + COMPREPLY=( $( compgen -W '-dvd-compat -overburn -speed= -Z -M' \ + -- "$cur" ) ) + [[ ${COMPREPLY[@]} == *= ]] && compopt -o nospace &>/dev/null + return 0 + fi + + _filedir +} && +complete -F _growisofs growisofs + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/e2fsprogs b/.bash/bash_completion.d/e2fsprogs new file mode 100644 index 0000000..50ce788 --- /dev/null +++ b/.bash/bash_completion.d/e2fsprogs @@ -0,0 +1,180 @@ +# bash completion for e2fsprogs + +have badblocks && +_badblocks() +{ + COMPREPLY=() + local cur prev + _get_comp_words_by_ref cur prev + + case $prev in + -b|-c|-e|-d|-p|-t) + return 0 + ;; + -i|-o) + _filedir + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + # -w (dangerous) and -X (internal use) not here on purpose + COMPREPLY=( $( compgen -W '-b -c -e -d -f -i -n -o -p -s -t -v' \ + -- "$cur" ) ) + return 0 + fi + + cur=${cur:=/dev/} + _filedir +} && +complete -F _badblocks badblocks + + +have dumpe2fs && +_dumpe2fs() +{ + COMPREPLY=() + local cur prev + _get_comp_words_by_ref cur prev + + case $prev in + -o|-V) + return 0 + ;; + -i) + _filedir + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-b -o -f -h -i -x -V' -- "$cur" ) ) + return 0 + fi + + cur=${cur:=/dev/} + _filedir +} && +complete -F _dumpe2fs dumpe2fs + + +have e2freefrag && +_e2freefrag() +{ + COMPREPLY=() + local cur prev + _get_comp_words_by_ref cur prev + + case $prev in + -c|-h) + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-c -h' -- "$cur" ) ) + return 0 + fi + + cur=${cur:=/dev/} + _filedir +} && +complete -F _e2freefrag e2freefrag + + +have e2label && +_e2label() +{ + COMPREPLY=() + local cur cword + _get_comp_words_by_ref cur cword + + if [ $cword -eq 1 ]; then + cur=${cur:=/dev/} + _filedir + fi +} && +complete -F _e2label e2label + + +have filefrag && +_filefrag() +{ + COMPREPLY=() + local cur + _get_comp_words_by_ref cur + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-B -b -s -v -x' -- "$cur" ) ) + return 0 + fi + + _filedir +} && +complete -F _filefrag filefrag + + +have tune2fs && +_tune2fs() +{ + COMPREPLY=() + local cur prev + _get_comp_words_by_ref cur prev + + case $prev in + -c|-C|-E|-i|-J|-L|-m|-r|-T) + return 0 + ;; + -e) + COMPREPLY=( $( compgen -W 'continue remount-ro panic' -- "$cur" ) ) + return 0 + ;; + -g) + _gids + COMPREPLY=( $( compgen -g -W '${COMPREPLY[@]}' -- "$cur" ) ) + return 0 + ;; + -M) + _filedir -d + ;; + -o) + local -a opts=(^debug ^bsdgroups ^user_xattr ^acl ^uid16 + ^journal_data ^journal_data_ordered ^journal_data_writeback) + COMPREPLY=( $( compgen -W '${opts[@]} ${opts[@]#^}' -- "$cur" ) ) + return 0 + ;; + -O) + local -a opts=(^dir_index ^dir_nlink ^extent ^extra_isize ^filetype + ^flex_bg ^has_journal ^huge_file ^large_file ^resize_inode + ^sparse_super ^uninit_bg) + COMPREPLY=( $( compgen -W '${opts[@]} ${opts[@]#^}' -- "$cur" ) ) + return 0 + ;; + -u) + _uids + COMPREPLY=( $( compgen -u -W '${COMPREPLY[@]}' -- "$cur" ) ) + return 0 + ;; + -U) + COMPREPLY=( $( compgen -W 'clear random time' -- "$cur" ) ) + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-c -C -e -E -f -g -i -j -J -l -L -m -M -o + -O -r -T -u -U' -- "$cur" ) ) + fi + + cur=${cur:=/dev/} + _filedir +} && +complete -F _tune2fs tune2fs + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/findutils b/.bash/bash_completion.d/findutils new file mode 100644 index 0000000..b8aaa57 --- /dev/null +++ b/.bash/bash_completion.d/findutils @@ -0,0 +1,128 @@ +# bash completion for GNU find. This makes heavy use of ksh style extended +# globs and contains Linux specific code for completing the parameter +# to the -fstype option. + +have find && +_find() +{ + local cur prev i exprfound onlyonce + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -maxdepth|-mindepth) + COMPREPLY=( $( compgen -W '0 1 2 3 4 5 6 7 8 9' -- "$cur" ) ) + return 0 + ;; + -newer|-anewer|-cnewer|-fls|-fprint|-fprint0|-fprintf|-name|-iname|\ + -lname|-ilname|-wholename|-iwholename|-samefile) + _filedir + return 0 + ;; + -fstype) + _fstypes + if [[ "$( uname -s )" == *BSD ]] ; then + COMPREPLY=( "${COMPREPLY[@]}" \ + $( compgen -W 'local rdonly' -- "$cur" ) ) + fi + return 0 + ;; + -gid) + _gids + return 0 + ;; + -group) + COMPREPLY=( $( compgen -g -- "$cur" 2>/dev/null) ) + return 0 + ;; + -xtype|-type) + COMPREPLY=( $( compgen -W 'b c d p f l s' -- "$cur" ) ) + return 0 + ;; + -uid) + _uids + return 0 + ;; + -user) + COMPREPLY=( $( compgen -u -- "$cur" ) ) + return 0 + ;; + -exec|-execdir|-ok|-okdir) + COMP_WORDS=(COMP_WORDS[0] "$cur") + COMP_CWORD=1 + _command + return 0 + ;; + -[acm]min|-[acm]time|-iname|-lname|-wholename|-iwholename|-lwholename|\ + -ilwholename|-inum|-path|-ipath|-regex|-iregex|-links|-perm|-size|\ + -used|-printf|-context) + # do nothing, just wait for a parameter to be given + return 0 + ;; + -regextype) + COMPREPLY=( $( compgen -W 'emacs posix-awk posix-basic \ + posix-egrep posix-extended' -- "$cur" ) ) + return 0 + ;; + esac + + _expand || return 0 + # set exprfound to 1 if there is already an expression present + for i in ${COMP_WORDS[@]}; do + [[ "$i" = [-\(\),\!]* ]] && exprfound=1 && break + done + + # handle case where first parameter is not a dash option + if [[ "$exprfound" != 1 && "$cur" != [-\(\),\!]* ]]; then + _filedir -d + return 0 + fi + + # complete using basic options + COMPREPLY=( $( compgen -W '-daystart -depth -follow -help \ + -ignore_readdir_race -maxdepth -mindepth -mindepth -mount \ + -noignore_readdir_race -noleaf -regextype -version -warn -nowarn \ + -xdev \ + -amin -anewer -atime -cmin -cnewer -ctime -empty -executable -false \ + -fstype -gid -group -ilname -iname -inum -ipath -iregex -iwholename \ + -links -lname -mmin -mtime -name -newer -nogroup -nouser -path -perm \ + -readable -regex -samefile -size -true -type -uid -used -user \ + -wholename -writable -xtype -context \ + -delete -exec -execdir -fls -fprint -fprint0 -fprintf -ls -ok -okdir \ + -print -print0 -printf -prune -quit' -- "$cur" ) ) + + # this removes any options from the list of completions that have + # already been specified somewhere on the command line, as long as + # these options can only be used once (in a word, "options", in + # opposition to "tests" and "actions", as in the find(1) manpage). + onlyonce=' -daystart -depth -follow -help -ignore_readdir_race -maxdepth \ + -mindepth -mount -noignore_readdir_race -noleaf -nowarn -regextype \ + -version -warn -xdev ' + COMPREPLY=( $( \ + (while read -d ' ' i; do + [[ -z "$i" || "${onlyonce/ ${i%% *} / }" == "$onlyonce" ]] && + continue + # flatten array with spaces on either side, + # otherwise we cannot grep on word boundaries of + # first and last word + COMPREPLY=" ${COMPREPLY[@]} " + # remove word from list of completions + COMPREPLY=( ${COMPREPLY/ ${i%% *} / } ) + done + printf '%s ' "${COMPREPLY[@]}") <<<"${COMP_WORDS[@]}" + ) ) + + _filedir + + return 0 +} && +complete -F _find find + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/freeciv b/.bash/bash_completion.d/freeciv new file mode 100644 index 0000000..602ad76 --- /dev/null +++ b/.bash/bash_completion.d/freeciv @@ -0,0 +1,65 @@ +# freeciv completions + +have civserver && +_civserver() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -f|-g|-l|-r|--file|--log|--gamelog|--read) + _filedir + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-d -f -g -h -i -l -m -M -p -q -r -v\ + --debug --file --gamelog --help --info --log --meta \ + --Metaserver --port --quitidle --read --version' -- "$cur" ) ) + fi + +} && +complete -F _civserver civserver + +have civclient && +_civclient() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -l|-S|-t|--log|--Sound|--tiles) + _filedir + return 0 + ;; + -P|--Plugin) + COMPREPLY=( $( compgen -W 'none esd sdl' -- "$cur" ) ) + return 0 + ;; + -s|--server) + _known_hosts_real "$cur" + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-a -d -h -l -m -n -p -P -s -S -t -v\ + --autoconnect --debug --help --log --meta --name --port \ + --Plugin --server --Sound --tiles --version' -- "$cur" ) ) + fi + +} && +complete -F _civclient civclient + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/freerdp b/.bash/bash_completion.d/freerdp new file mode 100644 index 0000000..82a4646 --- /dev/null +++ b/.bash/bash_completion.d/freerdp @@ -0,0 +1,47 @@ +# bash completion for xfreerdp + +have xfreerdp && +_xfreerdp() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -k) + COMPREPLY=( $( compgen -W "$(xfreerdp --kbd-list | \ + awk '/^0x/ {print $1}')" -- "$cur" ) ) + return 0 + ;; + -a) + COMPREPLY=( $( compgen -W '8 15 16 24 32' -- "$cur" ) ) + return 0 + ;; + -x) + COMPREPLY=( $( compgen -W 'b broadband m modem l lan' -- $cur ) ) + return 0 + ;; + --plugin) + COMPREPLY=( $( compgen -W 'cliprdr rdpsnd rdpdr' -- "$cur" ) ) + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-u -d -s -c -p -n -t -g -a -z -f -x -O -o \ + -k --kbd-list -h --plugin --data' -- "$cur" ) ) + else + _known_hosts_real "$cur" + fi + +} && +complete -F _xfreerdp xfreerdp + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/fuse b/.bash/bash_completion.d/fuse new file mode 100644 index 0000000..58d0c51 --- /dev/null +++ b/.bash/bash_completion.d/fuse @@ -0,0 +1,36 @@ +# bash completion for fuse + +have fusermount && +_fusermount() +{ + COMPREPLY=() + local cur prev + _get_comp_words_by_ref cur prev + + case $prev in + -h|-V|-o) + return 0 + ;; + -u) + COMPREPLY=( $( compgen -W "$( awk \ + '{ if ($3 ~ /^fuse\./) print $2 }' /etc/mtab 2>/dev/null )" \ + -- "$cur" ) ) + return 0 + ;; + esac + + if [[ "$cur" == -* ]] ; then + COMPREPLY=( $( compgen -W '-h -V -o -u -q -z' -- "$cur" ) ) + else + _filedir -d + fi +} && +complete -F _fusermount fusermount + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/gcc b/.bash/bash_completion.d/gcc new file mode 100644 index 0000000..d78e3e2 --- /dev/null +++ b/.bash/bash_completion.d/gcc @@ -0,0 +1,59 @@ +# gcc(1) completion +# +# The only unusual feature is that we don't parse "gcc --help -v" output +# directly, because that would include the options of all the other backend +# tools (linker, assembler, preprocessor, etc) without any indication that +# you cannot feed such options to the gcc driver directly. (For example, the +# linker takes a -z option, but you must type -Wl,-z for gcc.) Instead, we +# ask the driver ("g++") for the name of the compiler ("cc1"), and parse the +# --help output of the compiler. + +have gcc && +_gcc() +{ + local cur cc backend + + COMPREPLY=() + _get_comp_words_by_ref cur + + _expand || return 0 + + case $1 in + gcj) + backend=jc1 + ;; + gpc) + backend=gpc1 + ;; + *77) + backend=f771 + ;; + *) + backend=cc1 # (near-)universal backend + ;; + esac + + if [[ "$cur" == -* ]]; then + cc=$( $1 -print-prog-name=$backend ) + # sink stderr: + # for C/C++/ObjectiveC it's useless + # for FORTRAN/Java it's an error + COMPREPLY=( $( compgen -W "$( $cc --help 2>/dev/null | \ + tr '\t' ' ' | \ + sed -e '/^ *-/!d' -e 's/ *-\([^ ]*\).*/-\1/' | \ + sort -u )" -- "$cur" ) ) + else + _filedir + fi +} && +complete -F _gcc gcc g++ c++ g77 gcj gpc +[ $USERLAND = GNU -o $UNAME = Cygwin ] && \ +[ -n "${have:-}" ] && complete -F _gcc cc + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/gcl b/.bash/bash_completion.d/gcl new file mode 100644 index 0000000..e093153 --- /dev/null +++ b/.bash/bash_completion.d/gcl @@ -0,0 +1,30 @@ +# bash programmable completion for various Common Lisp implementations by +# Nikodemus Siivola + +have gcl && +_gcl() +{ + local cur + + COMPREPLY=() + _get_comp_words_by_ref cur + + # completing an option (may or may not be separated by a space) + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-eval -load -f -batch -dir -libdir \ + -compile -o-file -c-file -h-file -data-file -system-p '-- "$cur" ) ) + else + _filedir + fi + + return 0 +} && +complete -F _gcl -o default gcl + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/gdb b/.bash/bash_completion.d/gdb new file mode 100644 index 0000000..f0bc42d --- /dev/null +++ b/.bash/bash_completion.d/gdb @@ -0,0 +1,44 @@ +# bash completion for gdb + +have gdb && +_gdb() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + if [ $COMP_CWORD -eq 1 ]; then + local IFS + _compopt_o_filenames + if [[ "$cur" == */* ]]; then + # compgen -c works as expected if $cur contains any slashes. + IFS=$'\n' + COMPREPLY=( $( PATH="$PATH:." compgen -d -c -- "$cur" ) ) + else + # otherwise compgen -c contains Bash's built-in commands, + # functions and aliases. Thus we need to retrieve the program + # names manually. + IFS=":" + local path_array=( $( \ + sed -e 's/:\{2,\}/:/g' -e 's/^://' -e 's/:$//' <<<"$PATH" ) ) + IFS=$'\n' + COMPREPLY=( $( compgen -d -W '$(find "${path_array[@]}" . \ + -mindepth 1 -maxdepth 1 -not -type d -executable \ + -printf "%f\\n" 2>/dev/null)' -- "$cur" ) ) + fi + elif [ $COMP_CWORD -eq 2 ]; then + prev=${prev##*/} + COMPREPLY=( $( compgen -fW "$( command ps axo comm,pid | \ + awk '{if ($1 ~ /^'"$prev"'/) print $2}' )" -- "$cur" ) ) + fi +} && +complete -F _gdb -o default gdb + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/gdbus b/.bash/bash_completion.d/gdbus new file mode 100644 index 0000000..79f4cb4 --- /dev/null +++ b/.bash/bash_completion.d/gdbus @@ -0,0 +1,33 @@ + +# Check for bash +[ -z "$BASH_VERSION" ] && return + +#################################################################################################### + + +__gdbus() { + local IFS=$'\n' + local cur=`_get_cword :` + + local suggestions=$(gdbus complete "${COMP_LINE}" ${COMP_POINT}) + COMPREPLY=($(compgen -W "$suggestions" -- "$cur")) + + # Remove colon-word prefix from COMPREPLY items + case "$cur" in + *:*) + case "$COMP_WORDBREAKS" in + *:*) + local colon_word=${cur%${cur##*:}} + local i=${#COMPREPLY[*]} + while [ $((--i)) -ge 0 ]; do + COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"} + done + ;; + esac + ;; + esac +} + +#################################################################################################### + +complete -o nospace -F __gdbus gdbus diff --git a/.bash/bash_completion.d/genisoimage b/.bash/bash_completion.d/genisoimage new file mode 100644 index 0000000..61b1811 --- /dev/null +++ b/.bash/bash_completion.d/genisoimage @@ -0,0 +1,77 @@ +# bash completion for mkisofs/genisoimage + +(have mkisofs || have genisoimage) && +_mkisofs() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + -o|-abstract|-biblio|-check-session|-copyright|-log-file| \ + -root-info|-prep-boot|-*-list) + _filedir + return 0 + ;; + -*-charset) + COMPREPLY=( $( compgen -W '$( mkisofs -input-charset \ + help 2>&1 | tail -n +3 )' -- "$cur" ) ) + return 0 + ;; + -uid) + _uids + return 0 + ;; + -gid) + _gids + return 0 + ;; + esac + + if [[ "$cur" == -* ]]; then + COMPREPLY=( $( compgen -W '-abstract -appid -allow-lowercase \ + -allow-multidot -biblio -cache-inodes -no-cache-inodes \ + -eltorito-boot -eltorito-alt-boot -sparc-boot -generic-boot \ + -hard-disk-boot -no-emul-boot -no-boot -boot-load-seg \ + -boot-load-size -boot-info-table -cdrecord-params \ + -eltorito-catalog -check-oldname -check-session -copyright \ + -omit-period -disable-deep-relocation -dir-mode -dvd-video \ + -follow-links -file-mode -gid -gui -graft-points -hide -hide-list \ + -hidden -hidden-list -hide-joliet -hide-joliet-list \ + -hide-joliet-trans-tbl -hide-rr-moved -input-charset \ + -output-charset -iso-level -joliet -joliet-long -jcharset \ + -full-iso9660-filenames -allow-leading-dots -log-file -exclude \ + -exclude-list -max-iso9660-filenames -prev-session \ + -omit-version-number -new-dir-mode -nobak -no-bak -force-rr -no-rr \ + -no-split-symlink-components -no-split-symlink-fields -output -pad \ + -no-pad -path-list -publisher -preparer -print-size -quiet -rock + -rational-rock -relaxed-filenames -sort -split-output \ + -stream-media-size -stream-file-name -sysid -translation-table \ + -table-name -ucs-level -udf -uid -use-fileversion \ + -untranslated-filenames -no-iso-translate -volid -volset \ + -volset-size -volset-seqno -verbose -old-exclude \ + -transparent-compression -hfs -apple -map -magic -hfs-creator \ + -hfs-type -probe -no-desktop -mac-name \ + -boot-hfs-file -part -auto -cluster-size \ + -hide-hfs -hide-hfs-list -hfs-volid \ + -icon-position -root-info -prep-boot \ + -input-hfs-charset -output-hfs-charset \ + -hfs-unlock -hfs-bless -hfs-parms --cap \ + --netatalk --double --ethershare --ushare \ + --exchange --sgi --xinet --macbin --single \ + --dave --sfm --osx-double --osx-hfs' -- "$cur" )) + else + _filedir + fi + +} && +complete -F _mkisofs mkisofs genisoimage + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/getent b/.bash/bash_completion.d/getent new file mode 100644 index 0000000..54e62ab --- /dev/null +++ b/.bash/bash_completion.d/getent @@ -0,0 +1,55 @@ +# bash completion for getent + +have getent && +_getent() +{ + local cur prev + + COMPREPLY=() + _get_comp_words_by_ref cur prev + + case $prev in + passwd) + COMPREPLY=( $( compgen -u "$cur" ) ) + return 0 + ;; + group) + COMPREPLY=( $( compgen -g "$cur" ) ) + return 0 + ;; + services) + COMPREPLY=( $( compgen -s "$cur" ) ) + return 0 + ;; + hosts) + COMPREPLY=( $( compgen -A hostname "$cur" ) ) + return 0 + ;; + protocols|networks|ahosts|ahostsv4|ahostsv6|rpc) + COMPREPLY=( $( compgen -W "$( getent "$prev" | \ + awk '{ print $1 }' )" -- "$cur" ) ) + return 0 + ;; + aliases|shadow) + COMPREPLY=( $( compgen -W "$( getent "$prev" | cut -d: -f1 )" \ + -- "$cur" ) ) + return 0 + ;; + esac + + + if [ $COMP_CWORD -eq 1 ]; then + COMPREPLY=( $( compgen -W 'passwd group hosts services protocols \ + networks ahosts ahostsv4 ahostsv6 aliases ethers netgroup rpc \ + shadow' -- "$cur" ) ) + fi +} && +complete -F _getent getent + +# Local variables: +# mode: shell-script +# sh-basic-offset: 4 +# sh-indent-comment: t +# indent-tabs-mode: nil +# End: +# ex: ts=4 sw=4 et filetype=sh diff --git a/.bash/bash_completion.d/git b/.bash/bash_completion.d/git new file mode 100644 index 0000000..1496c6d --- /dev/null +++ b/.bash/bash_completion.d/git @@ -0,0 +1,2765 @@ +#!bash +# +# bash/zsh completion support for core Git. +# +# Copyright (C) 2006,2007 Shawn O. Pearce +# Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/). +# Distributed under the GNU General Public License, version 2.0. +# +# The contained completion routines provide support for completing: +# +# *) local and remote branch names +# *) local and remote tag names +# *) .git/remotes file names +# *) git 'subcommands' +# *) tree paths within 'ref:path/to/file' expressions +# *) common --long-options +# +# To use these routines: +# +# 1) Copy this file to somewhere (e.g. ~/.git-completion.sh). +# 2) Add the following line to your .bashrc/.zshrc: +# source ~/.git-completion.sh +# +# 3) Consider changing your PS1 to also show the current branch: +# Bash: PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ ' +# ZSH: PS1='[%n@%m %c$(__git_ps1 " (%s)")]\$ ' +# +# The argument to __git_ps1 will be displayed only if you +# are currently in a git repository. The %s token will be +# the name of the current branch. +# +# In addition, if you set GIT_PS1_SHOWDIRTYSTATE to a nonempty +# value, unstaged (*) and staged (+) changes will be shown next +# to the branch name. You can configure this per-repository +# with the bash.showDirtyState variable, which defaults to true +# once GIT_PS1_SHOWDIRTYSTATE is enabled. +# +# You can also see if currently something is stashed, by setting +# GIT_PS1_SHOWSTASHSTATE to a nonempty value. If something is stashed, +# then a '$' will be shown next to the branch name. +# +# If you would like to see if there're untracked files, then you can +# set GIT_PS1_SHOWUNTRACKEDFILES to a nonempty value. If there're +# untracked files, then a '%' will be shown next to the branch name. +# +# If you would like to see the difference between HEAD and its +# upstream, set GIT_PS1_SHOWUPSTREAM="auto". A "<" indicates +# you are behind, ">" indicates you are ahead, and "<>" +# indicates you have diverged. You can further control +# behaviour by setting GIT_PS1_SHOWUPSTREAM to a space-separated +# list of values: +# verbose show number of commits ahead/behind (+/-) upstream +# legacy don't use the '--count' option available in recent +# versions of git-rev-list +# git always compare HEAD to @{upstream} +# svn always compare HEAD to your SVN upstream +# By default, __git_ps1 will compare HEAD to your SVN upstream +# if it can find one, or @{upstream} otherwise. Once you have +# set GIT_PS1_SHOWUPSTREAM, you can override it on a +# per-repository basis by setting the bash.showUpstream config +# variable. +# +# +# To submit patches: +# +# *) Read Documentation/SubmittingPatches +# *) Send all patches to the current maintainer: +# +# "Shawn O. Pearce" +# +# *) Always CC the Git mailing list: +# +# git@vger.kernel.org +# + +if [[ -n ${ZSH_VERSION-} ]]; then + autoload -U +X bashcompinit && bashcompinit +fi + +case "$COMP_WORDBREAKS" in +*:*) : great ;; +*) COMP_WORDBREAKS="$COMP_WORDBREAKS:" +esac + +# __gitdir accepts 0 or 1 arguments (i.e., location) +# returns location of .git repo +__gitdir () +{ + if [ -z "${1-}" ]; then + if [ -n "${__git_dir-}" ]; then + echo "$__git_dir" + elif [ -d .git ]; then + echo .git + else + git rev-parse --git-dir 2>/dev/null + fi + elif [ -d "$1/.git" ]; then + echo "$1/.git" + else + echo "$1" + fi +} + +# stores the divergence from upstream in $p +# used by GIT_PS1_SHOWUPSTREAM +__git_ps1_show_upstream () +{ + local key value + local svn_remote=() svn_url_pattern count n + local upstream=git legacy="" verbose="" + + # get some config options from git-config + local output="$(git config -z --get-regexp '^(svn-remote\..*\.url|bash\.showupstream)$' 2>/dev/null | tr '\0\n' '\n ')" + while read -r key value; do + case "$key" in + bash.showupstream) + GIT_PS1_SHOWUPSTREAM="$value" + if [[ -z "${GIT_PS1_SHOWUPSTREAM}" ]]; then + p="" + return + fi + ;; + svn-remote.*.url) + svn_remote[ $((${#svn_remote[@]} + 1)) ]="$value" + svn_url_pattern+="\\|$value" + upstream=svn+git # default upstream is SVN if available, else git + ;; + esac + done <<< "$output" + + # parse configuration values + for option in ${GIT_PS1_SHOWUPSTREAM}; do + case "$option" in + git|svn) upstream="$option" ;; + verbose) verbose=1 ;; + legacy) legacy=1 ;; + esac + done + + # Find our upstream + case "$upstream" in + git) upstream="@{upstream}" ;; + svn*) + # get the upstream from the "git-svn-id: ..." in a commit message + # (git-svn uses essentially the same procedure internally) + local svn_upstream=($(git log --first-parent -1 \ + --grep="^git-svn-id: \(${svn_url_pattern#??}\)" 2>/dev/null)) + if [[ 0 -ne ${#svn_upstream[@]} ]]; then + svn_upstream=${svn_upstream[ ${#svn_upstream[@]} - 2 ]} + svn_upstream=${svn_upstream%@*} + local n_stop="${#svn_remote[@]}" + for ((n=1; n <= n_stop; ++n)); do + svn_upstream=${svn_upstream#${svn_remote[$n]}} + done + + if [[ -z "$svn_upstream" ]]; then + # default branch name for checkouts with no layout: + upstream=${GIT_SVN_ID:-git-svn} + else + upstream=${svn_upstream#/} + fi + elif [[ "svn+git" = "$upstream" ]]; then + upstream="@{upstream}" + fi + ;; + esac + + # Find how many commits we are ahead/behind our upstream + if [[ -z "$legacy" ]]; then + count="$(git rev-list --count --left-right \ + "$upstream"...HEAD 2>/dev/null)" + else + # produce equivalent output to --count for older versions of git + local commits + if commits="$(git rev-list --left-right "$upstream"...HEAD 2>/dev/null)" + then + local commit behind=0 ahead=0 + for commit in $commits + do + case "$commit" in + "<"*) let ++behind + ;; + *) let ++ahead + ;; + esac + done + count="$behind $ahead" + else + count="" + fi + fi + + # calculate the result + if [[ -z "$verbose" ]]; then + case "$count" in + "") # no upstream + p="" ;; + "0 0") # equal to upstream + p="=" ;; + "0 "*) # ahead of upstream + p=">" ;; + *" 0") # behind upstream + p="<" ;; + *) # diverged from upstream + p="<>" ;; + esac + else + case "$count" in + "") # no upstream + p="" ;; + "0 0") # equal to upstream + p=" u=" ;; + "0 "*) # ahead of upstream + p=" u+${count#0 }" ;; + *" 0") # behind upstream + p=" u-${count% 0}" ;; + *) # diverged from upstream + p=" u+${count#* }-${count% *}" ;; + esac + fi + +} + + +# __git_ps1 accepts 0 or 1 arguments (i.e., format string) +# returns text to add to bash PS1 prompt (includes branch name) +__git_ps1 () +{ + local g="$(__gitdir)" + if [ -n "$g" ]; then + local r="" + local b="" + if [ -f "$g/rebase-merge/interactive" ]; then + r="|REBASE-i" + b="$(cat "$g/rebase-merge/head-name")" + elif [ -d "$g/rebase-merge" ]; then + r="|REBASE-m" + b="$(cat "$g/rebase-merge/head-name")" + else + if [ -d "$g/rebase-apply" ]; then + if [ -f "$g/rebase-apply/rebasing" ]; then + r="|REBASE" + elif [ -f "$g/rebase-apply/applying" ]; then + r="|AM" + else + r="|AM/REBASE" + fi + elif [ -f "$g/MERGE_HEAD" ]; then + r="|MERGING" + elif [ -f "$g/CHERRY_PICK_HEAD" ]; then + r="|CHERRY-PICKING" + elif [ -f "$g/BISECT_LOG" ]; then + r="|BISECTING" + fi + + b="$(git symbolic-ref HEAD 2>/dev/null)" || { + + b="$( + case "${GIT_PS1_DESCRIBE_STYLE-}" in + (contains) + git describe --contains HEAD ;; + (branch) + git describe --contains --all HEAD ;; + (describe) + git describe HEAD ;; + (* | default) + git describe --tags --exact-match HEAD ;; + esac 2>/dev/null)" || + + b="$(cut -c1-7 "$g/HEAD" 2>/dev/null)..." || + b="unknown" + b="($b)" + } + fi + + local w="" + local i="" + local s="" + local u="" + local c="" + local p="" + + if [ "true" = "$(git rev-parse --is-inside-git-dir 2>/dev/null)" ]; then + if [ "true" = "$(git rev-parse --is-bare-repository 2>/dev/null)" ]; then + c="BARE:" + else + b="GIT_DIR!" + fi + elif [ "true" = "$(git rev-parse --is-inside-work-tree 2>/dev/null)" ]; then + if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ]; then + if [ "$(git config --bool bash.showDirtyState)" != "false" ]; then + git diff --no-ext-diff --quiet --exit-code || w="*" + if git rev-parse --quiet --verify HEAD >/dev/null; then + git diff-index --cached --quiet HEAD -- || i="+" + else + i="#" + fi + fi + fi + if [ -n "${GIT_PS1_SHOWSTASHSTATE-}" ]; then + git rev-parse --verify refs/stash >/dev/null 2>&1 && s="$" + fi + + if [ -n "${GIT_PS1_SHOWUNTRACKEDFILES-}" ]; then + if [ -n "$(git ls-files --others --exclude-standard)" ]; then + u="%" + fi + fi + + if [ -n "${GIT_PS1_SHOWUPSTREAM-}" ]; then + __git_ps1_show_upstream + fi + fi + + local f="$w$i$s$u" + printf "${1:- (%s)}" "$c${b##refs/heads/}${f:+ $f}$r$p" + fi +} + +# __gitcomp_1 requires 2 arguments +__gitcomp_1 () +{ + local c IFS=' '$'\t'$'\n' + for c in $1; do + case "$c$2" in + --*=*) printf %s$'\n' "$c$2" ;; + *.) printf %s$'\n' "$c$2" ;; + *) printf %s$'\n' "$c$2 " ;; + esac + done +} + +# The following function is based on code from: +# +# bash_completion - programmable completion functions for bash 3.2+ +# +# Copyright © 2006-2008, Ian Macdonald +# © 2009-2010, Bash Completion Maintainers +# +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The latest version of this software can be obtained here: +# +# http://bash-completion.alioth.debian.org/ +# +# RELEASE: 2.x + +# This function can be used to access a tokenized list of words +# on the command line: +# +# __git_reassemble_comp_words_by_ref '=:' +# if test "${words_[cword_-1]}" = -w +# then +# ... +# fi +# +# The argument should be a collection of characters from the list of +# word completion separators (COMP_WORDBREAKS) to treat as ordinary +# characters. +# +# This is roughly equivalent to going back in time and setting +# COMP_WORDBREAKS to exclude those characters. The intent is to +# make option types like --date= and : easy to +# recognize by treating each shell word as a single token. +# +# It is best not to set COMP_WORDBREAKS directly because the value is +# shared with other completion scripts. By the time the completion +# function gets called, COMP_WORDS has already been populated so local +# changes to COMP_WORDBREAKS have no effect. +# +# Output: words_, cword_, cur_. + +__git_reassemble_comp_words_by_ref() +{ + local exclude i j first + # Which word separators to exclude? + exclude="${1//[^$COMP_WORDBREAKS]}" + cword_=$COMP_CWORD + if [ -z "$exclude" ]; then + words_=("${COMP_WORDS[@]}") + return + fi + # List of word completion separators has shrunk; + # re-assemble words to complete. + for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do + # Append each nonempty word consisting of just + # word separator characters to the current word. + first=t + while + [ $i -gt 0 ] && + [ -n "${COMP_WORDS[$i]}" ] && + # word consists of excluded word separators + [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ] + do + # Attach to the previous token, + # unless the previous token is the command name. + if [ $j -ge 2 ] && [ -n "$first" ]; then + ((j--)) + fi + first= + words_[$j]=${words_[j]}${COMP_WORDS[i]} + if [ $i = $COMP_CWORD ]; then + cword_=$j + fi + if (($i < ${#COMP_WORDS[@]} - 1)); then + ((i++)) + else + # Done. + return + fi + done + words_[$j]=${words_[j]}${COMP_WORDS[i]} + if [ $i = $COMP_CWORD ]; then + cword_=$j + fi + done +} + +if ! type _get_comp_words_by_ref >/dev/null 2>&1; then +if [[ -z ${ZSH_VERSION:+set} ]]; then +_get_comp_words_by_ref () +{ + local exclude cur_ words_ cword_ + if [ "$1" = "-n" ]; then + exclude=$2 + shift 2 + fi + __git_reassemble_comp_words_by_ref "$exclude" + cur_=${words_[cword_]} + while [ $# -gt 0 ]; do + case "$1" in + cur) + cur=$cur_ + ;; + prev) + prev=${words_[$cword_-1]} + ;; + words) + words=("${words_[@]}") + ;; + cword) + cword=$cword_ + ;; + esac + shift + done +} +else +_get_comp_words_by_ref () +{ + while [ $# -gt 0 ]; do + case "$1" in + cur) + cur=${COMP_WORDS[COMP_CWORD]} + ;; + prev) + prev=${COMP_WORDS[COMP_CWORD-1]} + ;; + words) + words=("${COMP_WORDS[@]}") + ;; + cword) + cword=$COMP_CWORD + ;; + -n) + # assume COMP_WORDBREAKS is already set sanely + shift + ;; + esac + shift + done +} +fi +fi + +# Generates completion reply with compgen, appending a space to possible +# completion words, if necessary. +# It accepts 1 to 4 arguments: +# 1: List of possible completion words. +# 2: A prefix to be added to each possible completion word (optional). +# 3: Generate possible completion matches for this word (optional). +# 4: A suffix to be appended to each possible completion word (optional). +__gitcomp () +{ + local cur_="$cur" + + if [ $# -gt 2 ]; then + cur_="$3" + fi + case "$cur_" in + --*=) + COMPREPLY=() + ;; + *) + local IFS=$'\n' + COMPREPLY=($(compgen -P "${2-}" \ + -W "$(__gitcomp_1 "${1-}" "${4-}")" \ + -- "$cur_")) + ;; + esac +} + +# Generates completion reply with compgen from newline-separated possible +# completion words by appending a space to all of them. +# It accepts 1 to 4 arguments: +# 1: List of possible completion words, separated by a single newline. +# 2: A prefix to be added to each possible completion word (optional). +# 3: Generate possible completion matches for this word (optional). +# 4: A suffix to be appended to each possible completion word instead of +# the default space (optional). If specified but empty, nothing is +# appended. +__gitcomp_nl () +{ + local s=$'\n' IFS=' '$'\t'$'\n' + local cur_="$cur" suffix=" " + + if [ $# -gt 2 ]; then + cur_="$3" + if [ $# -gt 3 ]; then + suffix="$4" + fi + fi + + IFS=$s + COMPREPLY=($(compgen -P "${2-}" -S "$suffix" -W "$1" -- "$cur_")) +} + +__git_heads () +{ + local dir="$(__gitdir)" + if [ -d "$dir" ]; then + git --git-dir="$dir" for-each-ref --format='%(refname:short)' \ + refs/heads + return + fi +} + +__git_tags () +{ + local dir="$(__gitdir)" + if [ -d "$dir" ]; then + git --git-dir="$dir" for-each-ref --format='%(refname:short)' \ + refs/tags + return + fi +} + +# __git_refs accepts 0, 1 (to pass to __gitdir), or 2 arguments +# presence of 2nd argument means use the guess heuristic employed +# by checkout for tracking branches +__git_refs () +{ + local i hash dir="$(__gitdir "${1-}")" track="${2-}" + local format refs + if [ -d "$dir" ]; then + case "$cur" in + refs|refs/*) + format="refname" + refs="${cur%/*}" + track="" + ;; + *) + for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD; do + if [ -e "$dir/$i" ]; then echo $i; fi + done + format="refname:short" + refs="refs/tags refs/heads refs/remotes" + ;; + esac + git --git-dir="$dir" for-each-ref --format="%($format)" \ + $refs + if [ -n "$track" ]; then + # employ the heuristic used by git checkout + # Try to find a remote branch that matches the completion word + # but only output if the branch name is unique + local ref entry + git --git-dir="$dir" for-each-ref --shell --format="ref=%(refname:short)" \ + "refs/remotes/" | \ + while read -r entry; do + eval "$entry" + ref="${ref#*/}" + if [[ "$ref" == "$cur"* ]]; then + echo "$ref" + fi + done | uniq -u + fi + return + fi + case "$cur" in + refs|refs/*) + git ls-remote "$dir" "$cur*" 2>/dev/null | \ + while read -r hash i; do + case "$i" in + *^{}) ;; + *) echo "$i" ;; + esac + done + ;; + *) + git ls-remote "$dir" HEAD ORIG_HEAD 'refs/tags/*' 'refs/heads/*' 'refs/remotes/*' 2>/dev/null | \ + while read -r hash i; do + case "$i" in + *^{}) ;; + refs/*) echo "${i#refs/*/}" ;; + *) echo "$i" ;; + esac + done + ;; + esac +} + +# __git_refs2 requires 1 argument (to pass to __git_refs) +__git_refs2 () +{ + local i + for i in $(__git_refs "$1"); do + echo "$i:$i" + done +} + +# __git_refs_remotes requires 1 argument (to pass to ls-remote) +__git_refs_remotes () +{ + local i hash + git ls-remote "$1" 'refs/heads/*' 2>/dev/null | \ + while read -r hash i; do + echo "$i:refs/remotes/$1/${i#refs/heads/}" + done +} + +__git_remotes () +{ + local i ngoff IFS=$'\n' d="$(__gitdir)" + __git_shopt -q nullglob || ngoff=1 + __git_shopt -s nullglob + for i in "$d/remotes"/*; do + echo ${i#$d/remotes/} + done + [ "$ngoff" ] && __git_shopt -u nullglob + for i in $(git --git-dir="$d" config --get-regexp 'remote\..*\.url' 2>/dev/null); do + i="${i#remote.}" + echo "${i/.url*/}" + done +} + +__git_list_merge_strategies () +{ + git merge -s help 2>&1 | + sed -n -e '/[Aa]vailable strategies are: /,/^$/{ + s/\.$// + s/.*:// + s/^[ ]*// + s/[ ]*$// + p + }' +} + +__git_merge_strategies= +# 'git merge -s help' (and thus detection of the merge strategy +# list) fails, unfortunately, if run outside of any git working +# tree. __git_merge_strategies is set to the empty string in +# that case, and the detection will be repeated the next time it +# is needed. +__git_compute_merge_strategies () +{ + : ${__git_merge_strategies:=$(__git_list_merge_strategies)} +} + +__git_complete_revlist_file () +{ + local pfx ls ref cur_="$cur" + case "$cur_" in + *..?*:*) + return + ;; + ?*:*) + ref="${cur_%%:*}" + cur_="${cur_#*:}" + case "$cur_" in + ?*/*) + pfx="${cur_%/*}" + cur_="${cur_##*/}" + ls="$ref:$pfx" + pfx="$pfx/" + ;; + *) + ls="$ref" + ;; + esac + + case "$COMP_WORDBREAKS" in + *:*) : great ;; + *) pfx="$ref:$pfx" ;; + esac + + local IFS=$'\n' + COMPREPLY=($(compgen -P "$pfx" \ + -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \ + | sed '/^100... blob /{ + s,^.* ,, + s,$, , + } + /^120000 blob /{ + s,^.* ,, + s,$, , + } + /^040000 tree /{ + s,^.* ,, + s,$,/, + } + s/^.* //')" \ + -- "$cur_")) + ;; + *...*) + pfx="${cur_%...*}..." + cur_="${cur_#*...}" + __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_" + ;; + *..*) + pfx="${cur_%..*}.." + cur_="${cur_#*..}" + __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_" + ;; + *) + __gitcomp_nl "$(__git_refs)" + ;; + esac +} + + +__git_complete_file () +{ + __git_complete_revlist_file +} + +__git_complete_revlist () +{ + __git_complete_revlist_file +} + +__git_complete_remote_or_refspec () +{ + local cur_="$cur" cmd="${words[1]}" + local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0 + while [ $c -lt $cword ]; do + i="${words[c]}" + case "$i" in + --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;; + --all) + case "$cmd" in + push) no_complete_refspec=1 ;; + fetch) + COMPREPLY=() + return + ;; + *) ;; + esac + ;; + -*) ;; + *) remote="$i"; break ;; + esac + c=$((++c)) + done + if [ -z "$remote" ]; then + __gitcomp_nl "$(__git_remotes)" + return + fi + if [ $no_complete_refspec = 1 ]; then + COMPREPLY=() + return + fi + [ "$remote" = "." ] && remote= + case "$cur_" in + *:*) + case "$COMP_WORDBREAKS" in + *:*) : great ;; + *) pfx="${cur_%%:*}:" ;; + esac + cur_="${cur_#*:}" + lhs=0 + ;; + +*) + pfx="+" + cur_="${cur_#+}" + ;; + esac + case "$cmd" in + fetch) + if [ $lhs = 1 ]; then + __gitcomp_nl "$(__git_refs2 "$remote")" "$pfx" "$cur_" + else + __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_" + fi + ;; + pull) + if [ $lhs = 1 ]; then + __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_" + else + __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_" + fi + ;; + push) + if [ $lhs = 1 ]; then + __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_" + else + __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_" + fi + ;; + esac +} + +__git_complete_strategy () +{ + __git_compute_merge_strategies + case "$prev" in + -s|--strategy) + __gitcomp "$__git_merge_strategies" + return 0 + esac + case "$cur" in + --strategy=*) + __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}" + return 0 + ;; + esac + return 1 +} + +__git_list_all_commands () +{ + local i IFS=" "$'\n' + for i in $(git help -a|egrep '^ [a-zA-Z0-9]') + do + case $i in + *--*) : helper pattern;; + *) echo $i;; + esac + done +} + +__git_all_commands= +__git_compute_all_commands () +{ + : ${__git_all_commands:=$(__git_list_all_commands)} +} + +__git_list_porcelain_commands () +{ + local i IFS=" "$'\n' + __git_compute_all_commands + for i in "help" $__git_all_commands + do + case $i in + *--*) : helper pattern;; + applymbox) : ask gittus;; + applypatch) : ask gittus;; + archimport) : import;; + cat-file) : plumbing;; + check-attr) : plumbing;; + check-ref-format) : plumbing;; + checkout-index) : plumbing;; + commit-tree) : plumbing;; + count-objects) : infrequent;; + cvsexportcommit) : export;; + cvsimport) : import;; + cvsserver) : daemon;; + daemon) : daemon;; + diff-files) : plumbing;; + diff-index) : plumbing;; + diff-tree) : plumbing;; + fast-import) : import;; + fast-export) : export;; + fsck-objects) : plumbing;; + fetch-pack) : plumbing;; + fmt-merge-msg) : plumbing;; + for-each-ref) : plumbing;; + hash-object) : plumbing;; + http-*) : transport;; + index-pack) : plumbing;; + init-db) : deprecated;; + local-fetch) : plumbing;; + lost-found) : infrequent;; + ls-files) : plumbing;; + ls-remote) : plumbing;; + ls-tree) : plumbing;; + mailinfo) : plumbing;; + mailsplit) : plumbing;; + merge-*) : plumbing;; + mktree) : plumbing;; + mktag) : plumbing;; + pack-objects) : plumbing;; + pack-redundant) : plumbing;; + pack-refs) : plumbing;; + parse-remote) : plumbing;; + patch-id) : plumbing;; + peek-remote) : plumbing;; + prune) : plumbing;; + prune-packed) : plumbing;; + quiltimport) : import;; + read-tree) : plumbing;; + receive-pack) : plumbing;; + remote-*) : transport;; + repo-config) : deprecated;; + rerere) : plumbing;; + rev-list) : plumbing;; + rev-parse) : plumbing;; + runstatus) : plumbing;; + sh-setup) : internal;; + shell) : daemon;; + show-ref) : plumbing;; + send-pack) : plumbing;; + show-index) : plumbing;; + ssh-*) : transport;; + stripspace) : plumbing;; + symbolic-ref) : plumbing;; + tar-tree) : deprecated;; + unpack-file) : plumbing;; + unpack-objects) : plumbing;; + update-index) : plumbing;; + update-ref) : plumbing;; + update-server-info) : daemon;; + upload-archive) : plumbing;; + upload-pack) : plumbing;; + write-tree) : plumbing;; + var) : infrequent;; + verify-pack) : infrequent;; + verify-tag) : plumbing;; + *) echo $i;; + esac + done +} + +__git_porcelain_commands= +__git_compute_porcelain_commands () +{ + __git_compute_all_commands + : ${__git_porcelain_commands:=$(__git_list_porcelain_commands)} +} + +__git_pretty_aliases () +{ + local i IFS=$'\n' + for i in $(git --git-dir="$(__gitdir)" config --get-regexp "pretty\..*" 2>/dev/null); do + case "$i" in + pretty.*) + i="${i#pretty.}" + echo "${i/ */}" + ;; + esac + done +} + +__git_aliases () +{ + local i IFS=$'\n' + for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do + case "$i" in + alias.*) + i="${i#alias.}" + echo "${i/ */}" + ;; + esac + done +} + +# __git_aliased_command requires 1 argument +__git_aliased_command () +{ + local word cmdline=$(git --git-dir="$(__gitdir)" \ + config --get "alias.$1") + for word in $cmdline; do + case "$word" in + \!gitk|gitk) + echo "gitk" + return + ;; + \!*) : shell command alias ;; + -*) : option ;; + *=*) : setting env ;; + git) : git itself ;; + *) + echo "$word" + return + esac + done +} + +# __git_find_on_cmdline requires 1 argument +__git_find_on_cmdline () +{ + local word subcommand c=1 + while [ $c -lt $cword ]; do + word="${words[c]}" + for subcommand in $1; do + if [ "$subcommand" = "$word" ]; then + echo "$subcommand" + return + fi + done + c=$((++c)) + done +} + +__git_has_doubledash () +{ + local c=1 + while [ $c -lt $cword ]; do + if [ "--" = "${words[c]}" ]; then + return 0 + fi + c=$((++c)) + done + return 1 +} + +__git_whitespacelist="nowarn warn error error-all fix" + +_git_am () +{ + local dir="$(__gitdir)" + if [ -d "$dir"/rebase-apply ]; then + __gitcomp "--skip --continue --resolved --abort" + return + fi + case "$cur" in + --whitespace=*) + __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}" + return + ;; + --*) + __gitcomp " + --3way --committer-date-is-author-date --ignore-date + --ignore-whitespace --ignore-space-change + --interactive --keep --no-utf8 --signoff --utf8 + --whitespace= --scissors + " + return + esac + COMPREPLY=() +} + +_git_apply () +{ + case "$cur" in + --whitespace=*) + __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}" + return + ;; + --*) + __gitcomp " + --stat --numstat --summary --check --index + --cached --index-info --reverse --reject --unidiff-zero + --apply --no-add --exclude= + --ignore-whitespace --ignore-space-change + --whitespace= --inaccurate-eof --verbose + " + return + esac + COMPREPLY=() +} + +_git_add () +{ + __git_has_doubledash && return + + case "$cur" in + --*) + __gitcomp " + --interactive --refresh --patch --update --dry-run + --ignore-errors --intent-to-add + " + return + esac + COMPREPLY=() +} + +_git_archive () +{ + case "$cur" in + --format=*) + __gitcomp "$(git archive --list)" "" "${cur##--format=}" + return + ;; + --remote=*) + __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}" + return + ;; + --*) + __gitcomp " + --format= --list --verbose + --prefix= --remote= --exec= + " + return + ;; + esac + __git_complete_file +} + +_git_bisect () +{ + __git_has_doubledash && return + + local subcommands="start bad good skip reset visualize replay log run" + local subcommand="$(__git_find_on_cmdline "$subcommands")" + if [ -z "$subcommand" ]; then + if [ -f "$(__gitdir)"/BISECT_START ]; then + __gitcomp "$subcommands" + else + __gitcomp "replay start" + fi + return + fi + + case "$subcommand" in + bad|good|reset|skip|start) + __gitcomp_nl "$(__git_refs)" + ;; + *) + COMPREPLY=() + ;; + esac +} + +_git_branch () +{ + local i c=1 only_local_ref="n" has_r="n" + + while [ $c -lt $cword ]; do + i="${words[c]}" + case "$i" in + -d|-m) only_local_ref="y" ;; + -r) has_r="y" ;; + esac + c=$((++c)) + done + + case "$cur" in + --*) + __gitcomp " + --color --no-color --verbose --abbrev= --no-abbrev + --track --no-track --contains --merged --no-merged + --set-upstream + " + ;; + *) + if [ $only_local_ref = "y" -a $has_r = "n" ]; then + __gitcomp_nl "$(__git_heads)" + else + __gitcomp_nl "$(__git_refs)" + fi + ;; + esac +} + +_git_bundle () +{ + local cmd="${words[2]}" + case "$cword" in + 2) + __gitcomp "create list-heads verify unbundle" + ;; + 3) + # looking for a file + ;; + *) + case "$cmd" in + create) + __git_complete_revlist + ;; + esac + ;; + esac +} + +_git_checkout () +{ + __git_has_doubledash && return + + case "$cur" in + --conflict=*) + __gitcomp "diff3 merge" "" "${cur##--conflict=}" + ;; + --*) + __gitcomp " + --quiet --ours --theirs --track --no-track --merge + --conflict= --orphan --patch + " + ;; + *) + # check if --track, --no-track, or --no-guess was specified + # if so, disable DWIM mode + local flags="--track --no-track --no-guess" track=1 + if [ -n "$(__git_find_on_cmdline "$flags")" ]; then + track='' + fi + __gitcomp_nl "$(__git_refs '' $track)" + ;; + esac +} + +_git_cherry () +{ + __gitcomp "$(__git_refs)" +} + +_git_cherry_pick () +{ + case "$cur" in + --*) + __gitcomp "--edit --no-commit" + ;; + *) + __gitcomp_nl "$(__git_refs)" + ;; + esac +} + +_git_clean () +{ + __git_has_doubledash && return + + case "$cur" in + --*) + __gitcomp "--dry-run --quiet" + return + ;; + esac + COMPREPLY=() +} + +_git_clone () +{ + case "$cur" in + --*) + __gitcomp " + --local + --no-hardlinks + --shared + --reference + --quiet + --no-checkout + --bare + --mirror + --origin + --upload-pack + --template= + --depth + " + return + ;; + esac + COMPREPLY=() +} + +_git_commit () +{ + __git_has_doubledash && return + + case "$cur" in + --cleanup=*) + __gitcomp "default strip verbatim whitespace + " "" "${cur##--cleanup=}" + return + ;; + --reuse-message=*|--reedit-message=*|\ + --fixup=*|--squash=*) + __gitcomp_nl "$(__git_refs)" "" "${cur#*=}" + return + ;; + --untracked-files=*) + __gitcomp "all no normal" "" "${cur##--untracked-files=}" + return + ;; + --*) + __gitcomp " + --all --author= --signoff --verify --no-verify + --edit --amend --include --only --interactive + --dry-run --reuse-message= --reedit-message= + --reset-author --file= --message= --template= + --cleanup= --untracked-files --untracked-files= + --verbose --quiet --fixup= --squash= + " + return + esac + COMPREPLY=() +} + +_git_describe () +{ + case "$cur" in + --*) + __gitcomp " + --all --tags --contains --abbrev= --candidates= + --exact-match --debug --long --match --always + " + return + esac + __gitcomp_nl "$(__git_refs)" +} + +__git_diff_common_options="--stat --numstat --shortstat --summary + --patch-with-stat --name-only --name-status --color + --no-color --color-words --no-renames --check + --full-index --binary --abbrev --diff-filter= + --find-copies-harder + --text --ignore-space-at-eol --ignore-space-change + --ignore-all-space --exit-code --quiet --ext-diff + --no-ext-diff + --no-prefix --src-prefix= --dst-prefix= + --inter-hunk-context= + --patience + --raw + --dirstat --dirstat= --dirstat-by-file + --dirstat-by-file= --cumulative +" + +_git_diff () +{ + __git_has_doubledash && return + + case "$cur" in + --*) + __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex + --base --ours --theirs --no-index + $__git_diff_common_options + " + return + ;; + esac + __git_complete_revlist_file +} + +__git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff + tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc3 +" + +_git_difftool () +{ + __git_has_doubledash && return + + case "$cur" in + --tool=*) + __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}" + return + ;; + --*) + __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex + --base --ours --theirs + --no-renames --diff-filter= --find-copies-harder + --relative --ignore-submodules + --tool=" + return + ;; + esac + __git_complete_file +} + +__git_fetch_options=" + --quiet --verbose --append --upload-pack --force --keep --depth= + --tags --no-tags --all --prune --dry-run +" + +_git_fetch () +{ + case "$cur" in + --*) + __gitcomp "$__git_fetch_options" + return + ;; + esac + __git_complete_remote_or_refspec +} + +_git_format_patch () +{ + case "$cur" in + --thread=*) + __gitcomp " + deep shallow + " "" "${cur##--thread=}" + return + ;; + --*) + __gitcomp " + --stdout --attach --no-attach --thread --thread= + --output-directory + --numbered --start-number + --numbered-files + --keep-subject + --signoff --signature --no-signature + --in-reply-to= --cc= + --full-index --binary + --not --all + --cover-letter + --no-prefix --src-prefix= --dst-prefix= + --inline --suffix= --ignore-if-in-upstream + --subject-prefix= + " + return + ;; + esac + __git_complete_revlist +} + +_git_fsck () +{ + case "$cur" in + --*) + __gitcomp " + --tags --root --unreachable --cache --no-reflogs --full + --strict --verbose --lost-found + " + return + ;; + esac + COMPREPLY=() +} + +_git_gc () +{ + case "$cur" in + --*) + __gitcomp "--prune --aggressive" + return + ;; + esac + COMPREPLY=() +} + +_git_gitk () +{ + _gitk +} + +__git_match_ctag() { + awk "/^${1////\\/}/ { print \$1 }" "$2" +} + +_git_grep () +{ + __git_has_doubledash && return + + case "$cur" in + --*) + __gitcomp " + --cached + --text --ignore-case --word-regexp --invert-match + --full-name --line-number + --extended-regexp --basic-regexp --fixed-strings + --perl-regexp + --files-with-matches --name-only + --files-without-match + --max-depth + --count + --and --or --not --all-match + " + return + ;; + esac + + case "$cword,$prev" in + 2,*|*,-*) + if test -r tags; then + __gitcomp_nl "$(__git_match_ctag "$cur" tags)" + return + fi + ;; + esac + + __gitcomp_nl "$(__git_refs)" +} + +_git_help () +{ + case "$cur" in + --*) + __gitcomp "--all --info --man --web" + return + ;; + esac + __git_compute_all_commands + __gitcomp "$__git_all_commands $(__git_aliases) + attributes cli core-tutorial cvs-migration + diffcore gitk glossary hooks ignore modules + namespaces repository-layout tutorial tutorial-2 + workflows + " +} + +_git_init () +{ + case "$cur" in + --shared=*) + __gitcomp " + false true umask group all world everybody + " "" "${cur##--shared=}" + return + ;; + --*) + __gitcomp "--quiet --bare --template= --shared --shared=" + return + ;; + esac + COMPREPLY=() +} + +_git_ls_files () +{ + __git_has_doubledash && return + + case "$cur" in + --*) + __gitcomp "--cached --deleted --modified --others --ignored + --stage --directory --no-empty-directory --unmerged + --killed --exclude= --exclude-from= + --exclude-per-directory= --exclude-standard + --error-unmatch --with-tree= --full-name + --abbrev --ignored --exclude-per-directory + " + return + ;; + esac + COMPREPLY=() +} + +_git_ls_remote () +{ + __gitcomp_nl "$(__git_remotes)" +} + +_git_ls_tree () +{ + __git_complete_file +} + +# Options that go well for log, shortlog and gitk +__git_log_common_options=" + --not --all + --branches --tags --remotes + --first-parent --merges --no-merges + --max-count= + --max-age= --since= --after= + --min-age= --until= --before= + --min-parents= --max-parents= + --no-min-parents --no-max-parents +" +# Options that go well for log and gitk (not shortlog) +__git_log_gitk_options=" + --dense --sparse --full-history + --simplify-merges --simplify-by-decoration + --left-right --notes --no-notes +" +# Options that go well for log and shortlog (not gitk) +__git_log_shortlog_options=" + --author= --committer= --grep= + --all-match +" + +__git_log_pretty_formats="oneline short medium full fuller email raw format:" +__git_log_date_formats="relative iso8601 rfc2822 short local default raw" + +_git_log () +{ + __git_has_doubledash && return + + local g="$(git rev-parse --git-dir 2>/dev/null)" + local merge="" + if [ -f "$g/MERGE_HEAD" ]; then + merge="--merge" + fi + case "$cur" in + --pretty=*|--format=*) + __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases) + " "" "${cur#*=}" + return + ;; + --date=*) + __gitcomp "$__git_log_date_formats" "" "${cur##--date=}" + return + ;; + --decorate=*) + __gitcomp "long short" "" "${cur##--decorate=}" + return + ;; + --*) + __gitcomp " + $__git_log_common_options + $__git_log_shortlog_options + $__git_log_gitk_options + --root --topo-order --date-order --reverse + --follow --full-diff + --abbrev-commit --abbrev= + --relative-date --date= + --pretty= --format= --oneline + --cherry-pick + --graph + --decorate --decorate= + --walk-reflogs + --parents --children + $merge + $__git_diff_common_options + --pickaxe-all --pickaxe-regex + " + return + ;; + esac + __git_complete_revlist +} + +__git_merge_options=" + --no-commit --no-stat --log --no-log --squash --strategy + --commit --stat --no-squash --ff --no-ff --ff-only +" + +_git_merge () +{ + __git_complete_strategy && return + + case "$cur" in + --*) + __gitcomp "$__git_merge_options" + return + esac + __gitcomp_nl "$(__git_refs)" +} + +_git_mergetool () +{ + case "$cur" in + --tool=*) + __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}" + return + ;; + --*) + __gitcomp "--tool=" + return + ;; + esac + COMPREPLY=() +} + +_git_merge_base () +{ + __gitcomp_nl "$(__git_refs)" +} + +_git_mv () +{ + case "$cur" in + --*) + __gitcomp "--dry-run" + return + ;; + esac + COMPREPLY=() +} + +_git_name_rev () +{ + __gitcomp "--tags --all --stdin" +} + +_git_notes () +{ + local subcommands='add append copy edit list prune remove show' + local subcommand="$(__git_find_on_cmdline "$subcommands")" + + case "$subcommand,$cur" in + ,--*) + __gitcomp '--ref' + ;; + ,*) + case "${words[cword-1]}" in + --ref) + __gitcomp_nl "$(__git_refs)" + ;; + *) + __gitcomp "$subcommands --ref" + ;; + esac + ;; + add,--reuse-message=*|append,--reuse-message=*|\ + add,--reedit-message=*|append,--reedit-message=*) + __gitcomp_nl "$(__git_refs)" "" "${cur#*=}" + ;; + add,--*|append,--*) + __gitcomp '--file= --message= --reedit-message= + --reuse-message=' + ;; + copy,--*) + __gitcomp '--stdin' + ;; + prune,--*) + __gitcomp '--dry-run --verbose' + ;; + prune,*) + ;; + *) + case "${words[cword-1]}" in + -m|-F) + ;; + *) + __gitcomp_nl "$(__git_refs)" + ;; + esac + ;; + esac +} + +_git_pull () +{ + __git_complete_strategy && return + + case "$cur" in + --*) + __gitcomp " + --rebase --no-rebase + $__git_merge_options + $__git_fetch_options + " + return + ;; + esac + __git_complete_remote_or_refspec +} + +_git_push () +{ + case "$prev" in + --repo) + __gitcomp_nl "$(__git_remotes)" + return + esac + case "$cur" in + --repo=*) + __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}" + return + ;; + --*) + __gitcomp " + --all --mirror --tags --dry-run --force --verbose + --receive-pack= --repo= --set-upstream + " + return + ;; + esac + __git_complete_remote_or_refspec +} + +_git_rebase () +{ + local dir="$(__gitdir)" + if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then + __gitcomp "--continue --skip --abort" + return + fi + __git_complete_strategy && return + case "$cur" in + --whitespace=*) + __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}" + return + ;; + --*) + __gitcomp " + --onto --merge --strategy --interactive + --preserve-merges --stat --no-stat + --committer-date-is-author-date --ignore-date + --ignore-whitespace --whitespace= + --autosquash + " + + return + esac + __gitcomp_nl "$(__git_refs)" +} + +_git_reflog () +{ + local subcommands="show delete expire" + local subcommand="$(__git_find_on_cmdline "$subcommands")" + + if [ -z "$subcommand" ]; then + __gitcomp "$subcommands" + else + __gitcomp_nl "$(__git_refs)" + fi +} + +__git_send_email_confirm_options="always never auto cc compose" +__git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all" + +_git_send_email () +{ + case "$cur" in + --confirm=*) + __gitcomp " + $__git_send_email_confirm_options + " "" "${cur##--confirm=}" + return + ;; + --suppress-cc=*) + __gitcomp " + $__git_send_email_suppresscc_options + " "" "${cur##--suppress-cc=}" + + return + ;; + --smtp-encryption=*) + __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}" + return + ;; + --*) + __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to + --compose --confirm= --dry-run --envelope-sender + --from --identity + --in-reply-to --no-chain-reply-to --no-signed-off-by-cc + --no-suppress-from --no-thread --quiet + --signed-off-by-cc --smtp-pass --smtp-server + --smtp-server-port --smtp-encryption= --smtp-user + --subject --suppress-cc= --suppress-from --thread --to + --validate --no-validate" + return + ;; + esac + COMPREPLY=() +} + +_git_stage () +{ + _git_add +} + +__git_config_get_set_variables () +{ + local prevword word config_file= c=$cword + while [ $c -gt 1 ]; do + word="${words[c]}" + case "$word" in + --global|--system|--file=*) + config_file="$word" + break + ;; + -f|--file) + config_file="$word $prevword" + break + ;; + esac + prevword=$word + c=$((--c)) + done + + git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null | + while read -r line + do + case "$line" in + *.*=*) + echo "${line/=*/}" + ;; + esac + done +} + +_git_config () +{ + case "$prev" in + branch.*.remote) + __gitcomp_nl "$(__git_remotes)" + return + ;; + branch.*.merge) + __gitcomp_nl "$(__git_refs)" + return + ;; + remote.*.fetch) + local remote="${prev#remote.}" + remote="${remote%.fetch}" + if [ -z "$cur" ]; then + COMPREPLY=("refs/heads/") + return + fi + __gitcomp_nl "$(__git_refs_remotes "$remote")" + return + ;; + remote.*.push) + local remote="${prev#remote.}" + remote="${remote%.push}" + __gitcomp_nl "$(git --git-dir="$(__gitdir)" \ + for-each-ref --format='%(refname):%(refname)' \ + refs/heads)" + return + ;; + pull.twohead|pull.octopus) + __git_compute_merge_strategies + __gitcomp "$__git_merge_strategies" + return + ;; + color.branch|color.diff|color.interactive|\ + color.showbranch|color.status|color.ui) + __gitcomp "always never auto" + return + ;; + color.pager) + __gitcomp "false true" + return + ;; + color.*.*) + __gitcomp " + normal black red green yellow blue magenta cyan white + bold dim ul blink reverse + " + return + ;; + help.format) + __gitcomp "man info web html" + return + ;; + log.date) + __gitcomp "$__git_log_date_formats" + return + ;; + sendemail.aliasesfiletype) + __gitcomp "mutt mailrc pine elm gnus" + return + ;; + sendemail.confirm) + __gitcomp "$__git_send_email_confirm_options" + return + ;; + sendemail.suppresscc) + __gitcomp "$__git_send_email_suppresscc_options" + return + ;; + --get|--get-all|--unset|--unset-all) + __gitcomp_nl "$(__git_config_get_set_variables)" + return + ;; + *.*) + COMPREPLY=() + return + ;; + esac + case "$cur" in + --*) + __gitcomp " + --global --system --file= + --list --replace-all + --get --get-all --get-regexp + --add --unset --unset-all + --remove-section --rename-section + " + return + ;; + branch.*.*) + local pfx="${cur%.*}." cur_="${cur##*.}" + __gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur_" + return + ;; + branch.*) + local pfx="${cur%.*}." cur_="${cur#*.}" + __gitcomp_nl "$(__git_heads)" "$pfx" "$cur_" "." + return + ;; + guitool.*.*) + local pfx="${cur%.*}." cur_="${cur##*.}" + __gitcomp " + argprompt cmd confirm needsfile noconsole norescan + prompt revprompt revunmerged title + " "$pfx" "$cur_" + return + ;; + difftool.*.*) + local pfx="${cur%.*}." cur_="${cur##*.}" + __gitcomp "cmd path" "$pfx" "$cur_" + return + ;; + man.*.*) + local pfx="${cur%.*}." cur_="${cur##*.}" + __gitcomp "cmd path" "$pfx" "$cur_" + return + ;; + mergetool.*.*) + local pfx="${cur%.*}." cur_="${cur##*.}" + __gitcomp "cmd path trustExitCode" "$pfx" "$cur_" + return + ;; + pager.*) + local pfx="${cur%.*}." cur_="${cur#*.}" + __git_compute_all_commands + __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_" + return + ;; + remote.*.*) + local pfx="${cur%.*}." cur_="${cur##*.}" + __gitcomp " + url proxy fetch push mirror skipDefaultUpdate + receivepack uploadpack tagopt pushurl + " "$pfx" "$cur_" + return + ;; + remote.*) + local pfx="${cur%.*}." cur_="${cur#*.}" + __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "." + return + ;; + url.*.*) + local pfx="${cur%.*}." cur_="${cur##*.}" + __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_" + return + ;; + esac + __gitcomp " + add.ignoreErrors + advice.commitBeforeMerge + advice.detachedHead + advice.implicitIdentity + advice.pushNonFastForward + advice.resolveConflict + advice.statusHints + alias. + am.keepcr + apply.ignorewhitespace + apply.whitespace + branch.autosetupmerge + branch.autosetuprebase + browser. + clean.requireForce + color.branch + color.branch.current + color.branch.local + color.branch.plain + color.branch.remote + color.decorate.HEAD + color.decorate.branch + color.decorate.remoteBranch + color.decorate.stash + color.decorate.tag + color.diff + color.diff.commit + color.diff.frag + color.diff.func + color.diff.meta + color.diff.new + color.diff.old + color.diff.plain + color.diff.whitespace + color.grep + color.grep.context + color.grep.filename + color.grep.function + color.grep.linenumber + color.grep.match + color.grep.selected + color.grep.separator + color.interactive + color.interactive.error + color.interactive.header + color.interactive.help + color.interactive.prompt + color.pager + color.showbranch + color.status + color.status.added + color.status.changed + color.status.header + color.status.nobranch + color.status.untracked + color.status.updated + color.ui + commit.status + commit.template + core.abbrev + core.askpass + core.attributesfile + core.autocrlf + core.bare + core.bigFileThreshold + core.compression + core.createObject + core.deltaBaseCacheLimit + core.editor + core.eol + core.excludesfile + core.fileMode + core.fsyncobjectfiles + core.gitProxy + core.ignoreCygwinFSTricks + core.ignoreStat + core.ignorecase + core.logAllRefUpdates + core.loosecompression + core.notesRef + core.packedGitLimit + core.packedGitWindowSize + core.pager + core.preferSymlinkRefs + core.preloadindex + core.quotepath + core.repositoryFormatVersion + core.safecrlf + core.sharedRepository + core.sparseCheckout + core.symlinks + core.trustctime + core.warnAmbiguousRefs + core.whitespace + core.worktree + diff.autorefreshindex + diff.external + diff.ignoreSubmodules + diff.mnemonicprefix + diff.noprefix + diff.renameLimit + diff.renames + diff.suppressBlankEmpty + diff.tool + diff.wordRegex + difftool. + difftool.prompt + fetch.recurseSubmodules + fetch.unpackLimit + format.attach + format.cc + format.headers + format.numbered + format.pretty + format.signature + format.signoff + format.subjectprefix + format.suffix + format.thread + format.to + gc. + gc.aggressiveWindow + gc.auto + gc.autopacklimit + gc.packrefs + gc.pruneexpire + gc.reflogexpire + gc.reflogexpireunreachable + gc.rerereresolved + gc.rerereunresolved + gitcvs.allbinary + gitcvs.commitmsgannotation + gitcvs.dbTableNamePrefix + gitcvs.dbdriver + gitcvs.dbname + gitcvs.dbpass + gitcvs.dbuser + gitcvs.enabled + gitcvs.logfile + gitcvs.usecrlfattr + guitool. + gui.blamehistoryctx + gui.commitmsgwidth + gui.copyblamethreshold + gui.diffcontext + gui.encoding + gui.fastcopyblame + gui.matchtrackingbranch + gui.newbranchtemplate + gui.pruneduringfetch + gui.spellingdictionary + gui.trustmtime + help.autocorrect + help.browser + help.format + http.lowSpeedLimit + http.lowSpeedTime + http.maxRequests + http.minSessions + http.noEPSV + http.postBuffer + http.proxy + http.sslCAInfo + http.sslCAPath + http.sslCert + http.sslCertPasswordProtected + http.sslKey + http.sslVerify + http.useragent + i18n.commitEncoding + i18n.logOutputEncoding + imap.authMethod + imap.folder + imap.host + imap.pass + imap.port + imap.preformattedHTML + imap.sslverify + imap.tunnel + imap.user + init.templatedir + instaweb.browser + instaweb.httpd + instaweb.local + instaweb.modulepath + instaweb.port + interactive.singlekey + log.date + log.decorate + log.showroot + mailmap.file + man. + man.viewer + merge. + merge.conflictstyle + merge.log + merge.renameLimit + merge.renormalize + merge.stat + merge.tool + merge.verbosity + mergetool. + mergetool.keepBackup + mergetool.keepTemporaries + mergetool.prompt + notes.displayRef + notes.rewrite. + notes.rewrite.amend + notes.rewrite.rebase + notes.rewriteMode + notes.rewriteRef + pack.compression + pack.deltaCacheLimit + pack.deltaCacheSize + pack.depth + pack.indexVersion + pack.packSizeLimit + pack.threads + pack.window + pack.windowMemory + pager. + pretty. + pull.octopus + pull.twohead + push.default + rebase.autosquash + rebase.stat + receive.autogc + receive.denyCurrentBranch + receive.denyDeleteCurrent + receive.denyDeletes + receive.denyNonFastForwards + receive.fsckObjects + receive.unpackLimit + receive.updateserverinfo + remotes. + repack.usedeltabaseoffset + rerere.autoupdate + rerere.enabled + sendemail. + sendemail.aliasesfile + sendemail.aliasfiletype + sendemail.bcc + sendemail.cc + sendemail.cccmd + sendemail.chainreplyto + sendemail.confirm + sendemail.envelopesender + sendemail.from + sendemail.identity + sendemail.multiedit + sendemail.signedoffbycc + sendemail.smtpdomain + sendemail.smtpencryption + sendemail.smtppass + sendemail.smtpserver + sendemail.smtpserveroption + sendemail.smtpserverport + sendemail.smtpuser + sendemail.suppresscc + sendemail.suppressfrom + sendemail.thread + sendemail.to + sendemail.validate + showbranch.default + status.relativePaths + status.showUntrackedFiles + status.submodulesummary + submodule. + tar.umask + transfer.unpackLimit + url. + user.email + user.name + user.signingkey + web.browser + branch. remote. + " +} + +_git_remote () +{ + local subcommands="add rename rm show prune update set-head" + local subcommand="$(__git_find_on_cmdline "$subcommands")" + if [ -z "$subcommand" ]; then + __gitcomp "$subcommands" + return + fi + + case "$subcommand" in + rename|rm|show|prune) + __gitcomp_nl "$(__git_remotes)" + ;; + update) + local i c='' IFS=$'\n' + for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do + i="${i#remotes.}" + c="$c ${i/ */}" + done + __gitcomp "$c" + ;; + *) + COMPREPLY=() + ;; + esac +} + +_git_replace () +{ + __gitcomp_nl "$(__git_refs)" +} + +_git_reset () +{ + __git_has_doubledash && return + + case "$cur" in + --*) + __gitcomp "--merge --mixed --hard --soft --patch" + return + ;; + esac + __gitcomp_nl "$(__git_refs)" +} + +_git_revert () +{ + case "$cur" in + --*) + __gitcomp "--edit --mainline --no-edit --no-commit --signoff" + return + ;; + esac + __gitcomp_nl "$(__git_refs)" +} + +_git_rm () +{ + __git_has_doubledash && return + + case "$cur" in + --*) + __gitcomp "--cached --dry-run --ignore-unmatch --quiet" + return + ;; + esac + COMPREPLY=() +} + +_git_shortlog () +{ + __git_has_doubledash && return + + case "$cur" in + --*) + __gitcomp " + $__git_log_common_options + $__git_log_shortlog_options + --numbered --summary + " + return + ;; + esac + __git_complete_revlist +} + +_git_show () +{ + __git_has_doubledash && return + + case "$cur" in + --pretty=*|--format=*) + __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases) + " "" "${cur#*=}" + return + ;; + --*) + __gitcomp "--pretty= --format= --abbrev-commit --oneline + $__git_diff_common_options + " + return + ;; + esac + __git_complete_file +} + +_git_show_branch () +{ + case "$cur" in + --*) + __gitcomp " + --all --remotes --topo-order --current --more= + --list --independent --merge-base --no-name + --color --no-color + --sha1-name --sparse --topics --reflog + " + return + ;; + esac + __git_complete_revlist +} + +_git_stash () +{ + local save_opts='--keep-index --no-keep-index --quiet --patch' + local subcommands='save list show apply clear drop pop create branch' + local subcommand="$(__git_find_on_cmdline "$subcommands")" + if [ -z "$subcommand" ]; then + case "$cur" in + --*) + __gitcomp "$save_opts" + ;; + *) + if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then + __gitcomp "$subcommands" + else + COMPREPLY=() + fi + ;; + esac + else + case "$subcommand,$cur" in + save,--*) + __gitcomp "$save_opts" + ;; + apply,--*|pop,--*) + __gitcomp "--index --quiet" + ;; + show,--*|drop,--*|branch,--*) + COMPREPLY=() + ;; + show,*|apply,*|drop,*|pop,*|branch,*) + __gitcomp_nl "$(git --git-dir="$(__gitdir)" stash list \ + | sed -n -e 's/:.*//p')" + ;; + *) + COMPREPLY=() + ;; + esac + fi +} + +_git_submodule () +{ + __git_has_doubledash && return + + local subcommands="add status init update summary foreach sync" + if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then + case "$cur" in + --*) + __gitcomp "--quiet --cached" + ;; + *) + __gitcomp "$subcommands" + ;; + esac + return + fi +} + +_git_svn () +{ + local subcommands=" + init fetch clone rebase dcommit log find-rev + set-tree commit-diff info create-ignore propget + proplist show-ignore show-externals branch tag blame + migrate mkdirs reset gc + " + local subcommand="$(__git_find_on_cmdline "$subcommands")" + if [ -z "$subcommand" ]; then + __gitcomp "$subcommands" + else + local remote_opts="--username= --config-dir= --no-auth-cache" + local fc_opts=" + --follow-parent --authors-file= --repack= + --no-metadata --use-svm-props --use-svnsync-props + --log-window-size= --no-checkout --quiet + --repack-flags --use-log-author --localtime + --ignore-paths= $remote_opts + " + local init_opts=" + --template= --shared= --trunk= --tags= + --branches= --stdlayout --minimize-url + --no-metadata --use-svm-props --use-svnsync-props + --rewrite-root= --prefix= --use-log-author + --add-author-from $remote_opts + " + local cmt_opts=" + --edit --rmdir --find-copies-harder --copy-similarity= + " + + case "$subcommand,$cur" in + fetch,--*) + __gitcomp "--revision= --fetch-all $fc_opts" + ;; + clone,--*) + __gitcomp "--revision= $fc_opts $init_opts" + ;; + init,--*) + __gitcomp "$init_opts" + ;; + dcommit,--*) + __gitcomp " + --merge --strategy= --verbose --dry-run + --fetch-all --no-rebase --commit-url + --revision $cmt_opts $fc_opts + " + ;; + set-tree,--*) + __gitcomp "--stdin $cmt_opts $fc_opts" + ;; + create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\ + show-externals,--*|mkdirs,--*) + __gitcomp "--revision=" + ;; + log,--*) + __gitcomp " + --limit= --revision= --verbose --incremental + --oneline --show-commit --non-recursive + --authors-file= --color + " + ;; + rebase,--*) + __gitcomp " + --merge --verbose --strategy= --local + --fetch-all --dry-run $fc_opts + " + ;; + commit-diff,--*) + __gitcomp "--message= --file= --revision= $cmt_opts" + ;; + info,--*) + __gitcomp "--url" + ;; + branch,--*) + __gitcomp "--dry-run --message --tag" + ;; + tag,--*) + __gitcomp "--dry-run --message" + ;; + blame,--*) + __gitcomp "--git-format" + ;; + migrate,--*) + __gitcomp " + --config-dir= --ignore-paths= --minimize + --no-auth-cache --username= + " + ;; + reset,--*) + __gitcomp "--revision= --parent" + ;; + *) + COMPREPLY=() + ;; + esac + fi +} + +_git_tag () +{ + local i c=1 f=0 + while [ $c -lt $cword ]; do + i="${words[c]}" + case "$i" in + -d|-v) + __gitcomp_nl "$(__git_tags)" + return + ;; + -f) + f=1 + ;; + esac + c=$((++c)) + done + + case "$prev" in + -m|-F) + COMPREPLY=() + ;; + -*|tag) + if [ $f = 1 ]; then + __gitcomp_nl "$(__git_tags)" + else + COMPREPLY=() + fi + ;; + *) + __gitcomp_nl "$(__git_refs)" + ;; + esac +} + +_git_whatchanged () +{ + _git_log +} + +_git () +{ + local i c=1 command __git_dir + + if [[ -n ${ZSH_VERSION-} ]]; then + emulate -L bash + setopt KSH_TYPESET + + # workaround zsh's bug that leaves 'words' as a special + # variable in versions < 4.3.12 + typeset -h words + + # workaround zsh's bug that quotes spaces in the COMPREPLY + # array if IFS doesn't contain spaces. + typeset -h IFS + fi + + local cur words cword prev + _get_comp_words_by_ref -n =: cur words cword prev + while [ $c -lt $cword ]; do + i="${words[c]}" + case "$i" in + --git-dir=*) __git_dir="${i#--git-dir=}" ;; + --bare) __git_dir="." ;; + --version|-p|--paginate) ;; + --help) command="help"; break ;; + *) command="$i"; break ;; + esac + c=$((++c)) + done + + if [ -z "$command" ]; then + case "$cur" in + --*) __gitcomp " + --paginate + --no-pager + --git-dir= + --bare + --version + --exec-path + --html-path + --work-tree= + --namespace= + --help + " + ;; + *) __git_compute_porcelain_commands + __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;; + esac + return + fi + + local completion_func="_git_${command//-/_}" + declare -f $completion_func >/dev/null && $completion_func && return + + local expansion=$(__git_aliased_command "$command") + if [ -n "$expansion" ]; then + completion_func="_git_${expansion//-/_}" + declare -f $completion_func >/dev/null && $completion_func + fi +} + +_gitk () +{ + if [[ -n ${ZSH_VERSION-} ]]; then + emulate -L bash + setopt KSH_TYPESET + + # workaround zsh's bug that leaves 'words' as a special + # variable in versions < 4.3.12 + typeset -h words + + # workaround zsh's bug that quotes spaces in the COMPREPLY + # array if IFS doesn't contain spaces. + typeset -h IFS + fi + + local cur words cword prev + _get_comp_words_by_ref -n =: cur words cword prev + + __git_has_doubledash && return + + local g="$(__gitdir)" + local merge="" + if [ -f "$g/MERGE_HEAD" ]; then + merge="--merge" + fi + case "$cur" in + --*) + __gitcomp " + $__git_log_common_options + $__git_log_gitk_options + $merge + " + return + ;; + esac + __git_complete_revlist +} + +complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \ + || complete -o default -o nospace -F _git git +complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \ + || complete -o default -o nospace -F _gitk gitk + +# The following are necessary only for Cygwin, and only are needed +# when the user has tab-completed the executable name and consequently +# included the '.exe' suffix. +# +if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then +complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \ + || complete -o default -o nospace -F _git git.exe +fi + +if [[ -n ${ZSH_VERSION-} ]]; then + __git_shopt () { + local option + if [ $# -ne 2 ]; then + echo "USAGE: $0 (-q|-s|-u)