# 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
{
    var opttype = '', arg = '', opt = '', separator = '', optvar = ''
    set opttype = 'long'
    set arg = $2
    set opt = $1
    set separator = '" '"

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

    # Remove arguments.
    set opt = $(opt//\[*/)
    set opt = $(opt//=*/=)

    # Basic sanity.
    set opt = $(opt//\"*/)
    set opt = $(opt//\'*/)
    set opt = $(opt//\;*/)

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

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


proc __gtar_parse_help_line
{
    var i = ''

    for i in [$1] {
        match $i {
            # regular options
            with --*|-*
                __gtar_parse_help_opt $i $2
                

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


proc __gnu_tar_parse_help
{
    var str = '', line = '', arg = ''
    while env 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:]])?)+).*$ ]] {

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

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

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

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


# Hack: parse --warning keywords from tar's error output
proc __gtar_parse_warnings
{
    var line = ''
    while env 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
{
    var first_word = '', char = ''

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

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

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


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

    shift # progname

    __tar_parse_old_opt

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


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

    match $tar_mode {
        with c
            # no need to advise user to re-write existing tarball
            _filedir -d
            
        with *
            _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
{
    var opt = ''
    set opt = $1
    match $opt {
        with -[A-Za-z0-9?]
            [[ "$short_arg_req" =~ ${opt##-} ]] && return 0
            
        with [A-Za-z0-9?]
            [[ "$short_arg_req" =~ ${opt} ]] && return 0
            
        with --*
            [[ "$long_arg_req" =~ [[:blank:]]$opt=[[:blank:]] ]] && return 0
            
    }

    return 1
}


# Called only for short parameter
proc __tar_complete_mode
{
    var short_modes = '', has_mode = '', rawopt = '', generated = '', \
          allshort_raw_unused = '', allshort_raw = '', \
          filler = '', i = ''

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

    # Remove prefix when needed
    set rawopt = $(cur#-)

    # -c -z -x ... => czx
    set 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
        set filler = ''
        if [[ -z "$cur" && -z "$basic_tar" ]] {
            set filler = '-'
        }

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

        setglobal 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] {
        setglobal COMPREPLY = '( '"$cur" ) && return 0
    }

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

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

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

    return 0
}


proc __gtar_complete_lopts
{
    var rv = ''
    setglobal COMPREPLY = '( '$( compgen -W "$long_opts" -- "$cur" ) )
    set rv = $Status
    [[ $COMPREPLY == *= ]] && compopt -o nospace
    return $rv
}


proc __gtar_complete_sopts
{
    var generated = '', short_mode_opts = '', i = '', c = ''
    set short_mode_opts = '"ctxurdA'"
    set 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

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


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

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

            __tar_complete_mode && return 0
            

        with *
            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'
        setglobal prev = ""-$(old_opt_parsed[ $cword - 2 ])""
    }
}


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


proc __tar_try_list_archive
{
    var 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[@])
    set tarbin = $1
    set untar = '"tf'"
    shift

    read tarball <<<$[printf -- '%s\n' @Argv \
        | sed -n "/^.\{1,\}$regex\$/p" | tee /tmp/jetel]
    if [[ -n "$tarball" ]] {
        var IFS = '$'\n''
        setglobal 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'
        setglobal prev = ""-$[__tar_last_char $prev]""
    }
}

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

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


proc _gtar
{
    var 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)
    var tar_mode = 'none'

    # The mode argument, e.g. -cpf or -c
    # FIXME: handle long options
    var tar_mode_arg = ''

    if [[ "$_TAR_OPT_DEBUG" == 1 ]] {
        set -x
        setglobal PS4 = '"\$BASH_SOURCE:\$LINENO: '"
    }

    var cur = '', prev = '', words = '', cword = '', split = ''

    _init_completion -s || return

    # Fill the {long,short}_{opts,arg*}
    __gnu_tar_parse_help

    __tar_preparse_cmdline $(words[@])

    var 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.
        match $prev {
            with -C|--directory
                _filedir -d
                break
                
            with --atime-preserve
                setglobal COMPREPLY = '( '$( compgen -W 'replace system' -- "$cur" ) )
                break
                
            with --group
                setglobal COMPREPLY = '( '$( compgen -g -- "$cur" ) )
                break
                
            with --owner
                setglobal COMPREPLY = '( '$( compgen -u -- "$cur" ) )
                break
                
            with -F|--info-script|--new-volume-script|--rmt-command|--rsh-command|\
            -I|--use-compress-program
                compopt -o filenames
                setglobal COMPREPLY = '( '$( compgen -c -- "$cur" ) )
                break
                
            with --volno-file|--add-file|-T|--files-from|-X|--exclude-from|\
            --index-file|--listed-incremental|-g
                _filedir
                break
                
            with -H|--format
                setglobal COMPREPLY = '( '$( compgen -W 'gnu oldgnu pax posix ustar v7' \
                    -- "$cur" ) )
                break
                
            with --quoting-style
                setglobal COMPREPLY = '( '$( compgen -W 'literal shell shell-always c c-maybe
                    escape locale clocale' -- "$cur" ) )
                break
                
            with --totals
                setglobal COMPREPLY = '( '$( compgen -W 'SIGHUP SIGQUIT SIGINT SIGUSR1 SIGUSR2' \
                    -- "$cur" ) )
                break
                
            with --warning
                setglobal COMPREPLY = '( '$( compgen -W "$(__gtar_parse_warnings)" -- "$cur" ) )
                break
                
            with --file|-f|-!(-*)f
                __tar_file_option $ext
                break
                
            with --*
                # 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.
                
            with -[a-zA-Z0-9?]
                # argument required but no completion yet
                [[ "$short_arg_req" =~ ${prev##-} ]] && break
                
        }

        # safety belts
        match $cur {
            with -[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
        match $cur {
            with --*
                __gtar_complete_lopts
                break
                
            with -*
                # 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
{
    match $prev {
        with -f
            __tar_file_option $ext
            return 0
            
        with -b
            return 0
    }

    return 1
}


proc _posix_tar
{
    var 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)
    var tar_mode = 'none'

    # The mode argument, e.g. -cpf or -c
    var tar_mode_arg = ''

    var cur = '', prev = '', words = '', cword = '', split = ''

    _init_completion -s || return

    set basic_tar = 'yes'
    set tar_mode = 'none'

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

    __tar_preparse_cmdline $(words[@])

    var 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
{
    var cmd = $(COMP_WORDS[0]), output = '', line = ''
    read line <<<$[$cmd --version]
    match $line {
    with *GNU*
        _gtar @Argv
        
    with *
        _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