Current File : //proc/self/root/usr/share/bash-completion/completions/tar
# bash completion for GNU tar -*- shell-script -*-
#
# General info
# ============
#
# The "old" style arguments
# -------------------------
#
# We don't "advice" the old tar option format by default for GNU tar, example:
#
# 'tar czfT /tmp/archive.tar patterns.txt'
#
# We rather advice the 'tar -czf /tmp/archive.tar -T patterns.txt' format of
# arguments. Though, if user starts the 'first' tar argument without leading
# dash, we treat the command line apropriately.
#
#
# long/short options origin
# -------------------------
#
# For GNU tar, everything is parsed from `tar --help` output so not so much
# per-distribution work should be needed. The _parse_help does not seem to be
# good enough so parsed here directly.
#
#
# FIXME: --starting-file (-K) (should be matched for extraction only)
# FIXME: handle already used (at least short) options
# FIXME: Test-cases for make check.
# - check for no global variable pollution
# FIXME: why PS4='$BASH_SOURCE:$LINENO: ' shows sometimes negative lines?
# FIXME: timeout on tarball listing
# FIXME: cache 'tar --help' parsing results into global variables
# FIXME: at least 'tar -<tab>' should show some helping text (apart from just
# pure option advices)
# FIXME: short option completion should be more intuitive
# - verbose mode option should be advised multiple times
# - mode option should be advised only once
# - format option should be advised only once
# ...
__gtar_parse_help_opt()
{
local opttype arg opt separator optvar
opttype=long
arg="$2"
opt="$1"
separator=" "
case "$opt" in
--*) ;;
-\?)
return
;;
-*)
opttype=short
opt=${opt##-}
separator=
;;
*)
echo "bash_completion: $FUNCNAME: unknown option $opt" >&2
return 1
;;
esac
# Remove arguments.
opt=${opt//\[*/}
opt=${opt//=*/=}
# Basic sanity.
opt=${opt//\"*/}
opt=${opt//\'*/}
opt=${opt//\;*/}
optvar=$opttype'_arg_'$arg
eval "$optvar=\"\$$optvar$separator\"\"$opt\""
}
__gtar_parse_help_line()
{
local i
for i in $1; do
case "$i" in
# regular options
--* | -*)
__gtar_parse_help_opt "$i" "$2"
;;
# end once there is single non-option word
*)
break
;;
esac
done
}
__gnu_tar_parse_help()
{
local str line arg
while IFS= read line; do
# Ok, this requires some comment probably. The GNU help output prints
# options on lines beginning with spaces. After that, there is one
# or more options separated by ', ' separator string. We are matching
# like this then: ^<spaces>(<separator>?<option>)+<whatever>$
if [[ $line =~ \
^[[:blank:]]{1,10}(((,[[:blank:]])?(--?([\]\[a-zA-Z0-9?=-]+))(,[[:space:]])?)+).*$ ]]; then
line=${BASH_REMATCH[1]}
str="${line//,/ }"
# Detect that all options on this line accept arguments (and whether
# the arguments are required or not). Note that only long option
# description in GNU help output mentions arguments. So the $line
# variable may contain e.g. '-X, --XXX[=NAME], -XXX2[=NAME]'.
arg=none
if [[ $line =~ --[A-Za-z0-9-]+(\[?)= ]]; then
[[ -n ${BASH_REMATCH[1]} ]] && arg=opt || arg=req
fi
__gtar_parse_help_line "$str" "$arg"
fi
done <<<"$(tar --help)"
long_opts="\
$long_arg_none $long_arg_opt $long_arg_req"
short_opts="$short_arg_none$short_arg_opt$short_arg_req"
}
# Hack: parse --warning keywords from tar's error output
__gtar_parse_warnings()
{
local line
LC_ALL=C tar --warning= 2>&1 | while IFS= read line; do
if [[ $line =~ ^[[:blank:]]*-[[:blank:]]*[\`\']([a-zA-Z0-9-]+)\'$ ]]; then
echo "${BASH_REMATCH[1]} no-${BASH_REMATCH[1]}"
fi
done
}
# Helper to obtain last character of string.
__tar_last_char()
{
echo "${1:$((${#1} - 1))}"
}
__tar_parse_old_opt()
{
local first_word char
# current word is the first word
[[ $cword -eq 1 && -n $cur && ${cur:0:1} != '-' ]] &&
old_opt_progress=1
# check that first argument does not begin with "-"
first_word=${words[1]}
[[ -n $first_word && ${first_word:0:1} != "-" ]] &&
old_opt_used=1
# parse the old option (if present) contents to allow later code expect
# corresponding arguments
if ((old_opt_used == 1)); then
char=${first_word:0:1}
while [[ -n $char ]]; do
if __tar_is_argreq "$char"; then
old_opt_parsed+=("$char")
fi
first_word=${first_word##$char}
char=${first_word:0:1}
done
fi
}
# Make the analysis of whole command line.
__tar_preparse_cmdline()
{
local first_arg i modes="ctxurdA"
shift # progname
__tar_parse_old_opt
first_arg=1
for i in "$@"; do
case "$i" in
--delete | --test-label)
tar_mode=${i:2:100}
tar_mode_arg=$i
break
;;
--*)
# skip
;;
-*[$modes]*)
tar_mode=${i//[^$modes]/}
tar_mode=${tar_mode:0:1}
tar_mode_arg=$i
break
;;
*[$modes]*)
# Only the first arg may be "MODE" without leading dash
if ((first_arg == 1)); then
tar_mode=${i//[^$modes]/}
tar_mode=${tar_mode:0:1}
tar_mode_arg=$i
fi
;;
esac
first_arg=0
done
}
# Generate completions for -f/--file.
__tar_file_option()
{
local ext="$1"
case "$tar_mode" in
c)
# no need to advise user to re-write existing tarball
_filedir -d
;;
*)
_filedir "$ext"
;;
esac
}
# Returns truth if option requires argument. No equal sign must be pasted.
# Accepts option in format: 'c', '-c', '--create'
__tar_is_argreq()
{
local opt
opt=$1
case "$opt" in
-[A-Za-z0-9?])
[[ $short_arg_req =~ ${opt##-} ]] && return 0
;;
[A-Za-z0-9?])
[[ $short_arg_req =~ ${opt} ]] && return 0
;;
--*)
[[ $long_arg_req =~ [[:blank:]]$opt=[[:blank:]] ]] && return 0
;;
esac
return 1
}
# Called only for short parameter
__tar_complete_mode()
{
local short_modes rawopt generated \
allshort_raw_unused allshort_raw \
filler i
short_modes="ctx"
[[ ! -v basic_tar ]] && short_modes="ctxurdA"
# Remove prefix when needed
rawopt=${cur#-}
# -c -z -x ... => czx
allshort_raw=${short_opts//[- ]/}
# init the 'mode' option if no option is in ${cur}
if [[ $tar_mode == none ]]; then
# when user passed something like 'tar cf' do not put the '-' before
filler=
if [[ -z $cur && ! -v basic_tar ]]; then
filler=-
fi
generated=""
for ((i = 0; 1; i++)); do
local c="${short_modes:i:1}"
[[ -z $c ]] && break
generated+=" $filler$cur$c"
done
COMPREPLY=($(compgen -W "$generated"))
return 0
fi
# The last short option requires argument, like '-cf<TAB>'. Cut the
# completion here to enforce argument processing.
if ((old_opt_progress == 0)) &&
__tar_is_argreq "$(__tar_last_char "$cur")"; then
COMPREPLY=("$cur") && return 0
fi
allshort_raw_unused=${allshort_raw//[$rawopt]/}
if [[ $tar_mode != none ]]; then
allshort_raw_unused=${allshort_raw_unused//[$short_modes]/}
fi
generated=
for ((i = 0; 1; i++)); do
local c="${allshort_raw_unused:i:1}"
[[ -z $c ]] && break
generated+=" $cur$c"
done
COMPREPLY=($(compgen -W "$generated"))
return 0
}
__gtar_complete_lopts()
{
local rv
COMPREPLY=($(compgen -W "$long_opts" -- "$cur"))
rv=$?
[[ ${COMPREPLY-} == *= ]] && compopt -o nospace
return $rv
}
__gtar_complete_sopts()
{
local generated short_mode_opts i c
short_mode_opts="ctxurdA"
generated=${short_opts//[$short_mode_opts]/}
for ((i = 0; 1; i++)); do
c="${allshort_raw_unused:i:1}"
[[ -z $c ]] && break
generated+=" $cur$c"
done
COMPREPLY=($(compgen -W "$generated" -- "$cur"))
}
__tar_try_mode()
{
case "$cur" in
--*)
# posix tar does not support long opts
[[ -v basic_tar ]] && return 0
__gtar_complete_lopts
return $?
;;
-*)
# posix tar does not support short optios
[[ -v basic_tar ]] && return 0
__tar_complete_mode && return 0
;;
*)
if [[ $cword -eq 1 || $tar_mode == none ]]; then
__tar_complete_mode && return 0
fi
;;
esac
return 1
}
__tar_adjust_PREV_from_old_option()
{
# deal with old style arguments here
# $ tar cfTC # expects this sequence of arguments:
# $ tar cfTC ARCHIVE_FILE PATTERNS_FILE CHANGE_DIR
if ((old_opt_used == 1 && cword > 1 && \
cword < ${#old_opt_parsed[@]} + 2)); then
# make e.g. 'C' option from 'cffCT'
prev="-${old_opt_parsed[cword - 2]}"
fi
}
__tar_extract_like_mode()
{
local i
for i in x d t delete; do
[[ $tar_mode == "$i" ]] && return 0
done
return 1
}
__tar_try_list_archive()
{
local tarball tarbin untar i
__tar_extract_like_mode || return 1
# This all is just to approach directory completion from "virtual"
# directory structure in tarball (for which the _filedir is unusable)
set -- "${words[@]}"
tarbin=$1
untar="tf"
shift
for i in "$@"; do
if [[ $i == *.$ext ]]; then
tarball=$i
break
fi
done
if [[ -n $tarball ]]; then
local IFS=$'\n'
COMPREPLY=($(compgen -o filenames -W "$(
$tarbin $untar "$tarball" 2>/dev/null |
while read line; do
printf "%q\n" "$(printf %q"\n" "$line")"
done
)" -- "$(printf "%q\n" "$cur")"))
return 0
fi
}
__tar_cleanup_prev()
{
if [[ $prev =~ ^-[a-zA-Z0-9?]*$ ]]; then
# transform '-caf' ~> '-f'
prev="-$(__tar_last_char "$prev")"
fi
}
__tar_detect_ext()
{
local tars='@(@(tar|gem|spkg)?(.@(Z|[bgx]z|bz2|lz?(ma|o)|zst))|t@([abglx]z|b?(z)2|zst))'
ext="$tars"
case "$tar_mode_arg" in
--*)
# Should never happen?
;;
?(-)*[cr]*f)
ext='@(tar|gem|spkg)'
case ${words[1]} in
*a*) ext="$tars" ;;
*z*) ext='t?(ar.)gz' ;;
*Z*) ext='ta@(r.Z|z)' ;;
*[jy]*) ext='t@(?(ar.)bz?(2)|b2)' ;;
*J*) ext='t?(ar.)xz' ;;
esac
;;
+([^ZzJjy])f)
# Pass through using defaults above
;;
*[Zz]*f)
ext='@(@(t?(ar.)|gem.|spkg.)@(gz|Z)|taz)'
;;
*[jy]*f)
ext='@(@(t?(ar.)|gem.)bz?(2)|spkg|tb2)'
;;
*[J]*f)
ext='@(@(tar|gem|spkg).@(lzma|xz)|t[lx]z)'
;;
esac
}
_gtar()
{
local long_opts short_opts \
long_arg_none="" long_arg_opt="" long_arg_req="" \
short_arg_none="" short_arg_opt="" short_arg_req="" \
tar_mode tar_mode_arg old_opt_progress=0 \
old_opt_used=0 old_opt_parsed=()
# Main mode, e.g. -x or -c (extract/creation)
local tar_mode=none
# The mode argument, e.g. -cpf or -c
# FIXME: handle long options
local tar_mode_arg=
if [[ -v BASHCOMP_TAR_OPT_DEBUG ]]; then
set -x
PS4='$BASH_SOURCE:$LINENO: '
fi
local cur prev words cword split
_init_completion -s || return
# Fill the {long,short}_{opts,arg*}
__gnu_tar_parse_help
__tar_preparse_cmdline "${words[@]}"
local ext
__tar_detect_ext
while true; do # just-for-easy-break while, not looping
__tar_adjust_PREV_from_old_option
__tar_posix_prev_handle && break
__tar_cleanup_prev
# Handle all options *REQUIRING* argument. Optional arguments are up to
# user (TODO: is there any sane way to deal with this?). This case
# statement successes only if there already is PREV.
case $prev in
--directory | -!(-*)C)
_filedir -d
break
;;
--atime-preserve)
COMPREPLY=($(compgen -W 'replace system' -- "$cur"))
break
;;
--group)
COMPREPLY=($(compgen -g -- "$cur"))
break
;;
--owner)
COMPREPLY=($(compgen -u -- "$cur"))
break
;;
--info-script | --new-volume-script | --rmt-command | --rsh-command | \
--use-compress-program | -!(-*)[FI])
compopt -o filenames
COMPREPLY=($(compgen -c -- "$cur"))
break
;;
--volno-file | --add-file | --files-from | --exclude-from | \
--index-file | --listed-incremental | -!(-*)[TXg])
_filedir
break
;;
--format | -!(-*)H)
COMPREPLY=($(compgen -W 'gnu oldgnu pax posix ustar v7' \
-- "$cur"))
break
;;
--quoting-style)
COMPREPLY=($(compgen -W 'literal shell shell-always c c-maybe
escape locale clocale' -- "$cur"))
break
;;
--totals)
COMPREPLY=($(compgen -W 'SIGHUP SIGQUIT SIGINT SIGUSR1 SIGUSR2' \
-- "$cur"))
break
;;
--warning)
COMPREPLY=($(compgen -W "$(__gtar_parse_warnings)" -- "$cur"))
break
;;
--file | -!(-*)f)
__tar_file_option "$ext"
break
;;
--*)
# parameter with required argument but no completion yet
[[ " $long_arg_req " =~ \ $prev=\ ]] && break
# parameter with optional argument passed with =, something like
# --occurrence=*<TAB> which is not handled above
[[ " $long_arg_opt " =~ \ $prev\ ]] && break
# if there is some unknown option with '=', for example
# (literally) user does --nonexistent=<TAB>, we do not want
# continue also
$split && break
# Most probably, when code goes here, the PREV variable contains
# some string from "$long_arg_none" and we want continue.
;;
-!(-*)[a-zA-Z0-9?])
# argument required but no completion yet
[[ $short_arg_req =~ ${prev##-} ]] && break
;;
esac
# safety belts
case "$cur" in
-[a-zA-Z0-9]=*)
# e.g. 'tar -c -f=sth' does not what user could expect
break
;;
esac
# Handle the main operational mode of tar. We should do it as soon as
# possible.
__tar_try_mode && break
# handle others
case "$cur" in
--*)
__gtar_complete_lopts
break
;;
-*)
# called only if it is *not* first parameter
__gtar_complete_sopts
break
;;
esac
# the first argument must be "mode" argument or --param, if any of those
# was truth - the 'break' statement would have been already called
((cword == 1)) && break
__tar_try_list_archive && break
# file completion on relevant files
if [[ $tar_mode != none ]]; then
_filedir
fi
break
done # just-for-easy-break while
if [[ -v BASHCOMP_TAR_OPT_DEBUG ]]; then
set +x
unset PS4
fi
}
__tar_posix_prev_handle()
{
case "$prev" in
-f)
__tar_file_option "$ext"
return 0
;;
-b)
return 0
;;
esac
return 1
}
_posix_tar()
{
local long_opts short_opts basic_tar \
long_arg_none="" long_arg_opt long_arg_req="" \
short_arg_none short_arg_opt short_arg_req \
tar_mode tar_mode_arg old_opt_progress=0 \
old_opt_used=1 old_opt_parsed=()
# Main mode, e.g. -x or -c (extract/creation)
local tar_mode=none
# The mode argument, e.g. -cpf or -c
local tar_mode_arg=
local cur prev words cword split
_init_completion -s || return
basic_tar=yes
tar_mode=none
# relatively compatible modes are {c,t,x}
# relatively compatible options {b,f,m,v,w}
short_arg_req="fb"
short_arg_none="wmv"
short_opts="$short_arg_req$short_arg_none"
__tar_preparse_cmdline "${words[@]}"
local ext
__tar_detect_ext
__tar_adjust_PREV_from_old_option
__tar_posix_prev_handle && return
__tar_try_mode && return
__tar_try_list_archive && return
# file completion on relevant files
_filedir
}
_tar()
{
local cmd=${COMP_WORDS[0]} func line
line="$($cmd --version 2>/dev/null)"
case "$line" in
*GNU*)
func=_gtar
;;
*)
func=_posix_tar
;;
esac
$func "$@"
# Install real completion for subsequent completions
if [[ ${COMP_TAR_INTERNAL_PATHS-} ]]; then
complete -F $func -o dirnames tar
else
complete -F $func tar
fi
unset -f _tar
}
if [[ ${COMP_TAR_INTERNAL_PATHS-} ]]; then
complete -F _tar -o dirnames tar
complete -F _gtar -o dirnames gtar
complete -F _posix_tar -o dirnames bsdtar
complete -F _posix_tar -o dirnames star
else
complete -F _tar tar
complete -F _gtar gtar
complete -F _posix_tar bsdtar
complete -F _posix_tar star
fi
# ex: filetype=sh
Mini Shell