Attachment #353524 for bug #477024




# Copyright 1999-2009 Gentoo Foundation
# Distributed under the terms of the GNU General Public License, v2 or later

# also defined in bash_completion proper however, will produce command
# not found warnings when this is only enabled "locally" so we define it
# here as well.
have()
{
    unset -v have
    PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin type $1 >&/dev/null && have="yes"
}

#
# Retrieve PORTDIR/PORTDIR_OVERLAY location from user's make.conf or, if it
# is not defined there, from make.globals.

#
# This is an helper function for completion of  "-o <list>" / "--option=<list>"
# kind of command lines options.
#
# Usage: _list_compgen <current> <sep> <item1>[<sep><item2> ...]
# - <current>: what we have so far on the command line
# - <sep>: the separator character used in lists

# Returns: the function outputs each possible completion (one per line),
# and returns 0. Typical usage is COMPREPLY=($(_list_compgen ...)).
#
# Note: items must not contain the <sep> character (no backslash escaping has
# been implemented).
#
_list_compgen()
{
    # Read the three parameters.
    local current="${1}" ; shift
    local sep="${1}" ; shift
    local items="${*}"

    # Setting it to 0 means "never list anything" (only suggest <sep>).
    # Setting it to a positive value N means "list up to N possible items, and
    # only suggest <sep> if there are more".
    # It is probably not worth a parameter, thus it will defaults to my
    # prefered setting (1) if not already defined in the environment.
    local max_others_number=${max_others_number:-1}


#
# emerge completion command
#
have emerge && {
_emerge()
{
    local c cur prev curword numwords opts cond prepend

        [[ -z "${COMPREPLY}" ]] && _pkgname_only ${cur} @GENTOO_PORTAGE_EPREFIX@/var/db/pkg
        return 0
    fi

    # Check for conditional.
    cond="${cur%%[A-Za-z0-9]*}"
    cur="${cur:${#cond}}"

    else
        c="${cond}"
    fi

    # Handle cases where a conditional is specified.
    if [[ -n "${cond}" ]]; then
    if [[ -n "${cur}" ]]; then


                words=$(echo -ne ${w} | sort | uniq)
                COMPREPLY=( ${words} )

                # Complete on the specific versions (if appropriate).
                # TODO - see if we can use _pkgname
                if [[ ${#COMPREPLY[@]} -le 1 ]]; then

                done)"
        COMPREPLY=($(compgen -W "${words}" -- "${cur}"))
    fi

        # If all else fails, try to complete on package names without the
    # category being specified.
    if [[ -z "${COMPREPLY}" ]]; then

    fi

    return 0
} &&
complete -o filenames -F _emerge emerge
}

#
# ebuild completion command
#
have ebuild && {
_ebuild()
{
    local cur opts

    COMPREPLY=($(compgen -W "${opts}" -- ${cur}))
    fi
    return 0
} &&
complete -o filenames -F _ebuild ebuild
}

#
# Gentoo init.d completion
#

_gentoo_style_init()
{
    local script="${COMP_WORDS[0]}"
    local cur="${COMP_WORDS[$COMP_CWORD]}"

    if [[ ( -f "${script}" || -h "${script}" ) && -r "${script}" ]] \
    && [[ "${script}" != *.sh ]] \
    && [[ "$(head -n 1 "${script}")" = "#!/sbin/runscript" ]]
    then
    [[ $COMP_CWORD -gt 1 ]] && return 1
    COMPREPLY=($(opts="start stop status restart pause zap ineed needsme iuse usesme broken"; \
            eval "$(grep '^opts=' "${script}")"; echo "${opts}"))
    [[ -n "$COMPREPLY" ]] || COMPREPLY=(start stop restart zap)
    COMPREPLY=($(compgen -W "${COMPREPLY[*]}" -- "${cur}"))
    else
    COMPREPLY=($(compgen -o default -- "${cur}"))
    fi
    return 0
}
complete -F _gentoo_style_init @GENTOO_PORTAGE_EPREFIX@/etc/init.d/*

#
# rc completion command
#
have rc && {
_rc()
{
    local cur

    COMPREPLY=($(compgen -W "$(for i in @GENTOO_PORTAGE_EPREFIX@/etc/runlevels/*; do echo ${i##*/}; done)" -- $cur))
    fi
    return 0
} &&
complete -F _rc rc
}

#
# rc-status completion command
#
have rc-status && {
_rcstatus()
{
    local cur

    unset COMPREPLY
    fi
    return 0
} &&
complete -F _rcstatus rc-status
}

#
# rc-update completion command
#
have rc-update && {
_rcupdate()
{
    local cur show

    fi
    fi
    return 0
} &&
complete -F _rcupdate rc-update
}

#
# gcc-config completion command
#
have gcc-config && {
_gcc_config() {
    local cur prev opts
    COMPREPLY=()

                $(gcc-config -l | sed -r -e 's/(\[([^]]*)\]) //g')" -- ${cur}) )
            ;;
    esac
} &&
complete -F _gcc_config gcc-config
}

#
# distcc-config completion command
#
have distcc-config && {
_distccconfig()
{
    local cur curword numwords opts

    fi
    COMPREPLY=($(compgen -W "${opts}" | grep ^$cur))
    return 0
} &&
complete -F _distccconfig distcc-config
}

#
# java-config completion command
#
have java-config && {
_javaconfig()
{
    local cur prev curword numwords opts args arg spec flag sedcmd grepcmd

    fi
    COMPREPLY=($(compgen $nospace -W "${opts}" -- ${cur}))
    return 0
} &&
complete $nospace -F _javaconfig java-config
}

#
# browser-config completion command
#
have browser-config && {
_browserconfig()
{
    local cur prev

    unset COMPREPLY
    fi
    return 0
} &&
complete -F _browserconfig browser-config
}

#
# Helper routine for the subcommand 'meta' of 'equery'

#
# Bash completion for the Gentoo 'equery' command
#
have equery && {
_equery()
{
    local cur prev mode portdir i j

        esac
        ;;
    c?(hanges))
        # Complete package name only if it is not yet supplied.
        if [[ ${prev} == ${mode} ]]; then
            case $cur in
                -*)

                return 0
            fi
        case $cur in
            --f*)
            # don't handle --filter= with others to avoid space after the "="
            COMPREPLY=($(compgen -P "--filter=" \
                -W "dir obj sym dev fifo path conf cmd doc man info"))

            *)
            case $prev in
                -a|--all-packages)
                # Complete on all package names.
                _pkgname -A $cur
                ;;
                *)

            ;;
    esac
    return 0
} &&
complete -F _equery equery
}

#
# epkginfo completion
#

have epkginfo && {
_epkginfo()
{
    local cur prev

    fi

    return 0
} &&
complete -F _epkginfo epkginfo
}

#
# ekeyword completion
#

have ekeyword && {
_ekeyword()
{
    local cur portdir archl_s archl_u archl_r archl_m arch

            _filedir 'ebuild'
            ;;
        esac
} &&
complete -o filenames -F _ekeyword ekeyword
}

#
# portageq completion
#

have portageq && {
_portageq() {
    local cur prev opts
    COMPREPLY=()

      pkgdir \
      portdir_overlay \
      distdir"

    if [[ $COMP_CWORD -eq 1 ]] ; then
    # would always be correct, but it's pretty slow...
    #COMPREPLY=($(compgen -W "$(portageq | grep '^   [[:lower:]]' | \

    config*|vdb_path|gentoo_mirrors|*dir*)
        COMPREPLY=()
        ;;

    # this also isn't the fastest, but I welcome an alternative method
    envvar)
        COMPREPLY=($(compgen -W "$(env -i emerge -v --info | \
                sed -n -e '/^[[:upper:]].*=".*"/s/^\(.*\)=".*$/\1/p')" -- ${cur}))
        ;;

    *v@(isible|ersion)|match)
        COMPREPLY=($(compgen $nospace -W '/' -- $cur))
        ;;

    # $prev is a path, so complete on category/package
    */*)
            local x a=0
            for x in ${COMP_WORDS[@]} ; do
                # This is the only one
                if [[ "${x}" == "all_best_visible" ]] ; then
                    a=1
                    break

                    _pkgname -A $cur
#                fi
            fi
        ;;
    esac
} &&

complete -F _portageq portageq
}

#
# webapp-config completion
#

have webapp-config && {
_webapp_complete_appver()
{
    local x proot ibase cur="$2"

            fi ; \
        done)" -- ${cur}))
        ;;

    # complete on uninstalled
    uninstalled)
        COMPREPLY=($(compgen -W "$(\

            fi ; \
        done)" -- ${cur}))
        ;;

    # all
    all)
        COMPREPLY=($(compgen -W "$(\

            [[ -d "${x}" ]] && echo "${x##*/}" ; \
        done)" -- ${cur}))
        ;;

    # complete on version
    *)
        [[ -d "${proot}/$1" ]] || return 1

        COMPREPLY=($(compgen -W "${opts} ${actions}" -- ${cur}))
        return 0
    fi

    case "${prev}" in
        --bug-report|-p|--pretend)
        COMPREPLY=($(compgen -W "${opts} ${actions}" -- ${cur}))

        --list-unused-installs)
            _webapp_complete_appver uninstalled ${cur}
            ;;

        --list-installs|--show-postinst)
            _webapp_complete_appver all ${cur}
            ;;

        #  hrm... anyone know a better way to reliably do this?
        -h|--host)
            local x

                    [[ -d "${x}" ]] && echo "${x##*/}" ; \
                done)" -- ${cur}))
            ;;

        --virtual*)
            COMPREPLY=($(compgen -W "server-owned config-owned virtual" \
            -- ${cur}))
            ;;

        -d|--dir)
        local host x i=0
                # see if --host has been specified, and if so, get the value

            eval $(. @GENTOO_PORTAGE_EPREFIX@/etc/vhosts/webapp-config ; \
            echo host="${VHOST_HOSTNAME:-localhost}")
        fi

            COMPREPLY=($(compgen -W "$(\
            for x in ${hostroot}${host}/* ; do \
            [[ -d "${x}" ]] && echo "${x}" ; \

                    _webapp_complete_appver all ${cur}
            ;;
    esac
} &&
complete -F _webapp_config webapp-config
}

have revdep-rebuild && {
_revdep_rebuild() {
    local cur prev numwords opts
    local words i x

    if [[ ${prev} == '>' || ${prev} == '<' ]] ; then
            COMPREPLY=($(compgen -f -- ${cur}))
            return 0
        fi

    # find action
    for ((i = 0; i < ${numwords}; i++ )); do

            COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
        fi
        return 0
    fi
    if [[ ${action} == '--library' ]] || [[ ${action} == '-L' ]] ; then
        if [[ "${cur}" == */* ]]; then
            COMPREPLY=( $(builtin cd @GENTOO_PORTAGE_EPREFIX@/lib; compgen -f -- "${cur}") )

        fi
    fi
    return 0
} &&
complete -F _revdep_rebuild revdep-rebuild
}

have splat && {
_splat() {
    local cur prev opts
    COMPREPLY=()

            COMPREPLY=($(compgen -W "${COMPREPLY[@]} ${opts}" -- ${cur}))
            ;;
    esac
} &&
complete -o filenames -F _splat splat
}

have euse && {
_euse() {
    local cur prev opts sopts use portdir
    COMPREPLY=()

                COMPREPLY=($(compgen -W "${use}" -- ${cur}))
            fi
    esac
} &&
complete -F _euse euse
}

have glsa-check && {
_glsa_check() {
    local cur opts
    COMPREPLY=()

    fi

    COMPREPLY=($(compgen -W "${opts} $(< ${ROOT}/tmp/gc.out)" -- ${cur}))
} &&
complete -F _glsa_check glsa-check
}

have epm && {
_epm() {
    local cur prev opts
    COMPREPLY=()

            fi
            ;;
    esac
} &&
complete -o filenames -F _epm epm
}

have metagen &&
_metagen() {
    local cur prev opts
    COMPREPLY=()


    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
    return 0
} &&
complete -F _metagen metagen

have rc-service && {
_rc_service() {
    local cur prev numwords opts
    local words i x filename

    if [[ ${prev} == '>' || ${prev} == '<' ]] ; then
            COMPREPLY=($(compgen -f -- ${cur}))
            return 0
        fi

    # find action
    for x in ${COMP_LINE} ; do

                break
            fi
        done

        for ((i = 1; i < ${numwords}; i++ )); do
            if [[ ! ${COMP_WORDS[$i]} == -* ]]; then
                break

    if [[ ${COMP_CWORD} -eq 3 ]]; then
        return 1
    fi

    # check if an option was typed
    if [[ ${cur} == -* ]]; then
        if [[ ${cur} == --* ]]; then

            return 0
        fi


        # NOTE: This slows things down!
        # (Adapted from bash_completion by Ian Macdonald <ian@caliban.org>)
        # This removes any options from the list of completions that have

        done))
        return 0
    fi

    return 0
} &&
complete -F _rc_service rc-service

# vim: ft=sh:et:ts=4:sw=4:tw=80




# Gentoo init.d completion
#
# $Id$
#
# Copyright 1999-2009 Gentoo Foundation
# Distributed under the terms of the GNU General Public License, v2 or later

_gentoo_style_init()
{
    local script="${COMP_WORDS[0]}"
    local cur="${COMP_WORDS[$COMP_CWORD]}"

    if [[ ( -f "${script}" || -h "${script}" ) && -r "${script}" ]] \
    && [[ "${script}" != *.sh ]] \
    && [[ "$(head -n 1 "${script}")" = "#!/sbin/runscript" ]]
    then
    [[ $COMP_CWORD -gt 1 ]] && return 1
    COMPREPLY=($(opts="start stop status restart pause zap ineed needsme iuse usesme broken"; \
            eval "$(grep '^opts=' "${script}")"; echo "${opts}"))
    [[ -n "$COMPREPLY" ]] || COMPREPLY=(start stop restart zap)
    COMPREPLY=($(compgen -W "${COMPREPLY[*]}" -- "${cur}"))
    else
    COMPREPLY=($(compgen -o default -- "${cur}"))
    fi
    return 0
}
complete -F _gentoo_style_init @GENTOO_PORTAGE_EPREFIX@/etc/init.d/*

Lines 9-15 Link Here

(-)a/layman (-2 / +1 lines)
9	# Originally written by: Peter "Link" Sterk <link@penguindevelopment.org>	9	# Originally written by: Peter "Link" Sterk <link@penguindevelopment.org>
10		10
11		11
12	have layman &&
13	_layman() {	12	_layman() {
14	local cur prev opts r_overlays l_overlays splitopt	13	local cur prev opts r_overlays l_overlays splitopt
15		14
Lines 65-71 _layman() { Link Here
65	$splitopt && return 0	64	$splitopt && return 0
66		65
67	COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )	66	COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
68	}	67	} &&
69	complete -F _layman layman	68	complete -F _layman layman
70		69
71	# vim: ft=sh:et:ts=4:sw=4:tw=80	70	# vim: ft=sh:et:ts=4:sw=4:tw=80

Lines 59-65 _repoman() Link Here

(-)a/repoman (-2 / +2 lines)
59	esac	59	esac
60		60
61	return 0	61	return 0
62	}	62	} &&
63
64	complete -F _repoman repoman	63	complete -F _repoman repoman
		64
65	# vim: ft=sh:et:ts=4:sw=4:tw=80	65	# vim: ft=sh:et:ts=4:sw=4:tw=80

Return to bug 477024

Line 0 Link Here

(-)a/gentoo-style-init (+27 lines)
	1	# Gentoo init.d completion
	2	#
	3	# $Id$
	4	#
	5	# Copyright 1999-2009 Gentoo Foundation
	6	# Distributed under the terms of the GNU General Public License, v2 or later
	7
	8	_gentoo_style_init()
	9	{
	10	local script="${COMP_WORDS[0]}"
	11	local cur="${COMP_WORDS[$COMP_CWORD]}"
	12
	13	if [[ ( -f "${script}" \|\| -h "${script}" ) && -r "${script}" ]] \
	14	&& [[ "${script}" != *.sh ]] \
	15	&& [[ "$(head -n 1 "${script}")" = "#!/sbin/runscript" ]]
	16	then
	17	[[ $COMP_CWORD -gt 1 ]] && return 1
	18	COMPREPLY=($(opts="start stop status restart pause zap ineed needsme iuse usesme broken"; \
	19	eval "$(grep '^opts=' "${script}")"; echo "${opts}"))
	20	[[ -n "$COMPREPLY" ]] \|\| COMPREPLY=(start stop restart zap)
	21	COMPREPLY=($(compgen -W "${COMPREPLY[*]}" -- "${cur}"))
	22	else
	23	COMPREPLY=($(compgen -o default -- "${cur}"))
	24	fi
	25	return 0
	26	}
	27	complete -F _gentoo_style_init @GENTOO_PORTAGE_EPREFIX@/etc/init.d/*