# 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 adviced multiple times
#        - mode option should be adviced only once
#        - format option should be adviced only once
#        ...

proc __gtar_parse_help_opt {
    local opttype arg opt separator optvar
    setvar opttype = 'long'
    setvar arg = "$2"
    setvar opt = "$1"
    setvar separator = "" ""

    case (opt) {
        --* {
            }
        -\? {
            return }
        -* {
            setvar opttype = 'short'
            setvar opt = ${opt##-}
            setvar separator = ''
            }
        * {
            echo >&2 "not an option $opt>&2 "not an option $opt"
            return 1
            }
    }

    # Remove arguments.
    setvar opt = ${opt//\[*/}
    setvar opt = ${opt//=*/=}

    # Basic sanity.
    setvar opt = ${opt//\"*/}
    setvar opt = ${opt//\'*/}
    setvar opt = ${opt//\;*/}

    setvar optvar = "$opttype'_arg_'$arg"

    eval "$optvar=\"\$$optvar$separator\"\"$opt\""
}


proc __gtar_parse_help_line {
    local i

    for i in $1 {
        case (i) {
            # regular options
            --*|-* {
                __gtar_parse_help_opt $i $2
                }

            # end once there is single non-option word
            * {
                break;
        }
}
    }
}


proc __gnu_tar_parse_help {
    local str line arg''
    while IFS= read line {
        # 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:]])?)+).*$ ]] {

            setvar line = ${BASH_REMATCH[1]}
            setvar 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]'.
            setvar arg = 'none'
            if [[ "$line" =~ --[A-Za-z0-9-]+(\[?)= ]] {
                [[ -n "${BASH_REMATCH[1]}" ]] && setvar arg = 'opt' || setvar arg = 'req'
            }

            __gtar_parse_help_line $str $arg
        }
    } <<<"$(tar --help)"

    setvar long_opts = ""\
        $long_arg_none\
        $long_arg_opt\
        $long_arg_req""

    setvar short_opts = ""$short_arg_none$short_arg_opt$short_arg_req""
}


# Hack: parse --warning keywords from tar's error output
proc __gtar_parse_warnings {
    local line''
    while IFS= read line {
        if [[ $line =~ ^[[:blank:]]*-[[:blank:]]*[\`\']([a-zA-Z0-9-]+)\'$ ]] {
            echo "${BASH_REMATCH[1]} no-${BASH_REMATCH[1]}"
        }
    } <<<"$(LC_ALL=C tar --warning= 2>&1)"
}


# Helper to obtain last character of string.
proc __tar_last_char {
    echo ${1: $(( ${#1} - 1))}
}


proc __tar_parse_old_opt {
    local first_word char

    # current word is the first word
    [[ "$cword" -eq 1 && -n "$cur" && "${cur:0:1}" != '-' ]] \
        && setvar old_opt_progress = '1'

    # check that first argument does not begin with "-"
    setvar first_word = ${words[1]}
    [[ -n "$first_word" && "${first_word:0:1}" != "-" ]] \
        && setvar old_opt_used = '1'

    # parse the old option (if present) contents to allow later code expect
    # corresponding arguments
    if [[ $old_opt_used -eq 1 ]] {
        setvar char = ${first_word:0:1} {
            if __tar_is_argreq $char {
                setvar old_opt_parsed = ''("$char")
            }
            setvar first_word = ${first_word##$char}
            setvar char = ${first_word:0:1}
        }
    }
}


# Make the analysis of whole command line.
proc __tar_preparse_cmdline {
    local first_arg my_args tmparg i modes="ctxurdA"

    shift # progname

    __tar_parse_old_opt

    setvar first_arg = '1'
    for i in "$@" {
        case (i) {
            --delete|--test-label {
                setvar tar_mode = ${i:2:100}
                setvar tar_mode_arg = "$i"
                break
                }
            --* {
                # skip
                }
            -*[$modes]* {
                setvar tar_mode = ${i//[^$modes]/}
                setvar tar_mode = ${tar_mode:0:1}
                setvar tar_mode_arg = "$i"
                break
                }
            *[$modes]* {
                # Only the first arg may be "MODE" without leading dash
                if [[ $first_arg -eq 1 ]] {
                    setvar tar_mode = ${i//[^$modes]/}
                    setvar tar_mode = ${tar_mode:0:1}
                    setvar tar_mode_arg = "$i"
                }
                }
        }
        setvar first_arg = '0'
    }
}


# Generate completions for -f/--file.
proc __tar_file_option {
    local ext="$1"

    case (tar_mode) {
        c {
            # no need to advise user to re-write existing tarball
            _filedir -d
            }
        * {
            _filedir $ext
            }
    }
}


# Returns truth if option requires argument.  No equal sign must be pasted.
# Accepts option in format: 'c', '-c', '--create'
proc __tar_is_argreq {
    local opt
    setvar opt = "$1"
    case (opt) {
        -[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
            }
    }

    return 1
}


# Called only for short parameter
proc __tar_complete_mode {
    local short_modes has_mode rawopt generated \
          allshort_raw_unused allshort_raw \
          filler i

    setvar short_modes = ""ctx""
    [[ -z "$basic_tar" ]] && setvar short_modes = ""ctxurdA""

    # Remove prefix when needed
    setvar rawopt = ${cur#-}

    # -c -z -x ... => czx
    setvar allshort_raw = ${short_opts//[- ]/}

    # init the 'mode' option if no option is in ${cur}
    if [[ "$tar_mode" == none ]] {

        # when user passed something like 'tar cf' do not put the '-' before
        setvar filler = ''
        if [[ -z "$cur" && -z "$basic_tar" ]] {
            setvar filler = '-'
        }

        setvar generated = """"
        for (( i=0 ; 1; i++ )); do
            local c="${short_modes:$i:1}"
            [[ -z "$c" ]] && break
            generated+=" $filler$cur$c"
        done

        setvar COMPREPLY = ''( $(compgen -W "$generated" ) )
        return 0
    }

    # The last short option requires argument, like '-cf<TAB>'.  Cut the
    # completion here to enforce argument processing.
    if [[ "$old_opt_progress" -eq 0 ]] \
        && __tar_is_argreq $(__tar_last_char "$cur") {
        setvar COMPREPLY = ''( "$cur" ) && return 0
    }

    setvar allshort_raw_unused = ${allshort_raw//[$rawopt]/}
    if [[ "$tar_mode" != none ]] {
        setvar allshort_raw_unused = ${allshort_raw_unused//[$short_modes]}
    }

    setvar generated = ''
    for (( i=0 ; 1; i++ )); do
        local c="${allshort_raw_unused:$i:1}"
        [[ -z "$c" ]] && break
        generated+=" $cur$c"
    done

    setvar COMPREPLY = ''( $( compgen -W "$generated" ) )

    return 0
}


proc __gtar_complete_lopts {
    local rv
    setvar COMPREPLY = ''( $( compgen -W "$long_opts" -- "$cur" ) )
    setvar rv = ""$?
    [[ $COMPREPLY == *= ]] && compopt -o nospace
    return $rv
}


proc __gtar_complete_sopts {
    local generated short_mode_opts i c
    setvar short_mode_opts = ""ctxurdA""
    setvar 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

    setvar COMPREPLY = ''( $( compgen -W "$generated" -- "$cur" ) )
}


proc __tar_try_mode {
    case (cur) {
        --* {
            # posix tar does not support long opts
            [[ -n "$basic_tar" ]] && return 0
            __gtar_complete_lopts
            return $?
            }

        -* {
            # posix tar does not support short optios
            [[ -n "$basic_tar" ]] && return 0

            __tar_complete_mode && return 0
            }

        * {
            if [[ "$cword" -eq 1 || "$tar_mode" == none ]] {
                __tar_complete_mode && return 0
            }
            }
    }
    return 1
}


proc __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" -eq 1 && "$cword" -gt 1 \
         && "$cword" -lt $(( ${#old_opt_parsed[@]} + 2 )) ]]
    {
        # make e.g. 'C' option from 'cffCT'
        setvar prev = ""-${old_opt_parsed[ $cword - 2 ]}""
    }
}


proc __tar_extract_like_mode {
    local i
    for i in x d t delete {
        [[ "$tar_mode" == "$i" ]] && return 0
    }
    return 1
}


proc __tar_try_list_archive {
    local tarball tarbin untar

    __tar_extract_like_mode || return 1

    # This all is just to approach directory completion from "virtual"
    # directory structure in tarbal (for which the _filedir is unusable)

    set -- ${words[@]}
    setvar tarbin = "$1"
    setvar untar = ""tf""
    shift

    read tarball <<<"$(printf -- '%s\n' "$@" \
        | sed -n "/^.\{1,\}$regex\$/p" | tee /tmp/jetel)"
    if [[ -n "$tarball" ]] {
        local IFS=$'\n'
        setvar COMPREPLY = ''($(compgen -o filenames -W "$(
            while read line; do
                printf "%q\n" "$(printf %q"\n" "$line")"
            done <<<"$($tarbin $untar "$tarball" 2>/dev/null)"
        )" -- "$(printf "%q\n" "$cur")"))
        return 0
    }
}

proc __tar_cleanup_prev {
    if [[ "$prev" =~ ^-[a-zA-Z0-9?]*$ ]] {
        # transformate '-caf' ~> '-f'
        setvar prev = ""-$(__tar_last_char "$prev")""
    }
}

proc __tar_detect_ext {
    local tars='@(@(tar|gem|spkg)?(.@(Z|[bgx]z|bz2|lz?(ma)))|t@([abglx]z|b?(z)2))'
    setvar ext = "$tars"
    setvar regex = ''\(\(tar\|gem\|spkg\)\(\.\(Z\|[bgx]z\|bz2\|lz\(ma\)\?\)\)\?\|t\([abglx]z\|bz\?2\)\)''

    case (tar_mode_arg) {
        --* {
            # Should never happen?
            }
        ?(-)*[cr]*f {
            setvar ext = ''@(tar|gem|spkg)''
            case{
                *a* {    setvar ext = "$tars"               }
                *z* {    setvar ext = ''t?(ar.)gz''           }
                *Z* {    setvar ext = ''ta@(r.Z|z)''          }
                *[jy]* { setvar ext = ''t@(?(ar.)bz?(2)|b2)'' }
                *J* {    setvar ext = ''t?(ar.)xz''           }
            }
            }
        +([^ZzJjy])f {
            setvar ext = "$tars"
            setvar regex = ''\(\(tar\|gem\|spkg\)\(\.\(Z\|[bgx]z\|bz2\|lz\(ma\)\?\)\)\?\|t\([abglx]z\|bz\?2\)\)''
            }
        *[Zz]*f {
            setvar ext = ''@(@(t?(ar.)|gem.|spkg.)@(gz|Z)|taz)''
            setvar regex = ''\(\(t\(ar\.\)\?\|gem\.\|spkg\.\)\(gz\|Z\)\|taz\)''
            }
        *[jy]*f {
            setvar ext = ''@(@(t?(ar.)|gem.)bz?(2)|spkg|tb2)''
            setvar regex = ''\(\(t\(ar\.\)\?\|gem\.\)bz2\?\|spkg\|tb2\)''
            }
        *[J]*f {
            setvar ext = ''@(@(tar|gem|spkg).@(lzma|xz)|t[lx]z)''
            setvar regex = ''\(\(tar\|gem\|spkg\)\.\(lzma\|xz\)\|t[lx]z\)''
            }
    }
}


proc _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 [[ "$_TAR_OPT_DEBUG" == 1 ]] {
        set -x
        setvar PS4 = ""\$BASH_SOURCE:\$LINENO: ""
    }

    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 regex tar untar

    __tar_detect_ext

    while true { # 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) {
            -C|--directory {
                _filedir -d
                break
                }
            --atime-preserve {
                setvar COMPREPLY = ''( $( compgen -W 'replace system' -- "$cur" ) )
                break
                }
            --group {
                setvar COMPREPLY = ''( $( compgen -g -- "$cur" ) )
                break
                }
            --owner {
                setvar COMPREPLY = ''( $( compgen -u -- "$cur" ) )
                break
                }
            -F|--info-script|--new-volume-script|--rmt-command|--rsh-command|\
            -I|--use-compress-program {
                compopt -o filenames
                setvar COMPREPLY = ''( $( compgen -c -- "$cur" ) )
                break
                }
            --volno-file|--add-file|-T|--files-from|-X|--exclude-from|\
            --index-file|--listed-incremental|-g {
                _filedir
                break
                }
            -H|--format {
                setvar COMPREPLY = ''( $( compgen -W 'gnu oldgnu pax posix ustar v7' \
                    -- "$cur" ) )
                break
                }
            --quoting-style {
                setvar COMPREPLY = ''( $( compgen -W 'literal shell shell-always c c-maybe
                    escape locale clocale' -- "$cur" ) )
                break
                }
            --totals {
                setvar COMPREPLY = ''( $( compgen -W 'SIGHUP SIGQUIT SIGINT SIGUSR1 SIGUSR2' \
                    -- "$cur" ) )
                break
                }
            --warning {
                setvar COMPREPLY = ''( $( compgen -W "$(__gtar_parse_warnings)" -- "$cur" ) )
                break
                }
            --file|-f|-!(-*)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
                # --ocurrence=*<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 varibale 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
                }
        }

        # safety belts
        case (cur) {
            -[a-zA-Z0-9]=* {
                # e.g. 'tar -c -f=sth' does not what user could expect
                break
                }
        }

        # Handle the main operational mode of tar.  We should do it as soon as
        # possible.
        __tar_try_mode && break

        # handle others
        case (cur) {
            --* {
                __gtar_complete_lopts
                break
                }
            -* {
                # called only if it is *not* first parameter
                __gtar_complete_sopts
                break
                }
        }

        # the first argument must be "mode" argument or --param, if any of those
        # was truth - the 'break' statement would have been already called
        [[ "$cword" -eq 1 ]] && break

        __tar_try_list_archive && break

        # file completion on relevant files
        if [[ $tar_mode != none ]] {
            _filedir
        }

        break
    } # just-for-easy-break while

    if [[ "$_TAR_OPT_DEBUG" == 1 ]] {
        set +x
        unset PS4
    }

    return 0
}


proc __tar_posix_prev_handle {
    case (prev) {
        -f {
            __tar_file_option $ext
            return 0
            }
        -b {
            return 0
    }
}

    return 1
}


proc _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

    setvar basic_tar = 'yes'
    setvar tar_mode = 'none'

    # relatively compatible modes are {c,t,x}
    # relatively compatible options {b,f,m,v,w}
    setvar short_arg_req = ""fb""
    setvar short_arg_none = ""wmv""
    setvar short_opts = ""$short_arg_req$short_arg_none""

    __tar_preparse_cmdline ${words[@]}

    local ext regex tar untar

    __tar_detect_ext

    __tar_adjust_PREV_from_old_option

    __tar_posix_prev_handle && return 0

    __tar_try_mode && return

    __tar_try_list_archive && return

    # file completion on relevant files
    _filedir
}


proc _tar {
    local cmd=${COMP_WORDS[0]} output line
    read line <<<"$($cmd --version)"
    case (line) {
    *GNU* {
        _gtar @ARGV
        }
    * {
        _posix_tar @ARGV
        }
    }
}


if test -n ${COMP_TAR_INTERNAL_PATHS:-} {
    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
}

# ex: ts=4 sw=4 et filetype=sh