diff options
Diffstat (limited to 'completions/tar')
| -rw-r--r-- | completions/tar | 388 |
1 files changed, 213 insertions, 175 deletions
diff --git a/completions/tar b/completions/tar index 04b7fc0..83a4073 100644 --- a/completions/tar +++ b/completions/tar @@ -12,15 +12,15 @@ # # 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. +# dash, we treat the command line appropriately. # # # 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. +# per-distribution work should be needed. The _comp_compgen_help does not seem +# to be good enough so parsed here directly. # # # FIXME: --starting-file (-K) (should be matched for extraction only) @@ -37,8 +37,29 @@ # - mode option should be advised only once # - format option should be advised only once # ... +# +# Tar files vs internal paths +# =========================== +# +# bash's programmable completion is limited in how it handles the list of +# possible completions it returns. +# +# Because the paths returned from within the tar file are likely not existing +# paths on the file system, `-o dirnames` must be passed to the `complete` +# built-in to make it treat them as such. However, then bash will append a +# space when completing on directories during pathname completion to the tar +# files themselves. +# +# It's more important to have proper completion of paths to tar files than it +# is to have completion for their contents, so this sacrifice was made and +# `-o filenames` is used with complete instead by default. Setting the +# `$BASH_COMPLETION_CMD_TAR_INTERNAL_PATHS` environment variable to a non-null +# value *before sourcing* this completion toggles that the other way around. -__gtar_parse_help_opt() +_comp_deprecate_var 2.12 \ + COMP_TAR_INTERNAL_PATHS BASH_COMPLETION_CMD_TAR_INTERNAL_PATHS + +_comp_cmd_gtar__parse_help_opt() { local opttype arg opt separator optvar opttype=long @@ -77,35 +98,36 @@ __gtar_parse_help_opt() eval "$optvar=\"\$$optvar$separator\"\"$opt\"" } -__gtar_parse_help_line() +_comp_cmd_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 + local -a tmp + while read -ra tmp; do + for i in "${tmp[@]}"; do + case "$i" in + # regular options + --* | -*) + _comp_cmd_gtar__parse_help_opt "$i" "$2" + ;; + + # end once there is single non-option word + *) + break + ;; + esac + done + done <<<"$1" } -__gnu_tar_parse_help() +_comp_cmd_gtar__parse_help() { local str line arg - while IFS= read line; do + while IFS= read -r 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 + if [[ $line =~ ^[[:blank:]]{1,10}(((,[[:blank:]])?(--?([\]\[a-zA-Z0-9?=-]+))(,[[:space:]])?)+).*$ ]]; then line=${BASH_REMATCH[1]} str="${line//,/ }" @@ -116,10 +138,10 @@ __gnu_tar_parse_help() # 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 + [[ ${BASH_REMATCH[1]} ]] && arg=opt || arg=req fi - __gtar_parse_help_line "$str" "$arg" + _comp_cmd_gtar__parse_help_line "$str" "$arg" fi done <<<"$(tar --help)" @@ -130,59 +152,55 @@ __gnu_tar_parse_help() } # Hack: parse --warning keywords from tar's error output -__gtar_parse_warnings() +_comp_cmd_gtar__parse_warnings() { - local line - LC_ALL=C tar --warning= 2>&1 | while IFS= read line; do + local -a warnings=() + local lines line + _comp_split -l lines "$(LC_ALL=C exec tar --warning= 2>&1)" + for line in "${line[@]}"; do if [[ $line =~ ^[[:blank:]]*-[[:blank:]]*[\`\']([a-zA-Z0-9-]+)\'$ ]]; then - echo "${BASH_REMATCH[1]} no-${BASH_REMATCH[1]}" + warnings+=("${BASH_REMATCH[1]}" "no-${BASH_REMATCH[1]}") fi done + _comp_compgen -- -W '"${warnings[@]}"' } -# Helper to obtain last character of string. -__tar_last_char() -{ - echo "${1:$((${#1} - 1))}" -} - -__tar_parse_old_opt() +_comp_cmd_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 + [[ $cword -eq 1 && $cur && ${cur:0:1} != '-' ]] && + old_opt_progress=set # check that first argument does not begin with "-" first_word=${words[1]} - [[ -n $first_word && ${first_word:0:1} != "-" ]] && - old_opt_used=1 + [[ $first_word && ${first_word:0:1} != "-" ]] && + old_opt_used=set # parse the old option (if present) contents to allow later code expect # corresponding arguments - if ((old_opt_used == 1)); then + if [[ $old_opt_used ]]; then char=${first_word:0:1} - while [[ -n $char ]]; do - if __tar_is_argreq "$char"; then + while [[ $char ]]; do + if _comp_cmd_tar__is_argreq "$char"; then old_opt_parsed+=("$char") fi - first_word=${first_word##$char} + first_word=${first_word##"$char"} char=${first_word:0:1} done fi } # Make the analysis of whole command line. -__tar_preparse_cmdline() +_comp_cmd_tar__preparse_cmdline() { - local first_arg i modes="ctxurdA" + local first_arg=set i modes="ctxurdA" shift # progname - __tar_parse_old_opt + _comp_cmd_tar__parse_old_opt - first_arg=1 for i in "$@"; do case "$i" in --delete | --test-label) @@ -201,36 +219,36 @@ __tar_preparse_cmdline() ;; *[$modes]*) # Only the first arg may be "MODE" without leading dash - if ((first_arg == 1)); then + if [[ $first_arg ]]; then tar_mode=${i//[^$modes]/} tar_mode=${tar_mode:0:1} tar_mode_arg=$i fi ;; esac - first_arg=0 + first_arg="" done } # Generate completions for -f/--file. -__tar_file_option() +_comp_cmd_tar__file_option() { local ext="$1" case "$tar_mode" in c) # no need to advise user to re-write existing tarball - _filedir -d + _comp_compgen_filedir -d ;; *) - _filedir "$ext" + _comp_compgen_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() +_comp_cmd_tar__is_argreq() { local opt opt=$1 @@ -250,14 +268,14 @@ __tar_is_argreq() } # Called only for short parameter -__tar_complete_mode() +_comp_cmd_tar__mode() { local short_modes rawopt generated \ allshort_raw_unused allshort_raw \ filler i short_modes="ctx" - [[ ! -v basic_tar ]] && short_modes="ctxurdA" + [[ ! $basic_tar ]] && short_modes="ctxurdA" # Remove prefix when needed rawopt=${cur#-} @@ -270,25 +288,25 @@ __tar_complete_mode() # when user passed something like 'tar cf' do not put the '-' before filler= - if [[ -z $cur && ! -v basic_tar ]]; then + if [[ ! $cur && ! $basic_tar ]]; then filler=- fi generated="" for ((i = 0; 1; i++)); do local c="${short_modes:i:1}" - [[ -z $c ]] && break + [[ ! $c ]] && break generated+=" $filler$cur$c" done - COMPREPLY=($(compgen -W "$generated")) + _comp_compgen -R -- -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 + if [[ ! $old_opt_progress ]] && + _comp_cmd_tar__is_argreq "${cur: -1}"; then COMPREPLY=("$cur") && return 0 fi @@ -300,25 +318,25 @@ __tar_complete_mode() generated= for ((i = 0; 1; i++)); do local c="${allshort_raw_unused:i:1}" - [[ -z $c ]] && break + [[ ! $c ]] && break generated+=" $cur$c" done - COMPREPLY=($(compgen -W "$generated")) + _comp_compgen -R -- -W "$generated" return 0 } -__gtar_complete_lopts() +_comp_cmd_tar__gnu_long_options() { local rv - COMPREPLY=($(compgen -W "$long_opts" -- "$cur")) + _comp_compgen -- -W "$long_opts" rv=$? [[ ${COMPREPLY-} == *= ]] && compopt -o nospace return $rv } -__gtar_complete_sopts() +_comp_cmd_tar__gnu_short_options() { local generated short_mode_opts i c short_mode_opts="ctxurdA" @@ -326,52 +344,51 @@ __gtar_complete_sopts() for ((i = 0; 1; i++)); do c="${allshort_raw_unused:i:1}" - [[ -z $c ]] && break + [[ ! $c ]] && break generated+=" $cur$c" done - COMPREPLY=($(compgen -W "$generated" -- "$cur")) + _comp_compgen -- -W "$generated" } -__tar_try_mode() +_comp_cmd_tar__try_mode() { case "$cur" in --*) # posix tar does not support long opts - [[ -v basic_tar ]] && return 0 - __gtar_complete_lopts + [[ $basic_tar ]] && return 0 + _comp_cmd_tar__gnu_long_options return $? ;; -*) - # posix tar does not support short optios - [[ -v basic_tar ]] && return 0 + # posix tar does not support short options + [[ $basic_tar ]] && return 0 - __tar_complete_mode && return 0 + _comp_cmd_tar__mode && return 0 ;; *) if [[ $cword -eq 1 || $tar_mode == none ]]; then - __tar_complete_mode && return 0 + _comp_cmd_tar__mode && return 0 fi ;; esac return 1 } -__tar_adjust_PREV_from_old_option() +_comp_cmd_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 + if [[ $old_opt_used ]] && ((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() +_comp_cmd_tar__extract_like_mode() { local i for i in x d t delete; do @@ -380,14 +397,15 @@ __tar_extract_like_mode() return 1 } -__tar_try_list_archive() +_comp_cmd_tar__try_list_archive() { - local tarball tarbin untar i + local tarball="" tarbin untar i - __tar_extract_like_mode || return 1 + _comp_cmd_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) + # directory structure in tarball (for which the _comp_compgen_filedir is + # unusable) set -- "${words[@]}" tarbin=$1 @@ -400,29 +418,39 @@ __tar_try_list_archive() break fi done - if [[ -n $tarball ]]; then - local IFS=$'\n' - COMPREPLY=($(compgen -o filenames -W "$( + if [[ $tarball ]]; then + _comp_compgen -c "$(printf %q "$cur")" split -lo filenames -- "$( $tarbin $untar "$tarball" 2>/dev/null | - while read line; do - printf "%q\n" "$(printf %q"\n" "$line")" + while read -r line; do + printf "%q\n" "$line" done - )" -- "$(printf "%q\n" "$cur")")) + )" return 0 fi } -__tar_cleanup_prev() +_comp_cmd_tar__cleanup_prev() { if [[ $prev =~ ^-[a-zA-Z0-9?]*$ ]]; then # transform '-caf' ~> '-f' - prev="-$(__tar_last_char "$prev")" + prev="-${prev: -1}" fi } -__tar_detect_ext() +_comp_cmd_tar__detect_ext() { - local tars='@(@(tar|gem|spkg)?(.@(Z|[bgx]z|bz2|lz?(ma|o)|zst))|t@([abglx]z|b?(z)2|zst))' + local tars='@(@(tar|spkg)?(.@(Z|[bgx]z|bz2|lz?(ma|o)|zst))|t@([abglx]z|b?(z)2|zst)|cbt|gem|xbps)' + if [[ ${COMP_WORDS[0]} == ?(*/)bsdtar ]]; then + # https://github.com/libarchive/libarchive/wiki/LibarchiveFormats + tars=${tars/%\)/|pax|cpio|iso|zip|@(j|x)ar|mtree|a|7z|warc} + if _comp_cmd_tar__extract_like_mode; then + # read only + tars+="|l@(ha|zh)|rar|cab)" + else + # write only + tars+="|shar)" + fi + fi ext="$tars" case "$tar_mode_arg" in @@ -430,7 +458,7 @@ __tar_detect_ext() # Should never happen? ;; ?(-)*[cr]*f) - ext='@(tar|gem|spkg)' + ext='@(tar|gem|spkg|cbt|xpbs)' case ${words[1]} in *a*) ext="$tars" ;; *z*) ext='t?(ar.)gz' ;; @@ -443,24 +471,24 @@ __tar_detect_ext() # Pass through using defaults above ;; *[Zz]*f) - ext='@(@(t?(ar.)|gem.|spkg.)@(gz|Z)|taz)' + ext='@(@(t?(ar.)|spkg.)@(gz|Z)|taz)' ;; *[jy]*f) - ext='@(@(t?(ar.)|gem.)bz?(2)|spkg|tb2)' + ext='@(t?(ar.)bz?(2)|spkg|tb2)' ;; *[J]*f) - ext='@(@(tar|gem|spkg).@(lzma|xz)|t[lx]z)' + ext='@(@(tar|spkg).@(lzma|xz)|t[lx]z)' ;; esac } -_gtar() +_comp_cmd_tar__gnu() { - local long_opts short_opts \ + 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=0 old_opt_parsed=() + tar_mode tar_mode_arg old_opt_progress="" \ + old_opt_used="" old_opt_parsed=() # Main mode, e.g. -x or -c (extract/creation) local tar_mode=none @@ -469,81 +497,93 @@ _gtar() # FIXME: handle long options local tar_mode_arg= - if [[ -v BASHCOMP_TAR_OPT_DEBUG ]]; then + if [[ -v _comp_cmd_tar__debug ]]; then set -x - PS4='$BASH_SOURCE:$LINENO: ' + local PS4='$BASH_SOURCE:$LINENO: ' fi - local cur prev words cword split + local cur prev words cword was_split comp_args - _init_completion -s || return + _comp_initialize -s -- "$@" || return # Fill the {long,short}_{opts,arg*} - __gnu_tar_parse_help + _comp_cmd_gtar__parse_help - __tar_preparse_cmdline "${words[@]}" + _comp_cmd_tar__preparse_cmdline "${words[@]}" local ext - __tar_detect_ext + _comp_cmd_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 + _comp_cmd_tar__adjust_PREV_from_old_option + _comp_cmd_tar__posix_prev_handle && break + _comp_cmd_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. + local noargopts='!(-*|*[TXgCFIfH]*)' + # shellcheck disable=SC2254 case $prev in - --directory | -!(-*)C) - _filedir -d + --add-file | --exclude | --exclude-ignore | \ + --exclude-ignore-recursive | --exclude-tag | \ + --exclude-tag-all | --exclude-tag-under | --files-from | \ + --exclude-from | --listed-incremental | --group-map | \ + --mtime | --owner-map | --volno-file | --newer | \ + --after-date | --index-file | -${noargopts}[TXg]) + _comp_compgen_filedir + break + ;; + --directory | -${noargopts}C) + _comp_compgen_filedir -d + break + ;; + --hole-detection) + _comp_compgen -- -W 'raw seek' + break + ;; + --to-command | --info-script | --new-volume-script | \ + --rmt-command | --rsh-command | --use-compress-program | \ + -${noargopts}[FI]) + _comp_compgen_commands break ;; --atime-preserve) - COMPREPLY=($(compgen -W 'replace system' -- "$cur")) + _comp_compgen -- -W 'replace system' break ;; --group) - COMPREPLY=($(compgen -g -- "$cur")) + _comp_compgen -- -g break ;; --owner) - COMPREPLY=($(compgen -u -- "$cur")) + _comp_compgen -- -u break ;; - --info-script | --new-volume-script | --rmt-command | --rsh-command | \ - --use-compress-program | -!(-*)[FI]) - compopt -o filenames - COMPREPLY=($(compgen -c -- "$cur")) + --sort) + _comp_compgen -- -W 'none name inode' break ;; - --volno-file | --add-file | --files-from | --exclude-from | \ - --index-file | --listed-incremental | -!(-*)[TXg]) - _filedir + --file | -${noargopts}f) + _comp_cmd_tar__file_option "$ext" break ;; - --format | -!(-*)H) - COMPREPLY=($(compgen -W 'gnu oldgnu pax posix ustar v7' \ - -- "$cur")) + --format | -${noargopts}H) + _comp_compgen -- -W 'gnu oldgnu pax posix ustar v7' break ;; --quoting-style) - COMPREPLY=($(compgen -W 'literal shell shell-always c c-maybe - escape locale clocale' -- "$cur")) + _comp_compgen -- -W 'literal shell shell-always shell-escape + shell-escape-always c c-maybe escape locale clocale' break ;; --totals) - COMPREPLY=($(compgen -W 'SIGHUP SIGQUIT SIGINT SIGUSR1 SIGUSR2' \ - -- "$cur")) + _comp_compgen -- -W 'SIGHUP SIGQUIT SIGINT SIGUSR1 SIGUSR2' break ;; --warning) - COMPREPLY=($(compgen -W "$(__gtar_parse_warnings)" -- "$cur")) - break - ;; - --file | -!(-*)f) - __tar_file_option "$ext" + _comp_cmd_gtar__parse_warnings break ;; --*) @@ -557,12 +597,12 @@ _gtar() # if there is some unknown option with '=', for example # (literally) user does --nonexistent=<TAB>, we do not want # continue also - $split && break + [[ $was_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?]) + -${noargopts}[a-zA-Z0-9?]) # argument required but no completion yet [[ $short_arg_req =~ ${prev##-} ]] && break ;; @@ -578,17 +618,17 @@ _gtar() # Handle the main operational mode of tar. We should do it as soon as # possible. - __tar_try_mode && break + _comp_cmd_tar__try_mode && break # handle others case "$cur" in --*) - __gtar_complete_lopts + _comp_cmd_tar__gnu_long_options break ;; -*) # called only if it is *not* first parameter - __gtar_complete_sopts + _comp_cmd_tar__gnu_short_options break ;; esac @@ -597,27 +637,26 @@ _gtar() # was truth - the 'break' statement would have been already called ((cword == 1)) && break - __tar_try_list_archive && break + _comp_cmd_tar__try_list_archive && break # file completion on relevant files if [[ $tar_mode != none ]]; then - _filedir + _comp_compgen_filedir fi break done # just-for-easy-break while - if [[ -v BASHCOMP_TAR_OPT_DEBUG ]]; then + if [[ -v _comp_cmd_tar__debug ]]; then set +x - unset PS4 fi } -__tar_posix_prev_handle() +_comp_cmd_tar__posix_prev_handle() { case "$prev" in -f) - __tar_file_option "$ext" + _comp_cmd_tar__file_option "$ext" return 0 ;; -b) @@ -628,13 +667,13 @@ __tar_posix_prev_handle() return 1 } -_posix_tar() +_comp_cmd_tar__posix() { - local long_opts short_opts basic_tar \ + local long_opts short_opts basic_tar=set \ 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=() + tar_mode tar_mode_arg old_opt_progress="" \ + old_opt_used=set old_opt_parsed=() # Main mode, e.g. -x or -c (extract/creation) local tar_mode=none @@ -642,11 +681,10 @@ _posix_tar() # The mode argument, e.g. -cpf or -c local tar_mode_arg= - local cur prev words cword split + local cur prev words cword was_split comp_args - _init_completion -s || return + _comp_initialize -s -- "$@" || return - basic_tar=yes tar_mode=none # relatively compatible modes are {c,t,x} @@ -655,57 +693,57 @@ _posix_tar() short_arg_none="wmv" short_opts="$short_arg_req$short_arg_none" - __tar_preparse_cmdline "${words[@]}" + _comp_cmd_tar__preparse_cmdline "${words[@]}" local ext - __tar_detect_ext + _comp_cmd_tar__detect_ext - __tar_adjust_PREV_from_old_option + _comp_cmd_tar__adjust_PREV_from_old_option - __tar_posix_prev_handle && return + _comp_cmd_tar__posix_prev_handle && return - __tar_try_mode && return + _comp_cmd_tar__try_mode && return - __tar_try_list_archive && return + _comp_cmd_tar__try_list_archive && return # file completion on relevant files - _filedir + _comp_compgen_filedir } -_tar() +_comp_cmd_tar() { local cmd=${COMP_WORDS[0]} func line - line="$($cmd --version 2>/dev/null)" + line="$("$cmd" --version 2>/dev/null)" case "$line" in *GNU*) - func=_gtar + func=_comp_cmd_tar__gnu ;; *) - func=_posix_tar + func=_comp_cmd_tar__posix ;; esac $func "$@" # Install real completion for subsequent completions - if [[ ${COMP_TAR_INTERNAL_PATHS-} ]]; then + if [[ ${BASH_COMPLETION_CMD_TAR_INTERNAL_PATHS-} ]]; then complete -F $func -o dirnames tar else complete -F $func tar fi - unset -f _tar + unset -f "$FUNCNAME" } -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 +if [[ ${BASH_COMPLETION_CMD_TAR_INTERNAL_PATHS-} ]]; then + complete -F _comp_cmd_tar -o dirnames tar + complete -F _comp_cmd_tar__gnu -o dirnames gtar + complete -F _comp_cmd_tar__posix -o dirnames bsdtar + complete -F _comp_cmd_tar__posix -o dirnames star else - complete -F _tar tar - complete -F _gtar gtar - complete -F _posix_tar bsdtar - complete -F _posix_tar star + complete -F _comp_cmd_tar tar + complete -F _comp_cmd_tar__gnu gtar + complete -F _comp_cmd_tar__posix bsdtar + complete -F _comp_cmd_tar__posix star fi # ex: filetype=sh |