path: root/completions/java

# bash completion for java, javac and javadoc

# available path elements completion
have java || have javac || have javadoc &&
_java_path()
{
    cur=${cur##*:}
    _filedir '@(jar|zip)'
}

have java || have javadoc && {
# exact classpath determination
_java_find_classpath()
{
    local i

    # search first in current options
    for (( i=1; i < COMP_CWORD; i++ )); do
        if [[ "${COMP_WORDS[i]}" == -@(cp|classpath) ]]; then
            classpath=${COMP_WORDS[i+1]}
            break
        fi
    done

    # default to environment
    [ -z "$classpath" ] && classpath=$CLASSPATH

    # default to current directory
    [ -z "$classpath" ] && classpath=.
}

# exact sourcepath determination
_java_find_sourcepath()
{
    local i

    # search first in current options
    for (( i=1; i < COMP_CWORD; i++ )); do
        if [[ "${COMP_WORDS[i]}" == -sourcepath ]]; then
            sourcepath=${COMP_WORDS[i+1]}
            break
        fi
    done

    # default to classpath
    if [ -z "$sourcepath" ]; then
        _java_find_classpath
        sourcepath=$classpath
    fi
}

# available classes completion
_java_classes()
{
    local classpath i

    # find which classpath to use
    _java_find_classpath

    # convert package syntax to path syntax
    cur=${cur//.//}
    # parse each classpath element for classes
    for i in ${classpath//:/ }; do
        if [[ "$i" == *.@(jar|zip) && -r $i ]]; then
            if type zipinfo &>/dev/null; then
                COMPREPLY=( "${COMPREPLY[@]}" $( zipinfo -1 \
                    "$i" "$cur*" 2>/dev/null | \
                    command grep '^[^$]*\.class$' ) )
            else
                COMPREPLY=( "${COMPREPLY[@]}" $( jar tf "$i" \
                    "$cur" | command grep '^[^$]*\.class$' ) )
            fi

        elif [ -d $i ]; then
            # Intentionally looking for *.class only in $i (not subdirs),
            # see Debian bug #496828.
            COMPREPLY=( "${COMPREPLY[@]}"
                $( command ls $i/$cur*.class 2>/dev/null | \
                    sed -ne '/\$/d' -e "s|^$i//*||p" ) )

            # FIXME: if we have foo.class and foo/, the completion
            # returns "foo/"... how to give precedence to files
            # over directories?
        fi
    done

    # remove class extension
    COMPREPLY=( ${COMPREPLY[@]%.class} )
    # convert path syntax to package syntax
    COMPREPLY=( ${COMPREPLY[@]//\//.} )
}

# available packages completion
_java_packages()
{
    local sourcepath i

    # find which sourcepath to use
    _java_find_sourcepath

    # convert package syntax to path syntax
    cur=${cur//.//}
    # parse each sourcepath element for packages
    for i in ${sourcepath//:/ }; do
        if [ -d $i ]; then
            COMPREPLY=( "${COMPREPLY[@]}" $( command ls -F -d \
                $i/$cur* 2>/dev/null | sed -e 's|^'$i'/||' ) )
        fi
    done
    # keep only packages
    COMPREPLY=( $( tr " " "\n" <<<"${COMPREPLY[@]}" | command grep "/$" ) )
    # remove packages extension
    COMPREPLY=( ${COMPREPLY[@]%/} )
    # convert path syntax to package syntax
    cur=${COMPREPLY[@]//\//.}
}
}

# java completion
#
have java &&
_java()
{
    local cur prev words cword i

    COMPREPLY=()
    _get_comp_words_by_ref -n : cur prev words cword

    for ((i=1; i < $cword; i++)); do
        case ${words[$i]} in
            -cp|-classpath)
                ((i++)) # skip the classpath string.
                ;;
            -*)
                # this is an option, not a class/jarfile name.
                ;;
            *)
                # once we've seen a class, just do filename completion
                _filedir
                return 0
                ;;
        esac
    done

    case $cur in
        # standard option completions
        -verbose:*)
            COMPREPLY=( $( compgen -W 'class gc jni' -- "${cur#*:}" ) )
            return 0
            ;;
        -javaagent:*)
            cur=${cur#*:}
            _filedir '@(jar|zip)'
            return 0
            ;;
        -agentpath:*)
            cur=${cur#*:}
            _filedir so
            return 0
            ;;
        # various non-standard option completions
        -splash:*)
            cur=${cur#*:}
            _filedir '@(gif|jp?(e)g|png)'
            return 0
            ;;
        -Xbootclasspath*:*)
            _java_path
            return 0
            ;;
        -Xcheck:*)
            COMPREPLY=( $( compgen -W 'jni' -- "${cur#*:}" ) )
            return 0
            ;;
        -Xgc:*)
            COMPREPLY=( $( compgen -W 'singlecon gencon singlepar genpar' \
                -- "${cur#*:}" ) )
            return 0
            ;;
        -Xgcprio:*)
            COMPREPLY=( $( compgen -W 'throughput pausetime deterministic' \
                -- "${cur#*:}" ) )
            return 0
            ;;
        -Xloggc:*|-Xverboselog:*)
            cur=${cur#*:}
            _filedir
            return 0
            ;;
        -Xshare:*)
            COMPREPLY=( $( compgen -W 'auto off on' -- "${cur#*:}" ) )
            return 0
            ;;
        -Xverbose:*)
            COMPREPLY=( $( compgen -W 'memory load jni cpuinfo codegen opt
                gcpause gcreport' -- "${cur#*:}" ) )
            return 0
            ;;
        -Xverify:*)
            COMPREPLY=( $( compgen -W 'all none remote' -- "${cur#*:}" ) )
            return 0
            ;;
        # the rest that we have no completions for
        -D*|-*:*)
            return 0
            ;;
    esac

    case $prev in
        -cp|-classpath)
            _java_path
            return 0
            ;;
    esac

    if [[ "$cur" == -* ]]; then
        # standard options
        COMPREPLY=( $( compgen -W '-client -server -agentlib: -agentpath:
            -classpath -D -d32 -d64 -enableassertions -disableassertions
            -enablesystemassertions -disablesystemassertions -jar -javaagent:
            -verbose -verbose -version -showversion -help -X' -- "$cur" ) )
    else
        if [[ "$prev" == -jar ]]; then
            # jar file completion
            _filedir jar
        else
            # classes completion
            _java_classes
        fi
    fi

    [[ ${#COMPREPLY[@]} -eq 1 && ${COMPREPLY[0]} == -*[:=] ]] && \
        type compopt &>/dev/null && compopt -o nospace

    __ltrim_colon_completions "$cur"
} &&
complete -F _java java

have javadoc &&
_javadoc()
{
    COMPREPLY=()
    local cur prev classpath

    _get_comp_words_by_ref cur prev

    case $prev in
        -overview|-helpfile)
            _filedir '?(x)htm?(l)'
            return 0
            ;;
        -stylesheetfile)
            _filedir css
            return 0
            ;;
        -d|-link|-linkoffline)
            # TODO: -linkoffline takes two arguments
            _filedir -d
            return 0
            ;;
        -classpath|-bootclasspath|-docletpath|-sourcepath|-extdirs)
            _java_path
            return 0
            ;;
    esac

    if [[ "$cur" == -* ]]; then
        # relevant options completion
        COMPREPLY=( $( compgen -W '-overview -public -protected \
            -package -private -help -doclet -docletpath \
            -sourcepath -classpath -exclude -subpackages \
            -breakiterator -bootclasspath -source -extdirs \
            -verbose -locale -encoding -J -d -use -version \
            -author -docfilessubdirs -splitindex \
            -windowtitle -doctitle -header -footer -bottom \
            -link -linkoffline -excludedocfilessubdir \
            -group -nocomment -nodeprecated -noqualifier \
            -nosince -nodeprecatedlist -notree -noindex \
            -nohelp -nonavbar -quiet -serialwarn -tag \
            -taglet -tagletpath -charset -helpfile \
            -linksource -stylesheetfile -docencoding' -- "$cur" ) )
    else
        # source files completion
        _filedir java
        # packages completion
        _java_packages
    fi
} &&
complete -F _javadoc javadoc

