mirror of
git://git.code.sf.net/p/zsh/code
synced 2025-11-04 07:21:06 +01:00
147 lines
4.8 KiB
Text
147 lines
4.8 KiB
Text
#compdef tar
|
|
|
|
# Tar completion. Features:
|
|
# - Tries to collect tar commands from second position, single letter
|
|
# option, and long options.
|
|
# - `tar' can be called anything, will use the correct name
|
|
# - Uses the function `_tar_archive' to complete archive files.
|
|
# - Tries to find out if compressed archives should be used.
|
|
# - Completes files inside archive. This is supposed to look pretty
|
|
# much as if the files are in an ordinary directory hierarchy.
|
|
# Handles extraction from compressed archives (GNU tar).
|
|
# - Anywhere -- appears, gets a list of long options to complete from
|
|
# tar itself (GNU tar)
|
|
# - Things like --directory=... are also completed correctly.
|
|
|
|
local _tar_cmd tf tmp del
|
|
|
|
# First we collect in `_tar_cmd' single letter options describing what
|
|
# should be done with the archive and if it is compressed. This
|
|
# collected from options arguments that start with only one hyphen,
|
|
# from some of the possible long options, and from the second word if
|
|
# that does not start with a hyphen.
|
|
|
|
tmp=("${(@M)words:#-[^-]*}")
|
|
_tar_cmd="${(j::)tmp#-}"
|
|
|
|
(( $words[(I)--(un|)gzip] )) && _tar_cmd="z$_tar_cmd"
|
|
(( $words[(I)--(un|)compress] )) && _tar_cmd="Z$_tar_cmd"
|
|
(( $words[(I)--list] )) && _tar_cmd="t$_tar_cmd"
|
|
(( $words[(I)--(extract|get)] )) && _tar_cmd="x$_tar_cmd"
|
|
(( $words[(I)--create] )) && _tar_cmd="c$_tar_cmd"
|
|
|
|
# Other ways of finding out what we're doing: first
|
|
# look in the first argument if it's not an option
|
|
if [[ "$words[2]" = *[txcdruA]*~-* ]]; then
|
|
_tar_cmd="$words[2]$_tar_cmd"
|
|
elif [[ $_tar_cmd != *[txcdruA]* && CURRENT -gt 2 ]]; then
|
|
# look for more obscure long options: these aren't all handled.
|
|
(( $words[(I)--(diff|compare)] )) && _tar_cmd="d$_tar_cmd"
|
|
(( $words[(I)--append] )) && _tar_cmd="r$_tar_cmd"
|
|
(( $words[(I)--update] )) && _tar_cmd="u$_tar_cmd"
|
|
(( $words[(I)--(con|)catenate] )) && _tar_cmd="A$_tar_cmd"
|
|
(( $words[(I)--delete] )) && del=1
|
|
fi
|
|
|
|
# Next, we try to find the archive name and store it in `tf'. The name
|
|
# is searched after a `--file=' long option, in the third word if the
|
|
# second one didn't start with a hyphen but contained a `f', and after
|
|
# an option argument starting with only one hyphen and containing a `f'.
|
|
# unless that option argument also contains a `C'.
|
|
|
|
tmp="$words[(I)--file=*]"
|
|
tmpb="$words[(I)-*Cf*~--*]"
|
|
|
|
if (( tmp )); then
|
|
tf=${~words[tmp][8,-1]}
|
|
_tar_cmd="f$_tar_cmd"
|
|
elif [[ "$words[2]" != -* && "$words[2]" = *f* ]]; then
|
|
tf=${~words[3]}
|
|
_tar_cmd="f$_tar_cmd"
|
|
elif (( tmpb )); then
|
|
tf=${~words[tmpb+2]}
|
|
wdir=${~words[tmpb+1]}
|
|
_tar_cmd="Cf$_tar_cmd"
|
|
else
|
|
tmp="${words[(I)-*f*~--*]}"
|
|
if (( tmp )); then
|
|
tf=${~words[tmp+1]}
|
|
_tar_cmd="f$_tar_cmd"
|
|
fi
|
|
fi
|
|
|
|
# See if we should use a path prefix. We have to use eval as the dir can
|
|
# be any unevaluated thing which appears on the command line, including a
|
|
# parameter.
|
|
|
|
# This isn't used right now.
|
|
|
|
tmp=${words[(r)--dir[a-z]#=*]}
|
|
|
|
if [[ -n $tmp ]]; then
|
|
eval "wdir=(${tmp#*=})"
|
|
fi
|
|
|
|
# Now we complete...
|
|
|
|
if [[ "$PREFIX" = --* ]]; then
|
|
|
|
# ...long options after `--'.
|
|
|
|
_arguments -- '--owner*:user:_users' \
|
|
'*=(PROG|COMMAND)*:program:_command_names -e' \
|
|
'*=ARCHIVE*:archive: _tar_archive' \
|
|
'*=NAME*:file:_files' \
|
|
'*=DIR*:directory:_files -/' \
|
|
'*=CONTROL*::version control:(t numbered nil existing never simple)'
|
|
|
|
elif [[ ( CURRENT -gt 2 && "$words[CURRENT-1]" = -*f* &&
|
|
"$words[CURRENT-1]" != --* && "$words[CURRENT-1]" != -*Cf* ) ||
|
|
( CURRENT -eq 3 && "$words[2]" = *f* && "$words[2]" != -* &&
|
|
"$words[2]" != *Cf* ) ||
|
|
( CURRENT -gt 2 && "$words[CURRENT-2]" = -*Cf* &&
|
|
"$words[CURRENT-2]" != --* && "$words[CURRENT-1]" != --* ) ||
|
|
( CURRENT -eq 4 && "$words[2]" = *Cf* && "$words[2]" != -* ) ]]; then
|
|
|
|
# ...archive files if we think they are wanted here.
|
|
|
|
_tar_archive
|
|
|
|
elif [[ ( CURRENT -gt 2 && "$words[CURRENT-1]" = -*Cf*) ||
|
|
( CURRENT -eq 3 && "$words[2]" = *Cf* ) ]]; then
|
|
|
|
# a directory for -C
|
|
|
|
_files -/
|
|
|
|
elif [[ ( "$_tar_cmd" = *[xt]* || -n $del ) && -n "$tf" ]]; then
|
|
|
|
# ...and files from the archive if we found an archive name and tar
|
|
# commands. We run `tar t...' on the file, keeping the list of
|
|
# filenames cached, plus the name of the tarfile so we know if it
|
|
# changes. We skip this test if the alleged archive is not a file.
|
|
|
|
local largs=-tf expl
|
|
|
|
if [[ $_tar_cmd = *z* ]]; then
|
|
largs=-tzf
|
|
elif [[ $_tar_cmd = *Z* ]]; then
|
|
largs=-tZf
|
|
elif [[ $_tar_cmd = *I* ]]; then
|
|
largs=-tIf
|
|
else
|
|
# Some random compression program
|
|
tmp="${words[(r)--use-comp*]}"
|
|
[[ -n $tmp ]] && largs=($tmp -tf)
|
|
fi
|
|
|
|
if [[ $tf != $_tar_cache_name && -f $tf ]]; then
|
|
_tar_cache_list=("${(@f)$($words[1] $largs $tf)}")
|
|
_tar_cache_name=$tf
|
|
fi
|
|
|
|
_wanted files expl 'file from archive' &&
|
|
_multi_parts "$expl[@]" / _tar_cache_list
|
|
else
|
|
_files
|
|
fi
|