csonto/bash-completion
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
bash-completion/bash_completion
ianmacd 5dfe16ea34 make gv also complete on encapsulated PostScript files 
add jadetex and pdfjadetex to commands that complete on tex files
improved tar completion to handle .tgz and .tar files
inproved tar completion to perform file completion when c*f is the first
  parameter
2002-01-05 19:42:41 +00:00

1472 lines
36 KiB
Bash
Raw Blame History

# bash_completion - some programmable completion functions for bash 2.05a
#
# <![CDATA[
#
# $Id: bash_completion,v 1.45 2002/01/05 20:42:41 ianmacd Exp $
#
# Copyright (C) Ian Macdonald <ian@caliban.org>
#
# 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.
[ -n "$DEBUG" ] && set -v
# Set a couple of useful vars
#
OS=$( uname -s )
RELEASE=$( uname -r )
# 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 mkdir rmdir pushd
# Make file commands see only files
complete -f cat less more ln strip
# the following section lists completions that are redefined later
# START exclude -- do NOT remove this line
complete -f -X '*.bz2' bzip2
complete -f -X '!*.bz2' bunzip2
complete -f -X '!*.zip' unzip
complete -f -X '*.gz' gzip
complete -f -X '*.Z' compress
complete -f -X '!*.+(Z|gz|tgz|Gz)' gunzip zcat zmore
complete -f -X '!*.Z' uncompress
complete -f -X '!*.+(gif|jpg|jpeg|tif|tiff|png|GIF|JPG|TIF|TIFF|PNG|bmp)' ee xv
complete -f -X '!*.+(?(e)ps|?(E)PS|?(e)ps.gz|pdf|PDF)' gv
complete -f -X '!*.+(dvi|DVI)' dvips xdvi dviselect dvitype
complete -f -X '!*.+(pdf|PDF)' acroread xpdf
complete -f -X '!*.texi*' makeinfo texi2dvi texi2html
complete -f -X '!*.+(tex|TEX)' tex latex slitex jadetex pdfjadetex
complete -f -X '!*.+(mp3|MP3)' mpg123
# FINISH exclude -- do not remove this line
# kill sees only signals
complete -A signal -P '-' kill
# user commands see only users
complete -u finger su usermod userdel passwd
# group commands see only groups
complete -g groupmod groupdel passwd
# bg completes with stopped jobs
complete -A stopped -P '%' bg
# other job commands
complete -j -P '%' fg jobs disown
# network commands complete with hostname
complete -A hostname ssh rsh telnet rlogin ftp ping fping host traceroute \
nslookup
# export and others complete with shell variables
complete -v export local 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
# Now we get to the meat of the file, the functions themselves. Some
# of these are works in progress. Most assume GNU versions of the
# tools in question and may require modifications for use on vanilla
# UNIX systems.
#
# A couple of functions may have non-portable, Linux specific code in
# them, but this will be noted where applicable
# This function is handy for checking whether we have certain programs
# on the system. No need for bulky functions in memory if we don't.
#
have()
{
unset -v have
type $1 &> /dev/null
[ $? = 0 ] && have="yes"
}
# GNU chown(1) completion. This should be expanded to allow the use of
# ':' as well as '.' as the user.group separator.
#
_chown()
{
local cur prev user group i
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
# do not attempt completion if we're specifying an option
[ "$cur" == -* ] && return 0
# first parameter on line or first since an option?
if [ $COMP_CWORD -eq 1 ] || [[ "$prev" == -* ]]; then
if [[ "$cur" == [a-zA-Z]*.* ]]; then
user=${cur%.*}
group=${cur#*.}
COMPREPLY=( $( compgen -g $group ) )
for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
COMPREPLY[i]=$user.${COMPREPLY[i]}
done
else
COMPREPLY=( $( compgen -u $cur -S '.' ) )
fi
fi
return 0
}
complete -F _chown -o default chown
# umount(8) completion. This relies on the mount point being the third
# space-delimited field in the output of mount(8)
#
_umount()
{
local cur
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
# could rewrite the cut | grep to be a sed command, but this is
# clearer and doesn't result in much overhead
COMPREPLY=( $( mount | cut -d' ' -f 3 | grep ^$cur) )
return 0
}
complete -F _umount -o filenames umount
# mount(8) completion. This will pull a list of possible mounts out of
# /etc/fstab, unless the word being completed contains a ':', which
# would indicate the specification of an NFS server. In that case, we
# query the server for a list of all available exports and complete on
# that instead.
#
_mount()
{ local cur i sm
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
for i in {,/usr}/sbin/showmount; do [ -x $i ] && sm=$i && break; done
if [ -n "$sm" ] && [[ "$cur" == *:* ]]; then
COMPREPLY=( $( $sm -e --no-headers ${cur%%:*} | \
grep ^${cur#*:} | awk '{print $1}' ) )
else
COMPREPLY=( $( awk '{if ($2 ~ /\//) print $2}' /etc/fstab | \
grep ^$cur ) )
fi
return 0
}
complete -F _mount -o default mount
# Linux rmmod(1) completion. This completes on a list of all currently
# installed kernel modules.
#
[ $OS = Linux ] &&
_rmmod()
{
local cur
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
COMPREPLY=( $( /sbin/lsmod | \
awk '{if (NR != 1 && $1 ~ /^'$cur'/) print $1}' ) )
return 0
}
[ $OS = Linux ] && complete -F _rmmod rmmod
# Linux insmod(8) & modprobe(8) completion. This completes on a list of all
# available modules for the version of the kernel currently running.
#
[ $OS = Linux ] &&
_insmod()
{
local cur prev modpath
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
modpath=/lib/modules/`uname -r`
# behave like lsmod for modprobe -r
if [ ${COMP_WORDS[0]} = "modprobe" ] && [ "${COMP_WORDS[1]}" = "-r" ]; then
COMPREPLY=( $( /sbin/lsmod | \
awk '{if (NR != 1 && $1 ~ /^'$cur'/) print $1}' ) )
return 0
fi
# do filename completion if we're giving a path to a module
if [[ "$cur" == /* ]]; then
COMPREPLY=( $( compgen -f $cur ) )
return 0
fi
if [ $COMP_CWORD -gt 1 ]; then
# do module parameter completion
COMPREPLY=( $( /sbin/modinfo -p ${COMP_WORDS[1]} | \
awk '{if ($1 ~ /^'$cur'/) print $1}' ) )
else
# do module name completion
COMPREPLY=( $( ls -R $modpath | sed -ne 's/^\('$cur'.*\)\.o$/\1/p') )
fi
return 0
}
[ $OS = Linux ] && complete -F _insmod -o filenames insmod modprobe
# man(1) completion. This is Linux specific, in that 'man <section> <page>'
# is the expected syntax. This allows one to do something like
# 'man 3 str<tab>' to obtain a list of all string handling syscalls on
# the system.
#
[ $OS = Linux ] &&
_man()
{
local cur prev cmd
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
# default completion if parameter contains /
[[ "$cur" == /* ]] && return 0
# default to command completion if no man.config
if [ ! -f /etc/man.config ]; then
COMPREPLY=( $( compgen -c $cur ) )
return 0
fi
if [[ "$prev" == [0-9ln] ]]; then
# churn out a string of paths to search, with * appended to $cur
cmd=`awk '{if ($1 ~ /^MANPATH/) \
print $(NF)"/man'$prev'/'$cur'*"}' /etc/man.config | \
sort -u`
# strip off * from paths ending in /*
cmd=${cmd//\/\\*/\/}
# redirect stderr for when path doesn't exist
cmd="ls $cmd 2>/dev/null"
COMPREPLY=( $( eval $cmd ) )
# get basename of man pages
COMPREPLY=( ${COMPREPLY[@]##*/} )
# strip suffix from man pages
COMPREPLY=( ${COMPREPLY[@]%.gz} )
COMPREPLY=( ${COMPREPLY[@]%.*} )
else
cmd=`awk '{if ($1 ~ /^MANPATH/) \
print $(NF)"/man?/'$cur'*"}' /etc/man.config | sort -u`
cmd=${cmd//\/\\*/\/}
cmd="ls $cmd 2>/dev/null"
COMPREPLY=( $( eval $cmd ) )
COMPREPLY=( ${COMPREPLY[@]##*/} )
COMPREPLY=( ${COMPREPLY[@]%.gz} )
COMPREPLY=( ${COMPREPLY[@]%.*} $( compgen -G $cur\*.[0-9ln] ) )
fi
return 0
}
[ $OS = Linux ] && complete -F _man -o default man
# Linux killall(1) completion. This wouldn't be much use on, say,
# Solaris, where killall does exactly that: kills ALL processes.
#
# This could be improved. For example, it currently doesn't take
# command line options into account
#
_killall()
{
local cur prev i
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
if [[ "$prev" == -[A-Z0-9]* ]]; then
# get a list of processes (the gensub() in the awk takes care
# of getting the basename of the process, the first sed
# evaluation takes care of swapped out processes, and the
# second takes care of getting the basename of the process)
COMPREPLY=( $( ps ahx | sed -e 's#[]\[()]##g' | \
awk '{if (gensub("^.*/","",1,$5) ~ /^'$cur'/) print $5}' | \
sed -e 's#^.*/##' ) )
return 0
fi
# first parameter can be either a signal or a process
if [ $COMP_CWORD -eq 1 ]; then
# 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
fi
# get processes, adding to signals if applicable
COMPREPLY=( ${COMPREPLY[*]} $( ps ahx | sed -e 's#[]\[()]##g' | \
awk '{if (gensub("^.*/","",1,$5) ~ /^'$cur'/) print $5}' | \
sed -e 's#^.*/##' ))
return 0
}
complete -F _killall killall
# GNU find(1) completion. This makes heavy use of ksh style extended
# globs and contains Linux specific code for completing the parameter
# to the -fstype option.
#
_find()
{
local cur prev i
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]#-}
prev=${COMP_WORDS[COMP_CWORD-1]}
case "$prev" in
-@(max|min)depth)
COMPREPLY=( $( compgen -W '0 1 2 3 4 5 6 7 8 9' ) )
return 0
;;
-?(a)newer|-fls|-fprint?(0|f))
COMPREPLY=( $( compgen -f $cur ) )
return 0
;;
-fstype)
# this is highly non-portable
COMPREPLY=( $( cut -d$'\t' -f 2 /proc/filesystems | grep ^$cur ) )
return 0
;;
-gid)
COMPREPLY=( $( awk 'BEGIN {FS=":"} \
{if ($3 ~ /^'$cur'/) print $3}' /etc/group ) )
return 0
;;
-group)
COMPREPLY=( $( compgen -g $cur ) )
return 0
;;
-?(x)type)
COMPREPLY=( $( compgen -W 'b c d p f l s' $cur ) )
return 0
;;
-uid)
COMPREPLY=( $( awk 'BEGIN {FS=":"} \
{if ($3 ~ /^'$cur'/) print $3}' /etc/passwd ) )
return 0
;;
-user)
COMPREPLY=( $( compgen -u $cur ) )
return 0
;;
-[acm]min|-[acm]time|-?(i)?(l)name|-inum|-?(i)path|-?(i)regex| \
-links|-perm|-size|-used|-exec|-ok|-printf)
# do nothing, just wait for a parameter to be given
return 0
;;
esac
# complete using basic options ($cur has had its dash removed here,
# as otherwise compgen will bomb out with an error, since it thinks
# the dash is an option to itself)
COMPREPLY=( $( compgen -W 'daystart depth follow help maxdepth \
mindepth mount noleaf version xdev amin anewer atime \
cmin cnewer ctime empty false fstype gid group ilname \
iname inum ipath iregex links lname mmin mtime name \
newer nouser nogroup perm regex size true type uid \
used user xtype exec fls fprint fprint0 fprintf ok \
print print0 printf prune ls' $cur ) )
# this removes any options from the list of completions that have
# already been specified somewhere on the command line.
COMPREPLY=( $( echo "${COMP_WORDS[@]}-" | \
(while read -d '-' i; do
[ "$i" == "" ] && 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
echo ${COMPREPLY[@]})
) )
# put dashes back
for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
COMPREPLY[i]=-${COMPREPLY[i]}
done
return 0
}
complete -F _find -o dirnames find
# Linux ifconfig(8) completion
#
[ $OS = Linux ] &&
_ifconfig()
{
local cur
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
case "${COMP_WORDS[1]}" in
-|*[0-9]*)
COMPREPLY=( $( compgen -W '-a up down arp promisc allmulti \
metric mtu dstaddr netmask add del \
tunnel irq io_addr mem_start media \
broadcast pointopoint hw multicast \
address txqueuelen' $cur ))
COMPREPLY=( $( echo " ${COMP_WORDS[@]}" | \
(while read -d ' ' i; do
[ "$i" == "" ] && 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
echo ${COMPREPLY[@]})
) )
return 0
;;
esac
COMPREPLY=( $( ifconfig -a | sed -ne 's/^\('$cur'[^ ]*\).*$/\1/p' ))
}
[ $OS = Linux ] && complete -F _ifconfig ifconfig
# Linux ipsec(8) completion (for FreeS/WAN). Basic.
#
[ $OS = Linux ] && have ipsec &&
_ipsec()
{
local cur
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
if [ $COMP_CWORD = 1 ]; then
COMPREPLY=( $( compgen -W 'auto barf eroute klipsdebug look manual \
pluto ranbits rsasigkey setup showdefaults \
showhostkey spi spigrp tncfg whack' $cur ))
return 0
fi
case ${COMP_WORDS[1]} in
auto)
COMPREPLY=( $( compgen -W '--asynchronous --up --add --delete \
--replace --down --route --unroute \
--ready --status --rereadsecrets' $cur ) )
return 0
;;
manual)
COMPREPLY=( $( compgen -W '--up --down --route --unroute \
--union' $cur ) )
return 0
;;
ranbits)
COMPREPLY=( $( compgen -W '--quick --continuous --bytes' $cur ) )
return 0
;;
setup)
COMPREPLY=( $( compgen -W '--start --stop --restart' $cur ) )
return 0
;;
*)
return 0
;;
esac
return 0
}
[ $OS = Linux ] && [ "$have" ] && complete -F _ipsec ipsec
# cvs(1) completion
#
_cvs()
{
local cur prev
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
if [ $COMP_CWORD -eq 1 ] || [[ "$prev" == -* ]]; then
COMPREPLY=( $( compgen -W 'add admin checkout commit diff \
export history import log rdiff release remove rtag status \
tag update' $cur ))
fi
return 0
}
complete -F _cvs -o default cvs
# rpm(8) completion. This is quite comprehensive now and covers rpm 4.x
#
have rpm &&
_rpm()
{
dashify()
{
local i
for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
if [ ${#COMPREPLY[i]} -le 2 ]; then
COMPREPLY[i]=-${COMPREPLY[i]}
else
COMPREPLY[i]=--${COMPREPLY[i]}
fi
done
}
add_package_list()
{
if [ -f /var/log/rpmpkgs ]; then
# using RHL 7.2 - this is quicker than querying the DB
COMPREPLY=( ${COMPREPLY[@]}
$( sed -ne 's/^\('$cur'.*\)-[0-9a-zA-Z._]\+-[0-9a-z.]\+.*\.rpm$/\1/p' /var/log/rpmpkgs ) )
else
COMPREPLY=( ${COMPREPLY[@]} $( rpm -qa | \
sed -ne 's/^\('$cur'.*\)-[0-9a-zA-Z._]\+-[0-9a-z.]\+$/\1/p' ) )
fi
}
file_glob()
{
local suffix
# get extension of current word, if relevant
suffix=${cur##*.}
# nullify it if it's not a substring of the extension we're
# completing on
[ "$suffix" != "${1:0:${#suffix}}" ] && suffix=""
COMPREPLY=( ${COMPREPLY[@]} $( compgen -G $cur\*${1:${#suffix}} ) )
# directory completion if all else fails and current word
# contains a slash
if [ ${#COMPREPLY[@]} = 0 ] && [[ $cur == */* ]]; then
COMPREPLY=( $( compgen -d $cur ) )
fi
}
local cur cur_nodash prev
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
cur_nodash=${cur#-}
prev=${COMP_WORDS[COMP_CWORD-1]}
if [ $COMP_CWORD = 1 ]; then
# first parameter on line
case "$cur" in
-b*)
COMPREPLY=( $( compgen -W 'ba bb bc bi bl bp bs' \
$cur_nodash ) )
dashify
return 0
;;
-t*)
COMPREPLY=( $( compgen -W 'ta tb tc ti tl tp ts' \
$cur_nodash ) )
dashify
return 0
;;
--*)
COMPREPLY=( $( compgen -W 'help version initdb \
checksig recompile rebuild resign addsign rebuilddb \
showrc setperms setugids tarbuild eval install \
upgrade query freshen erase verify querytags rmsource' \
${cur_nodash#-} ) )
dashify
return 0
;;
*)
COMPREPLY=( $( compgen -W 'b e F i q t U V' \
$cur_nodash ) )
dashify
return 0
;;
esac
fi
case "$prev" in
--@(db|exclude)path|prefix|relocate|root)
COMPREPLY=( $( compgen -d $cur ) )
return 0
;;
--eval)
# get a list of macros
COMPREPLY=( $( sed -ne 's/^\(%'${cur#\%}'[^ '$'\t'']*\).*$/\1/p' \
/usr/lib/rpm/macros ) )
return 0
;;
--pipe)
COMPREPLY=( $( compgen -c $cur ) )
return 0
;;
--rcfile)
COMPREPLY=( $( compgen -f $cur ) )
return 0
;;
--specfile)
# complete on .spec files
file_glob spec
return 0
;;
--whatprovides)
# complete on capabilities
COMPREPLY=( $( rpm -qa --queryformat '%{providename}\n' | grep ^$cur ) )
return 0
;;
--whatrequires)
# complete on capabilities
COMPREPLY=( $( rpm -qa --queryformat '%{requirename}\n' | grep ^$cur ) )
return 0
;;
esac
case "${COMP_WORDS[1]}" in
-@([iFU]*|-install|-freshen|-upgrade))
# complete on list of relevant options
COMPREPLY=( $( compgen -W 'percent force test replacepkgs \
replacefiles root excludedocs includedocs noscripts rcfile \
ignorearch dbpath prefix ignoreos nodeps allfiles ftpproxy \
ftpport justdb httpproxy httpport noorder relocate badreloc \
notriggers excludepath ignoresize oldpackage define eval \
pipe queryformat repackage' ${cur_nodash#-} ))
dashify
# return if $cur is an option
[[ "$cur" == -* ]] && return 0
# add a list of RPMS to possible completions
file_glob rpm
return 0
;;
-qp*)
# complete on list of relevant options
COMPREPLY=( $( compgen -W 'scripts root rcfile whatprovides \
whatrequires requires triggeredby ftpport ftpproxy httpproxy \
httpport provides triggers dump changelog dbpath filesbypkg \
define eval pipe showrc info list state docfiles \
configfiles queryformat conflicts obsoletes' ${cur_nodash#-} ) )
dashify
# return if $cur is an option
[[ "$cur" == -* ]] && return 0
# add a list of RPMS to possible completions
file_glob rpm
return 0
;;
-*f)
# standard filename completion
COMPREPLY=( $( compgen -f $cur ) )
return 0
;;
-@(e|-erase))
# complete on list of relevant options
COMPREPLY=( $( compgen -W 'allmatches noscripts notriggers \
nodeps test repackage' ${cur_nodash#-} ) )
dashify
# return if $cur is an option
[[ "$cur" == -* ]] && return 0
add_package_list
return 0
;;
-q*)
# complete on list of relevant options
COMPREPLY=( $( compgen -W 'scripts root rcfile whatprovides \
whatrequires requires triggeredby ftpport ftpproxy httpproxy \
httpport provides triggers dump changelog dbpath specfile \
querybynumber last filesbypkg define eval pipe showrc info \
list state docfiles configfiles queryformat conflicts \
obsoletes' ${cur_nodash#-} ) )
dashify
# return if $cur is an option
[[ "$cur" == -* ]] && return 0
# don't complete on packages if we are querying all packages
[[ ${COMP_WORDS[1]} == -qa* ]] && return 0
add_package_list
return 0
;;
-@(K|-checksig))
# complete on list of relevant options
COMPREPLY=( $( compgen -W 'nopgp nogpg nomd5' \
${cur_nodash#-} ) )
dashify
# return if $cur is an option
[[ "$cur" == -* ]] && return 0
# add a list of RPMS to possible completions
file_glob rpm
return 0
;;
-@([Vy]*|-verify))
# complete on list of relevant options
COMPREPLY=( $( compgen -W 'root rcfile dbpath nodeps nofiles \
noscripts nomd5' ${cur_nodash#-} ) )
dashify
# return if $cur is an option
[[ "$cur" == -* ]] && return 0
add_package_list
return 0
;;
-[bt]*)
# complete on list of relevant options
COMPREPLY=( $( compgen -W 'short-circuit timecheck clean \
rmsource test sign buildroot target buildarch buildos \
nobuild' ${cur_nodash#-} ) )
dashify
# return if $cur is an option
[[ "$cur" == -* ]] && return 0
if [[ ${COMP_WORDS[1]} == -b* ]]; then
# complete on .spec files
file_glob spec
else
# complete on .tar files
COMPREPLY=( $( compgen -G $cur\*.+(tgz|tar.+(gz|bz2)) ) )
fi
return 0
;;
--re@(build|compile))
# complete on source RPMs
COMPREPLY=( $( compgen -G $cur\*.src.rpm ) )
return 0
;;
--tarbuild)
# complete on tarred sources
COMPREPLY=( $( compgen -G $cur\*.+(tgz|tar.+(gz|bz2)) ) )
return 0
;;
--@(re|add)sign)
# complete on RPMs
file_glob rpm
return 0
;;
--set@(perms|gids))
add_package_list
return 0
;;
--rmsource)
file_glob spec
return 0
;;
-*g)
# package group completion
local IFS=$'\t'
# remove trailing backslash, or grep will complain
cur=${cur%'\'}
COMPREPLY=( $( rpm -qa --queryformat '%{group}\n' | \
grep ^$cur ) )
# backslash escape spaces and translate newlines to tabs
COMPREPLY=( $( echo ${COMPREPLY[@]} | sed 's/ /\\ /g' | \
tr '\n' '\t' ) )
return 0
;;
esac
return 0
}
[ "$have" ] && complete -F _rpm -o filenames rpm
# Debian Linux apt-get(8) completion.
#
have apt-get &&
_apt-get()
{
local cur prev special i
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
for (( i=0; i < ${#COMP_WORDS}-1; i++ )); do
if [[ ${COMP_WORDS[i]} == @(install|remove|source) ]]; then
special=${COMP_WORDS[i]}
fi
done
if [ -n "$special" ]; then
case $special in
@(install|remove|source))
COMPREPLY=( $( apt-cache pkgnames $cur ) )
return 0
;;
esac
fi
if [[ "$prev" == -*c ]] || [ "$prev" = --config-file ]; then
COMPREPLY=( $( compgen -f $cur ) )
else
COMPREPLY=( $( compgen -W 'update upgrade dselect-upgrade \
dist-upgrade install remove source check \
clean autoclean -d -f -h -v -m -q -s -y -u \
-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 \
--compile --build --ignore-hold \
--no-upgrade --force-yes --print-uris \
--purge --reinstall --list-cleanup \
--trivial-only --no-remove --diff-only \
--tar-only --config-file --option ' | \
grep ^$cur ) )
fi
return 0
}
[ "$have" ] && complete -F _apt-get -o filenames apt-get
# Debian Linux apt-cache(8) completion.
#
have apt-cache &&
_apt-cache()
{
local cur prev special i
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
for (( i=0; i < ${#COMP_WORDS}-1; i++ )); do
if [[ ${COMP_WORDS[i]} == @(add|showpkg) ]]; then
special=${COMP_WORDS[i]}
fi
done
if [ -n "$special" ]; then
case $special in
add)
COMPREPLY=( $( compgen -f $cur ) )
return 0
;;
showpkg)
COMPREPLY=( $( apt-cache pkgnames $cur ) )
return 0
;;
esac
fi
if [[ "$prev" == -*c ]] || [ "$prev" = --config-file ]; then
COMPREPLY=( $( compgen -f $cur ) )
else
COMPREPLY=( $( compgen -W 'add gencaches showpkg stats dump \
dumpavail unmet check search show showpkg \
depends pkgnames -h -v -p -s -q -i -f -a -g -c \
-o --help --version --pkg-cache --src-cache \
--quiet --important --full --all-versions \
--no-generate --names-only --all-names \
--config-file --option' | grep ^$cur ) )
fi
return 0
}
[ "$have" ] && complete -F _apt-cache -o filenames apt-cache
# chsh(1) completion
#
_chsh()
{
local cur prev
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
if [ "$prev" = "-s" ]; then
COMPREPLY=( $( chsh -l | grep ^$cur ) )
else
COMPREPLY=( $( compgen -u $cur ) )
fi
return 0
}
complete -F _chsh chsh
# chkconfig(8) completion
#
have chkconfig &&
_chkconfig()
{
local cur prev i
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
cur_nodash=${cur#--}
prev=${COMP_WORDS[COMP_CWORD-1]}
if [ $COMP_CWORD -eq 1 ]; then
COMPREPLY=( $( compgen -W 'list add del level' $cur_nodash ) )
for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
COMPREPLY[i]=--${COMPREPLY[i]}
done
return 0
fi
if [ $COMP_CWORD -eq 4 ]; then
COMPREPLY=( $( compgen -W 'on off reset' $cur ) )
return 0
fi
case "$prev" in
@([1-6]|--@(list|add|del)))
COMPREPLY=( $( compgen -W "`(cd /etc/rc.d/init.d; echo *)`" \
$cur) )
return 0
;;
--level)
COMPREPLY=( $( compgen -W '1 2 3 4 5 6' $cur ) )
return 0
;;
esac
return 0
}
[ "$have" ] && complete -F _chkconfig chkconfig
# This function performs host completion based on ssh's known_hosts files, defaulting
# to standard host completion if they don't exist.
#
_known_hosts()
{
local cur kh
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
cur=${cur#*@}
# Escape slashes and dots in paths for awk
cur=${cur//\//\\\/}
cur=${cur//\./\\\.}
kh=()
[ -r /etc/known_hosts ] && kh[0]=/etc/known_hosts
[ -r /etc/known_hosts2 ] && kh[1]=/etc/known_hosts2
[ -r ~/.ssh/known_hosts ] && kh[2]=~/.ssh/known_hosts
[ -r ~/.ssh/known_hosts2 ] && kh[3]=~/.ssh/known_hosts2
# If we have known_hosts files to use
if [ ${#kh[@]} -gt 0 ]; then
if [[ "$cur" == [0-9]*.* ]]; then
# Digits followed by a dot - just search for that
cur="^$cur.*"
elif [[ "$cur" == [0-9]* ]]; then
# Digits followed by no dot - search for digits followed
# by a dot
cur="^$cur.*\."
elif [ -z "$cur" ]; then
# A blank - search for a dot or an alpha character
cur="[a-z.]"
else
cur="^$cur"
fi
# FS needs to look for a comma separated list
COMPREPLY=( $( awk 'BEGIN {FS=","}
{for (i=1; i<=2; ++i) { \
gsub(" .*$", "", $i); \
if ($i ~ /'$cur'/) {print $i} \
}}' ${kh[@]} ) )
else
# Just do normal hostname completion
COMPREPLY=( $( compgen -A hostname $cur ) )
fi
return 0
}
complete -F _known_hosts traceroute ping fping telnet host nslookup
# ssh(1) completion. Should be able to improve this with user@host notation,
# but the '@' seems to trigger some kind of bug in bash's completion.
#
have ssh &&
_ssh()
{
local cur prev
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
case "$prev" in
-*c)
COMPREPLY=( $( compgen -W 'blowfish 3des 3des-cbc blowfish-cbc \
arcfour cast128-cbc' $cur ) )
;;
-*l)
COMPREPLY=( $( compgen -u $cur ) )
;;
*)
_known_hosts
[ $COMP_CWORD = 1 ] || \
COMPREPLY=( ${COMPREPLY[@]} $( compgen -c $cur ) )
esac
return 0
}
[ "$have" ] && complete -F _ssh ssh slogin sftp
have scp &&
_scp()
{
local cur
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
_known_hosts
COMPREPLY=( ${COMPREPLY[@]} $( compgen -f $cur ) )
return 0
}
[ "$have" ] && complete -o filenames -F _scp scp
# Linux route(8) completion. This could be improved by adding address family
# completion for -A, etc.
#
_route()
{
local cur prev
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
if [ "$prev" = dev ]; then
COMPREPLY=( $( ifconfig -a | sed -ne 's/^\('$cur'[^ ]*\).*$/\1/p' ))
return 0
fi
# Must use grep here, otherwise $cur will cause compgen to barf, if
# it begins with a hyphen
COMPREPLY=( $( compgen -W 'add del -host -net netmask metric mss \
window irtt reject mod dyn reinstate dev' | \
grep ^$cur ) )
COMPREPLY=( $( echo " ${COMP_WORDS[@]}" | \
(while read -d ' ' i; do
[ "$i" == "" ] && 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
echo ${COMPREPLY[@]})
) )
return 0
}
complete -F _route route
# GNU make(1) completion (adapted from the example supplied with the bash 2.04
# source code)
#
_make()
{
local mdef makef gcmd cur prev i
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
# if prev argument is -f, return possible filename completions.
# we could be a little smarter here and return matches against
# `makefile Makefile *.mk', whatever exists
if [[ "$prev" == -*f ]]; then
COMPREPLY=( $( compgen -f $cur ) )
return 0
fi
# if we want an option, return the possible posix options
if [[ "$cur" == - ]]; then
COMPREPLY=( $( compgen -W '-e -f -i -k -n -p -q -r -S -s -t' | grep ^$cur ) )
return 0
fi
# make reads `makefile' before `Makefile'
if [ -f makefile ]; then
mdef=makefile
elif [ -f Makefile ]; then
mdef=Makefile
else
mdef=*.mk # local convention
fi
# before we scan for targets, see if a makefile name was specified
# with -f
for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
if [[ ${COMP_WORDS[i]} == -*f ]]; then
eval makef=${COMP_WORDS[i+1]} # eval for tilde expansion
break
fi
done
[ -z "$makef" ] && makef=$mdef
# if we have a partial word to complete, restrict completions to
# matches of that word
[ -n "$2" ] && gcmd='grep "^$2"' || gcmd=cat
# if we don't want to use *.mk, we can take out the cat and use
# test -f $makef and input redirection
COMPREPLY=( $( cat $makef 2>/dev/null | \
awk 'BEGIN {FS=":"} /^[^.# ][^=]*:/ {print $1}' | \
eval $gcmd ) )
# default to filename completion if all else failed
if [ ${#COMPREPLY[@]} = 0 ]; then
COMPREPLY=( $( compgen -f $cur ) )
fi
return 0
}
complete -F _make -X '+($*|*.[cho])' -o filenames make gmake pmake
# Red Hat Linux service completion. This completes on a list of all available
# service scripts in the SysV init.d directory, followed by that script's
# available commands
#
have service &&
_service()
{
local cur sysvdir
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
[ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
|| sysvdir=/etc/init.d
#[[ "$cur" == -* ]] && return 0
if [ $COMP_CWORD = 1 ]; then
COMPREPLY=( $( compgen -W '`echo $sysvdir/!(*.rpmsave|*.rpmorig)`' ) )
COMPREPLY=( $( compgen -W '${COMPREPLY[@]#$sysvdir/}' $cur ) )
else
COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \
s/^.*Usage.*{\(.*\)}.*$/\1/p" \
$sysvdir/${COMP_WORDS[1]}`' $cur ) )
fi
return 0
}
[ "$have" ] && complete -F _service service
# The beginnings of a completion function for GNU tar(1)
#
_tar()
{
local cur
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
if [[ ${COMP_WORDS[1]} == c*f ]]; then
COMPREPLY=( $( compgen -f $cur ) )
elif [[ ${COMP_WORDS[1]} == +([^zj])f ]]; then
COMPREPLY=( $( compgen -G $cur\*.tar ) )
elif [[ ${COMP_WORDS[1]} == *z*f ]]; then
COMPREPLY=( $( compgen -G $cur\*.t?(ar.)gz ) )
elif [[ ${COMP_WORDS[1]} == *j*f ]]; then
COMPREPLY=( $( compgen -G $cur\*.tar.bz2 ) )
fi
return 0
}
complete -F _tar -o default tar
# Linux iptables(8) completion
#
have iptables &&
_iptables()
{
local cur
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
[ "$prev" = -t ] && COMPREPLY=( $( compgen -W 'nat filter mangle' $cur ) )
}
[ "$have" ] && complete -F _iptables iptables
# tcpdump(8) completion
#
have tcpdump &&
_tcpdump()
{
local cur
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
COMPREPLY=( $( compgen -W 'host net port src dst ether gateway
less greater' $cur ) )
}
[ "$have" ] && complete -F _tcpdump tcpdump
# This meta-cd function observes the CDPATH variable, so that cd additionally
# completes on directories under those specified in CDPATH.
#
_cd()
{
local IFS=$'\t\n' cur=${COMP_WORDS[COMP_CWORD]} dirs=() i
# expand ~username type directory specifications
if [[ "$cur" == \~*/* ]]; then
eval cur=$cur
elif [[ "$cur" == \~* ]]; then
cur=${cur#\~}
COMPREPLY=( $( compgen -P '~' -u $cur ) )
return 0
fi
# standard dir completion if parameter starts with /, ./ or ../
[[ "$cur" == ?(.)?(.)/* ]] && COMPREPLY=( $( compgen -d $cur ) ) && return 0
if [ -n "$CDPATH" ]; then
# we have a CDPATH, so loop on its contents
for i in ${CDPATH//:/ }; do
# create an array of matched subdirs
dirs=( $( compgen -d $i/$cur ) )
# add subdirs to list of completions as necessary
[ ${#dirs[@]} ] && COMPREPLY=( ${COMPREPLY[@]} ${dirs[@]#$i/})
done
else
COMPREPLY=( $( compgen -d $cur ) )
fi
return 0
}
complete -F _cd -o filenames cd
# A meta-command completion function, for commands like sudo, which often
# need to complete on a command, followed by a file-name
#
_command()
{
local cur
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
if [ $COMP_CWORD -eq 1 ]; then
COMPREPLY=( $( compgen -c $cur ) )
else
COMPREPLY=( $( compgen -f $cur ) )
fi
}
complete -F _command -o filenames type nohup exec nice eval strace sudo gdb
# Basic Perforce completion by Frank Cusack (frank@google.com)
#
have p4 &&
_p4()
{
local cur prev prev2 p4commands p4filetypes
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}
# rename isn't really a command
p4commands="add admin branch branches change changes client \
clients counter counters delete depot depots describe \
diff diff2 dirs edit filelog files fix fixes flush \
fstat group groups have help info integrate integrated \
job jobs jobspec label labels labelsync lock obliterate \
opened passwd print protect rename reopen resolve \
resolved revert review reviews set submit sync triggers \
typemap unlock user users verify where"
p4filetypes="ctext cxtext ktext kxtext ltext tempobj ubinary \
uresource uxbinary xbinary xltext xtempobj xtext \
text binary resource"
if [ $COMP_CWORD -eq 1 ]; then
COMPREPLY=( $( compgen -W "$p4commands" $cur ) )
elif [ $COMP_CWORD -eq 2 ]; then
case "$prev" in
help)
COMPREPLY=( $( compgen -W "simple commands \
environment filetypes jobview revisions \
usage views $p4commands" $cur ) )
;;
admin)
COMPREPLY=( $( compgen -W "checkpoint stop" $cur ) )
;;
*)
;;
esac
elif [ $COMP_CWORD -gt 2 ]; then
prev2=${COMP_WORDS[COMP_CWORD-2]}
case "$prev" in
-t)
case "$prev2" in
add|edit|reopen)
COMPREPLY=( $(compgen -W "$p4filetypes" $cur) )
;;
*)
;;
esac
;;
*)
;;
esac
fi
return 0
}
[ "$have" ] && complete -F _p4 -o default p4 g4
# ant completion is modified from the original submitted by
# Claus-Peter Klas <peter.klas@uni-dortmund.de>
#
have ant &&
_ant_targets()
{
COMPREPLY=()
local gcmd
# if we have a partial word to complete, restrict completions to
# matches of that word
[ ! -f build.xml ] && return 0
[ -n "$2" ] && gcmd='grep "^$2"' || gcmd=cat
COMPREPLY=( $( awk 'BEGIN {FS="\""} /\<target/ {print $2}' < build.xml \
| tr -s ' ' '\012' | sort -u | eval $gcmd ) )
}
[ "$have" ] && complete -F _ant_targets ant
have nslookup &&
_nslookup()
{
local cur
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]#-}
COMPREPLY=( $( compgen -P '-' -W 'all class= debug d2 domain= \
srchlist= defname search port= querytype= \
type= recurse retry root timeout vc \
ignoretc' $cur ) )
}
[ "$have" ] && complete -F _nslookup nslookup
# Return 1 if $1 appears to contain a redirection operator. Handles backslash
# quoting (barely).
#
_redir_op()
{
case "$1" in
*\\'[\<\>]'*) return 1;;
*[\<\>]*) return 0;;
*) return 1;;
esac
}
# _redir_test tests the current word ($1) and the previous word ($2) for
# redirection operators and does filename completion on the current word
# if either one contains a redirection operator
_redir_test()
{
if _redir_op "$1" ; then
COMPREPLY=( $( compgen -f "$1" ) )
return 0
elif _redir_op "$2" ; then
COMPREPLY=( $( compgen -f "$1" ) )
return 0
fi
return 1
}
_configure_func ()
{
case "$2" in
-*) ;;
*) return ;;
esac
case "$1" in
\~*) eval cmd=$1 ;;
*) cmd="$1" ;;
esac
COMPREPLY=( $( "$cmd" --help | sed -ne 's/^ *\('$2'[^ '$'\t'',[]\+\).*$/\1/p' ) )
}
complete -F _configure_func configure
_file_and_dir()
{
local IFS cur xspec
IFS=$'\t\n'
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]#-}
# get first exclusion compspec that matches this command
xspec=$( sed -ne '/ '$1'/{p;q;}' /etc/bash_completion )
# prune to leave nothing but the -X spec
xspec=${xspec#*-X }
xspec=${xspec%% *}
COMPREPLY=( $( eval compgen -f -X "$xspec" $cur ) $( compgen -d $cur ) )
}
list=( $( sed -ne '/^# START exclude/,/^# FINISH exclude/p' \
/etc/bash_completion | \
# read exclusion compspecs
(
while read line
do
line=${line%# START exclude*}
line=${line%# FINISH exclude*}
line=${line##*\'}
list=( ${list[@]} $line )
done
echo ${list[@]}
)
) )
# remove previous compspecs
if [ ${#list[@]} -gt 0 ]; then
eval complete -r ${list[@]}
# install new compspecs
eval complete -F _file_and_dir -o filenames ${list[@]}
fi
unset list[@]
# source user completion file
[ -f ~/.bash_completion ] && . ~/.bash_completion
unset -f have
unset OS RELEASE have
Reference in New Issue View Git Blame Copy Permalink