# 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 -eq 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 my_args tmparg 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 -eq 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 has_mode rawopt generated \
          allshort_raw_unused allshort_raw \
          filler i

    short_modes="ctx"
    [[ -z "$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" && -z "$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" -eq 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
            [[ -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 ]]; 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" -eq 1 && "$cword" -gt 1 \
        && "$cword" -lt $(( ${#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 [[ "$_TAR_OPT_DEBUG" == 1 ]]; 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 untar

    __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" -eq 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 [[ "$_TAR_OPT_DEBUG" == 1 ]]; 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 untar

    __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 [ -n "${COMP_TAR_INTERNAL_PATHS:-}" ]; then
        complete -F $func -o dirnames tar
    else
        complete -F $func tar
    fi
    unset -f _tar
}


if [ -n "${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