about summary refs log tree commit diff
path: root/Completion/Unix/Command/_tar
blob: 3e3b3fc519fc338dc0a7b5609e8b79fc2431dfab (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
#compdef tar gtar star

# 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 tmpb del index

# 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]" = -[^C]#f* &&
          "$words[CURRENT-1]" != --* ) ||
        ( CURRENT -eq 3 && "$words[2]" = [^C]#f* && "$words[2]" != -* ) ||
        ( CURRENT -gt 2 && "$words[CURRENT-2]" = -*C*f* &&
          "$words[CURRENT-2]" != --* && "$words[CURRENT-1]" != --* ) ||
        ( CURRENT -eq 4 && "$words[2]" = *C*f* && "$words[2]" != -* ) ]]; then

  # ...archive files if we think they are wanted here.

  _tar_archive

elif [[ ( CURRENT -gt 2 && "$words[CURRENT-1]" = -[^f]#C*) ||
        ( CURRENT -eq 3 && "$words[2]" = [^f]#C* ) ]]; then

  # a directory for -C

  _directories

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 = *j* ]]; then
    largs=-tjf
  elif [[ $_tar_cmd = *y* ]]; then
    largs=-tyf
  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 / _tar_cache_list
elif (( CURRENT == 2 )); then
  _values -s '' 'tar function' \
    '(c t u x)A[append to an archive]' \
    '(A t u x)c[create a new archive]' \
    '(A c u x)t[list archive contents]' \
    '(A c t x)u[update archive]' \
    '(A c t u)x[extract files from an archive]' \
    'v[verbose output]' \
    'f[specify archive file or device]'
else
  if ! (( index=$words[(I)-*C*] )); then
    if [[ $words[2] = [^f]#C* ]]; then
      index=1
    elif [[ $words[2] = *f*C* ]]; then
      index=2
    fi
  fi
  if (( index )); then
    index="$~words[index+1]"
    [[ $index = (.|..|)/* ]] || index=~+/$index
    _files -W $index
  else
    _files
  fi
fi