have javac &&
_javac()
{
    COMPREPLY=()
    local cur prev

    _get_comp_words_by_ref cur prev

    case $prev in
        -d)
            _filedir -d
            return 0
            ;;
        -classpath|-bootclasspath|-sourcepath|-extdirs)
            _java_path
            return 0
            ;;
    esac

    if [[ "$cur" == -* ]]; then
        # relevant options completion
        COMPREPLY=( $( compgen -W '-g -g:none -g:lines -g:vars \
            -g:source -O -nowarn -verbose -deprecation -classpath \
            -sourcepath -bootclasspath -extdirs -d -encoding -source \
            -target -help' -- "$cur" ) )
    else
        # source files completion
        _filedir java
    fi
} &&
complete -F _javac javac

have pack200 &&
_pack200()
{
    COMPREPLY=()
    local cur prev
    _get_comp_words_by_ref cur prev

    case $prev in
        -S|--segment-limit|-P|--pass-file|-C|--class-attribute|\
        -F|--field-attribute|-M|--method-attribute|-D|--code-attribute|\
        '-?'|-h|--help|-V|--version|-J)
            return 0
            ;;
        -E|--effort)
            COMPREPLY=( $( compgen -W '0 1 2 3 4 5 6 7 8 9' -- "$cur" ) )
            return 0
            ;;
        -H|--deflate-hint)
            COMPREPLY=( $( compgen -W 'true false keep' -- "$cur" ) )
            return 0
            ;;
        -m|--modification-time)
            COMPREPLY=( $( compgen -W 'latest keep' -- "$cur" ) )
            return 0
            ;;
        -U|--unknown-attribute)
            COMPREPLY=( $( compgen -W 'error strip pass' -- "$cur" ) )
            return 0
            ;;
        -f|--config-file)
            _filedir properties
            return 0
            ;;
        -l|--log-file)
            COMPREPLY=( $( compgen -W '-' -- "$cur" ) )
            _filedir log
            return 0
            ;;
        -r|--repack)
            _filedir jar
            return 0
            ;;
    esac

    # Check if a pack or a jar was already given.
    local i pack=false jar=false
    for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )) ; do
        case ${COMP_WORDS[i]} in
            *.pack|*.pack.gz) pack=true ;;
            *.jar) jar=true ;;
        esac
    done

    if ! $pack ; then
        if [[ "$cur" == -* ]] ; then
            COMPREPLY=( $( compgen -W '--no-gzip --gzip --strip-debug \
                --no-keep-file-order --segment-limit= --effort= \
                --deflate-hint= --modification-time= --pass-file= \
                --unknown-attribute= --class-attribute= --field-attribute= \
                --method-attribute= --code-attribute= --config-file= \
                --verbose --quiet --log-file= --help --version -J \
                --repack' -- "$cur" ) )
            [[ ${#COMPREPLY[@]} -eq 1 && ${COMPREPLY[0]} == *= ]] && \
                type compopt &>/dev/null && compopt -o nospace
        else
            _filedir 'pack?(.gz)'
        fi
    elif ! $jar ; then
        _filedir jar
    fi
} &&
complete -F _pack200 pack200

have unpack200 &&
_unpack200()
{
    COMPREPLY=()
    local cur prev
    _get_comp_words_by_ref cur prev

    case $prev in
        '-?'|-h|--help|-V|--version|-J)
            return 0
            ;;
        -H|--deflate-hint)
            COMPREPLY=( $( compgen -W 'true false keep' -- "$cur" ) )
            return 0
            ;;
        -l|--log-file)
            COMPREPLY=( $( compgen -W '-' -- "$cur" ) )
            _filedir log
            return 0
            ;;
    esac

    # Check if a pack or a jar was already given.
    local i pack=false jar=false
    for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )) ; do
        case ${COMP_WORDS[i]} in
            *.pack|*.pack.gz) pack=true ;;
            *.jar) jar=true ;;
        esac
    done

    if ! $pack ; then
        if [[ "$cur" == -* ]] ; then
            COMPREPLY=( $( compgen -W '--deflate-hint= --remove-pack-file \
                --verbose --quiet --log-file= --help --version' -- "$cur" ) )
            [[ ${#COMPREPLY[@]} -eq 1 && ${COMPREPLY[0]} == *= ]] && \
                type compopt &>/dev/null && compopt -o nospace
        else
            _filedir 'pack?(.gz)'
        fi
    elif ! $jar ; then
        _filedir jar
    fi
} &&
complete -F _unpack200 unpack200

have jarsigner &&
_jarsigner()
{
    COMPREPLY=()
    local cur prev
    _get_comp_words_by_ref cur prev

    case $prev in
        -keystore)
            COMPREPLY=( $( compgen -W 'NONE' -- "$cur" ) )
            _filedir '@(jks|ks|p12|pfx)'
            return 0
            ;;
        -storepass|-keypass|-sigfile|-digestalg|-sigalg|-tsacert|-altsigner|\
        -altsignerpath|-providerName|-providerClass|-providerArg)
            return 0
            ;;
        -storetype)
            COMPREPLY=( $( compgen -W 'JKS PKCS11 PKCS12' -- "$cur" ) )
            return 0
            ;;
        -signedjar)
            _filedir jar
            return 0
            ;;
        -tsa)
            _filedir
            return 0
            ;;
    esac

    # Check if a jar was already given.
    local i jar=false
    for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )) ; do
        if [[ "${COMP_WORDS[i]}" == *.jar && \
            "${COMP_WORDS[i-1]}" != -signedjar ]] ; then
            jar=true
            break
        fi
    done

    if ! $jar ; then
        if [[ "$cur" == -* ]] ; then
            # Documented as "should not be used": -internalsf, -sectionsonly
            COMPREPLY=( $( compgen -W '-keystore -storepass -storetype \
                -keypass -sigfile -signedjar -digestalg -sigalg -verify \
                -verbose -certs -tsa -tsacert -altsigner -altsignerpath \
                -protected -providerName -providerClass -providerArg' \
                -- "$cur" ) )
        fi
        _filedir jar
    fi
} &&
complete -F _jarsigner jarsigner

# Local variables:
# mode: shell-script
# sh-basic-offset: 4
# sh-indent-comment: t
# indent-tabs-mode: nil
# End:
# ex: ts=4 sw=4 et filetype=sh