-
-
Save tjt263/790b65f5f2c3625709f500c7fbe6c616 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| __expand_tilde_by_ref () | |
| { | |
| if [[ ${!1} == \~* ]]; then | |
| if [[ ${!1} == */* ]]; then | |
| eval $1="${!1/%\/*}"/'${!1#*/}'; | |
| else | |
| eval $1="${!1}"; | |
| fi; | |
| fi | |
| } | |
| __get_cword_at_cursor_by_ref () | |
| { | |
| local cword words=(); | |
| __reassemble_comp_words_by_ref "$1" words cword; | |
| local i cur index=$COMP_POINT lead=${COMP_LINE:0:$COMP_POINT}; | |
| if [[ $index -gt 0 && ( -n $lead && -n ${lead//[[:space:]]} ) ]]; then | |
| cur=$COMP_LINE; | |
| for ((i = 0; i <= cword; ++i )) | |
| do | |
| while [[ ${#cur} -ge ${#words[i]} && "${cur:0:${#words[i]}}" != "${words[i]}" ]]; do | |
| cur="${cur:1}"; | |
| ((index--)); | |
| done; | |
| if [[ $i -lt $cword ]]; then | |
| local old_size=${#cur}; | |
| cur="${cur#"${words[i]}"}"; | |
| local new_size=${#cur}; | |
| index=$(( index - old_size + new_size )); | |
| fi; | |
| done; | |
| [[ -n $cur && ! -n ${cur//[[:space:]]} ]] && cur=; | |
| [[ $index -lt 0 ]] && index=0; | |
| fi; | |
| local "$2" "$3" "$4" && _upvars -a${#words[@]} $2 "${words[@]}" -v $3 "$cword" -v $4 "${cur:0:$index}" | |
| } | |
| __git_eread () | |
| { | |
| local f="$1"; | |
| shift; | |
| test -r "$f" && read "$@" < "$f" | |
| } | |
| __git_ps1 () | |
| { | |
| local exit=$?; | |
| local pcmode=no; | |
| local detached=no; | |
| local ps1pc_start='\u@\h:\w '; | |
| local ps1pc_end='\$ '; | |
| local printf_format=' (%s)'; | |
| case "$#" in | |
| 2 | 3) | |
| pcmode=yes; | |
| ps1pc_start="$1"; | |
| ps1pc_end="$2"; | |
| printf_format="${3:-$printf_format}"; | |
| PS1="$ps1pc_start$ps1pc_end" | |
| ;; | |
| 0 | 1) | |
| printf_format="${1:-$printf_format}" | |
| ;; | |
| *) | |
| return $exit | |
| ;; | |
| esac; | |
| local ps1_expanded=yes; | |
| [ -z "$ZSH_VERSION" ] || [[ -o PROMPT_SUBST ]] || ps1_expanded=no; | |
| [ -z "$BASH_VERSION" ] || shopt -q promptvars || ps1_expanded=no; | |
| local repo_info rev_parse_exit_code; | |
| repo_info="$(git rev-parse --git-dir --is-inside-git-dir --is-bare-repository --is-inside-work-tree --short HEAD 2>/dev/null)"; | |
| rev_parse_exit_code="$?"; | |
| if [ -z "$repo_info" ]; then | |
| return $exit; | |
| fi; | |
| local short_sha; | |
| if [ "$rev_parse_exit_code" = "0" ]; then | |
| short_sha="${repo_info##* | |
| }"; | |
| repo_info="${repo_info% | |
| *}"; | |
| fi; | |
| local inside_worktree="${repo_info##* | |
| }"; | |
| repo_info="${repo_info% | |
| *}"; | |
| local bare_repo="${repo_info##* | |
| }"; | |
| repo_info="${repo_info% | |
| *}"; | |
| local inside_gitdir="${repo_info##* | |
| }"; | |
| local g="${repo_info% | |
| *}"; | |
| if [ "true" = "$inside_worktree" ] && [ -n "${GIT_PS1_HIDE_IF_PWD_IGNORED-}" ] && [ "$(git config --bool bash.hideIfPwdIgnored)" != "false" ] && git check-ignore -q .; then | |
| return $exit; | |
| fi; | |
| local r=""; | |
| local b=""; | |
| local step=""; | |
| local total=""; | |
| if [ -d "$g/rebase-merge" ]; then | |
| __git_eread "$g/rebase-merge/head-name" b; | |
| __git_eread "$g/rebase-merge/msgnum" step; | |
| __git_eread "$g/rebase-merge/end" total; | |
| if [ -f "$g/rebase-merge/interactive" ]; then | |
| r="|REBASE-i"; | |
| else | |
| r="|REBASE-m"; | |
| fi; | |
| else | |
| if [ -d "$g/rebase-apply" ]; then | |
| __git_eread "$g/rebase-apply/next" step; | |
| __git_eread "$g/rebase-apply/last" total; | |
| if [ -f "$g/rebase-apply/rebasing" ]; then | |
| __git_eread "$g/rebase-apply/head-name" b; | |
| r="|REBASE"; | |
| else | |
| if [ -f "$g/rebase-apply/applying" ]; then | |
| r="|AM"; | |
| else | |
| r="|AM/REBASE"; | |
| fi; | |
| fi; | |
| else | |
| if [ -f "$g/MERGE_HEAD" ]; then | |
| r="|MERGING"; | |
| else | |
| if [ -f "$g/CHERRY_PICK_HEAD" ]; then | |
| r="|CHERRY-PICKING"; | |
| else | |
| if [ -f "$g/REVERT_HEAD" ]; then | |
| r="|REVERTING"; | |
| else | |
| if [ -f "$g/BISECT_LOG" ]; then | |
| r="|BISECTING"; | |
| fi; | |
| fi; | |
| fi; | |
| fi; | |
| fi; | |
| if [ -n "$b" ]; then | |
| :; | |
| else | |
| if [ -h "$g/HEAD" ]; then | |
| b="$(git symbolic-ref HEAD 2>/dev/null)"; | |
| else | |
| local head=""; | |
| if ! __git_eread "$g/HEAD" head; then | |
| return $exit; | |
| fi; | |
| b="${head#ref: }"; | |
| if [ "$head" = "$b" ]; then | |
| detached=yes; | |
| b="$( | |
| case "${GIT_PS1_DESCRIBE_STYLE-}" in | |
| (contains) | |
| git describe --contains HEAD ;; | |
| (branch) | |
| git describe --contains --all HEAD ;; | |
| (describe) | |
| git describe HEAD ;; | |
| (* | default) | |
| git describe --tags --exact-match HEAD ;; | |
| esac 2>/dev/null)" || b="$short_sha..."; | |
| b="($b)"; | |
| fi; | |
| fi; | |
| fi; | |
| fi; | |
| if [ -n "$step" ] && [ -n "$total" ]; then | |
| r="$r $step/$total"; | |
| fi; | |
| local w=""; | |
| local i=""; | |
| local s=""; | |
| local u=""; | |
| local c=""; | |
| local p=""; | |
| if [ "true" = "$inside_gitdir" ]; then | |
| if [ "true" = "$bare_repo" ]; then | |
| c="BARE:"; | |
| else | |
| b="GIT_DIR!"; | |
| fi; | |
| else | |
| if [ "true" = "$inside_worktree" ]; then | |
| if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ] && [ "$(git config --bool bash.showDirtyState)" != "false" ]; then | |
| git diff --no-ext-diff --quiet || w="*"; | |
| git diff --no-ext-diff --cached --quiet || i="+"; | |
| if [ -z "$short_sha" ] && [ -z "$i" ]; then | |
| i="#"; | |
| fi; | |
| fi; | |
| if [ -n "${GIT_PS1_SHOWSTASHSTATE-}" ] && git rev-parse --verify --quiet refs/stash > /dev/null; then | |
| s="$"; | |
| fi; | |
| if [ -n "${GIT_PS1_SHOWUNTRACKEDFILES-}" ] && [ "$(git config --bool bash.showUntrackedFiles)" != "false" ] && git ls-files --others --exclude-standard --directory --no-empty-directory --error-unmatch -- ':/*' > /dev/null 2> /dev/null; then | |
| u="%${ZSH_VERSION+%}"; | |
| fi; | |
| if [ -n "${GIT_PS1_SHOWUPSTREAM-}" ]; then | |
| __git_ps1_show_upstream; | |
| fi; | |
| fi; | |
| fi; | |
| local z="${GIT_PS1_STATESEPARATOR-" "}"; | |
| if [ $pcmode = yes ] && [ -n "${GIT_PS1_SHOWCOLORHINTS-}" ]; then | |
| __git_ps1_colorize_gitstring; | |
| fi; | |
| b=${b##refs/heads/}; | |
| if [ $pcmode = yes ] && [ $ps1_expanded = yes ]; then | |
| __git_ps1_branch_name=$b; | |
| b="\${__git_ps1_branch_name}"; | |
| fi; | |
| local f="$w$i$s$u"; | |
| local gitstring="$c$b${f:+$z$f}$r$p"; | |
| if [ $pcmode = yes ]; then | |
| if [ "${__git_printf_supports_v-}" != yes ]; then | |
| gitstring=$(printf -- "$printf_format" "$gitstring"); | |
| else | |
| printf -v gitstring -- "$printf_format" "$gitstring"; | |
| fi; | |
| PS1="$ps1pc_start$gitstring$ps1pc_end"; | |
| else | |
| printf -- "$printf_format" "$gitstring"; | |
| fi; | |
| return $exit | |
| } | |
| __git_ps1_colorize_gitstring () | |
| { | |
| if [[ -n ${ZSH_VERSION-} ]]; then | |
| local c_red='%F{red}'; | |
| local c_green='%F{green}'; | |
| local c_lblue='%F{blue}'; | |
| local c_clear='%f'; | |
| else | |
| local c_red='\[\e[31m\]'; | |
| local c_green='\[\e[32m\]'; | |
| local c_lblue='\[\e[1;34m\]'; | |
| local c_clear='\[\e[0m\]'; | |
| fi; | |
| local bad_color=$c_red; | |
| local ok_color=$c_green; | |
| local flags_color="$c_lblue"; | |
| local branch_color=""; | |
| if [ $detached = no ]; then | |
| branch_color="$ok_color"; | |
| else | |
| branch_color="$bad_color"; | |
| fi; | |
| c="$branch_color$c"; | |
| z="$c_clear$z"; | |
| if [ "$w" = "*" ]; then | |
| w="$bad_color$w"; | |
| fi; | |
| if [ -n "$i" ]; then | |
| i="$ok_color$i"; | |
| fi; | |
| if [ -n "$s" ]; then | |
| s="$flags_color$s"; | |
| fi; | |
| if [ -n "$u" ]; then | |
| u="$bad_color$u"; | |
| fi; | |
| r="$c_clear$r" | |
| } | |
| __git_ps1_show_upstream () | |
| { | |
| local key value; | |
| local svn_remote svn_url_pattern count n; | |
| local upstream=git legacy="" verbose="" name=""; | |
| svn_remote=(); | |
| local output="$(git config -z --get-regexp '^(svn-remote\..*\.url|bash\.showupstream)$' 2>/dev/null | tr '\0\n' '\n ')"; | |
| while read -r key value; do | |
| case "$key" in | |
| bash.showupstream) | |
| GIT_PS1_SHOWUPSTREAM="$value"; | |
| if [[ -z "${GIT_PS1_SHOWUPSTREAM}" ]]; then | |
| p=""; | |
| return; | |
| fi | |
| ;; | |
| svn-remote.*.url) | |
| svn_remote[$((${#svn_remote[@]} + 1))]="$value"; | |
| svn_url_pattern="$svn_url_pattern\\|$value"; | |
| upstream=svn+git | |
| ;; | |
| esac; | |
| done <<< "$output"; | |
| for option in ${GIT_PS1_SHOWUPSTREAM}; | |
| do | |
| case "$option" in | |
| git | svn) | |
| upstream="$option" | |
| ;; | |
| verbose) | |
| verbose=1 | |
| ;; | |
| legacy) | |
| legacy=1 | |
| ;; | |
| name) | |
| name=1 | |
| ;; | |
| esac; | |
| done; | |
| case "$upstream" in | |
| git) | |
| upstream="@{upstream}" | |
| ;; | |
| svn*) | |
| local -a svn_upstream; | |
| svn_upstream=($(git log --first-parent -1 --grep="^git-svn-id: \(${svn_url_pattern#??}\)" 2>/dev/null)); | |
| if [[ 0 -ne ${#svn_upstream[@]} ]]; then | |
| svn_upstream=${svn_upstream[${#svn_upstream[@]} - 2]}; | |
| svn_upstream=${svn_upstream%@*}; | |
| local n_stop="${#svn_remote[@]}"; | |
| for ((n=1; n <= n_stop; n++)) | |
| do | |
| svn_upstream=${svn_upstream#${svn_remote[$n]}}; | |
| done; | |
| if [[ -z "$svn_upstream" ]]; then | |
| upstream=${GIT_SVN_ID:-git-svn}; | |
| else | |
| upstream=${svn_upstream#/}; | |
| fi; | |
| else | |
| if [[ "svn+git" = "$upstream" ]]; then | |
| upstream="@{upstream}"; | |
| fi; | |
| fi | |
| ;; | |
| esac; | |
| if [[ -z "$legacy" ]]; then | |
| count="$(git rev-list --count --left-right "$upstream"...HEAD 2>/dev/null)"; | |
| else | |
| local commits; | |
| if commits="$(git rev-list --left-right "$upstream"...HEAD 2>/dev/null)"; then | |
| local commit behind=0 ahead=0; | |
| for commit in $commits; | |
| do | |
| case "$commit" in | |
| "<"*) | |
| ((behind++)) | |
| ;; | |
| *) | |
| ((ahead++)) | |
| ;; | |
| esac; | |
| done; | |
| count="$behind $ahead"; | |
| else | |
| count=""; | |
| fi; | |
| fi; | |
| if [[ -z "$verbose" ]]; then | |
| case "$count" in | |
| "") | |
| p="" | |
| ;; | |
| "0 0") | |
| p="=" | |
| ;; | |
| "0 "*) | |
| p=">" | |
| ;; | |
| *" 0") | |
| p="<" | |
| ;; | |
| *) | |
| p="<>" | |
| ;; | |
| esac; | |
| else | |
| case "$count" in | |
| "") | |
| p="" | |
| ;; | |
| "0 0") | |
| p=" u=" | |
| ;; | |
| "0 "*) | |
| p=" u+${count#0 }" | |
| ;; | |
| *" 0") | |
| p=" u-${count% 0}" | |
| ;; | |
| *) | |
| p=" u+${count#* }-${count% *}" | |
| ;; | |
| esac; | |
| if [[ -n "$count" && -n "$name" ]]; then | |
| __git_ps1_upstream_name=$(git rev-parse --abbrev-ref "$upstream" 2>/dev/null); | |
| if [ $pcmode = yes ] && [ $ps1_expanded = yes ]; then | |
| p="$p \${__git_ps1_upstream_name}"; | |
| else | |
| p="$p ${__git_ps1_upstream_name}"; | |
| unset __git_ps1_upstream_name; | |
| fi; | |
| fi; | |
| fi | |
| } | |
| __grub_dir () | |
| { | |
| local i c=1 boot_dir; | |
| for ((c=1; c <= ${#COMP_WORDS[@]}; c++ )) | |
| do | |
| i="${COMP_WORDS[c]}"; | |
| case "$i" in | |
| --boot-directory) | |
| c=$((++c)); | |
| i="${COMP_WORDS[c]}"; | |
| boot_dir="${i##*=}"; | |
| break | |
| ;; | |
| esac; | |
| done; | |
| boot_dir=${boot_dir-/boot}; | |
| echo "${boot_dir%/}/grub" | |
| } | |
| __grub_get_last_option () | |
| { | |
| local i; | |
| for ((i=$COMP_CWORD-1; i > 0; i-- )) | |
| do | |
| if [[ "${COMP_WORDS[i]}" == -* ]]; then | |
| echo "${COMP_WORDS[i]}"; | |
| break; | |
| fi; | |
| done | |
| } | |
| __grub_get_options_from_help () | |
| { | |
| local prog; | |
| if [ $# -ge 1 ]; then | |
| prog="$1"; | |
| else | |
| prog="${COMP_WORDS[0]}"; | |
| fi; | |
| local i IFS=" "' '' | |
| '; | |
| for i in $(LC_ALL=C $prog --help); | |
| do | |
| case $i in | |
| --*) | |
| echo "${i%=*}" | |
| ;; | |
| esac; | |
| done | |
| } | |
| __grub_get_options_from_usage () | |
| { | |
| local prog; | |
| if [ $# -ge 1 ]; then | |
| prog="$1"; | |
| else | |
| prog="${COMP_WORDS[0]}"; | |
| fi; | |
| local i IFS=" "' '' | |
| '; | |
| for i in $(LC_ALL=C $prog --usage); | |
| do | |
| case $i in | |
| \[--*\]) | |
| i=${i#[}; | |
| echo ${i%%?(=*)]} | |
| ;; | |
| esac; | |
| done | |
| } | |
| __grub_list_menuentries () | |
| { | |
| local cur="${COMP_WORDS[COMP_CWORD]}"; | |
| local config_file=$(__grub_dir)/grub.cfg; | |
| if [ -f "$config_file" ]; then | |
| local IFS=' | |
| '; | |
| COMPREPLY=($(compgen -W "$( awk -F "[\"']" '/menuentry/ { print $2 }' $config_file )" -- "$cur" )); | |
| fi | |
| } | |
| __grub_list_modules () | |
| { | |
| local grub_dir=$(__grub_dir); | |
| local IFS=' | |
| '; | |
| COMPREPLY=($( compgen -f -X '!*/*.mod' -- "${grub_dir}/$cur" | { | |
| while read -r tmp; do | |
| [ -n $tmp ] && { | |
| tmp=${tmp##*/} | |
| printf '%s\n' ${tmp%.mod} | |
| } | |
| done | |
| } | |
| )) | |
| } | |
| __grubcomp () | |
| { | |
| local cur="${COMP_WORDS[COMP_CWORD]}"; | |
| if [ $# -gt 2 ]; then | |
| cur="$3"; | |
| fi; | |
| case "$cur" in | |
| --*=) | |
| COMPREPLY=() | |
| ;; | |
| *) | |
| local IFS=' '' '' | |
| '; | |
| COMPREPLY=($(compgen -P "${2-}" -W "${1-}" -S "${4-}" -- "$cur")) | |
| ;; | |
| esac | |
| } | |
| __ltrim_colon_completions () | |
| { | |
| if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then | |
| local colon_word=${1%"${1##*:}"}; | |
| local i=${#COMPREPLY[*]}; | |
| while [[ $((--i)) -ge 0 ]]; do | |
| COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}; | |
| done; | |
| fi | |
| } | |
| __parse_options () | |
| { | |
| local option option2 i IFS=' | |
| ,/|'; | |
| option=; | |
| for i in $1; | |
| do | |
| case $i in | |
| ---*) | |
| break | |
| ;; | |
| --?*) | |
| option=$i; | |
| break | |
| ;; | |
| -?*) | |
| [[ -n $option ]] || option=$i | |
| ;; | |
| *) | |
| break | |
| ;; | |
| esac; | |
| done; | |
| [[ -n $option ]] || return 0; | |
| IFS=' | |
| '; | |
| if [[ $option =~ (\[((no|dont)-?)\]). ]]; then | |
| option2=${option/"${BASH_REMATCH[1]}"/}; | |
| option2=${option2%%[<{().[]*}; | |
| printf '%s\n' "${option2/=*/=}"; | |
| option=${option/"${BASH_REMATCH[1]}"/"${BASH_REMATCH[2]}"}; | |
| fi; | |
| option=${option%%[<{().[]*}; | |
| printf '%s\n' "${option/=*/=}" | |
| } | |
| __reassemble_comp_words_by_ref () | |
| { | |
| local exclude i j line ref; | |
| if [[ -n $1 ]]; then | |
| exclude="${1//[^$COMP_WORDBREAKS]}"; | |
| fi; | |
| eval $3=$COMP_CWORD; | |
| if [[ -n $exclude ]]; then | |
| line=$COMP_LINE; | |
| for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)) | |
| do | |
| while [[ $i -gt 0 && ${COMP_WORDS[$i]} == +([$exclude]) ]]; do | |
| [[ $line != [' ']* ]] && (( j >= 2 )) && ((j--)); | |
| ref="$2[$j]"; | |
| eval $2[$j]=\${!ref}\${COMP_WORDS[i]}; | |
| [[ $i == $COMP_CWORD ]] && eval $3=$j; | |
| line=${line#*"${COMP_WORDS[$i]}"}; | |
| [[ $line == [' ']* ]] && ((j++)); | |
| (( $i < ${#COMP_WORDS[@]} - 1)) && ((i++)) || break 2; | |
| done; | |
| ref="$2[$j]"; | |
| eval $2[$j]=\${!ref}\${COMP_WORDS[i]}; | |
| line=${line#*"${COMP_WORDS[i]}"}; | |
| [[ $i == $COMP_CWORD ]] && eval $3=$j; | |
| done; | |
| [[ $i == $COMP_CWORD ]] && eval $3=$j; | |
| else | |
| eval $2=\( \"\${COMP_WORDS[@]}\" \); | |
| fi | |
| } | |
| _allowed_groups () | |
| { | |
| if _complete_as_root; then | |
| local IFS=' | |
| '; | |
| COMPREPLY=($( compgen -g -- "$1" )); | |
| else | |
| local IFS=' | |
| '; | |
| COMPREPLY=($( compgen -W "$( id -Gn 2>/dev/null || groups 2>/dev/null )" -- "$1" )); | |
| fi | |
| } | |
| _allowed_users () | |
| { | |
| if _complete_as_root; then | |
| local IFS=' | |
| '; | |
| COMPREPLY=($( compgen -u -- "${1:-$cur}" )); | |
| else | |
| local IFS=' | |
| '; | |
| COMPREPLY=($( compgen -W "$( id -un 2>/dev/null || whoami 2>/dev/null )" -- "${1:-$cur}" )); | |
| fi | |
| } | |
| _available_interfaces () | |
| { | |
| local cmd PATH=$PATH:/sbin; | |
| if [[ ${1:-} == -w ]]; then | |
| cmd="iwconfig"; | |
| else | |
| if [[ ${1:-} == -a ]]; then | |
| cmd="{ ifconfig || ip link show up; }"; | |
| else | |
| cmd="{ ifconfig -a || ip link show; }"; | |
| fi; | |
| fi; | |
| COMPREPLY=($( eval $cmd 2>/dev/null | awk '/^[^ \t]/ { if ($1 ~ /^[0-9]+:/) { print $2 } else { print $1 } }' )); | |
| COMPREPLY=($( compgen -W '${COMPREPLY[@]/%[[:punct:]]/}' -- "$cur" )) | |
| } | |
| _cd () | |
| { | |
| local cur prev words cword; | |
| _init_completion || return; | |
| local IFS=' | |
| ' i j k; | |
| compopt -o filenames; | |
| if [[ -z "${CDPATH:-}" || "$cur" == ?(.)?(.)/* ]]; then | |
| _filedir -d; | |
| return 0; | |
| fi; | |
| local -r mark_dirs=$(_rl_enabled mark-directories && echo y); | |
| local -r mark_symdirs=$(_rl_enabled mark-symlinked-directories && echo y); | |
| for i in ${CDPATH//:/' | |
| '}; | |
| do | |
| k="${#COMPREPLY[@]}"; | |
| for j in $( compgen -d $i/$cur ); | |
| do | |
| if [[ ( -n $mark_symdirs && -h $j || -n $mark_dirs && ! -h $j ) && ! -d ${j#$i/} ]]; then | |
| j+="/"; | |
| fi; | |
| COMPREPLY[k++]=${j#$i/}; | |
| done; | |
| done; | |
| _filedir -d; | |
| if [[ ${#COMPREPLY[@]} -eq 1 ]]; then | |
| i=${COMPREPLY[0]}; | |
| if [[ "$i" == "$cur" && $i != "*/" ]]; then | |
| COMPREPLY[0]="${i}/"; | |
| fi; | |
| fi; | |
| return 0 | |
| } | |
| _cd_devices () | |
| { | |
| COMPREPLY+=($( compgen -f -d -X "!*/?([amrs])cd*" -- "${cur:-/dev/}" )) | |
| } | |
| _command () | |
| { | |
| local offset i; | |
| offset=1; | |
| for ((i=1; i <= COMP_CWORD; i++ )) | |
| do | |
| if [[ "${COMP_WORDS[i]}" != -* ]]; then | |
| offset=$i; | |
| break; | |
| fi; | |
| done; | |
| _command_offset $offset | |
| } | |
| _command_offset () | |
| { | |
| local word_offset=$1 i j; | |
| for ((i=0; i < $word_offset; i++ )) | |
| do | |
| for ((j=0; j <= ${#COMP_LINE}; j++ )) | |
| do | |
| [[ "$COMP_LINE" == "${COMP_WORDS[i]}"* ]] && break; | |
| COMP_LINE=${COMP_LINE:1}; | |
| ((COMP_POINT--)); | |
| done; | |
| COMP_LINE=${COMP_LINE#"${COMP_WORDS[i]}"}; | |
| ((COMP_POINT-=${#COMP_WORDS[i]})); | |
| done; | |
| for ((i=0; i <= COMP_CWORD - $word_offset; i++ )) | |
| do | |
| COMP_WORDS[i]=${COMP_WORDS[i+$word_offset]}; | |
| done; | |
| for ((i; i <= COMP_CWORD; i++ )) | |
| do | |
| unset COMP_WORDS[i]; | |
| done; | |
| ((COMP_CWORD -= $word_offset)); | |
| COMPREPLY=(); | |
| local cur; | |
| _get_comp_words_by_ref cur; | |
| if [[ $COMP_CWORD -eq 0 ]]; then | |
| local IFS=' | |
| '; | |
| compopt -o filenames; | |
| COMPREPLY=($( compgen -d -c -- "$cur" )); | |
| else | |
| local cmd=${COMP_WORDS[0]} compcmd=${COMP_WORDS[0]}; | |
| local cspec=$( complete -p $cmd 2>/dev/null ); | |
| if [[ ! -n $cspec && $cmd == */* ]]; then | |
| cspec=$( complete -p ${cmd##*/} 2>/dev/null ); | |
| [[ -n $cspec ]] && compcmd=${cmd##*/}; | |
| fi; | |
| if [[ ! -n $cspec ]]; then | |
| compcmd=${cmd##*/}; | |
| _completion_loader $compcmd; | |
| cspec=$( complete -p $compcmd 2>/dev/null ); | |
| fi; | |
| if [[ -n $cspec ]]; then | |
| if [[ ${cspec#* -F } != $cspec ]]; then | |
| local func=${cspec#*-F }; | |
| func=${func%% *}; | |
| if [[ ${#COMP_WORDS[@]} -ge 2 ]]; then | |
| $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}" "${COMP_WORDS[${#COMP_WORDS[@]}-2]}"; | |
| else | |
| $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}"; | |
| fi; | |
| local opt; | |
| while [[ $cspec == *" -o "* ]]; do | |
| cspec=${cspec#*-o }; | |
| opt=${cspec%% *}; | |
| compopt -o $opt; | |
| cspec=${cspec#$opt}; | |
| done; | |
| else | |
| cspec=${cspec#complete}; | |
| cspec=${cspec%%$compcmd}; | |
| COMPREPLY=($( eval compgen "$cspec" -- '$cur' )); | |
| fi; | |
| else | |
| if [[ ${#COMPREPLY[@]} -eq 0 ]]; then | |
| _minimal; | |
| fi; | |
| fi; | |
| fi | |
| } | |
| _complete_as_root () | |
| { | |
| [[ $EUID -eq 0 || -n ${root_command:-} ]] | |
| } | |
| _completion_loader () | |
| { | |
| local compfile=./completions; | |
| [[ $BASH_SOURCE == */* ]] && compfile="${BASH_SOURCE%/*}/completions"; | |
| compfile+="/${1##*/}"; | |
| [[ -f "$compfile" ]] && . "$compfile" &> /dev/null && return 124; | |
| complete -F _minimal "$1" && return 124 | |
| } | |
| _configured_interfaces () | |
| { | |
| if [[ -f /etc/debian_version ]]; then | |
| COMPREPLY=($( compgen -W "$( sed -ne 's|^iface \([^ ]\{1,\}\).*$|\1|p' /etc/network/interfaces )" -- "$cur" )); | |
| else | |
| if [[ -f /etc/SuSE-release ]]; then | |
| COMPREPLY=($( compgen -W "$( printf '%s\n' /etc/sysconfig/network/ifcfg-* | sed -ne 's|.*ifcfg-\(.*\)|\1|p' )" -- "$cur" )); | |
| else | |
| if [[ -f /etc/pld-release ]]; then | |
| COMPREPLY=($( compgen -W "$( command ls -B /etc/sysconfig/interfaces | sed -ne 's|.*ifcfg-\(.*\)|\1|p' )" -- "$cur" )); | |
| else | |
| COMPREPLY=($( compgen -W "$( printf '%s\n' /etc/sysconfig/network-scripts/ifcfg-* | sed -ne 's|.*ifcfg-\(.*\)|\1|p' )" -- "$cur" )); | |
| fi; | |
| fi; | |
| fi | |
| } | |
| _count_args () | |
| { | |
| local i cword words; | |
| __reassemble_comp_words_by_ref "$1" words cword; | |
| args=1; | |
| for i in "${words[@]:1:cword-1}"; | |
| do | |
| [[ "$i" != -* ]] && args=$(($args+1)); | |
| done | |
| } | |
| _cryptdisks () | |
| { | |
| local tf; | |
| tf=${TABFILE-"/etc/crypttab"}; | |
| COMPREPLY=($(egrep -v "^[[:space:]]*(#|$)" "${tf}" | egrep -o "^${COMP_WORDS[COMP_CWORD]}[^[:space:]]*")); | |
| return 0 | |
| } | |
| _debtags () | |
| { | |
| local cur prev options; | |
| _get_comp_words_by_ref -n : cur prev words cword; | |
| COMPREPLY=(); | |
| options='cat check diff dumpavail grep help \ | |
| mkpatch search \ | |
| show submit tag tagcat tagsearch \ | |
| tagshow update vocfilter'; | |
| for ((i=0; i < ${#words[@]}; i++ )) | |
| do | |
| case ${words[i]} in | |
| check | mkpatch | diff | submit) | |
| _filedir; | |
| return 0 | |
| ;; | |
| tag) | |
| case $prev in | |
| add | rm | ls) | |
| COMPREPLY=($( apt-cache pkgnames $cur 2> /dev/null )); | |
| return 0 | |
| ;; | |
| tag) | |
| tag_cmds='add rm ls'; | |
| COMPREPLY=($( compgen -W "$tag_cmds" -- $cur )); | |
| return 0 | |
| ;; | |
| *) | |
| if [[ -n "${words[cword-2]}" ]]; then | |
| case ${words[cword-2]} in | |
| add | rm) | |
| COMPREPLY=($( grep "^Tag: $cur" /var/lib/debtags/vocabulary |cut -b 6- )); | |
| return 0 | |
| ;; | |
| *) | |
| return 0 | |
| ;; | |
| esac; | |
| fi; | |
| return 0 | |
| ;; | |
| esac | |
| ;; | |
| show) | |
| COMPREPLY=($( apt-cache pkgnames $cur 2> /dev/null )); | |
| return 0 | |
| ;; | |
| tagshow) | |
| if [[ "$prev" == "grep" && "$cur" == -* ]]; then | |
| COMPREPLY=($( compgen -W '--invert-match --quiet' -- $cur )); | |
| return 0; | |
| fi; | |
| COMPREPLY=($( grep "^Tag: $cur" /var/lib/debtags/vocabulary |cut -b 6- )); | |
| __ltrim_colon_completions "$cur"; | |
| return 0 | |
| ;; | |
| grep | search) | |
| if [[ "$prev" == "grep" && "$cur" == -* ]]; then | |
| COMPREPLY=($( compgen -W '--invert-match --quiet' -- $cur )); | |
| return 0; | |
| fi; | |
| COMPREPLY=($( grep "^Tag: $cur" /var/lib/debtags/vocabulary |cut -b 6- )); | |
| __ltrim_colon_completions "$cur"; | |
| return 0 | |
| ;; | |
| cat) | |
| COMPREPLY=($( compgen -W "--group-items" -- $cur )); | |
| return 0 | |
| ;; | |
| *) | |
| ;; | |
| esac; | |
| done; | |
| if [[ "$cur" == -* ]]; then | |
| options='--verbose --debug -V --version -? --help'; | |
| COMPREPLY=($( compgen -W "$options" -- $cur )); | |
| return 0; | |
| fi; | |
| if [[ "$cword" == 1 ]]; then | |
| COMPREPLY=($( compgen -W "$options" -- $cur )); | |
| return 0; | |
| fi | |
| } | |
| _desktop_file_validate () | |
| { | |
| COMPRELY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| _filedir '@(desktop)' | |
| } | |
| _dkms () | |
| { | |
| local cur prev command module i; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| if [[ $COMP_CWORD -eq 1 ]]; then | |
| COMPREPLY=($( compgen -W "add autoinstall remove build install uninstall match mkdriverdisk mktarball ldtarball mkrpm mkdeb mkdsc mkkmp status" -- $cur )); | |
| else | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| command=${COMP_WORDS[1]}; | |
| case $prev in | |
| -m) | |
| if [ "$command" = 'add' ]; then | |
| _filename_parts '.*-.*' 1; | |
| else | |
| _subdirectories /var/lib/dkms; | |
| fi; | |
| return 0 | |
| ;; | |
| -v) | |
| for ((i=1; i < COMP_CWORD; i++ )) | |
| do | |
| if [[ "${COMP_WORDS[i]}" == -m ]]; then | |
| module=${COMP_WORDS[i+1]}; | |
| break; | |
| fi; | |
| done; | |
| if [ -n "$module" ]; then | |
| if [ "$command" = 'add' ]; then | |
| _filename_parts "$module-.*" 2; | |
| else | |
| _subdirectories /var/lib/dkms/$module; | |
| fi; | |
| return 0; | |
| fi | |
| ;; | |
| -k) | |
| _kernels; | |
| return 0 | |
| ;; | |
| -@\(c | -spec | -archive | -config\)) | |
| _filedir; | |
| return 0 | |
| ;; | |
| --kernelsourcedir) | |
| _filedir -d; | |
| return 0 | |
| ;; | |
| esac; | |
| if [[ "$cur" == -* ]]; then | |
| case $command in | |
| add) | |
| options='-c --rpm_safe_upgrade' | |
| ;; | |
| remove) | |
| options='--rpm_safe_upgrade' | |
| ;; | |
| build) | |
| options='--config' | |
| ;; | |
| mkdriverdisk) | |
| options='-d --distro -r --release --size' | |
| ;; | |
| ldtarball) | |
| options='--archive --force' | |
| ;; | |
| mktarball) | |
| options='--source-only --binaries-only' | |
| ;; | |
| mkrpm) | |
| options='--source-only' | |
| ;; | |
| mkkmp) | |
| options='--spec' | |
| ;; | |
| match) | |
| options='--templatekernel' | |
| ;; | |
| esac; | |
| options="$options -m -v -k -a --arch -q --quiet -V --version --all --no-prepare-kernel --no-clean-kernel --kernelsourcedir --directive"; | |
| COMPREPLY=($( compgen -W "$options" -- $cur )); | |
| fi; | |
| fi | |
| } | |
| _dvd_devices () | |
| { | |
| COMPREPLY+=($( compgen -f -d -X "!*/?(r)dvd*" -- "${cur:-/dev/}" )) | |
| } | |
| _expand () | |
| { | |
| if [[ "$cur" == \~*/* ]]; then | |
| eval cur=$cur 2> /dev/null; | |
| else | |
| if [[ "$cur" == \~* ]]; then | |
| cur=${cur#\~}; | |
| COMPREPLY=($( compgen -P '~' -u "$cur" )); | |
| [[ ${#COMPREPLY[@]} -eq 1 ]] && eval COMPREPLY[0]=${COMPREPLY[0]}; | |
| return ${#COMPREPLY[@]}; | |
| fi; | |
| fi | |
| } | |
| _filedir () | |
| { | |
| local i IFS=' | |
| ' xspec; | |
| _tilde "$cur" || return 0; | |
| local -a toks; | |
| local quoted x tmp; | |
| _quote_readline_by_ref "$cur" quoted; | |
| x=$( compgen -d -- "$quoted" ) && while read -r tmp; do | |
| toks+=("$tmp"); | |
| done <<< "$x"; | |
| if [[ "$1" != -d ]]; then | |
| xspec=${1:+"!*.@($1|${1^^})"}; | |
| x=$( compgen -f -X "$xspec" -- $quoted ) && while read -r tmp; do | |
| toks+=("$tmp"); | |
| done <<< "$x"; | |
| fi; | |
| [[ -n ${COMP_FILEDIR_FALLBACK:-} && -n "$1" && "$1" != -d && ${#toks[@]} -lt 1 ]] && x=$( compgen -f -- $quoted ) && while read -r tmp; do | |
| toks+=("$tmp"); | |
| done <<< "$x"; | |
| if [[ ${#toks[@]} -ne 0 ]]; then | |
| compopt -o filenames 2> /dev/null; | |
| COMPREPLY+=("${toks[@]}"); | |
| fi | |
| } | |
| _filedir_xspec () | |
| { | |
| local cur prev words cword; | |
| _init_completion || return; | |
| _tilde "$cur" || return 0; | |
| local IFS=' | |
| ' xspec=${_xspecs[${1##*/}]} tmp; | |
| local -a toks; | |
| toks=($( | |
| compgen -d -- "$(quote_readline "$cur")" | { | |
| while read -r tmp; do | |
| printf '%s\n' $tmp | |
| done | |
| } | |
| )); | |
| eval xspec="${xspec}"; | |
| local matchop=!; | |
| if [[ $xspec == !* ]]; then | |
| xspec=${xspec#!}; | |
| matchop=@; | |
| fi; | |
| xspec="$matchop($xspec|${xspec^^})"; | |
| toks+=($( | |
| eval compgen -f -X "!$xspec" -- "\$(quote_readline "\$cur")" | { | |
| while read -r tmp; do | |
| [[ -n $tmp ]] && printf '%s\n' $tmp | |
| done | |
| } | |
| )); | |
| if [[ ${#toks[@]} -ne 0 ]]; then | |
| compopt -o filenames; | |
| COMPREPLY=("${toks[@]}"); | |
| fi | |
| } | |
| _filename_parts () | |
| { | |
| COMPREPLY=($( command ls -F /usr/src/ 2>/dev/null | grep -E '^'$1'/$' | sed -r -e 's/^([^-]+)-(.+)\/$/\'$2'/' | grep "^$cur" )) | |
| } | |
| _fstypes () | |
| { | |
| local fss; | |
| if [[ -e /proc/filesystems ]]; then | |
| fss="$( cut -d' ' -f2 /proc/filesystems ) | |
| $( awk '! /\*/ { print $NF }' /etc/filesystems 2>/dev/null )"; | |
| else | |
| fss="$( awk '/^[ \t]*[^#]/ { print $3 }' /etc/fstab 2>/dev/null ) | |
| $( awk '/^[ \t]*[^#]/ { print $3 }' /etc/mnttab 2>/dev/null ) | |
| $( awk '/^[ \t]*[^#]/ { print $4 }' /etc/vfstab 2>/dev/null ) | |
| $( awk '{ print $1 }' /etc/dfs/fstypes 2>/dev/null ) | |
| $( [[ -d /etc/fs ]] && command ls /etc/fs )"; | |
| fi; | |
| [[ -n $fss ]] && COMPREPLY+=($( compgen -W "$fss" -- "$cur" )) | |
| } | |
| _function () | |
| { | |
| local cur prev words cword; | |
| _init_completion || return; | |
| if [[ $1 == @(declare|typeset) ]]; then | |
| if [[ $prev == -f ]]; then | |
| COMPREPLY=($( compgen -A function -- "$cur" )); | |
| else | |
| if [[ "$cur" == -* ]]; then | |
| COMPREPLY=($( compgen -W '$( _parse_usage "$1" )' -- "$cur" )); | |
| fi; | |
| fi; | |
| else | |
| if [[ $cword -eq 1 ]]; then | |
| COMPREPLY=($( compgen -A function -- "$cur" )); | |
| else | |
| COMPREPLY=("() $( type -- ${words[1]} | sed -e 1,2d )"); | |
| fi; | |
| fi | |
| } | |
| _get_comp_words_by_ref () | |
| { | |
| local exclude flag i OPTIND=1; | |
| local cur cword words=(); | |
| local upargs=() upvars=() vcur vcword vprev vwords; | |
| while getopts "c:i:n:p:w:" flag "$@"; do | |
| case $flag in | |
| c) | |
| vcur=$OPTARG | |
| ;; | |
| i) | |
| vcword=$OPTARG | |
| ;; | |
| n) | |
| exclude=$OPTARG | |
| ;; | |
| p) | |
| vprev=$OPTARG | |
| ;; | |
| w) | |
| vwords=$OPTARG | |
| ;; | |
| esac; | |
| done; | |
| while [[ $# -ge $OPTIND ]]; do | |
| case ${!OPTIND} in | |
| cur) | |
| vcur=cur | |
| ;; | |
| prev) | |
| vprev=prev | |
| ;; | |
| cword) | |
| vcword=cword | |
| ;; | |
| words) | |
| vwords=words | |
| ;; | |
| *) | |
| echo "bash: $FUNCNAME(): \`${!OPTIND}': unknown argument" 1>&2; | |
| return 1 | |
| ;; | |
| esac; | |
| let "OPTIND += 1"; | |
| done; | |
| __get_cword_at_cursor_by_ref "$exclude" words cword cur; | |
| [[ -n $vcur ]] && { | |
| upvars+=("$vcur"); | |
| upargs+=(-v $vcur "$cur") | |
| }; | |
| [[ -n $vcword ]] && { | |
| upvars+=("$vcword"); | |
| upargs+=(-v $vcword "$cword") | |
| }; | |
| [[ -n $vprev && $cword -ge 1 ]] && { | |
| upvars+=("$vprev"); | |
| upargs+=(-v $vprev "${words[cword - 1]}") | |
| }; | |
| [[ -n $vwords ]] && { | |
| upvars+=("$vwords"); | |
| upargs+=(-a${#words[@]} $vwords "${words[@]}") | |
| }; | |
| (( ${#upvars[@]} )) && local "${upvars[@]}" && _upvars "${upargs[@]}" | |
| } | |
| _get_cword () | |
| { | |
| local LC_CTYPE=C; | |
| local cword words; | |
| __reassemble_comp_words_by_ref "$1" words cword; | |
| if [[ -n ${2//[^0-9]/} ]]; then | |
| printf "%s" "${words[cword-$2]}"; | |
| else | |
| if [[ "${#words[cword]}" -eq 0 || "$COMP_POINT" == "${#COMP_LINE}" ]]; then | |
| printf "%s" "${words[cword]}"; | |
| else | |
| local i; | |
| local cur="$COMP_LINE"; | |
| local index="$COMP_POINT"; | |
| for ((i = 0; i <= cword; ++i )) | |
| do | |
| while [[ "${#cur}" -ge ${#words[i]} && "${cur:0:${#words[i]}}" != "${words[i]}" ]]; do | |
| cur="${cur:1}"; | |
| ((index--)); | |
| done; | |
| if [[ "$i" -lt "$cword" ]]; then | |
| local old_size="${#cur}"; | |
| cur="${cur#${words[i]}}"; | |
| local new_size="${#cur}"; | |
| index=$(( index - old_size + new_size )); | |
| fi; | |
| done; | |
| if [[ "${words[cword]:0:${#cur}}" != "$cur" ]]; then | |
| printf "%s" "${words[cword]}"; | |
| else | |
| printf "%s" "${cur:0:$index}"; | |
| fi; | |
| fi; | |
| fi | |
| } | |
| _get_first_arg () | |
| { | |
| local i; | |
| arg=; | |
| for ((i=1; i < COMP_CWORD; i++ )) | |
| do | |
| if [[ "${COMP_WORDS[i]}" != -* ]]; then | |
| arg=${COMP_WORDS[i]}; | |
| break; | |
| fi; | |
| done | |
| } | |
| _get_pword () | |
| { | |
| if [[ $COMP_CWORD -ge 1 ]]; then | |
| _get_cword "${@:-}" 1; | |
| fi | |
| } | |
| _gids () | |
| { | |
| if type getent &> /dev/null; then | |
| COMPREPLY=($( compgen -W '$( getent group | cut -d: -f3 )' -- "$cur" )); | |
| else | |
| if type perl &> /dev/null; then | |
| COMPREPLY=($( compgen -W '$( perl -e '"'"'while (($gid) = (getgrent)[2]) { print $gid . "\n" }'"'"' )' -- "$cur" )); | |
| else | |
| COMPREPLY=($( compgen -W '$( cut -d: -f3 /etc/group )' -- "$cur" )); | |
| fi; | |
| fi | |
| } | |
| _grub_editenv () | |
| { | |
| local cur prev; | |
| COMPREPLY=(); | |
| cur=`_get_cword`; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| case "$prev" in | |
| create | list | set | unset) | |
| COMPREPLY=(""); | |
| return | |
| ;; | |
| esac; | |
| __grubcomp "$(__grub_get_options_from_help) | |
| create list set unset" | |
| } | |
| _grub_install () | |
| { | |
| local cur prev last split=false; | |
| COMPREPLY=(); | |
| cur=`_get_cword`; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| last=$(__grub_get_last_option); | |
| _split_longopt && split=true; | |
| case "$prev" in | |
| --boot-directory) | |
| _filedir -d; | |
| return | |
| ;; | |
| --disk-module) | |
| __grubcomp "biosdisk ata"; | |
| return | |
| ;; | |
| esac; | |
| $split && return 0; | |
| if [[ "$cur" == -* ]]; then | |
| __grubcomp "$(__grub_get_options_from_help)"; | |
| else | |
| case "$last" in | |
| --modules) | |
| __grub_list_modules; | |
| return | |
| ;; | |
| esac; | |
| _filedir; | |
| fi | |
| } | |
| _grub_mkconfig () | |
| { | |
| local cur prev; | |
| COMPREPLY=(); | |
| cur=`_get_cword`; | |
| if [[ "$cur" == -* ]]; then | |
| __grubcomp "$(__grub_get_options_from_help)"; | |
| else | |
| _filedir; | |
| fi | |
| } | |
| _grub_mkfont () | |
| { | |
| local cur; | |
| COMPREPLY=(); | |
| cur=`_get_cword`; | |
| if [[ "$cur" == -* ]]; then | |
| __grubcomp "$(__grub_get_options_from_help)"; | |
| else | |
| _filedir; | |
| fi | |
| } | |
| _grub_mkimage () | |
| { | |
| local cur prev split=false; | |
| COMPREPLY=(); | |
| cur=`_get_cword`; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| _split_longopt && split=true; | |
| case "$prev" in | |
| -d | --directory | -p | --prefix) | |
| _filedir -d; | |
| return | |
| ;; | |
| -O | --format) | |
| local prog=${COMP_WORDS[0]}; | |
| __grubcomp "$(LC_ALL=C $prog --help | awk -F ":" '/available formats/ { print $2 }' | sed 's/, / /g')"; | |
| return | |
| ;; | |
| esac; | |
| $split && return 0; | |
| if [[ "$cur" == -* ]]; then | |
| __grubcomp "$(__grub_get_options_from_help)"; | |
| else | |
| _filedir; | |
| fi | |
| } | |
| _grub_mkpasswd_pbkdf2 () | |
| { | |
| local cur; | |
| COMPREPLY=(); | |
| cur=`_get_cword`; | |
| if [[ "$cur" == -* ]]; then | |
| __grubcomp "$(__grub_get_options_from_help)"; | |
| else | |
| _filedir; | |
| fi | |
| } | |
| _grub_mkrescue () | |
| { | |
| local cur prev last; | |
| COMPREPLY=(); | |
| cur=`_get_cword`; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| last=$(__grub_get_last_option); | |
| if [[ "$cur" == -* ]]; then | |
| __grubcomp "$(__grub_get_options_from_help)"; | |
| else | |
| case "$last" in | |
| --modules) | |
| __grub_list_modules; | |
| return | |
| ;; | |
| esac; | |
| _filedir; | |
| fi | |
| } | |
| _grub_probe () | |
| { | |
| local cur prev split=false; | |
| COMPREPLY=(); | |
| cur=`_get_cword`; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| _split_longopt && split=true; | |
| case "$prev" in | |
| -t | --target) | |
| local prog=${COMP_WORDS[0]}; | |
| __grubcomp "$(LC_ALL=C $prog --help | awk -F "[()]" '/--target=/ { print $2 }' | sed 's/|/ /g')"; | |
| return | |
| ;; | |
| esac; | |
| $split && return 0; | |
| if [[ "$cur" == -* ]]; then | |
| __grubcomp "$(__grub_get_options_from_help)"; | |
| else | |
| _filedir; | |
| fi | |
| } | |
| _grub_script_check () | |
| { | |
| local cur; | |
| COMPREPLY=(); | |
| cur=`_get_cword`; | |
| if [[ "$cur" == -* ]]; then | |
| __grubcomp "$(__grub_get_options_from_help)"; | |
| else | |
| _filedir; | |
| fi | |
| } | |
| _grub_set_entry () | |
| { | |
| local cur prev split=false; | |
| COMPREPLY=(); | |
| cur=`_get_cword`; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| _split_longopt && split=true; | |
| case "$prev" in | |
| --boot-directory) | |
| _filedir -d; | |
| return | |
| ;; | |
| esac; | |
| $split && return 0; | |
| if [[ "$cur" == -* ]]; then | |
| __grubcomp "$(__grub_get_options_from_help)"; | |
| else | |
| __grub_list_menuentries; | |
| fi | |
| } | |
| _grub_setup () | |
| { | |
| local cur prev split=false; | |
| COMPREPLY=(); | |
| cur=`_get_cword`; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| _split_longopt && split=true; | |
| case "$prev" in | |
| -d | --directory) | |
| _filedir -d; | |
| return | |
| ;; | |
| esac; | |
| $split && return 0; | |
| if [[ "$cur" == -* ]]; then | |
| __grubcomp "$(__grub_get_options_from_help)"; | |
| else | |
| _filedir; | |
| fi | |
| } | |
| _have () | |
| { | |
| PATH=$PATH:/usr/sbin:/sbin:/usr/local/sbin type $1 &> /dev/null | |
| } | |
| _init_completion () | |
| { | |
| local exclude= flag outx errx inx OPTIND=1; | |
| while getopts "n:e:o:i:s" flag "$@"; do | |
| case $flag in | |
| n) | |
| exclude+=$OPTARG | |
| ;; | |
| e) | |
| errx=$OPTARG | |
| ;; | |
| o) | |
| outx=$OPTARG | |
| ;; | |
| i) | |
| inx=$OPTARG | |
| ;; | |
| s) | |
| split=false; | |
| exclude+== | |
| ;; | |
| esac; | |
| done; | |
| COMPREPLY=(); | |
| local redir="@(?([0-9])<|?([0-9&])>?(>)|>&)"; | |
| _get_comp_words_by_ref -n "$exclude<>&" cur prev words cword; | |
| _variables && return 1; | |
| if [[ $cur == $redir* || $prev == $redir ]]; then | |
| local xspec; | |
| case $cur in | |
| 2'>'*) | |
| xspec=$errx | |
| ;; | |
| *'>'*) | |
| xspec=$outx | |
| ;; | |
| *'<'*) | |
| xspec=$inx | |
| ;; | |
| *) | |
| case $prev in | |
| 2'>'*) | |
| xspec=$errx | |
| ;; | |
| *'>'*) | |
| xspec=$outx | |
| ;; | |
| *'<'*) | |
| xspec=$inx | |
| ;; | |
| esac | |
| ;; | |
| esac; | |
| cur="${cur##$redir}"; | |
| _filedir $xspec; | |
| return 1; | |
| fi; | |
| local i skip; | |
| for ((i=1; i < ${#words[@]}; 1)) | |
| do | |
| if [[ ${words[i]} == $redir* ]]; then | |
| [[ ${words[i]} == $redir ]] && skip=2 || skip=1; | |
| words=("${words[@]:0:i}" "${words[@]:i+skip}"); | |
| [[ $i -le $cword ]] && cword=$(( cword - skip )); | |
| else | |
| i=$(( ++i )); | |
| fi; | |
| done; | |
| [[ $cword -le 0 ]] && return 1; | |
| prev=${words[cword-1]}; | |
| [[ -n ${split-} ]] && _split_longopt && split=true; | |
| return 0 | |
| } | |
| _insserv () | |
| { | |
| local cur prev sysvdir services options; | |
| cur=`_get_cword`; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d || sysvdir=/etc/init.d; | |
| services=($(echo $sysvdir/!(README*|*.dpkg*|*.rpm@(orig|new|save)))); | |
| services=(${services[@]#$sysvdir/}); | |
| options=(-c --config -d -f -n -o --override -p --path -r -v); | |
| case "$prev" in | |
| -c | --config) | |
| _filedir | |
| ;; | |
| -o | --override | -p | --path) | |
| _filedir -d | |
| ;; | |
| *) | |
| COMPREPLY=($( compgen -W '${options[@]} ${services[@]}' -- $cur )) | |
| ;; | |
| esac; | |
| return 0 | |
| } | |
| _installed_modules () | |
| { | |
| COMPREPLY=($( compgen -W "$( PATH="$PATH:/sbin" lsmod | awk '{if (NR != 1) print $1}' )" -- "$1" )) | |
| } | |
| _ip_addresses () | |
| { | |
| local PATH=$PATH:/sbin; | |
| COMPREPLY+=($( compgen -W "$( { LC_ALL=C ifconfig -a || ip addr show; } 2>/dev/null | | |
| sed -ne 's/.*addr:\([^[:space:]]*\).*/\1/p' -ne 's|.*inet[[:space:]]\{1,\}\([^[:space:]/]*\).*|\1|p' )" -- "$cur" )) | |
| } | |
| _kernel_versions () | |
| { | |
| COMPREPLY=($( compgen -W '$( command ls /lib/modules )' -- "$cur" )) | |
| } | |
| _kernels () | |
| { | |
| COMPREPLY=($( cd /lib/modules && compgen -d -- "$cur" )) | |
| } | |
| _known_hosts () | |
| { | |
| local cur prev words cword; | |
| _init_completion -n : || return; | |
| local options; | |
| [[ "$1" == -a || "$2" == -a ]] && options=-a; | |
| [[ "$1" == -c || "$2" == -c ]] && options+=" -c"; | |
| _known_hosts_real $options -- "$cur" | |
| } | |
| _known_hosts_real () | |
| { | |
| local configfile flag prefix; | |
| local cur curd awkcur user suffix aliases i host; | |
| local -a kh khd config; | |
| local OPTIND=1; | |
| while getopts "acF:p:" flag "$@"; do | |
| case $flag in | |
| a) | |
| aliases='yes' | |
| ;; | |
| c) | |
| suffix=':' | |
| ;; | |
| F) | |
| configfile=$OPTARG | |
| ;; | |
| p) | |
| prefix=$OPTARG | |
| ;; | |
| esac; | |
| done; | |
| [[ $# -lt $OPTIND ]] && echo "error: $FUNCNAME: missing mandatory argument CWORD"; | |
| cur=${!OPTIND}; | |
| let "OPTIND += 1"; | |
| [[ $# -ge $OPTIND ]] && echo "error: $FUNCNAME("$@"): unprocessed arguments:" $(while [[ $# -ge $OPTIND ]]; do printf '%s\n' ${!OPTIND}; shift; done); | |
| [[ $cur == *@* ]] && user=${cur%@*}@ && cur=${cur#*@}; | |
| kh=(); | |
| if [[ -n $configfile ]]; then | |
| [[ -r $configfile ]] && config+=("$configfile"); | |
| else | |
| for i in /etc/ssh/ssh_config ~/.ssh/config ~/.ssh2/config; | |
| do | |
| [[ -r $i ]] && config+=("$i"); | |
| done; | |
| fi; | |
| if [[ ${#config[@]} -gt 0 ]]; then | |
| local OIFS=$IFS IFS=' | |
| ' j; | |
| local -a tmpkh; | |
| tmpkh=($( awk 'sub("^[ \t]*([Gg][Ll][Oo][Bb][Aa][Ll]|[Uu][Ss][Ee][Rr])[Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee][ \t]+", "") { print $0 }' "${config[@]}" | sort -u )); | |
| IFS=$OIFS; | |
| for i in "${tmpkh[@]}"; | |
| do | |
| while [[ $i =~ ^([^\"]*)\"([^\"]*)\"(.*)$ ]]; do | |
| i=${BASH_REMATCH[1]}${BASH_REMATCH[3]}; | |
| j=${BASH_REMATCH[2]}; | |
| __expand_tilde_by_ref j; | |
| [[ -r $j ]] && kh+=("$j"); | |
| done; | |
| for j in $i; | |
| do | |
| __expand_tilde_by_ref j; | |
| [[ -r $j ]] && kh+=("$j"); | |
| done; | |
| done; | |
| fi; | |
| if [[ -z $configfile ]]; then | |
| for i in /etc/ssh/ssh_known_hosts /etc/ssh/ssh_known_hosts2 /etc/known_hosts /etc/known_hosts2 ~/.ssh/known_hosts ~/.ssh/known_hosts2; | |
| do | |
| [[ -r $i ]] && kh+=("$i"); | |
| done; | |
| for i in /etc/ssh2/knownhosts ~/.ssh2/hostkeys; | |
| do | |
| [[ -d $i ]] && khd+=("$i"/*pub); | |
| done; | |
| fi; | |
| if [[ ${#kh[@]} -gt 0 || ${#khd[@]} -gt 0 ]]; then | |
| awkcur=${cur//\//\\\/}; | |
| awkcur=${awkcur//\./\\\.}; | |
| curd=$awkcur; | |
| if [[ "$awkcur" == [0-9]*[.:]* ]]; then | |
| awkcur="^$awkcur[.:]*"; | |
| else | |
| if [[ "$awkcur" == [0-9]* ]]; then | |
| awkcur="^$awkcur.*[.:]"; | |
| else | |
| if [[ -z $awkcur ]]; then | |
| awkcur="[a-z.:]"; | |
| else | |
| awkcur="^$awkcur"; | |
| fi; | |
| fi; | |
| fi; | |
| if [[ ${#kh[@]} -gt 0 ]]; then | |
| COMPREPLY+=($( awk 'BEGIN {FS=","} | |
| /^\s*[^|\#]/ { | |
| sub("^@[^ ]+ +", ""); \ | |
| sub(" .*$", ""); \ | |
| for (i=1; i<=NF; ++i) { \ | |
| sub("^\\[", "", $i); sub("\\](:[0-9]+)?$", "", $i); \ | |
| if ($i !~ /[*?]/ && $i ~ /'"$awkcur"'/) {print $i} \ | |
| }}' "${kh[@]}" 2>/dev/null )); | |
| fi; | |
| if [[ ${#khd[@]} -gt 0 ]]; then | |
| for i in "${khd[@]}"; | |
| do | |
| if [[ "$i" == *key_22_$curd*.pub && -r "$i" ]]; then | |
| host=${i/#*key_22_/}; | |
| host=${host/%.pub/}; | |
| COMPREPLY+=($host); | |
| fi; | |
| done; | |
| fi; | |
| for ((i=0; i < ${#COMPREPLY[@]}; i++ )) | |
| do | |
| COMPREPLY[i]=$prefix$user${COMPREPLY[i]}$suffix; | |
| done; | |
| fi; | |
| if [[ ${#config[@]} -gt 0 && -n "$aliases" ]]; then | |
| local hosts=$( sed -ne 's/^[ \t]*[Hh][Oo][Ss][Tt]\([Nn][Aa][Mm][Ee]\)\{0,1\}['"$'\t '"']\{1,\}\([^#*?]*\)\(#.*\)\{0,1\}$/\2/p' "${config[@]}" ); | |
| COMPREPLY+=($( compgen -P "$prefix$user" -S "$suffix" -W "$hosts" -- "$cur" )); | |
| fi; | |
| COMPREPLY+=($( compgen -W "$( ruptime 2>/dev/null | awk '!/^ruptime:/ { print $1 }' )" -- "$cur" )); | |
| if [[ -n ${COMP_KNOWN_HOSTS_WITH_HOSTFILE-1} ]]; then | |
| COMPREPLY+=($( compgen -A hostname -P "$prefix$user" -S "$suffix" -- "$cur" )); | |
| fi; | |
| __ltrim_colon_completions "$prefix$user$cur"; | |
| return 0 | |
| } | |
| _longopt () | |
| { | |
| local cur prev words cword split; | |
| _init_completion -s || return; | |
| case "${prev,,}" in | |
| --help | --usage | --version) | |
| return 0 | |
| ;; | |
| --*dir*) | |
| _filedir -d; | |
| return 0 | |
| ;; | |
| --*file* | --*path*) | |
| _filedir; | |
| return 0 | |
| ;; | |
| --+([-a-z0-9_])) | |
| local argtype=$( $1 --help 2>&1 | sed -ne "s|.*$prev\[\{0,1\}=[<[]\{0,1\}\([-A-Za-z0-9_]\{1,\}\).*|\1|p" ); | |
| case ${argtype,,} in | |
| *dir*) | |
| _filedir -d; | |
| return 0 | |
| ;; | |
| *file* | *path*) | |
| _filedir; | |
| return 0 | |
| ;; | |
| esac | |
| ;; | |
| esac; | |
| $split && return 0; | |
| if [[ "$cur" == -* ]]; then | |
| COMPREPLY=($( compgen -W "$( $1 --help 2>&1 | sed -ne 's/.*\(--[-A-Za-z0-9]\{1,\}=\{0,1\}\).*/\1/p' | sort -u )" -- "$cur" )); | |
| [[ $COMPREPLY == *= ]] && compopt -o nospace; | |
| else | |
| if [[ "$1" == @(mk|rm)dir ]]; then | |
| _filedir -d; | |
| else | |
| _filedir; | |
| fi; | |
| fi | |
| } | |
| _lynis () | |
| { | |
| local cur prev; | |
| COMPREPLY=(); | |
| _get_comp_words_by_ref cur prev; | |
| if [ $COMP_CWORD -eq 1 ]; then | |
| case $cur in | |
| -*) | |
| COMPREPLY=($( compgen -W '--check-all --help --info --version' -- "$cur" )) | |
| ;; | |
| *) | |
| COMPREPLY=($( compgen -W '--check-all --help --info --version' -- "$cur" )) | |
| ;; | |
| esac; | |
| return 0; | |
| fi; | |
| case $prev in | |
| --auditor) | |
| COMPREPLY=('"Mr. Auditor"'); | |
| return 0 | |
| ;; | |
| --check-update | --help | --info | --version) | |
| return 0 | |
| ;; | |
| --logfile) | |
| COMPREPLY=('myfile.log'); | |
| return 0 | |
| ;; | |
| --plugin-dir) | |
| _filedir -d; | |
| return 0 | |
| ;; | |
| --profile) | |
| COMPREPLY=('default.prf'); | |
| return 0 | |
| ;; | |
| --tests) | |
| COMPREPLY=('"TEST-0001 TEST-0002 TEST-0003"'); | |
| return 0 | |
| ;; | |
| --tests-category) | |
| COMPREPLY=('"accounting authentication"'); | |
| return 0 | |
| ;; | |
| *) | |
| COMPREPLY=($( compgen -W ' \ | |
| --auditor --cronjob --debug --quick --quiet --logfile --no-colors --no-log --pentest --reverse-colors \ | |
| --tests --tests-category --upload --view-categories' -- "$cur" )) | |
| ;; | |
| esac; | |
| return 0 | |
| } | |
| _mac_addresses () | |
| { | |
| local re='\([A-Fa-f0-9]\{2\}:\)\{5\}[A-Fa-f0-9]\{2\}'; | |
| local PATH="$PATH:/sbin:/usr/sbin"; | |
| COMPREPLY+=($( { LC_ALL=C ifconfig -a || ip link show; } 2>/dev/null | sed -ne "s/.*[[:space:]]HWaddr[[:space:]]\{1,\}\($re\)[[:space:]].*/\1/p" -ne "s/.*[[:space:]]HWaddr[[:space:]]\{1,\}\($re\)[[:space:]]*$/\1/p" -ne "s|.*[[:space:]]\(link/\)\{0,1\}ether[[:space:]]\{1,\}\($re\)[[:space:]].*|\2|p" -ne "s|.*[[:space:]]\(link/\)\{0,1\}ether[[:space:]]\{1,\}\($re\)[[:space:]]*$|\2|p" | |
| )); | |
| COMPREPLY+=($( { arp -an || ip neigh show; } 2>/dev/null | sed -ne "s/.*[[:space:]]\($re\)[[:space:]].*/\1/p" -ne "s/.*[[:space:]]\($re\)[[:space:]]*$/\1/p" )); | |
| COMPREPLY+=($( sed -ne "s/^[[:space:]]*\($re\)[[:space:]].*/\1/p" /etc/ethers 2>/dev/null )); | |
| COMPREPLY=($( compgen -W '${COMPREPLY[@]}' -- "$cur" )); | |
| __ltrim_colon_completions "$cur" | |
| } | |
| _mdb_export () | |
| { | |
| local cur prev; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| if [[ "$prev" == -@(d|R|q|X|D|N) ]]; then | |
| return 0; | |
| else | |
| if [[ "$prev" == -I ]]; then | |
| COMPREPLY=($( compgen -W 'access sybase oracle postgres mysql' -- $cur )); | |
| else | |
| if [[ "$cur" == -* ]]; then | |
| COMPREPLY=($( compgen -W '-T -H -d -R -Q -q -X -I -D -N' -- $cur )); | |
| else | |
| if [[ "$prev" == *@(mdb|mdw|accdb) ]]; then | |
| local dbname; | |
| local tablenames; | |
| dbname=$prev; | |
| __expand_tilde_by_ref dbname; | |
| tablenames=$(eval mdb-tables -S -d / "${dbname}" 2>/dev/null); | |
| COMPREPLY=($( IFS=/ compgen -W "${tablenames}" -- $cur )); | |
| else | |
| _filedir '@(mdb|mdw|accdb)'; | |
| fi; | |
| fi; | |
| fi; | |
| fi; | |
| return 0 | |
| } | |
| _mdb_hexdump () | |
| { | |
| local cur; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| if (( COMP_CWORD == 1 )); then | |
| _filedir '@(mdb|mdw|accdb)'; | |
| fi; | |
| return 0 | |
| } | |
| _mdb_parsecsv () | |
| { | |
| local cur; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| if (( COMP_CWORD == 1 )); then | |
| _filedir '@(txt|csv)'; | |
| fi; | |
| return 0 | |
| } | |
| _mdb_prop () | |
| { | |
| local cur; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| if (( COMP_CWORD == 1 )); then | |
| _filedir '@(mdb|mdw|accdb)'; | |
| else | |
| if (( COMP_CWORD == 2 )); then | |
| local dbname; | |
| local tablenames; | |
| dbname=${COMP_WORDS[1]}; | |
| __expand_tilde_by_ref dbname; | |
| tablenames=$(eval mdb-tables -S -d / "${dbname}" 2>/dev/null); | |
| COMPREPLY=($( IFS=/ compgen -W "${tablenames}" -- $cur )); | |
| else | |
| if (( COMP_CWORD == 3 )); then | |
| COMPREPLY=($( compgen -W 'Lv LvProp LvModule LvExtra' -- $cur )); | |
| fi; | |
| fi; | |
| fi; | |
| return 0 | |
| } | |
| _mdb_schema () | |
| { | |
| local cur prev; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| if [[ "$prev" == -@(T|table|N) ]]; then | |
| return 0; | |
| else | |
| if [[ "$cur" == -* ]]; then | |
| COMPREPLY=($( compgen -W '-T --table -N \ | |
| --drop-table --no-drop-table \ | |
| --not-null --no-not-null \ | |
| --default-values --no-default-values \ | |
| --not-empty --no-not-empty \ | |
| --indexes --no-indexes \ | |
| --relations --no-relations' -- $cur )); | |
| else | |
| if [[ "$prev" == @(*mdb|*mdw|*accdb) ]]; then | |
| COMPREPLY=($( compgen -W 'access sybase oracle postgres mysql' -- $cur )); | |
| else | |
| _filedir '@(mdb|mdw|accdb)'; | |
| fi; | |
| fi; | |
| fi; | |
| return 0 | |
| } | |
| _mdb_sql () | |
| { | |
| local cur prev; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| if [[ "$prev" == -d ]]; then | |
| return 0; | |
| else | |
| if [[ "$prev" == -@(i|o) ]]; then | |
| _filedir; | |
| else | |
| if [[ "$cur" == -* ]]; then | |
| COMPREPLY=($( compgen -W '-H -f -p -d -i -o' -- $cur )); | |
| else | |
| _filedir '@(mdb|mdw|accdb)'; | |
| fi; | |
| fi; | |
| fi; | |
| return 0 | |
| } | |
| _mdb_tables () | |
| { | |
| local cur prev; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| if [[ "$prev" == -d ]]; then | |
| return 0; | |
| else | |
| if [[ "$prev" == -t ]]; then | |
| COMPREPLY=($( compgen -W 'form table macro systable report query linkedtable module relationship dbprop any all' -- $cur )); | |
| return 0; | |
| else | |
| if [[ "$cur" == -* ]]; then | |
| COMPREPLY=($( compgen -W '-S -1 -d -t' -- $cur )); | |
| else | |
| _filedir '@(mdb|mdw|accdb)'; | |
| fi; | |
| fi; | |
| fi; | |
| return 0 | |
| } | |
| _mdb_ver () | |
| { | |
| local cur; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| if [[ "$cur" == -* ]]; then | |
| COMPREPLY=($( compgen -W '-M' -- $cur )); | |
| else | |
| _filedir '@(mdb|mdw|accdb)'; | |
| fi; | |
| return 0 | |
| } | |
| _minimal () | |
| { | |
| local cur prev words cword split; | |
| _init_completion -s || return; | |
| $split && return; | |
| _filedir | |
| } | |
| _modules () | |
| { | |
| local modpath; | |
| modpath=/lib/modules/$1; | |
| COMPREPLY=($( compgen -W "$( command ls -RL $modpath 2>/dev/null | sed -ne 's/^\(.*\)\.k\{0,1\}o\(\.[gx]z\)\{0,1\}$/\1/p' )" -- "$cur" )) | |
| } | |
| _ncpus () | |
| { | |
| local var=NPROCESSORS_ONLN; | |
| [[ $OSTYPE == *linux* ]] && var=_$var; | |
| local n=$( getconf $var 2>/dev/null ); | |
| printf %s ${n:-1} | |
| } | |
| _openvpn () | |
| { | |
| local cur; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| if [ $COMP_CWORD -eq 1 ]; then | |
| COMPREPLY=($( compgen -W '$( /etc/init.d/openvpn 2>&1 \ | |
| | cut -d"{" -f2 | tr -d "}" | tr "|" " " )' -- $cur )); | |
| else | |
| COMPREPLY=($( compgen -W '$( command ls /etc/openvpn/*.conf 2>/dev/null \ | |
| | sed -e 's%/etc/openvpn/%%' -e 's/\.conf//' )' -- $cur )); | |
| fi | |
| } | |
| _parse_help () | |
| { | |
| eval local cmd=$( quote "$1" ); | |
| local line; | |
| { | |
| case $cmd in | |
| -) | |
| cat | |
| ;; | |
| *) | |
| LC_ALL=C "$( dequote "$cmd" )" ${2:---help} 2>&1 | |
| ;; | |
| esac | |
| } | while read -r line; do | |
| [[ $line == *([ ' '])-* ]] || continue; | |
| while [[ $line =~ ((^|[^-])-[A-Za-z0-9?][[:space:]]+)\[?[A-Z0-9]+\]? ]]; do | |
| line=${line/"${BASH_REMATCH[0]}"/"${BASH_REMATCH[1]}"}; | |
| done; | |
| __parse_options "${line// or /, }"; | |
| done | |
| } | |
| _parse_usage () | |
| { | |
| eval local cmd=$( quote "$1" ); | |
| local line match option i char; | |
| { | |
| case $cmd in | |
| -) | |
| cat | |
| ;; | |
| *) | |
| LC_ALL=C "$( dequote "$cmd" )" ${2:---usage} 2>&1 | |
| ;; | |
| esac | |
| } | while read -r line; do | |
| while [[ $line =~ \[[[:space:]]*(-[^]]+)[[:space:]]*\] ]]; do | |
| match=${BASH_REMATCH[0]}; | |
| option=${BASH_REMATCH[1]}; | |
| case $option in | |
| -?(\[)+([a-zA-Z0-9?])) | |
| for ((i=1; i < ${#option}; i++ )) | |
| do | |
| char=${option:i:1}; | |
| [[ $char != '[' ]] && printf '%s\n' -$char; | |
| done | |
| ;; | |
| *) | |
| __parse_options "$option" | |
| ;; | |
| esac; | |
| line=${line#*"$match"}; | |
| done; | |
| done | |
| } | |
| _paster () | |
| { | |
| local cur prev paster_options commands; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| paster_options='-h --help -v --version --plugin'; | |
| commands="$(python -c 'from paste.script.command import get_commands; print " ".join(get_commands().keys())' 2>/dev/null)"; | |
| case ${COMP_WORDS[1]} in | |
| -h | --help | -v | --version) | |
| COMPREPLY=() | |
| ;; | |
| help) | |
| COMPREPLY=($( compgen -W "$commands" | grep "^$cur" )) | |
| ;; | |
| serve) | |
| COMPREPLY=($( compgen -G "${cur}*.ini" -W "$(paster help serve 2>/dev/null | grep -o '\-\{1,2\}[a-zA-Z][-a-zA-Z]*')" | grep "^$cur" )) | |
| ;; | |
| *) | |
| COMPREPLY=($( compgen -W "$paster_options $commands" | grep "^$cur" )) | |
| ;; | |
| esac; | |
| return 0 | |
| } | |
| _pci_ids () | |
| { | |
| COMPREPLY+=($( compgen -W "$( PATH="$PATH:/sbin" lspci -n | awk '{print $3}')" -- "$cur" )) | |
| } | |
| _pgids () | |
| { | |
| COMPREPLY=($( compgen -W '$( command ps axo pgid= )' -- "$cur" )) | |
| } | |
| _pids () | |
| { | |
| COMPREPLY=($( compgen -W '$( command ps axo pid= )' -- "$cur" )) | |
| } | |
| _pnames () | |
| { | |
| COMPREPLY=($( compgen -X '<defunct>' -W '$( command ps axo command= | \ | |
| sed -e "s/ .*//" -e "s:.*/::" -e "s/:$//" -e "s/^[[(-]//" \ | |
| -e "s/[])]$//" | sort -u )' -- "$cur" )) | |
| } | |
| _quote_readline_by_ref () | |
| { | |
| if [ -z "$1" ]; then | |
| printf -v $2 %s "$1"; | |
| else | |
| if [[ $1 == \'* ]]; then | |
| printf -v $2 %s "${1:1}"; | |
| else | |
| if [[ $1 == ~* ]]; then | |
| printf -v $2 ~%q "${1:1}"; | |
| else | |
| printf -v $2 %q "$1"; | |
| fi; | |
| fi; | |
| fi; | |
| [[ ${!2} == *\\* ]] && printf -v $2 %s "${1//\\\\/\\}"; | |
| [[ ${!2} == \$* ]] && eval $2=${!2} | |
| } | |
| _rake () | |
| { | |
| local cur prev rakef i; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| rakef="Rakefile"; | |
| if [[ "$prev" == "-f" ]]; then | |
| _filedir; | |
| return 0; | |
| fi; | |
| if [[ "$cur" == *=* ]]; then | |
| prev=${cur/=*/}; | |
| cur=${cur/*=/}; | |
| if [[ "$prev" == "--rakefile=" ]]; then | |
| _filedir -o nospace; | |
| return 0; | |
| fi; | |
| fi; | |
| if [[ "$cur" == -* ]]; then | |
| COMPREPLY=($( compgen -W '-n -H -I -N -P -q -f\ | |
| -r -s -T -t -h -v -V\ | |
| --dry-run --help '--libdir=' --nosearch --prereqs --quiet\ | |
| '--rakefile=' '--require=' --silent --tasks --trace --usage\ | |
| --verbose --version' -- $cur )); | |
| else | |
| for ((i=0; i < ${#COMP_WORDS[@]}; i++)) | |
| do | |
| case "${COMP_WORDS[i]}" in | |
| -f) | |
| eval rakef=${COMP_WORDS[i+1]}; | |
| break | |
| ;; | |
| --rakefile=* | --rakefile\=*) | |
| eval rakef=${COMP_WORDS[i]/*=/}; | |
| break | |
| ;; | |
| esac; | |
| done; | |
| [ ! -f $rakef ] && return 0; | |
| _get_comp_words_by_ref -n : cur; | |
| more_recent=`ls -1t .rake_tasks~ $rafefile */*/*.rake 2>/dev/null | head -n 1`; | |
| if [ "$more_recent" != ".rake_tasks~" ]; then | |
| rake -T | awk '{print($2)}' > .rake_tasks~; | |
| fi; | |
| tasks=$(cat .rake_tasks~); | |
| COMPREPLY=($(compgen -W "$tasks" -- "$cur")); | |
| __ltrim_colon_completions "$cur"; | |
| fi | |
| } | |
| _realcommand () | |
| { | |
| type -P "$1" > /dev/null && { | |
| if type -p realpath > /dev/null; then | |
| realpath "$(type -P "$1")"; | |
| else | |
| if type -p greadlink > /dev/null; then | |
| greadlink -f "$(type -P "$1")"; | |
| else | |
| if type -p readlink > /dev/null; then | |
| readlink -f "$(type -P "$1")"; | |
| else | |
| type -P "$1"; | |
| fi; | |
| fi; | |
| fi | |
| } | |
| } | |
| _redis-cli () | |
| { | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| opts='bgrewriteaof bgsave dbsize debug decr decrby del echo exists expire expireat flushall flushdb get getset incr incrby info keys lastsave lindex llen lpop lpush lrange lrem lset ltrim mget move mset msetnx ping randomkey rename renamenx rewriteaof rpop rpoplpush rpush sadd save scard sdiff sdiffstore select set setnx shutdown sinter sinterstore sismember slaveof smembers smove sort spop srandmember srem sunion sunionstore ttl type zadd zcard zincrby zrange zrangebyscore zrem zremrangebyscore zrevrange zscore'; | |
| if [ $COMP_CWORD -eq 1 ]; then | |
| COMPREPLY=($(compgen -W "${opts}" -- ${cur})); | |
| return 0; | |
| fi | |
| } | |
| _rl_enabled () | |
| { | |
| [[ "$( bind -v )" = *$1+([[:space:]])on* ]] | |
| } | |
| _root_command () | |
| { | |
| local PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin; | |
| local root_command=$1; | |
| _command | |
| } | |
| _service () | |
| { | |
| local cur prev words cword; | |
| _init_completion || return; | |
| [[ $cword -gt 2 ]] && return 0; | |
| if [[ $cword -eq 1 && $prev == ?(*/)service ]]; then | |
| _services; | |
| [[ -e /etc/mandrake-release ]] && _xinetd_services; | |
| else | |
| local sysvdirs; | |
| _sysvdirs; | |
| COMPREPLY=($( compgen -W '`sed -e "y/|/ /" \ | |
| -ne "s/^.*\(U\|msg_u\)sage.*{\(.*\)}.*$/\2/p" \ | |
| ${sysvdirs[0]}/${prev##*/} 2>/dev/null` start stop' -- "$cur" )); | |
| fi | |
| } | |
| _services () | |
| { | |
| local sysvdirs; | |
| _sysvdirs; | |
| local restore_nullglob=$(shopt -p nullglob); | |
| shopt -s nullglob; | |
| COMPREPLY=($( printf '%s\n' ${sysvdirs[0]}/!($_backup_glob|functions) )); | |
| $restore_nullglob; | |
| COMPREPLY+=($( systemctl list-units --full --all 2>/dev/null | awk '$1 ~ /\.service$/ { sub("\\.service$", "", $1); print $1 }' )); | |
| COMPREPLY=($( compgen -W '${COMPREPLY[@]#${sysvdirs[0]}/}' -- "$cur" )) | |
| } | |
| _shells () | |
| { | |
| local shell rest; | |
| while read -r shell rest; do | |
| [[ $shell == /* && $shell == "$cur"* ]] && COMPREPLY+=($shell); | |
| done 2> /dev/null < /etc/shells | |
| } | |
| _signals () | |
| { | |
| local -a sigs=($( compgen -P "$1" -A signal "SIG${cur#$1}" )); | |
| COMPREPLY+=("${sigs[@]/#${1}SIG/${1}}") | |
| } | |
| _split_longopt () | |
| { | |
| if [[ "$cur" == --?*=* ]]; then | |
| prev="${cur%%?(\\)=*}"; | |
| cur="${cur#*=}"; | |
| return 0; | |
| fi; | |
| return 1 | |
| } | |
| _subdirectories () | |
| { | |
| COMPREPLY=($( cd $1 && compgen -d -- "$cur" )) | |
| } | |
| _sysvdirs () | |
| { | |
| sysvdirs=(); | |
| [[ -d /etc/rc.d/init.d ]] && sysvdirs+=(/etc/rc.d/init.d); | |
| [[ -d /etc/init.d ]] && sysvdirs+=(/etc/init.d); | |
| [[ -f /etc/slackware-version ]] && sysvdirs=(/etc/rc.d) | |
| } | |
| _terms () | |
| { | |
| COMPREPLY+=($( compgen -W "$( sed -ne 's/^\([^[:space:]#|]\{2,\}\)|.*/\1/p' /etc/termcap 2>/dev/null )" -- "$cur" )); | |
| COMPREPLY+=($( compgen -W "$( { toe -a 2>/dev/null || toe 2>/dev/null; } | awk '{ print $1 }' | sort -u )" -- "$cur" )) | |
| } | |
| _tilde () | |
| { | |
| local result=0; | |
| if [[ $1 == \~* && $1 != */* ]]; then | |
| COMPREPLY=($( compgen -P '~' -u "${1#\~}" )); | |
| result=${#COMPREPLY[@]}; | |
| [[ $result -gt 0 ]] && compopt -o filenames 2> /dev/null; | |
| fi; | |
| return $result | |
| } | |
| _uids () | |
| { | |
| if type getent &> /dev/null; then | |
| COMPREPLY=($( compgen -W '$( getent passwd | cut -d: -f3 )' -- "$cur" )); | |
| else | |
| if type perl &> /dev/null; then | |
| COMPREPLY=($( compgen -W '$( perl -e '"'"'while (($uid) = (getpwent)[2]) { print $uid . "\n" }'"'"' )' -- "$cur" )); | |
| else | |
| COMPREPLY=($( compgen -W '$( cut -d: -f3 /etc/passwd )' -- "$cur" )); | |
| fi; | |
| fi | |
| } | |
| _update_initramfs () | |
| { | |
| local cur prev valid_options; | |
| cur=$(_get_cword); | |
| prev=${COMP_WORDS[COMP_CWORD-1]}; | |
| if [[ "$prev" == '-k' ]]; then | |
| _kernel_versions; | |
| COMPREPLY=($( compgen -W '${COMPREPLY[@]} all' -- "$cur" )); | |
| return; | |
| fi; | |
| valid_options=$( update-initramfs -h 2>&1 | sed -e '/^ -/!d;s/^ \(-\w\+\).*/\1/' ); | |
| COMPREPLY=($( compgen -W "$valid_options" -- $cur )) | |
| } | |
| _upvar () | |
| { | |
| if unset -v "$1"; then | |
| if (( $# == 2 )); then | |
| eval $1=\"\$2\"; | |
| else | |
| eval $1=\(\"\${@:2}\"\); | |
| fi; | |
| fi | |
| } | |
| _upvars () | |
| { | |
| if ! (( $# )); then | |
| echo "${FUNCNAME[0]}: usage: ${FUNCNAME[0]} [-v varname" "value] | [-aN varname [value ...]] ..." 1>&2; | |
| return 2; | |
| fi; | |
| while (( $# )); do | |
| case $1 in | |
| -a*) | |
| [[ -n ${1#-a} ]] || { | |
| echo "bash: ${FUNCNAME[0]}: \`$1': missing" "number specifier" 1>&2; | |
| return 1 | |
| }; | |
| printf %d "${1#-a}" &> /dev/null || { | |
| echo "bash:" "${FUNCNAME[0]}: \`$1': invalid number specifier" 1>&2; | |
| return 1 | |
| }; | |
| [[ -n "$2" ]] && unset -v "$2" && eval $2=\(\"\${@:3:${1#-a}}\"\) && shift $((${1#-a} + 2)) || { | |
| echo "bash: ${FUNCNAME[0]}:" "\`$1${2+ }$2': missing argument(s)" 1>&2; | |
| return 1 | |
| } | |
| ;; | |
| -v) | |
| [[ -n "$2" ]] && unset -v "$2" && eval $2=\"\$3\" && shift 3 || { | |
| echo "bash: ${FUNCNAME[0]}: $1: missing" "argument(s)" 1>&2; | |
| return 1 | |
| } | |
| ;; | |
| *) | |
| echo "bash: ${FUNCNAME[0]}: $1: invalid option" 1>&2; | |
| return 1 | |
| ;; | |
| esac; | |
| done | |
| } | |
| _usb_ids () | |
| { | |
| COMPREPLY+=($( compgen -W "$( PATH="$PATH:/sbin" lsusb | awk '{print $6}' )" -- "$cur" )) | |
| } | |
| _user_at_host () | |
| { | |
| local cur prev words cword; | |
| _init_completion -n : || return; | |
| if [[ $cur == *@* ]]; then | |
| _known_hosts_real "$cur"; | |
| else | |
| COMPREPLY=($( compgen -u -- "$cur" )); | |
| fi; | |
| return 0 | |
| } | |
| _usergroup () | |
| { | |
| if [[ $cur = *\\\\* || $cur = *:*:* ]]; then | |
| return; | |
| else | |
| if [[ $cur = *\\:* ]]; then | |
| local prefix; | |
| prefix=${cur%%*([^:])}; | |
| prefix=${prefix//\\}; | |
| local mycur="${cur#*[:]}"; | |
| if [[ $1 == -u ]]; then | |
| _allowed_groups "$mycur"; | |
| else | |
| local IFS=' | |
| '; | |
| COMPREPLY=($( compgen -g -- "$mycur" )); | |
| fi; | |
| COMPREPLY=($( compgen -P "$prefix" -W "${COMPREPLY[@]}" )); | |
| else | |
| if [[ $cur = *:* ]]; then | |
| local mycur="${cur#*:}"; | |
| if [[ $1 == -u ]]; then | |
| _allowed_groups "$mycur"; | |
| else | |
| local IFS=' | |
| '; | |
| COMPREPLY=($( compgen -g -- "$mycur" )); | |
| fi; | |
| else | |
| if [[ $1 == -u ]]; then | |
| _allowed_users "$cur"; | |
| else | |
| local IFS=' | |
| '; | |
| COMPREPLY=($( compgen -u -- "$cur" )); | |
| fi; | |
| fi; | |
| fi; | |
| fi | |
| } | |
| _userland () | |
| { | |
| local userland=$( uname -s ); | |
| [[ $userland == @(Linux|GNU/*) ]] && userland=GNU; | |
| [[ $userland == $1 ]] | |
| } | |
| _variables () | |
| { | |
| if [[ $cur =~ ^(\$\{?)([A-Za-z0-9_]*)$ ]]; then | |
| [[ $cur == *{* ]] && local suffix=} || local suffix=; | |
| COMPREPLY+=($( compgen -P ${BASH_REMATCH[1]} -S "$suffix" -v -- "${BASH_REMATCH[2]}" )); | |
| return 0; | |
| fi; | |
| return 1 | |
| } | |
| _weboob () | |
| { | |
| local cur args; | |
| COMPREPLY=(); | |
| cur=${COMP_WORDS[COMP_CWORD]}; | |
| args="$(${COMP_WORDS[0]} --shell-completion)"; | |
| COMPREPLY=($(compgen -o default -W "${args}" -- "$cur" )) | |
| } | |
| _xfunc () | |
| { | |
| set -- "$@"; | |
| local srcfile=$1; | |
| shift; | |
| declare -F $1 &> /dev/null || { | |
| local compdir=./completions; | |
| [[ $BASH_SOURCE == */* ]] && compdir="${BASH_SOURCE%/*}/completions"; | |
| . "$compdir/$srcfile" | |
| }; | |
| "$@" | |
| } | |
| _xinetd_services () | |
| { | |
| local xinetddir=/etc/xinetd.d; | |
| if [[ -d $xinetddir ]]; then | |
| local restore_nullglob=$(shopt -p nullglob); | |
| shopt -s nullglob; | |
| local -a svcs=($( printf '%s\n' $xinetddir/!($_backup_glob) )); | |
| $restore_nullglob; | |
| COMPREPLY+=($( compgen -W '${svcs[@]#$xinetddir/}' -- "$cur" )); | |
| fi | |
| } | |
| dequote () | |
| { | |
| eval printf %s "$1" 2> /dev/null | |
| } | |
| hsts () | |
| { | |
| if [[ -n "$(curl -L -s -D- https://$1/ | grep -i 'strict-transport-security')" ]]; then | |
| echo -e "\x1b[32;01m https://$1/ 'True'; \x1b[39;49;00m"; | |
| else | |
| echo -e "\x1b[31;01m https://$1/ 'False'; \x1b[39;49;00m"; | |
| fi | |
| } | |
| ip0 () | |
| { | |
| ifconfig | grep -A1 'wlan0' | grep 'inet' | awk '{print $2}' | |
| } | |
| ip1 () | |
| { | |
| ifconfig | grep -A1 'wlan1' | grep 'inet' | awk '{print $2}' | |
| } | |
| ip2 () | |
| { | |
| ifconfig | grep -A1 'wlan2' | grep 'inet' | awk '{print $2}' | |
| } | |
| mac0 () | |
| { | |
| ifconfig wlan0 | awk '{print $2}' | grep ':' | grep -v '::' | |
| } | |
| mac1 () | |
| { | |
| ifconfig wlan1 | awk '{print $2}' | grep ':' | grep -v '::' | |
| } | |
| mac2 () | |
| { | |
| ifconfig wlan2 | awk '{print $2}' | grep ':' | grep -v '::' | |
| } | |
| quote () | |
| { | |
| local quoted=${1//\'/\'\\\'\'}; | |
| printf "'%s'" "$quoted" | |
| } | |
| quote_readline () | |
| { | |
| local quoted; | |
| _quote_readline_by_ref "$1" ret; | |
| printf %s "$ret" | |
| } | |
| rfreset () | |
| { | |
| rfkill block all; | |
| rfkill unblock all; | |
| service network-manager reload; | |
| service network-manager restart | |
| } | |
| sprunge () | |
| { | |
| tail -n +1 -- "$@" | curl -F 'sprunge=<-' http://sprunge.us | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment