XorA
/
bash-it
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add function tag on functions 

Add var protection ( starting )
Add stack trace builder start
pull/2209/head
Arnaud Crampet 2023-07-18 15:54:14 +02:00
parent e38696a0ac
commit 1d2687f1f4
317 changed files with 13872 additions and 12525 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
aliases/available/apt.aliases.bash
View File

@ -6,8 +6,15 @@ cite 'about-alias'
about-alias 'Apt and dpkg aliases for Ubuntu and Debian distros.'
# set apt aliases
function _set_pkg_aliases() {
if _command_exists apt; then
function _set_pkg_aliases()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
if _command_exists apt
then
alias apts='apt-cache search'
alias aptshow='apt-cache show'
alias aptinst='sudo apt-get install -V'

11
aliases/available/curl.aliases.bash
View File

@ -2,8 +2,15 @@
about-alias 'Curl aliases for convenience.'
# set apt aliases
function _set_pkg_aliases() {
if _command_exists curl; then
function _set_pkg_aliases()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
if _command_exists curl
then
# follow redirects
alias cl='curl -L'
# follow redirects, download as original name

3
aliases/available/docker.aliases.bash
View File

@ -19,7 +19,8 @@ case $OSTYPE in
;;
esac
if _bash-it-component-item-is-enabled plugin docker; then
if _bash-it-component-item-is-enabled plugin docker
then
# Function aliases from docker plugin:
alias dkrmlc='docker-remove-most-recent-container' # Delete most recent (i.e., last) Docker container
alias dkrmall='docker-remove-stale-assets' # Delete all untagged images and exited containers

3
aliases/available/fuck.aliases.bash
View File

@ -2,7 +2,8 @@
about-alias 'fuck/please to retry last command with sudo'
# Play nicely with 'thefuck' plugin
if ! _command_exists fuck; then
if ! _command_exists fuck
then
alias fuck='sudo $(fc -ln -1)'
fi
alias please=fuck

23
aliases/available/general.aliases.bash
View File

@ -1,7 +1,8 @@
# shellcheck shell=bash
about-alias 'general aliases'
if command ls --color -d . &> /dev/null; then
if command ls --color -d . &> /dev/null
then
alias ls='ls --color=auto'
# BSD `ls` doesn't need an argument (`-G`) when `$CLICOLOR` is set.
fi
@ -23,11 +24,13 @@ alias vbpf='${VISUAL:-vim} ~/.bash_profile'
# colored grep
# Need to check an existing file for a pattern that will be found to ensure
# that the check works when on an OS that supports the color option
if command grep --color=auto "a" "${BASH_IT?}"/*.md &> /dev/null; then
if command grep --color=auto "a" "${BASH_IT?}"/*.md &> /dev/null
then
alias grep='grep --color=auto'
fi
if _command_exists gshuf; then
if _command_exists gshuf
then
alias shuf=gshuf
fi
@ -60,7 +63,8 @@ alias -- -='cd -' # Go back
alias h='history'
# Tree
if ! _command_exists tree; then
if ! _command_exists tree
then
alias tree="find . -print | sed -e 's;[^/]*/;|____;g;s;____|; |;g'"
fi
@ -72,9 +76,16 @@ alias rd='rmdir'
alias xt='extract'
# Display whatever file is regular file or folder
function catt() {
function catt()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
for i in "$@"; do
if [[ -d "$i" ]]; then
if [[ -d "$i" ]]
then
ls "$i"
else
cat "$i"

22
aliases/available/git.aliases.bash
View File

@ -91,7 +91,8 @@ alias ggui='git gui'
# home
alias ghm='cd "$(git rev-parse --show-toplevel)"' # Git home
# appendage to ghm
if ! _command_exists gh; then
if ! _command_exists gh
then
alias gh='ghm'
fi
@ -199,12 +200,25 @@ case $OSTYPE in
esac
# functions
function gdv() {
function gdv()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
git diff --ignore-all-space "$@" | vim -R -
}
function get_default_branch() {
if git branch | grep -q '^. main\s*$'; then
function get_default_branch()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
if git branch | grep -q '^. main\s*$'
then
echo main
else
echo master

3
aliases/available/kubectl.aliases.bash
View File

@ -1,7 +1,8 @@
# shellcheck shell=bash
about-alias 'kubectl aliases'
if _command_exists kubectl; then
if _command_exists kubectl
then
alias kc='kubectl'
alias kcgp='kubectl get pods'
alias kcgd='kubectl get deployments'

3
aliases/available/osx.aliases.bash
View File

@ -21,7 +21,8 @@ alias skype='open -a Skype'
alias mou='open -a Mou'
alias subl='open -a "Sublime Text"'
if [[ -s /usr/bin/firefox ]]; then
if [[ -s /usr/bin/firefox ]]
then
unalias firefox
fi

6
aliases/available/uuidgen.aliases.bash
View File

@ -1,10 +1,12 @@
# shellcheck shell=bash
about-alias 'uuidgen aliases'
if _command_exists uuid; then # Linux
if _command_exists uuid
then # Linux
alias uuidu="uuid | tr '[:lower:]' '[:upper:]'"
alias uuidl=uuid
elif _command_exists uuidgen; then # macOS/BSD
elif _command_exists uuidgen
then # macOS/BSD
alias uuidu="uuidgen"
alias uuid="uuidgen | tr '[:upper:]' '[:lower:]'" # because upper case is like YELLING
alias uuidl=uuid

21
bash_it.sh
View File

@ -45,7 +45,8 @@ done
# Load theme, if a theme was set
# shellcheck source-path=SCRIPTDIR/themes
if [[ -n "${BASH_IT_THEME:-}" ]]; then
if [[ -n "${BASH_IT_THEME:-}" ]]
then
_log_debug "Loading theme '${BASH_IT_THEME}'."
BASH_IT_LOG_PREFIX="themes: githelpers: "
source "${BASH_IT}/themes/githelpers.theme.bash"
@ -64,7 +65,8 @@ fi
_log_debug "Loading custom aliases, completion, plugins..."
for _bash_it_main_file_type in "aliases" "completion" "plugins"; do
_bash_it_main_file_custom="${BASH_IT}/${_bash_it_main_file_type}/custom.${_bash_it_main_file_type}.bash"
if [[ -s "${_bash_it_main_file_custom}" ]]; then
if [[ -s "${_bash_it_main_file_custom}" ]]
then
_bash-it-log-prefix-by-path "${_bash_it_main_file_custom}"
_log_debug "Loading component..."
# shellcheck disable=SC1090
@ -76,7 +78,8 @@ done
# Custom
_log_debug "Loading general custom files..."
for _bash_it_main_file_custom in "${BASH_IT_CUSTOM}"/*.bash "${BASH_IT_CUSTOM}"/*/*.bash; do
if [[ -s "${_bash_it_main_file_custom}" ]]; then
if [[ -s "${_bash_it_main_file_custom}" ]]
then
_bash-it-log-prefix-by-path "${_bash_it_main_file_custom}"
_log_debug "Loading custom file..."
# shellcheck disable=SC1090
@ -85,21 +88,25 @@ for _bash_it_main_file_custom in "${BASH_IT_CUSTOM}"/*.bash "${BASH_IT_CUSTOM}"/
BASH_IT_LOG_PREFIX="core: main: "
done
if [[ -n "${PROMPT:-}" ]]; then
if [[ -n "${PROMPT:-}" ]]
then
PS1="${PROMPT}"
fi
# Adding Support for other OSes
if _command_exists gloobus-preview; then
if _command_exists gloobus-preview
then
PREVIEW="gloobus-preview"
elif [[ -d /Applications/Preview.app ]]; then
elif [[ -d /Applications/Preview.app ]]
then
PREVIEW="/Applications/Preview.app"
else
PREVIEW="less"
fi
# BASH_IT_RELOAD_LEGACY is set.
if [[ -n "${BASH_IT_RELOAD_LEGACY:-}" ]] && ! _command_exists reload; then
if [[ -n "${BASH_IT_RELOAD_LEGACY:-}" ]] && ! _command_exists reload
then
# shellcheck disable=SC2139
alias reload="builtin source '${BASH_IT_BASHRC?}'"
fi

34
completion/available/aliases.completion.bash
View File

@ -8,7 +8,12 @@ about-plugin 'Automatic completion of aliases'
# http://stackoverflow.com/a/1793178/1228454
# Automatically add completion for all aliases to commands having completion functions
function _bash-it-component-completion-callback-on-init-aliases() {
function _bash-it-component-completion-callback-on-init-aliases()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local namespace="alias_completion"
local tmp_file completion_loader alias_name line completions chars
local alias_arg_words new_completion compl_func compl_wrapper alias_defn
@ -27,7 +32,8 @@ function _bash-it-component-completion-callback-on-init-aliases() {
tmp_file="$(mktemp -t "${namespace}-${RANDOM}XXXXXX")" || return 1
IFS=$'\n' read -r completion_loader < <(complete -p -D 2> /dev/null)
if [[ "${completion_loader#complete }" =~ '-F'[[:space:]]([[:alnum:]_]+)[[:space:]] ]]; then
if [[ "${completion_loader#complete }" =~ '-F'[[:space:]]([[:alnum:]_]+)[[:space:]] ]]
then
completion_loader="${BASH_REMATCH[1]}"
else
completion_loader=""
@ -43,7 +49,8 @@ function _bash-it-component-completion-callback-on-init-aliases() {
alias_defn="${line#*=\'}" # alias definition
alias_defn="${alias_defn%\'}"
alias_cmd="${alias_defn%%[[:space:]]*}" # first word of alias
if [[ ${alias_defn} == ${alias_cmd} ]]; then
if [[ ${alias_defn} == ${alias_cmd} ]]
then
alias_args=''
else
alias_args="${alias_defn#*[[:space:]]}" # everything after first word
@ -51,15 +58,18 @@ function _bash-it-component-completion-callback-on-init-aliases() {
# skip aliases to pipes, boolean control structures and other command lists
chars=$'|&;()<>\n'
if [[ "${alias_defn}" =~ [$chars] ]]; then
if [[ "${alias_defn}" =~ [$chars] ]]
then
continue
fi
# avoid expanding wildcards
read -ra alias_arg_words <<< "$alias_args"
# skip alias if there is no completion function triggered by the aliased command
if ! _bash-it-array-contains-element "$alias_cmd" "${completions[@]}"; then
if [[ -n "$completion_loader" ]]; then
if ! _bash-it-array-contains-element "$alias_cmd" "${completions[@]}"
then
if [[ -n "$completion_loader" ]]
then
# force loading of completions for the aliased command
"${completion_loader:?}" "${alias_cmd}"
# 124 means completion loader was successful
@ -72,11 +82,13 @@ function _bash-it-component-completion-callback-on-init-aliases() {
new_completion="$(complete -p "$alias_cmd" 2> /dev/null)"
# create a wrapper inserting the alias arguments if any
if [[ -n $alias_args ]]; then
if [[ -n $alias_args ]]
then
compl_func="${new_completion/#* -F /}"
compl_func="${compl_func%% *}"
# avoid recursive call loops by ignoring our own functions
if [[ "${compl_func#_"$namespace"::}" == "$compl_func" ]]; then
if [[ "${compl_func#_"$namespace"::}" == "$compl_func" ]]
then
compl_wrapper="_${namespace}::${alias_name}"
echo "function $compl_wrapper {
local compl_word=\${2?}
@ -84,7 +96,8 @@ function _bash-it-component-completion-callback-on-init-aliases() {
# check if prec_word is the alias itself. if so, replace it
# with the last word in the unaliased form, i.e.,
# alias_cmd + ' ' + alias_args.
if [[ \$COMP_LINE == \"\$prec_word \$compl_word\" ]]; then
if [[ \$COMP_LINE == \"\$prec_word \$compl_word\" ]]
then
prec_word='$alias_cmd $alias_args'
prec_word=\${prec_word#* }
fi
@ -100,7 +113,8 @@ function _bash-it-component-completion-callback-on-init-aliases() {
fi
# replace completion trigger by alias
if [[ -n $new_completion ]]; then
if [[ -n $new_completion ]]
then
new_completion="${new_completion% *} $alias_name"
echo "$new_completion" >> "$tmp_file"
fi

3
completion/available/awless.completion.bash
View File

@ -1,5 +1,6 @@
# shellcheck shell=bash
if _command_exists awless; then
if _command_exists awless
then
# shellcheck disable=SC1090
source <(awless completion bash)
fi

3
completion/available/awscli.completion.bash
View File

@ -1,5 +1,6 @@
# shellcheck shell=bash
if _command_exists aws_completer; then
if _command_exists aws_completer
then
complete -C "$(command -v aws_completer)" aws
fi

28
completion/available/bash-it.completion.bash
View File

@ -1,12 +1,24 @@
# shellcheck shell=bash
function _compreply_candidates() {
function _compreply_candidates()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local IFS=$'\n'
read -d '' -ra COMPREPLY < <(compgen -W "${candidates[*]}" -- "${cur}")
}
function _bash-it() {
function _bash-it()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local cur prev verb file_type candidates suffix
COMPREPLY=()
cur="${COMP_WORDS[COMP_CWORD]}"
@ -20,7 +32,8 @@ function _bash-it() {
_compreply_candidates
;;
help)
if [[ "${prev}" == "aliases" ]]; then
if [[ "${prev}" == "aliases" ]]
then
candidates=('all' "$(_bash-it-component-list "${file_type}")")
_compreply_candidates
else
@ -31,7 +44,8 @@ function _bash-it() {
profile)
case "${file_type}" in
load | rm)
if [[ "${file_type}" == "$prev" ]]; then
if [[ "${file_type}" == "$prev" ]]
then
candidates=("${BASH_IT}/profiles"/*.bash_it)
candidates=("${candidates[@]##*/}")
candidates=("${candidates[@]%%.bash_it}")
@ -51,7 +65,8 @@ function _bash-it() {
_compreply_candidates
;;
update)
if [[ "${cur}" == -* ]]; then
if [[ "${cur}" == -* ]]
then
candidates=('-s' '--silent')
else
candidates=('stable' 'dev')
@ -64,7 +79,8 @@ function _bash-it() {
return 0
;;
enable | disable)
if [[ "${verb}" == "enable" ]]; then
if [[ "${verb}" == "enable" ]]
then
suffix="disabled"
else
suffix="enabled"

12
completion/available/brew.completion.bash
View File

@ -5,7 +5,8 @@ about-completion "brew completion"
# Load late to make sure `system` completion loads first
# BASH_IT_LOAD_PRIORITY: 375
if [[ "$OSTYPE" != 'darwin'* ]]; then
if [[ "$OSTYPE" != 'darwin'* ]];
then
_log_warning "unsupported operating system - only 'Darwin' is supported"
return 0
fi
@ -13,15 +14,18 @@ fi
# Make sure brew is installed
_bash_it_homebrew_check || return 0
if [[ -r "$BASH_IT_HOMEBREW_PREFIX/etc/bash_completion.d/brew" ]]; then
if [[ -r "$BASH_IT_HOMEBREW_PREFIX/etc/bash_completion.d/brew" ]]
then
# shellcheck disable=1090,1091
source "$BASH_IT_HOMEBREW_PREFIX/etc/bash_completion.d/brew"
elif [[ -r "$BASH_IT_HOMEBREW_PREFIX/Library/Contributions/brew_bash_completion.sh" ]]; then
elif [[ -r "$BASH_IT_HOMEBREW_PREFIX/Library/Contributions/brew_bash_completion.sh" ]]
then
# shellcheck disable=1090,1091
source "$BASH_IT_HOMEBREW_PREFIX/Library/Contributions/brew_bash_completion.sh"
elif [[ -f "$BASH_IT_HOMEBREW_PREFIX/completions/bash/brew" ]]; then
elif [[ -f "$BASH_IT_HOMEBREW_PREFIX/completions/bash/brew" ]]
then
# For the git-clone based installation, see here for more info:
# https://github.com/Bash-it/bash-it/issues/1458
# https://docs.brew.sh/Shell-Completion

28
completion/available/bundler.completion.bash
View File

@ -27,8 +27,8 @@
# To use, source this file on bash:
# . completion-bundle
__bundle() {
local bundle_bin=("${_RUBY_COMMAND_PREFIX[@]}" "$1")
function __bundle() {
local bundle_bin=("${_RUBY_COMMAND_PREFIX[@]}" "${1}")
local cur prev
_get_comp_words_by_ref -n : cur prev
local bundle_command
@ -37,7 +37,8 @@ __bundle() {
COMPREPLY=()
local options
if [[ $cur = -* && $bundle_command != exec ]]; then
if [[ $cur = -* && $bundle_command != exec ]]
then
options="-V --help --no-color --no-no-color --verbose --no-verbose"
case $bundle_command in
"")
@ -140,10 +141,12 @@ __bundle() {
esac
;;
exec)
if [[ $COMP_CWORD -eq $bundle_command_index ]]; then
if [[ $COMP_CWORD -eq $bundle_command_index ]]
then
# Figure out Bundler's binaries dir
local bundler_bin=$(__bundle_exec_ruby 'puts Bundler.bundle_path + "bin"')
if [[ -d $bundler_bin ]]; then
if [[ -d $bundler_bin ]]
then
local binaries=("$bundler_bin"/*)
# If there are binaries, strip directory name and use them
[[ -f "$binaries" ]] && options="${binaries[@]##*/}"
@ -190,7 +193,7 @@ __bundle() {
COMPREPLY=($(compgen -W "${options[*]}" -- "$cur"))
}
__bundle_get_command() {
function __bundle_get_command() {
local i
for ((i=1; i < $COMP_CWORD; ++i)); do
local arg=${COMP_WORDS[$i]}
@ -216,13 +219,14 @@ __bundle_get_command() {
#
# Multiple groups can be entered, separated either by spaces or by colons.
# Input is read from $cur, and the result is directly written to $COMPREPLY.
__bundle_complete_groups() {
function __bundle_complete_groups() {
# Group being currently written
local cur_group=${cur##*[ :]}
# All groups written before
local prefix=${cur%"$cur_group"}
local groups=$(__bundle_exec_ruby 'puts Bundler.definition.dependencies.map(&:groups).reduce(:|).map(&:to_s)')
if [[ ! $groups ]]; then
if [[ ! $groups ]]
then
COMPREPLY=()
return
fi
@ -241,7 +245,7 @@ __bundle_complete_groups() {
#
# Runs a Ruby script with Bundler loaded.
# Results may be cached.
__bundle_exec_ruby() {
function __bundle_exec_ruby() {
local bundle_bin=(${bundle_bin[@]:-bundle})
# Lockfile is inferred here, and might not be correct (for example, when
# running on a subdirectory). However, a wrong file path won't be a
@ -256,11 +260,13 @@ __bundle_exec_ruby() {
local cache_id_line="${bundle_bin[*]} @ $lockfile: ${*//$'\n'/ }"
if [[ (! -f $lockfile || $cachefile -nt $lockfile) &&
$(head -n 1 -- "$cachefile" 2>/dev/null) = "$cache_id_line" ]]; then
$(head -n 1 -- "$cachefile" 2>/dev/null) = "$cache_id_line" ]]
then
tail -n +2 -- "$cachefile"
else
local output=$("${bundle_bin[@]}" exec ruby -e "$@" 2>/dev/null)
if [[ $? -eq 0 ]]; then
if [[ $? -eq 0 ]]
then
(mkdir -p -- "$cachedir" &&
echo "$cache_id_line"$'\n'"$output" >$cachefile) 2>/dev/null
echo "$output"

11
completion/available/capistrano.completion.bash
View File

@ -3,12 +3,15 @@
export COMP_WORDBREAKS=${COMP_WORDBREAKS/\:/}
_capcomplete() {
if [ -f Capfile ]; then
function _capcomplete() {
if [ -f Capfile ]
then
recent=`ls -t .cap_tasks~ Capfile **/*.cap 2> /dev/null | head -n 1`
if [[ $recent != '.cap_tasks~' ]]; then
if [[ $recent != '.cap_tasks~' ]]
then
cap --version | grep 'Capistrano v2.' > /dev/null
if [ $? -eq 0 ]; then
if [ $? -eq 0 ]
then
# Capistrano 2.x
cap --tool --verbose --tasks | cut -d " " -f 2 > .cap_tasks~
else

3
completion/available/cargo.completion.bash
View File

@ -1,6 +1,7 @@
# shellcheck shell=bash
# cargo (Rust package manager) completion
if _binary_exists rustup && _binary_exists cargo; then
if _binary_exists rustup && _binary_exists cargo
then
eval "$(rustup completions bash cargo)"
fi

17
completion/available/composer.completion.bash
View File

@ -2,21 +2,29 @@
cite "about-completion"
about-completion "composer completion"
function __composer_completion() {
function __composer_completion()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local cur coms opts com words
COMPREPLY=()
_get_comp_words_by_ref -n : cur words
# lookup for command
for word in "${words[@]:1}"; do
if [[ "${word}" != -* ]]; then
if [[ "${word}" != -* ]]
then
com="${word}"
break
fi
done
# completing for an option
if [[ ${cur} == --* ]]; then
if [[ ${cur} == --* ]]
then
opts="--help --quiet --verbose --version --ansi --no-ansi --no-interaction --profile --no-plugins --working-dir"
case "${com}" in
@ -115,7 +123,8 @@ function __composer_completion() {
fi
# completing for a command
if [[ "${cur}" == "${com}" ]]; then
if [[ "${cur}" == "${com}" ]]
then
coms="about archive browse clear-cache config create-project depends diagnose dump-autoload exec global help init install licenses list outdated prohibits remove require run-script search self-update show status suggests update validate"
# shellcheck disable=SC2207

6
completion/available/conda.completion.bash
View File

@ -2,8 +2,10 @@
cite "about-completion"
about-completion "conda completion"
if _command_exists conda; then
if _command_exists register-python-argcomplete; then
if _command_exists conda
then
if _command_exists register-python-argcomplete
then
eval "$(register-python-argcomplete conda)"
else
_log_warning "Argcomplete not found. Please run 'conda install argcomplete'"

3
completion/available/consul.completion.bash
View File

@ -2,6 +2,7 @@
cite "about-completion"
about-completion "Hashicorp consul completion"
if _command_exists consul; then
if _command_exists consul
then
complete -C "$(command -v consul)" consul
fi

2
completion/available/dart.completion.bash
View File

@ -1,6 +1,6 @@
# shellcheck shell=bash
__dart_completion() {
function __dart_completion() {
# shellcheck disable=SC2155
local prev=$(_get_pword)
# shellcheck disable=SC2155

3
completion/available/defaults.completion.bash
View File

@ -1,5 +1,6 @@
# shellcheck shell=bash
if test -s "${BASH_IT?}/vendor/github.com/gaelicWizard/bash-progcomp/defaults.completion.bash"; then
if test -s "${BASH_IT?}/vendor/github.com/gaelicWizard/bash-progcomp/defaults.completion.bash"
then
source "$_"
fi

5
completion/available/dirs.completion.bash
View File

@ -1,11 +1,12 @@
#!/usr/bin/env bash
# Bash completion support for the 'dirs' plugin (commands G, R).
_dirs-complete() {
function _dirs-complete() {
local CURRENT_PROMPT="${COMP_WORDS[COMP_CWORD]}"
# parse all defined shortcuts from ~/.dirs
if [ -r "$HOME/.dirs" ]; then
if [ -r "$HOME/.dirs" ]
then
COMPREPLY=($(compgen -W "$(grep -v '^#' ~/.dirs | sed -e 's/\(.*\)=.*/\1/')" -- ${CURRENT_PROMPT}) )
fi

98
completion/available/docker-compose.completion.bash
View File

@ -34,13 +34,13 @@
__docker_compose_previous_extglob_setting=$(shopt -p extglob)
shopt -s extglob
__docker_compose_q() {
function __docker_compose_q() {
docker-compose 2>/dev/null "${top_level_options[@]}" "$@"
}
# Transforms a multiline list of strings into a single line string
# with the words separated by "|".
__docker_compose_to_alternatives() {
function __docker_compose_to_alternatives() {
local parts=( $1 )
local IFS='|'
echo "${parts[*]}"
@ -48,17 +48,18 @@ __docker_compose_to_alternatives() {
# Transforms a multiline list of options into an extglob pattern
# suitable for use in case statements.
__docker_compose_to_extglob() {
local extglob=$( __docker_compose_to_alternatives "$1" )
function __docker_compose_to_extglob() {
local extglob=$( __docker_compose_to_alternatives "${1}" )
echo "@($extglob)"
}
# Determines whether the option passed as the first argument exist on
# the commandline. The option may be a pattern, e.g. `--force|-f`.
__docker_compose_has_option() {
local pattern="$1"
function __docker_compose_has_option() {
local pattern="${1}"
for (( i=2; i < $cword; ++i)); do
if [[ ${words[$i]} =~ ^($pattern)$ ]] ; then
if [[ ${words[$i]} =~ ^($pattern)$ ]]
then
return 0
fi
done
@ -68,17 +69,20 @@ __docker_compose_has_option() {
# Returns `key` if we are currently completing the value of a map option (`key=value`)
# which matches the extglob passed in as an argument.
# This function is needed for key-specific completions.
__docker_compose_map_key_of_current_option() {
local glob="$1"
function __docker_compose_map_key_of_current_option() {
local glob="${1}"
local key glob_pos
if [ "$cur" = "=" ] ; then # key= case
if [ "$cur" = "=" ]
then # key= case
key="$prev"
glob_pos=$((cword - 2))
elif [[ $cur == *=* ]] ; then # key=value case (OSX)
elif [[ $cur == *=* ]]
then # key=value case (OSX)
key=${cur%=*}
glob_pos=$((cword - 1))
elif [ "$prev" = "=" ] ; then
elif [ "$prev" = "=" ]
then
key=${words[$cword - 2]} # key=value case
glob_pos=$((cword - 3))
else
@ -91,7 +95,7 @@ __docker_compose_map_key_of_current_option() {
}
# suppress trailing whitespace
__docker_compose_nospace() {
function __docker_compose_nospace() {
# compopt is not available in ancient bash versions
type compopt &>/dev/null && compopt -o nospace
}
@ -100,25 +104,25 @@ __docker_compose_nospace() {
# Outputs a list of all defined services, regardless of their running state.
# Arguments for `docker-compose ps` may be passed in order to filter the service list,
# e.g. `status=running`.
__docker_compose_services() {
function __docker_compose_services() {
__docker_compose_q ps --services "$@"
}
# Applies completion of services based on the current value of `$cur`.
# Arguments for `docker-compose ps` may be passed in order to filter the service list,
# see `__docker_compose_services`.
__docker_compose_complete_services() {
function __docker_compose_complete_services() {
COMPREPLY=( $(compgen -W "$(__docker_compose_services "$@")" -- "$cur") )
}
# The services for which at least one running container exists
__docker_compose_complete_running_services() {
function __docker_compose_complete_running_services() {
local names=$(__docker_compose_services --filter status=running)
COMPREPLY=( $(compgen -W "$names" -- "$cur") )
}
_docker_compose_build() {
function _docker_compose_build() {
case "$prev" in
--build-arg)
COMPREPLY=( $( compgen -e -- "$cur" ) )
@ -141,7 +145,7 @@ _docker_compose_build() {
}
_docker_compose_bundle() {
function _docker_compose_bundle() {
case "$prev" in
--output|-o)
_filedir
@ -153,10 +157,11 @@ _docker_compose_bundle() {
}
_docker_compose_config() {
function _docker_compose_config() {
case "$prev" in
--hash)
if [[ $cur == \\* ]] ; then
if [[ $cur == \\* ]]
then
COMPREPLY=( '\*' )
else
COMPREPLY=( $(compgen -W "$(__docker_compose_services) \\\* " -- "$cur") )
@ -169,7 +174,7 @@ _docker_compose_config() {
}
_docker_compose_create() {
function _docker_compose_create() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--build --force-recreate --help --no-build --no-recreate" -- "$cur" ) )
@ -181,7 +186,7 @@ _docker_compose_create() {
}
_docker_compose_docker_compose() {
function _docker_compose_docker_compose() {
case "$prev" in
--tlscacert|--tlscert|--tlskey)
_filedir
@ -215,7 +220,7 @@ _docker_compose_docker_compose() {
}
_docker_compose_down() {
function _docker_compose_down() {
case "$prev" in
--rmi)
COMPREPLY=( $( compgen -W "all local" -- "$cur" ) )
@ -234,7 +239,7 @@ _docker_compose_down() {
}
_docker_compose_events() {
function _docker_compose_events() {
case "$prev" in
--json)
return
@ -252,7 +257,7 @@ _docker_compose_events() {
}
_docker_compose_exec() {
function _docker_compose_exec() {
case "$prev" in
--index|--user|-u|--workdir|-w)
return
@ -270,11 +275,11 @@ _docker_compose_exec() {
}
_docker_compose_help() {
function _docker_compose_help() {
COMPREPLY=( $( compgen -W "${commands[*]}" -- "$cur" ) )
}
_docker_compose_images() {
function _docker_compose_images() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --quiet -q" -- "$cur" ) )
@ -285,7 +290,7 @@ _docker_compose_images() {
esac
}
_docker_compose_kill() {
function _docker_compose_kill() {
case "$prev" in
-s)
COMPREPLY=( $( compgen -W "SIGHUP SIGINT SIGKILL SIGUSR1 SIGUSR2" -- "$(echo $cur | tr '[:lower:]' '[:upper:]')" ) )
@ -304,7 +309,7 @@ _docker_compose_kill() {
}
_docker_compose_logs() {
function _docker_compose_logs() {
case "$prev" in
--tail)
return
@ -322,7 +327,7 @@ _docker_compose_logs() {
}
_docker_compose_pause() {
function _docker_compose_pause() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
@ -334,7 +339,7 @@ _docker_compose_pause() {
}
_docker_compose_port() {
function _docker_compose_port() {
case "$prev" in
--protocol)
COMPREPLY=( $( compgen -W "tcp udp" -- "$cur" ) )
@ -356,7 +361,7 @@ _docker_compose_port() {
}
_docker_compose_ps() {
function _docker_compose_ps() {
local key=$(__docker_compose_map_key_of_current_option '--filter')
case "$key" in
source)
@ -388,7 +393,7 @@ _docker_compose_ps() {
}
_docker_compose_pull() {
function _docker_compose_pull() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --ignore-pull-failures --include-deps --no-parallel --quiet -q" -- "$cur" ) )
@ -400,7 +405,7 @@ _docker_compose_pull() {
}
_docker_compose_push() {
function _docker_compose_push() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --ignore-push-failures" -- "$cur" ) )
@ -412,7 +417,7 @@ _docker_compose_push() {
}
_docker_compose_restart() {
function _docker_compose_restart() {
case "$prev" in
--timeout|-t)
return
@ -430,13 +435,14 @@ _docker_compose_restart() {
}
_docker_compose_rm() {
function _docker_compose_rm() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--force -f --help --stop -s -v" -- "$cur" ) )
;;
*)
if __docker_compose_has_option "--stop|-s" ; then
if __docker_compose_has_option "--stop|-s"
then
__docker_compose_complete_services
else
__docker_compose_complete_services --filter status=stopped
@ -446,7 +452,7 @@ _docker_compose_rm() {
}
_docker_compose_run() {
function _docker_compose_run() {
case "$prev" in
-e)
COMPREPLY=( $( compgen -e -- "$cur" ) )
@ -469,7 +475,7 @@ _docker_compose_run() {
}
_docker_compose_scale() {
function _docker_compose_scale() {
case "$prev" in
=)
COMPREPLY=("$cur")
@ -492,7 +498,7 @@ _docker_compose_scale() {
}
_docker_compose_start() {
function _docker_compose_start() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
@ -504,7 +510,7 @@ _docker_compose_start() {
}
_docker_compose_stop() {
function _docker_compose_stop() {
case "$prev" in
--timeout|-t)
return
@ -522,7 +528,7 @@ _docker_compose_stop() {
}
_docker_compose_top() {
function _docker_compose_top() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
@ -534,7 +540,7 @@ _docker_compose_top() {
}
_docker_compose_unpause() {
function _docker_compose_unpause() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
@ -546,7 +552,7 @@ _docker_compose_unpause() {
}
_docker_compose_up() {
function _docker_compose_up() {
case "$prev" in
=)
COMPREPLY=("$cur")
@ -577,7 +583,7 @@ _docker_compose_up() {
}
_docker_compose_version() {
function _docker_compose_version() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--short" -- "$cur" ) )
@ -586,7 +592,7 @@ _docker_compose_version() {
}
_docker_compose() {
function _docker_compose() {
local previous_extglob_setting=$(shopt -p extglob)
shopt -s extglob

3
completion/available/docker.completion.bash
View File

@ -16,7 +16,8 @@ _docker_bash_completion_paths=(
)
for fn in "${_docker_bash_completion_paths[@]}"; do
if [ -r "$fn" ]; then
if [ -r "$fn" ]
then
# shellcheck disable=SC1090
source "$fn"
break

8
completion/available/dotnet.completion.bash
View File

@ -2,7 +2,13 @@
about-completion "bash parameter completion for the dotnet CLI"
# see https://docs.microsoft.com/en-us/dotnet/core/tools/enable-tab-autocomplete#bash
function _dotnet_bash_complete() {
function _dotnet_bash_complete()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local cur="${COMP_WORDS[COMP_CWORD]}" IFS=$'\n'
local candidates

42
completion/available/fabric.completion.bash
View File

@ -54,7 +54,13 @@ esac
#
# Get time of last fab cache file modification as seconds since Epoch
#
function __fab_chache_mtime() {
function __fab_chache_mtime()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
${__FAB_COMPLETION_MTIME_COMMAND} \
$FAB_COMPLETION_CACHED_TASKS_FILENAME | xargs -n 1 expr
}
@ -63,9 +69,16 @@ function __fab_chache_mtime() {
#
# Get time of last fabfile file/module modification as seconds since Epoch
#
function __fab_fabfile_mtime() {
function __fab_fabfile_mtime()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local f="fabfile"
if [[ -e "$f.py" ]]; then
if [[ -e "$f.py" ]]
then
${__FAB_COMPLETION_MTIME_COMMAND} "$f.py" | xargs -n 1 expr
else
# Suppose that it's a fabfile dir
@ -78,7 +91,13 @@ function __fab_fabfile_mtime() {
#
# Completion for "fab" command
#
function __fab_completion() {
function __fab_completion()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
# Return if "fab" command doesn't exists
[[ -e `which fab 2> /dev/null` ]] || return 0
@ -89,7 +108,8 @@ function __fab_completion() {
# Generate possible matches and store them in variable "opts"
case "${cur}" in
-*)
if [[ -z "${__FAB_COMPLETION_LONG_OPT}" ]]; then
if [[ -z "${__FAB_COMPLETION_LONG_OPT}" ]]
then
export __FAB_COMPLETION_LONG_OPT=$(
fab --help | grep -E -o "\-\-[A-Za-z_\-]+\=?" | sort -u)
fi
@ -99,7 +119,8 @@ function __fab_completion() {
# Completion for short options is not nessary.
# It's left here just for history.
# -*)
# if [[ -z "${__FAB_COMPLETION_SHORT_OPT}" ]]; then
# if [[ -z "${__FAB_COMPLETION_SHORT_OPT}" ]]
then
# export __FAB_COMPLETION_SHORT_OPT=$(
# fab --help | grep -E -o "^ +\-[A-Za-z_\]" | sort -u)
# fi
@ -109,12 +130,15 @@ function __fab_completion() {
*)
# If "fabfile.py" or "fabfile" dir with "__init__.py" file exists
local f="fabfile"
if [[ -e "$f.py" || (-d "$f" && -e "$f/__init__.py") ]]; then
if [[ -e "$f.py" || (-d "$f" && -e "$f/__init__.py") ]]
then
# Build a list of the available tasks
if $FAB_COMPLETION_CACHE_TASKS; then
if $FAB_COMPLETION_CACHE_TASKS
then
# If use cache
if [[ ! -s ${FAB_COMPLETION_CACHED_TASKS_FILENAME} ||
$(__fab_fabfile_mtime) -gt $(__fab_chache_mtime) ]]; then
$(__fab_fabfile_mtime) -gt $(__fab_chache_mtime) ]]
then
fab --shortlist > ${FAB_COMPLETION_CACHED_TASKS_FILENAME} \
2> /dev/null
fi

3
completion/available/flutter.completion.bash
View File

@ -1,5 +1,6 @@
# shellcheck shell=bash
if _command_exists flutter; then
if _command_exists flutter
then
eval "$(flutter bash-completion)"
fi

3
completion/available/gcloud.completion.bash
View File

@ -2,7 +2,8 @@
cite "about-completion"
about-completion "Google Cloud SDK completion"
if _command_exists gcloud; then
if _command_exists gcloud
then
# get install path
GOOGLE_SDK_ROOT=${GOOGLE_SDK_ROOT:-$(gcloud info --format="value(installation.sdk_root)")}

3
completion/available/gem.completion.bash
View File

@ -8,7 +8,8 @@ __gem_completion() {
case $prev in
install)
# list the remote gems and add to completion
if [ -z "$REMOTE_GEMS" ]; then
if [ -z "$REMOTE_GEMS" ]
then
read -r -a REMOTE_GEMS <<< "$(gem list --remote --no-versions | sed 's/\*\*\* REMOTE GEMS \*\*\*//' | tr '\n' ' ')"
fi

12
completion/available/git.completion.bash
View File

@ -6,13 +6,15 @@
_command_exists git || return
# Don't handle completion if it's already managed
if complete -p git &> /dev/null; then
if complete -p git &> /dev/null
then
_log_warning "completion already loaded - this usually means it is safe to stop using this completion"
return 0
fi
_git_bash_completion_xcrun_git=
if _command_exists xcrun; then
if _command_exists xcrun
then
_git_bash_completion_xcrun_git="$(xcrun --find git)"
fi
_git_bash_completion_paths=(
@ -27,7 +29,8 @@ _git_bash_completion_paths=(
# Load the first completion file found
_git_bash_completion_found=false
for _comp_path in "${_git_bash_completion_paths[@]}"; do
if [[ -r "$_comp_path" ]]; then
if [[ -r "$_comp_path" ]]
then
_git_bash_completion_found=true
# shellcheck disable=SC1090 # don't follow
source "$_comp_path"
@ -36,7 +39,8 @@ for _comp_path in "${_git_bash_completion_paths[@]}"; do
done
# Cleanup
if [[ "${_git_bash_completion_found}" == false ]]; then
if [[ "${_git_bash_completion_found}" == false ]]
then
_log_warning "no completion files found - please try enabling the 'system' completion instead."
fi
unset "${!_git_bash_completion@}"

30
completion/available/git_flow.completion.bash
View File

@ -45,11 +45,12 @@
#
# Distributed under the [MIT License](http://creativecommons.org/licenses/MIT/)
_git_flow ()
function _git_flow ()
{
local subcommands="init feature release hotfix"
local subcommand="$(__git_find_subcommand "$subcommands")"
if [ -z "$subcommand" ]; then
if [ -z "$subcommand" ]
then
__gitcomp "$subcommands"
return
fi
@ -73,11 +74,12 @@ _git_flow ()
esac
}
__git_flow_feature ()
function __git_flow_feature ()
{
local subcommands="list start finish publish track diff rebase checkout pull"
local subcommand="$(__git_find_subcommand "$subcommands")"
if [ -z "$subcommand" ]; then
if [ -z "$subcommand" ]
then
__gitcomp "$subcommands"
return
fi
@ -105,26 +107,27 @@ __git_flow_feature ()
esac
}
__git_flow_list_features ()
function __git_flow_list_features ()
{
git flow feature list 2> /dev/null | tr -d ' |*'
}
__git_flow_list_remote_features ()
function __git_flow_list_remote_features ()
{
git branch -r 2> /dev/null | grep "origin/$(__git_flow_feature_prefix)" | awk '{ sub(/^origin\/$(__git_flow_feature_prefix)/, "", $1); print }'
}
__git_flow_feature_prefix ()
function __git_flow_feature_prefix ()
{
git config gitflow.prefix.feature 2> /dev/null || echo "feature/"
}
__git_flow_release ()
function __git_flow_release ()
{
local subcommands="list start finish"
local subcommand="$(__git_find_subcommand "$subcommands")"
if [ -z "$subcommand" ]; then
if [ -z "$subcommand" ]
then
__gitcomp "$subcommands"
return
fi
@ -141,16 +144,17 @@ __git_flow_release ()
}
__git_flow_list_releases ()
function __git_flow_list_releases ()
{
git flow release list 2> /dev/null
}
__git_flow_hotfix ()
function __git_flow_hotfix ()
{
local subcommands="list start finish"
local subcommand="$(__git_find_subcommand "$subcommands")"
if [ -z "$subcommand" ]; then
if [ -z "$subcommand" ]
then
__gitcomp "$subcommands"
return
fi
@ -166,7 +170,7 @@ __git_flow_hotfix ()
esac
}
__git_flow_list_hotfixes ()
function __git_flow_list_hotfixes ()
{
git flow hotfix list 2> /dev/null
}

51
completion/available/git_flow_avh.completion.bash
View File

@ -53,11 +53,12 @@ __git_flow_config_file_options="
--local --global --system --file=
"
_git_flow ()
function _git_flow ()
{
local subcommands="init feature release hotfix support help version config finish delete publish rebase"
local subcommand="$(__git_find_on_cmdline "$subcommands")"
if [ -z "$subcommand" ]; then
if [ -z "$subcommand" ]
then
__gitcomp "$subcommands"
return
fi
@ -93,11 +94,12 @@ _git_flow ()
esac
}
__git_flow_init ()
function __git_flow_init ()
{
local subcommands="help"
local subcommand="$(__git_find_on_cmdline "$subcommands")"
if [ -z "$subcommand" ]; then
if [ -z "$subcommand" ]
then
__gitcomp "$subcommands"
fi
@ -113,12 +115,13 @@ __git_flow_init ()
esac
}
__git_flow_feature ()
function __git_flow_feature ()
{
local subcommands="list start finish publish track diff rebase checkout pull help delete"
local subcommand="$(__git_find_on_cmdline "$subcommands")"
if [ -z "$subcommand" ]; then
if [ -z "$subcommand" ]
then
__gitcomp "$subcommands"
return
fi
@ -196,11 +199,12 @@ __git_flow_feature ()
esac
}
__git_flow_release ()
function __git_flow_release ()
{
local subcommands="list start finish track publish help delete"
local subcommand="$(__git_find_on_cmdline "$subcommands")"
if [ -z "$subcommand" ]; then
if [ -z "$subcommand" ]
then
__gitcomp "$subcommands"
return
fi
@ -282,11 +286,12 @@ __git_flow_release ()
}
__git_flow_hotfix ()
function __git_flow_hotfix ()
{
local subcommands="list start finish track publish help delete"
local subcommand="$(__git_find_on_cmdline "$subcommands")"
if [ -z "$subcommand" ]; then
if [ -z "$subcommand" ]
then
__gitcomp "$subcommands"
return
fi
@ -366,11 +371,12 @@ __git_flow_hotfix ()
esac
}
__git_flow_support ()
function __git_flow_support ()
{
local subcommands="list start help"
local subcommand="$(__git_find_on_cmdline "$subcommands")"
if [ -z "$subcommand" ]; then
if [ -z "$subcommand" ]
then
__gitcomp "$subcommands"
return
fi
@ -406,11 +412,12 @@ __git_flow_support ()
esac
}
__git_flow_config ()
function __git_flow_config ()
{
local subcommands="list set base"
local subcommand="$(__git_find_on_cmdline "$subcommands")"
if [ -z "$subcommand" ]; then
if [ -z "$subcommand" ]
then
__gitcomp "$subcommands"
return
fi
@ -450,9 +457,9 @@ __git_flow_config ()
esac
}
__git_flow_prefix ()
function __git_flow_prefix ()
{
case "$1" in
case "${1}" in
feature|release|hotfix|support)
git config "gitflow.prefix.$1" 2> /dev/null || echo "$1/"
return
@ -460,9 +467,10 @@ __git_flow_prefix ()
esac
}
__git_flow_list_local_branches ()
function __git_flow_list_local_branches ()
{
if [ -n "$1" ]; then
if [ -n "${1}" ]
then
local prefix="$(__git_flow_prefix $1)"
git for-each-ref --shell --format="ref=%(refname:short)" refs/heads/$prefix | \
while read -r entry; do
@ -476,7 +484,7 @@ __git_flow_list_local_branches ()
fi
}
__git_flow_list_remote_branches ()
function __git_flow_list_remote_branches ()
{
local prefix="$(__git_flow_prefix $1)"
local origin="$(git config gitflow.origin 2> /dev/null || echo "origin")"
@ -488,10 +496,11 @@ __git_flow_list_remote_branches ()
done | sort
}
__git_flow_list_branches ()
function __git_flow_list_branches ()
{
local origin="$(git config gitflow.origin 2> /dev/null || echo "origin")"
if [ -n "$1" ]; then
if [ -n "${1}" ]
then
local prefix="$(__git_flow_prefix $1)"
git for-each-ref --shell --format="ref=%(refname:short)" refs/heads/$prefix refs/remotes/$origin/$prefix | \
while read -r entry; do

3
completion/available/github-cli.completion.bash
View File

@ -2,7 +2,8 @@
cite "about-completion"
about-completion "GitHub CLI completion"
if _binary_exists gh; then
if _binary_exists gh
then
# If gh already completed, stop
_completion_exists gh && return
eval "$(gh completion --shell=bash)"

6
completion/available/go.completion.bash
View File

@ -6,9 +6,11 @@ about-completion "completion for go command using gocomplete"
# Test `go version` because goenv creates shim scripts that will be found in PATH
# but do not always resolve to a working install.
if _command_exists go && go version &> /dev/null; then
if _command_exists go && go version &> /dev/null
then
# Same idea here, but no need to test a subcommand
if _command_exists gocomplete && gocomplete &> /dev/null; then
if _command_exists gocomplete && gocomplete &> /dev/null
then
# finally, apply completion
complete -C gocomplete go
fi

187
completion/available/gradle.completion.bash
View File

@ -24,56 +24,102 @@
# Avoid inaccurate completions for subproject tasks
COMP_WORDBREAKS=$(echo "$COMP_WORDBREAKS" | sed -e 's/://g')
function __gradle-set-project-root-dir() {
function __gradle-set-project-root-dir()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
project_root_dir="$(_bash-it-find-in-ancestor "settings.gradle" "gradlew")"
return "$?"
return "${?}"
}
__gradle-init-cache-dir() {
function __gradle-init-cache-dir()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
cache_dir="$HOME/.gradle/completion"
mkdir -p $cache_dir
mkdir -p ${cache_dir}
}
__gradle-set-build-file() {
function __gradle-set-build-file()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
# Look for default build script in the settings file (settings.gradle by default)
# Otherwise, default is the file 'build.gradle' in the current directory.
gradle_build_file="$project_root_dir/build.gradle"
if [[ -f "$project_root_dir/settings.gradle" ]]; then
if [[ -f "$project_root_dir/settings.gradle" ]]
then
local build_file_name=$(grep "^rootProject\.buildFileName" "$project_root_dir/settings.gradle" | \
sed -n -e "s/rootProject\.buildFileName = [\'\"]\(.*\)[\'\"]/\1/p")
gradle_build_file="$project_root_dir/${build_file_name:-build.gradle}"
fi
}
__gradle-set-cache-name() {
function __gradle-set-cache-name()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
# Cache name is constructed from the absolute path of the build file.
cache_name=$(echo $gradle_build_file | sed -e 's/\//_/g')
}
__gradle-set-files-checksum() {
function __gradle-set-files-checksum()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
# Cache MD5 sum of all Gradle scripts and modified timestamps
if _command_exists md5; then
if _command_exists md5
then
gradle_files_checksum=$(md5 -q -s "$(cat "$cache_dir/$cache_name" | xargs ls -o 2>/dev/null)")
elif _command_exists md5sum; then
elif _command_exists md5sum
then
gradle_files_checksum=$(cat "$cache_dir/$cache_name" | xargs ls -o 2>/dev/null | md5sum | awk '{print $1}')
else
echo "Cannot generate completions as neither md5 nor md5sum exist on \$PATH"
fi
}
__gradle-generate-script-cache() {
function __gradle-generate-script-cache()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
# Invalidate cache after 3 weeks by default
local cache_ttl_mins=${GRADLE_CACHE_TTL_MINUTES:-30240}
local script_exclude_pattern=${GRADLE_COMPLETION_EXCLUDE_PATTERN:-"/(build|integTest|out)/"}
if [[ ! $(find $cache_dir/$cache_name -mmin -$cache_ttl_mins 2>/dev/null) ]]; then
if [[ ! $(find $cache_dir/$cache_name -mmin -$cache_ttl_mins 2>/dev/null) ]]
then
# Cache all Gradle scripts
local gradle_build_scripts=$(find $project_root_dir -type f -name "*.gradle" -o -name "*.gradle.kts" 2>/dev/null | grep -E -v "$script_exclude_pattern")
printf "%s\n" "${gradle_build_scripts[@]}" > $cache_dir/$cache_name
fi
}
__gradle-long-options() {
function __gradle-long-options()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local args="--build-cache - Enables the Gradle build cache
--build-file - Specifies the build file
--configure-on-demand - Only relevant projects are configured
@ -118,7 +164,12 @@ __gradle-long-options() {
COMPREPLY=( $(compgen -W "$args" -- "${COMP_WORDS[COMP_CWORD]}") )
}
__gradle-properties() {
function __gradle-properties()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local args="-Dorg.gradle.cache.reserved.mb= - Reserve Gradle Daemon memory for operations
-Dorg.gradle.caching= - Set true to enable Gradle build cache
-Dorg.gradle.daemon.debug= - Set true to debug Gradle Daemon
@ -134,7 +185,12 @@ __gradle-properties() {
return 0
}
__gradle-short-options() {
function __gradle-short-options()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local args="-? - Shows a help message
-a - Do not rebuild project dependencies
-b - Specifies the build file
@ -159,7 +215,12 @@ __gradle-short-options() {
COMPREPLY=( $(compgen -W "$args" -- "${COMP_WORDS[COMP_CWORD]}") )
}
__gradle-notify-tasks-cache-build() {
function __gradle-notify-tasks-cache-build()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
# Notify user of cache rebuild
echo -e " (Building completion cache. Please wait)\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\c"
__gradle-generate-tasks-cache
@ -167,22 +228,29 @@ __gradle-notify-tasks-cache-build() {
echo -e " \b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\c"
}
__gradle-generate-tasks-cache() {
function __gradle-generate-tasks-cache()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
__gradle-set-files-checksum
# Use Gradle wrapper when it exists.
local gradle_cmd="gradle"
if [[ -x "$project_root_dir/gradlew" ]]; then
gradle_cmd="$project_root_dir/gradlew"
if [[ -x "${project_root_dir}/gradlew" ]]
then
gradle_cmd="${project_root_dir}/gradlew"
fi
# Run gradle to retrieve possible tasks and cache.
# Reuse Gradle Daemon if IDLE but don't start a new one.
local gradle_tasks_output
if [[ ! -z "$($gradle_cmd --status 2>/dev/null | grep IDLE)" ]]; then
gradle_tasks_output="$($gradle_cmd -b $gradle_build_file --daemon -q tasks --all)"
if [[ ! -z "$($gradle_cmd --status 2>/dev/null | grep IDLE)" ]]
then
gradle_tasks_output="$(${gradle_cmd} -b ${gradle_build_file} --daemon -q tasks --all)"
else
gradle_tasks_output="$($gradle_cmd -b $gradle_build_file --no-daemon -q tasks --all)"
gradle_tasks_output="$(${gradle_cmd} -b ${gradle_build_file} --no-daemon -q tasks --all)"
fi
local output_line
local task_description
@ -190,12 +258,14 @@ __gradle-generate-tasks-cache() {
local -a root_tasks=()
local -a subproject_tasks=()
for output_line in $gradle_tasks_output; do
if [[ $output_line =~ ^([[:lower:]][[:alnum:][:punct:]]*)([[:space:]]-[[:space:]]([[:print:]]*))? ]]; then
if [[ $output_line =~ ^([[:lower:]][[:alnum:][:punct:]]*)([[:space:]]-[[:space:]]([[:print:]]*))? ]]
then
task_name="${BASH_REMATCH[1]}"
task_description="${BASH_REMATCH[3]}"
gradle_all_tasks+=( "$task_name - $task_description" )
# Completion for subproject tasks with ':' prefix
if [[ $task_name =~ ^([[:alnum:][:punct:]]+):([[:alnum:]]+) ]]; then
if [[ $task_name =~ ^([[:alnum:][:punct:]]+):([[:alnum:]]+) ]]
then
gradle_all_tasks+=( ":$task_name - $task_description" )
subproject_tasks+=( "${BASH_REMATCH[2]}" )
else
@ -205,28 +275,36 @@ __gradle-generate-tasks-cache() {
done
# subproject tasks can be referenced implicitly from root project
if [[ $GRADLE_COMPLETION_UNQUALIFIED_TASKS == "true" ]]; then
if [[ $GRADLE_COMPLETION_UNQUALIFIED_TASKS == "true" ]]
then
local -a implicit_tasks=()
implicit_tasks=( $(comm -23 <(printf "%s\n" "${subproject_tasks[@]}" | sort) <(printf "%s\n" "${root_tasks[@]}" | sort)) )
for task in $(printf "%s\n" "${implicit_tasks[@]}"); do
for task in $(printf "%s\n" "${implicit_tasks[@]}")
do
gradle_all_tasks+=( $task )
done
fi
printf "%s\n" "${gradle_all_tasks[@]}" > $cache_dir/$gradle_files_checksum
echo $gradle_files_checksum > $cache_dir/$cache_name.md5
printf "%s\n" "${gradle_all_tasks[@]}" > ${cache_dir}/${gradle_files_checksum}
echo ${gradle_files_checksum} > ${cache_dir}/${cache_name}.md5
}
__gradle-completion-init() {
function __gradle-completion-init()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local cache_dir cache_name gradle_build_file gradle_files_checksum project_root_dir
local OLDIFS="$IFS"
local OLDIFS="${IFS}"
local IFS=$'\n'
__gradle-init-cache-dir
__gradle-set-project-root-dir
__gradle-set-build-file
if [[ -f $gradle_build_file ]]; then
if [[ -f ${gradle_build_file} ]]
then
__gradle-set-cache-name
__gradle-generate-script-cache
__gradle-set-files-checksum
@ -238,45 +316,57 @@ __gradle-completion-init() {
return 0
}
_gradle() {
function _gradle()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local cache_dir cache_name gradle_build_file gradle_files_checksum project_root_dir
local cur=${COMP_WORDS[COMP_CWORD]}
local cur="${COMP_WORDS[COMP_CWORD]}"
# Set bash internal field separator to '\n'
# This allows us to provide descriptions for options and tasks
local OLDIFS="$IFS"
local OLDIFS="${IFS}"
local IFS=$'\n'
if [[ ${cur} == --* ]]; then
if [[ ${cur} == --* ]]
then
__gradle-long-options
elif [[ ${cur} == -D* ]]; then
elif [[ ${cur} == -D* ]]
then
__gradle-properties
elif [[ ${cur} == -* ]]; then
elif [[ ${cur} == -* ]]
then
__gradle-short-options
else
__gradle-init-cache-dir
__gradle-set-project-root-dir
__gradle-set-build-file
if [[ -f $gradle_build_file ]]; then
if [[ -f ${gradle_build_file} ]]
then
__gradle-set-cache-name
__gradle-generate-script-cache
__gradle-set-files-checksum
# The cache key is md5 sum of all gradle scripts, so it's valid if it exists.
if [[ -f $cache_dir/$cache_name.md5 ]]; then
local cached_checksum="$(cat $cache_dir/$cache_name.md5)"
if [[ -f ${cache_dir}/${cache_name}.md5 ]]
then
local cached_checksum="$(cat ${cache_dir}/${cache_name}.md5)"
local -a cached_tasks
if [[ -z $cur ]]; then
cached_tasks=( $(cat $cache_dir/$cached_checksum) )
if [[ -z ${cur} ]]
then
cached_tasks=( $(cat ${cache_dir}/${cached_checksum}) )
else
cached_tasks=( $(grep "^$cur" $cache_dir/$cached_checksum) )
cached_tasks=( $(grep "^${cur}" ${cache_dir}/${cached_checksum}) )
fi
COMPREPLY=( $(compgen -W "${cached_tasks[*]}" -- "$cur") )
COMPREPLY=( $(compgen -W "${cached_tasks[*]}" -- "${cur}") )
else
__gradle-notify-tasks-cache-build
fi
# Regenerate tasks cache in the background
if [[ $gradle_files_checksum != "$(cat $cache_dir/$cache_name.md5)" || ! -f $cache_dir/$gradle_files_checksum ]]; then
if [[ ${gradle_files_checksum} != "$(cat ${cache_dir}/$cache_name.md5)" || ! -f ${cache_dir}/${gradle_files_checksum} ]]
then
$(__gradle-generate-tasks-cache 1>&2 2>/dev/null &)
fi
else
@ -300,12 +390,14 @@ wrapper - Generates Gradle wrapper files."
IFS="$OLDIFS"
# Remove description ("[:space:]" and after) if only one possibility
if [[ ${#COMPREPLY[*]} -eq 1 ]]; then
if [[ ${#COMPREPLY[*]} -eq 1 ]]
then
COMPREPLY=( ${COMPREPLY[0]%% *} )
fi
return 0
}
complete -F _gradle gradle
complete -F _gradle gradle.bat
complete -F _gradle gradlew
@ -313,6 +405,7 @@ complete -F _gradle gradlew.bat
complete -F _gradle ./gradlew
complete -F _gradle ./gradlew.bat
if hash gw 2>/dev/null || alias gw >/dev/null 2>&1; then
if hash gw 2>/dev/null || alias gw >/dev/null 2>&1
then
complete -F _gradle gw
fi

3
completion/available/grunt.completion.bash
View File

@ -45,7 +45,8 @@ function _grunt_gruntfile() {
local curpath="$PWD"
while [[ "$curpath" ]]; do
for gruntfile in "$curpath/"{G,g}runtfile.{js,coffee}; do
if [[ -e "$gruntfile" ]]; then
if [[ -e "$gruntfile" ]]
then
echo "$gruntfile"
return
fi

3
completion/available/helm.completion.bash
View File

@ -2,6 +2,7 @@
cite "about-completion"
about-completion "helm (Kubernetes Package Manager) completion"
if _command_exists helm; then
if _command_exists helm
then
eval "$(helm completion bash)"
fi

222
completion/available/hub.completion.bash
View File

@ -23,12 +23,14 @@
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
# If there is no git tab completion, but we have the _completion loader try to load it
if ! _is_function _git && _is_function _completion_loader; then
if ! _is_function _git && _is_function _completion_loader
then
_completion_loader git
fi
# Check that git tab completion is available and we haven't already set up completion
if _is_function _git && ! _is_function __git_list_all_commands_without_hub; then
if _is_function _git && ! _is_function __git_list_all_commands_without_hub
then
# Duplicate and rename the 'list_all_commands' function
eval "$(declare -f __git_list_all_commands | \
sed 's/__git_list_all_commands/__git_list_all_commands_without_hub/')"
@ -60,17 +62,25 @@ EOF
##########################
# hub alias [-s] [SHELL]
_git_alias() {
function _git_alias()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local i c=2 s=-s sh shells="bash zsh sh ksh csh fish"
while [ $c -lt $cword ]; do
while [ $c -lt $cword ]
do
i="${words[c]}"
case "$i" in
-s)
unset s
;;
*)
for sh in $shells; do
if [ "$sh" = "$i" ]; then
for sh in ${shells}
do
if [ "$sh" = "$i" ]
then
unset shells
break
fi
@ -79,35 +89,44 @@ EOF
esac
((c++))
done
__gitcomp "$s $shells"
__gitcomp "$s ${shells}"
}
# hub browse [-u] [--|[USER/]REPOSITORY] [SUBPAGE]
_git_browse() {
function _git_browse()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local i c=2 u=-u repo subpage
local subpages_="commits issues tree wiki pulls branches stargazers
contributors network network/ graphs graphs/"
local subpages_network="members"
local subpages_graphs="commit-activity code-frequency punch-card"
while [ $c -lt $cword ]; do
while [ $c -lt $cword ]
do
i="${words[c]}"
case "$i" in
-u)
unset u
;;
*)
if [ -z "$repo" ]; then
repo=$i
if [ -z "${repo}" ]
then
repo=${i}
else
subpage=$i
subpage=${i}
fi
;;
esac
((c++))
done
if [ -z "$repo" ]; then
if [ -z "${repo}" ]
then
__gitcomp "$u -- $(__hub_github_repos '\p')"
elif [ -z "$subpage" ]; then
elif [ -z "${subpage}" ]
then
case "$cur" in
*/*)
local pfx="${cur%/*}" cur_="${cur#*/}"
@ -124,29 +143,38 @@ EOF
}
# hub compare [-u] [USER[/REPOSITORY]] [[START...]END]
_git_compare() {
function _git_compare()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local i c=$((cword - 1)) u=-u user remote owner repo arg_repo rev
while [ $c -gt 1 ]; do
while [ $c -gt 1 ]
do
i="${words[c]}"
case "$i" in
-u)
unset u
;;
*)
if [ -z "$rev" ]; then
if [ -z "$rev" ]
then
# Even though the logic below is able to complete both user/repo
# and revision in the right place, when there is only one argument
# (other than -u) in the command, that argument will be taken as
# revision. For example:
# $ hub compare -u upstream
# > https://github.com/USER/REPO/compare/upstream
if __hub_github_repos '\p' | grep -Eqx "^$i(/[^/]+)?"; then
arg_repo=$i
if __hub_github_repos '\p' | grep -Eqx "^$i(/[^/]+)?"
then
arg_repo=${i}
else
rev=$i
fi
elif [ -z "$arg_repo" ]; then
arg_repo=$i
elif [ -z "${arg_repo}" ]
then
arg_repo=${i}
fi
;;
esac
@ -155,28 +183,35 @@ EOF
# Here we want to find out the git remote name of user/repo, in order to
# generate an appropriate revision list
if [ -z "$arg_repo" ]; then
if [ -z "$arg_repo" ]
then
user=$(__hub_github_user)
if [ -z "$user" ]; then
for i in $(__hub_github_repos); do
if [ -z "$user" ]
then
for i in $(__hub_github_repos)
do
remote=${i%%:*}
repo=${i#*:}
if [ "$remote" = origin ]; then
if [ "$remote" = origin ]
then
break
fi
done
else
for i in $(__hub_github_repos); do
for i in $(__hub_github_repos)
do
remote=${i%%:*}
repo=${i#*:}
owner=${repo%%/*}
if [ "$user" = "$owner" ]; then
if [ "$user" = "$owner" ]
then
break
fi
done
fi
else
for i in $(__hub_github_repos); do
for i in $(__hub_github_repos)
do
remote=${i%%:*}
repo=${i#*:}
owner=${repo%%/*}
@ -188,18 +223,20 @@ EOF
done
fi
local pfx cur_="$cur"
case "$cur_" in
local pfx cur_="${cur}"
case "${cur_}" in
*..*)
pfx="${cur_%%..*}..."
cur_="${cur_##*..}"
__gitcomp_nl "$(__hub_revlist $remote)" "$pfx" "$cur_"
__gitcomp_nl "$(__hub_revlist ${remote})" "${pfx}" "${cur_}"
;;
*)
if [ -z "${arg_repo}${rev}" ]; then
__gitcomp "$u $(__hub_github_repos '\o\n\p') $(__hub_revlist $remote)"
elif [ -z "$rev" ]; then
__gitcomp "$u $(__hub_revlist $remote)"
if [ -z "${arg_repo}${rev}" ]
then
__gitcomp "$u $(__hub_github_repos '\o\n\p') $(__hub_revlist ${remote})"
elif [ -z "$rev" ]
then
__gitcomp "$u $(__hub_revlist ${remote})"
else
__gitcomp "$u"
fi
@ -208,9 +245,15 @@ EOF
}
# hub create [NAME] [-p] [-d DESCRIPTION] [-h HOMEPAGE]
_git_create() {
function _git_create()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local i c=2 name repo flags="-p -d -h"
while [ $c -lt $cword ]; do
while [ $c -lt $cword ]
do
i="${words[c]}"
case "$i" in
-d|-h)
@ -226,7 +269,8 @@ EOF
esac
((c++))
done
if [ -z "$name" ]; then
if [ -z "$name" ]
then
repo="$(basename "${PWD}")"
fi
case "$prev" in
@ -234,15 +278,21 @@ EOF
COMPREPLY=()
;;
-p|*)
__gitcomp "$repo $flags"
__gitcomp "${repo} ${flags}"
;;
esac
}
# hub fork [--no-remote] [--remote-name REMOTE] [--org ORGANIZATION]
_git_fork() {
function _git_fork()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local i c=2 flags="--no-remote --remote-name --org"
while [ $c -lt $cword ]; do
while [ $c -lt ${cword} ]
do
i="${words[c]}"
case "$i" in
--org)
@ -261,20 +311,26 @@ EOF
esac
((c++))
done
case "$prev" in
case "${prev}" in
--remote-name|--org)
COMPREPLY=()
;;
*)
__gitcomp "$flags"
__gitcomp "${flags}"
;;
esac
}
# hub pull-request [-f] [-m <MESSAGE>|-F <FILE>|-i <ISSUE>|<ISSUE-URL>] [-b <BASE>] [-h <HEAD>] [-a <USER>] [-M <MILESTONE>] [-l <LABELS>]
_git_pull_request() {
fucntion _git_pull_request()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local i c=2 flags="-f -m -F -i -b -h -a -M -l"
while [ $c -lt $cword ]; do
while [ $c -lt ${cword} ]
do
i="${words[c]}"
case "$i" in
-m|-F|-i|-b|-h|-a|-M|-l)
@ -299,10 +355,10 @@ EOF
# __ltrim_colon_completions "$cur"
;;
-F)
COMPREPLY=( "$cur"* )
COMPREPLY=( "${cur}"* )
;;
-f|*)
__gitcomp "$flags"
__gitcomp "${flags}"
;;
esac
}
@ -314,21 +370,32 @@ EOF
# __hub_github_user [HOST]
# Return $GITHUB_USER or the default github user defined in hub config
# HOST - Host to be looked-up in hub config. Default is "github.com"
__hub_github_user() {
if [ -n "$GITHUB_USER" ]; then
function __hub_github_user()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
if [ -n "$GITHUB_USER" ]
then
echo $GITHUB_USER
return
fi
local line h k v host=${1:-github.com} config=${HUB_CONFIG:-~/.config/hub}
if [ -f "$config" ]; then
while read line; do
if [ "$line" = "---" ]; then
if [ -f "$config" ]
then
while read line
do
if [ "$line" = "---" ]
then
continue
fi
k=${line%%:*}
v=${line#*:}
if [ -z "$v" ]; then
if [ "$h" = "$host" ]; then
if [ -z "$v" ]
then
if [ "$h" = "$host" ]
then
break
fi
h=$k
@ -336,11 +403,12 @@ EOF
fi
k=${k#* }
v=${v#* }
if [ "$h" = "$host" ] && [ "$k" = "user" ]; then
if [ "$h" = "$host" ] && [ "$k" = "user" ]
then
echo "$v"
break
fi
done < "$config"
done < "${config}"
fi
}
@ -352,12 +420,19 @@ EOF
# \o owner
# escaped characters (\n, \t ...etc) work
# If omitted, prints all github repos in the format of "remote:owner/repo"
__hub_github_repos() {
function __hub_github_repos()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local f format=$1
if [ -z "$(__gitdir)" ]; then
if [ -z "$(__gitdir)" ]
then
return
fi
if [ -z "$format" ]; then
if [ -z "$format" ]
then
format='\1:\2'
else
format=${format//\m/\1}
@ -371,16 +446,24 @@ EOF
# __hub_heads
# List all local "branch", and remote "owner/repo:branch"
__hub_heads() {
function __hub_heads()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local i remote repo branch dir=$(__gitdir)
if [ -d "$dir" ]; then
if [ -d "$dir" ]
then
command git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
"refs/heads/"
for i in $(__hub_github_repos); do
for i in $(__hub_github_repos)
do
remote=${i%%:*}
repo=${i#*:}
command git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
"refs/remotes/${remote}/" | while read branch; do
"refs/remotes/${remote}/" | while read branch
do
echo "${repo}:${branch#${remote}/}"
done
done
@ -390,11 +473,18 @@ EOF
# __hub_revlist [REMOTE]
# List all tags, and branches under REMOTE, without the "remote/" prefix
# REMOTE - Remote name to search branches from. Default is "origin"
__hub_revlist() {
function __hub_revlist()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local i remote=${1:-origin} dir=$(__gitdir)
if [ -d "$dir" ]; then
if [ -d "$dir" ]
then
command git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
"refs/remotes/${remote}/" | while read i; do
"refs/remotes/${remote}/" | while read i
do
echo "${i#${remote}/}"
done
command git --git-dir="$dir" for-each-ref --format='%(refname:short)' \

7
completion/available/invoke.completion.bash
View File

@ -25,7 +25,12 @@
# https://github.com/pyinvoke/invoke/blob/master/completion/bash
_complete_invoke() {
funciton _complete_invoke()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local candidates
# COMP_WORDS contains the entire command string up til now (including

3
completion/available/jungle.completion.bash
View File

@ -2,6 +2,7 @@
cite "about-completion"
about-completion "jungle(AWS cli tool) completion"
if _command_exists jungle; then
if _command_exists jungle
then
eval "$(_JUNGLE_COMPLETE=source jungle)"
fi

3
completion/available/kind.completion.bash
View File

@ -1,5 +1,6 @@
#!/usr/bin/env bash
if _command_exists kind; then
if _command_exists kind
then
eval "$(kind completion bash)"
fi

137
completion/available/knife.completion.bash
View File

@ -33,20 +33,27 @@ stat -c %Y /dev/null > /dev/null 2>&1 && _KAC_STAT_COMMAND="stat -c %Y" || _KAC_
# returns 0 iff the file whose path is given as 1st argument
# exists and has last been modified in the last $2 seconds
# returns 1 otherwise
_KAC_is_file_newer_than() {
[ -f "$1" ] || return 1
[ $(($(date +%s) - $($_KAC_STAT_COMMAND "$1"))) -gt "$2" ] && return 1 || return 0
function _KAC_is_file_newer_than()
{
[ -f "${1}" ] || return 1
[ $(($(date +%s) - $($_KAC_STAT_COMMAND "${1}"))) -gt "${2}" ] && return 1 || return 0
}
# helper function for _KAC_get_and_regen_cache, see doc below
_KAC_regen_cache() {
local CACHE_NAME=$1
local CACHE_PATH="$_KNIFE_AUTOCOMPLETE_CACHE_DIR/$CACHE_NAME"
function _KAC_regen_cache()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local CACHE_NAME="${1}"
local CACHE_PATH="${_KNIFE_AUTOCOMPLETE_CACHE_DIR}/${CACHE_NAME}"
# shellcheck disable=SC2155
local TMP_FILE=$(mktemp "$_KAC_CACHE_TMP_DIR/$CACHE_NAME.XXXX")
local TMP_FILE="$(mktemp "${_KAC_CACHE_TMP_DIR}/${CACHE_NAME}.XXXX")"
shift 1
# discard the temp file if it's empty AND the previous command didn't exit successfully, but still mark the cache as updated
if ! "$@" > "$TMP_FILE" 2> /dev/null; then
if ! "$@" > "$TMP_FILE" 2> /dev/null
then
[[ $(wc -l "$TMP_FILE") == 0 ]] && rm -f "$TMP_FILE" && touch "$CACHE_PATH" && return 1
else
mv -f "$TMP_FILE" "$CACHE_PATH"
@ -54,12 +61,22 @@ _KAC_regen_cache() {
}
# cached files can't have spaces in their names
_KAC_get_cache_name_from_command() {
function _KAC_get_cache_name_from_command()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
echo "${@// /_SPACE_}"
}
# the reverse operation from the function above
_KAC_get_command_from_cache_name() {
function _KAC_get_command_from_cache_name()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
echo "${@//_SPACE_/ }"
}
@ -68,35 +85,48 @@ _KAC_get_command_from_cache_name() {
# in either case, it regenerates the cache, and sets the _KAC_CACHE_PATH env variable
# for obvious reason, do NOT call that in a sub-shell (in particular, no piping)
# shellcheck disable=SC2155
_KAC_get_and_regen_cache() {
function _KAC_get_and_regen_cache()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
# the cache name can't have space in it
local CACHE_NAME=$(_KAC_get_cache_name_from_command "$@")
local REGEN_CMD="_KAC_regen_cache $CACHE_NAME $*"
_KAC_CACHE_PATH="$_KNIFE_AUTOCOMPLETE_CACHE_DIR/$CACHE_NAME"
local REGEN_CMD="_KAC_regen_cache ${CACHE_NAME} $*"
_KAC_CACHE_PATH="${_KNIFE_AUTOCOMPLETE_CACHE_DIR}/${CACHE_NAME}"
# no need to wait for the regen if the file already exists
if [[ -f "$_KAC_CACHE_PATH" ]]; then
($REGEN_CMD &)
if [[ -f "${_KAC_CACHE_PATH}" ]]
then
(${REGEN_CMD} &)
else
$REGEN_CMD
${REGEN_CMD}
fi
}
# performs two things: first, deletes all obsolete temp files
# then refreshes stale caches that haven't been called in a long time
_KAC_clean_cache() {
function _KAC_clean_cache()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local FILE CMD
# delete all obsolete temp files, could be lingering there for any kind of crash in the caching process
for FILE in "$_KAC_CACHE_TMP_DIR"/*; do
_KAC_is_file_newer_than "$FILE" "$_KNIFE_AUTOCOMPLETE_MAX_CACHE_AGE" || rm -f "$FILE"
for FILE in "$_KAC_CACHE_TMP_DIR"/*
do
_KAC_is_file_newer_than "${FILE}" "${_KNIFE_AUTOCOMPLETE_MAX_CACHE_AGE}" || rm -f "${FILE}"
done
# refresh really stale caches
find "$_KNIFE_AUTOCOMPLETE_CACHE_DIR" -maxdepth 1 -type f -not -name '.*' \
| while read -r FILE; do
_KAC_is_file_newer_than "$FILE" "$_KNIFE_AUTOCOMPLETE_MAX_CACHE_AGE" && continue
find "${_KNIFE_AUTOCOMPLETE_CACHE_DIR}" -maxdepth 1 -type f -not -name '.*' \
| while read -r FILE
do
_KAC_is_file_newer_than "${FILE}" "${_KNIFE_AUTOCOMPLETE_MAX_CACHE_AGE}" && continue
# first let's get the original command
CMD=$(_KAC_get_command_from_cache_name "$(basename "$FILE")")
# then regen the cache
_KAC_get_and_regen_cache "$CMD" > /dev/null
_KAC_get_and_regen_cache "${CMD}" > /dev/null
done
}
@ -109,26 +139,37 @@ _KAC_clean_cache() {
#####################################
# returns all the possible knife sub-commands
_KAC_knife_commands() {
function _KAC_knife_commands()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
knife --help | grep -E "^knife" | sed -E 's/ \(options\)//g'
}
# rebuilds the knife base command currently being completed, and assigns it to $_KAC_CURRENT_COMMAND
# additionnally, returns 1 iff the current base command is not complete, 0 otherwise
# also sets $_KAC_CURRENT_COMMAND_NB_WORDS if the base command is complete
_KAC_get_current_base_command() {
function _KAC_get_current_base_command()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local PREVIOUS="knife"
local I=1
local CURRENT
while [[ "${I}" -le "${COMP_CWORD}" ]]; do
while [[ "${I}" -le "${COMP_CWORD}" ]]
do
# command words are all lower-case
echo "${COMP_WORDS[$I]}" | grep -E "^[a-z]+$" > /dev/null || break
CURRENT="$PREVIOUS ${COMP_WORDS[$I]}"
grep -E "^$CURRENT" "$_KAC_CACHE_PATH" > /dev/null || break
PREVIOUS=$CURRENT
CURRENT="${PREVIOUS} ${COMP_WORDS[$I]}"
grep -E "^${CURRENT}" "${_KAC_CACHE_PATH}" > /dev/null || break
PREVIOUS="${CURRENT}"
I=$((I + 1))
done
_KAC_CURRENT_COMMAND=$PREVIOUS
_KAC_CURRENT_COMMAND="${PREVIOUS}"
[[ "${I}" -le "${COMP_CWORD}" ]] && _KAC_CURRENT_COMMAND_NB_WORDS="${I}"
}
@ -136,21 +177,32 @@ _KAC_get_current_base_command() {
# (i.e. handles "plural" arguments such as knife cookbook upload cookbook1 cookbook2 and so on...)
# assumes the current base command is complete
# shellcheck disable=SC2155
_KAC_get_current_arg_position() {
function _KAC_get_current_arg_position()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local CURRENT_ARG_POS=$((_KAC_CURRENT_COMMAND_NB_WORDS + 1))
local COMPLETE_COMMAND=$(grep -E "^$_KAC_CURRENT_COMMAND" "$_KAC_CACHE_PATH")
local COMPLETE_COMMAND=$(grep -E "^${_KAC_CURRENT_COMMAND}" "${_KAC_CACHE_PATH}")
local CURRENT_ARG
while [ "$CURRENT_ARG_POS" -le "$COMP_CWORD" ]; do
CURRENT_ARG=$(echo "$COMPLETE_COMMAND" | cut -d ' ' -f "$CURRENT_ARG_POS")
while [ "${CURRENT_ARG_POS}" -le "${COMP_CWORD}" ]
do
CURRENT_ARG=$(echo "${COMPLETE_COMMAND}" | cut -d ' ' -f "${CURRENT_ARG_POS}")
# we break if the current arg is a "plural" arg
echo "$CURRENT_ARG" | grep -E "^\\[[^]]+(\\.\\.\\.\\]|$)" > /dev/null && break
echo "${CURRENT_ARG}" | grep -E "^\\[[^]]+(\\.\\.\\.\\]|$)" > /dev/null && break
CURRENT_ARG_POS=$((CURRENT_ARG_POS + 1))
done
echo "$CURRENT_ARG_POS"
echo "${CURRENT_ARG_POS}"
}
# the actual auto-complete function
_knife() {
function _knife()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
_KAC_get_and_regen_cache _KAC_knife_commands
local RAW_LIST ITEM REGEN_CMD ARG_POSITION
# shellcheck disable=SC2034
@ -165,10 +217,11 @@ _knife() {
# current base command - that might limit my script in some situation, but that way I'm sure it caches only
# not-sensitive stuff (a generic approach could be pretty bad e.g. with the knife-rackspace plugin)
LIST=""
for ITEM in $RAW_LIST; do
for ITEM in $RAW_LIST
do
# always relevant if only lower-case chars : continuation of the base command
echo "$ITEM" | grep -E "^[a-z]+$" > /dev/null && LIST="$LIST $ITEM" && continue
case "$ITEM" in
echo "${ITEM}" | grep -E "^[a-z]+$" > /dev/null && LIST="${LIST} ${ITEM}" && continue
case "${ITEM}" in
*COOKBOOK*)
# special case for cookbooks : from site or local
[[ ${COMP_WORDS[2]} == 'site' ]] && REGEN_CMD="knife cookbook site list" || REGEN_CMD="knife cookbook list"
@ -179,11 +232,11 @@ _knife() {
*ITEM*)
# data bag item : another special case
local DATA_BAG_NAME=${COMP_WORDS[$((COMP_CWORD - 1))]}
REGEN_CMD="knife data bag show $DATA_BAG_NAME"
REGEN_CMD="knife data bag show ${DATA_BAG_NAME}"
;;
*INDEX*)
# see doc @ http://docs.opscode.com/knife_search.html
LIST="$LIST client environment node role"
LIST="${LIST} client environment node role"
REGEN_CMD="knife data bag list"
;;
*BAG*) REGEN_CMD="knife data bag list" ;;

3
completion/available/kontena.completion.bash
View File

@ -1,5 +1,6 @@
# shellcheck shell=bash
if _command_exists kontena; then
if _command_exists kontena
then
# shellcheck disable=SC1090
source "$(kontena whoami --bash-completion-path)"
fi

3
completion/available/kubectl.completion.bash
View File

@ -2,6 +2,7 @@
cite "about-completion"
about-completion "kubectl (Kubernetes CLI) completion"
if _binary_exists kubectl; then
if _binary_exists kubectl
then
eval "$(kubectl completion bash)"
fi

13
completion/available/laravel.completion.bash
View File

@ -2,12 +2,19 @@
_command_exists laravel || return
function __laravel_completion() {
function __laravel_completion()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local OPTS=('-h' '--help' '-q' '--quiet' '--ansi' '--no-ansi' '-n' '--no-interaction' '-v' '-vv' '-vvv' '--verbose' 'help' 'list' 'new')
local _opt_
COMPREPLY=()
for _opt_ in "${OPTS[@]}"; do
if [[ "$_opt_" == "$2"* ]]; then
for _opt_ in "${OPTS[@]}"
do
if [[ "${_opt_}" == "${2}"* ]]
then
COMPREPLY+=("$_opt_")
fi
done

7
completion/available/lerna.completion.bash
View File

@ -2,7 +2,12 @@
cite "about-completion"
about-completion "lerna(javascript project manager tool) completion"
function __lerna_completion() {
function __lerna_completion()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local cur compls
# The currently-being-completed word.

3
completion/available/makefile.completion.bash
View File

@ -3,7 +3,8 @@
# Bash completion for Makefile
# Loosely adapted from http://stackoverflow.com/a/38415982/1472048
_makecomplete() {
function _makecomplete()
{
COMPREPLY=()
# https://www.gnu.org/software/make/manual/html_node/Makefile-Names.html

2
completion/available/maven.completion.bash
View File

@ -1,7 +1,7 @@
#!/usr/bin/env bash
# Bash Maven completion
_mvn()
function _mvn()
{
local cmds cur colonprefixes
cmds="clean validate compile test package integration-test \

3
completion/available/minikube.completion.bash
View File

@ -1,6 +1,7 @@
# shellcheck shell=bash
# minikube (Local Kubernetes) completion
if _command_exists minikube; then
if _command_exists minikube
then
eval "$(minikube completion bash)"
fi

3
completion/available/ng.completion.bash
View File

@ -1,4 +1,5 @@
if _command_exists ng; then
if _command_exists ng
then
# No longer supported, please see https://github.com/angular/angular-cli/issues/11043
# Fix courtesy of https://stackoverflow.com/questions/50194674/ng-completion-no-longer-exists
# . <(ng completion --bash)

3
completion/available/ngrok.completion.bash
View File

@ -1,6 +1,7 @@
# shellcheck shell=bash
__ngrok_completion() {
function __ngrok_completion()
{
# shellcheck disable=SC2155
local prev=$(_get_pword)
# shellcheck disable=SC2155

7
completion/available/notify-send.completion.bash
View File

@ -1,6 +1,11 @@
# shellcheck shell=bash
function __notify-send_completions() {
function __notify-send_completions()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
# shellcheck disable=SC2155
local curr=$(_get_cword)
# shellcheck disable=SC2155

3
completion/available/npm.completion.bash
View File

@ -2,6 +2,7 @@
cite "about-completion"
about-completion "npm (Node Package Manager) completion"
if _command_exists npm; then
if _command_exists npm
then
eval "$(npm completion)"
fi

3
completion/available/packer.completion.bash
View File

@ -2,6 +2,7 @@
cite "about-completion"
about-completion "packer completion"
if _binary_exists packer; then
if _binary_exists packer
then
complete -C packer packer
fi

11
completion/available/pip.completion.bash
View File

@ -8,8 +8,14 @@
# So that pip is in the system's path.
_command_exists pip || return
function __bash_it_complete_pip() {
if _command_exists _pip_completion; then
function __bash_it_complete_pip()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
if _command_exists _pip_completion
then
complete -o default -F _pip_completion pip
_pip_completion "$@"
else
@ -17,4 +23,5 @@ function __bash_it_complete_pip() {
_pip_completion "$@"
fi
}
complete -o default -F __bash_it_complete_pip pip

10
completion/available/pip3.completion.bash
View File

@ -8,8 +8,14 @@
# So that pip3 is in the system's path.
_command_exists pip3 || return
function __bash_it_complete_pip3() {
if _command_exists _pip_completion; then
function __bash_it_complete_pip3()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
if _command_exists _pip_completion
then
complete -o default -F _pip_completion pip3
_pip_completion "$@"
else

3
completion/available/pipenv.completion.bash
View File

@ -1,4 +1,5 @@
# shellcheck shell=bash
if _command_exists pipenv; then
if _command_exists pipenv
then
eval "$(_PIPENV_COMPLETE=bash_source pipenv)"
fi

3
completion/available/pipx.completion.bash
View File

@ -1,6 +1,7 @@
# shellcheck shell=bash
# pipx completion
if _command_exists register-python-argcomplete && _command_exists pipx; then
if _command_exists register-python-argcomplete && _command_exists pipx
then
eval "$(register-python-argcomplete pipx)"
fi

24
completion/available/projects.completion.bash
View File

@ -4,12 +4,17 @@ _is_function _init_completion ||
_is_function _rl_enabled ||
_log_error '_rl_enabled not found. Ensure bash-completion 2.0 or newer is installed and configured properly.'
_pj() {
function _pj()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
_is_function _init_completion || return
_is_function _rl_enabled || return
[ -n "$BASH_IT_PROJECT_PATHS" ] || return
shift
[ "$1" == "open" ] && shift
[ "${1}" == "open" ] && shift
local cur prev words cword
_init_completion || return
@ -21,20 +26,25 @@ _pj() {
local -r mark_dirs=$(_rl_enabled mark-directories && echo y)
local -r mark_symdirs=$(_rl_enabled mark-symlinked-directories && echo y)
for i in ${BASH_IT_PROJECT_PATHS//:/$'\n'}; do
for i in ${BASH_IT_PROJECT_PATHS//:/$'\n'}
do
# create an array of matched subdirs
k="${#COMPREPLY[@]}"
for j in $( compgen -d $i/$cur ); do
if [[ ( $mark_symdirs && -h $j || $mark_dirs && ! -h $j ) && ! -d ${j#$i/} ]]; then
for j in $( compgen -d $i/$cur )
do
if [[ ( ${mark_symdirs} && -h $j || ${mark_dirs} && ! -h $j ) && ! -d ${j#$i/} ]]
then
j+="/"
fi
COMPREPLY[k++]=${j#$i/}
done
done
if [[ ${#COMPREPLY[@]} -eq 1 ]]; then
if [[ ${#COMPREPLY[@]} -eq 1 ]]
then
i=${COMPREPLY[0]}
if [[ "$i" == "$cur" && $i != "*/" ]]; then
if [[ "$i" == "$cur" && $i != "*/" ]]
then
COMPREPLY[0]="${i}/"
fi
fi

8
completion/available/rake.completion.bash
View File

@ -3,10 +3,12 @@
export COMP_WORDBREAKS=${COMP_WORDBREAKS/\:/}
_rakecomplete() {
if [ -f Rakefile ]; then
function _rakecomplete() {
if [ -f Rakefile ]
then
recent=`ls -t .rake_tasks~ Rakefile **/*.rake 2> /dev/null | head -n 1`
if [[ $recent != '.rake_tasks~' ]]; then
if [[ $recent != '.rake_tasks~' ]]
then
rake --silent --tasks | cut -d " " -f 2 > .rake_tasks~
fi
COMPREPLY=($(compgen -W "`cat .rake_tasks~`" -- ${COMP_WORDS[COMP_CWORD]}))

3
completion/available/rustup.completion.bash
View File

@ -2,6 +2,7 @@
# rustup (Rust toolchain installer) completion
if _binary_exists rustup; then
if _binary_exists rustup
then
eval "$(rustup completions bash)"
fi

104
completion/available/salt.completion.bash
View File

@ -27,16 +27,24 @@
# TODO: is it ok to use '--timeout 2' ?
_salt_get_grains(){
if [ "$1" = 'local' ] ; then
function _salt_get_grains()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
if [ "${1}" = 'local' ]
then
salt-call --out=txt -- grains.ls | sed 's/^.*\[//' | tr -d ",']" |sed 's:\([a-z0-9]\) :\1\: :g'
else
salt '*' --timeout 2 --out=txt -- grains.ls | sed 's/^.*\[//' | tr -d ",']" |sed 's:\([a-z0-9]\) :\1\: :g'
fi
}
_salt_get_grain_values(){
if [ "$1" = 'local' ] ; then
function _salt_get_grain_values()
{
if [ "${1}" = 'local' ]
then
salt-call --out=txt -- grains.item $1 |sed 's/^\S*:\s//' |grep -v '^\s*$'
else
salt '*' --timeout 2 --out=txt -- grains.item $1 |sed 's/^\S*:\s//' |grep -v '^\s*$'
@ -44,15 +52,22 @@ _salt_get_grain_values(){
}
_salt(){
function _salt()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local cur prev opts _salt_grains _salt_coms pprev ppprev
COMPREPLY=()
cur="${COMP_WORDS[COMP_CWORD]}"
prev="${COMP_WORDS[COMP_CWORD-1]}"
if [ ${COMP_CWORD} -gt 2 ]; then
if [ ${COMP_CWORD} -gt 2 ]
then
pprev="${COMP_WORDS[COMP_CWORD-2]}"
fi
if [ ${COMP_CWORD} -gt 3 ]; then
if [ ${COMP_CWORD} -gt 3 ]
then
ppprev="${COMP_WORDS[COMP_CWORD-3]}"
fi
@ -64,7 +79,8 @@ _salt(){
--ipcidr --out=pprint --out=yaml --out=overstatestage --out=json \
--out=raw --out=highstate --out=key --out=txt --no-color --out-indent= "
if [[ "${cur}" == -* ]] ; then
if [[ "${cur}" == -* ]]
then
COMPREPLY=($(compgen -W "${opts}" -- ${cur}))
return 0
fi
@ -72,7 +88,8 @@ _salt(){
# 2 special cases for filling up grain values
case "${pprev}" in
-G|--grain|--grain-pcre)
if [ "${cur}" = ":" ]; then
if [ "${cur}" = ":" ]
then
COMPREPLY=($(compgen -W "`_salt_get_grain_values ${prev}`" ))
return 0
fi
@ -80,17 +97,20 @@ _salt(){
esac
case "${ppprev}" in
-G|--grain|--grain-pcre)
if [ "${prev}" = ":" ]; then
if [ "${prev}" = ":" ]
then
COMPREPLY=( $(compgen -W "`_salt_get_grain_values ${pprev}`" -- ${cur}) )
return 0
fi
;;
esac
if [ "${cur}" = "=" ] && [[ "${prev}" == --* ]]; then
if [ "${cur}" = "=" ] && [[ "${prev}" == --* ]]
then
cur=""
fi
if [ "${prev}" = "=" ] && [[ "${pprev}" == --* ]]; then
if [ "${prev}" = "=" ] && [[ "${pprev}" == --* ]]
then
prev="${pprev}"
fi
@ -141,7 +161,12 @@ _salt(){
complete -F _salt salt
_saltkey(){
function _saltkey()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local cur prev opts prev pprev
COMPREPLY=()
cur="${COMP_WORDS[COMP_CWORD]}"
@ -153,21 +178,26 @@ _saltkey(){
-d --delete= -D --delete-all -f --finger= -F --finger-all \
--out=pprint --out=yaml --out=overstatestage --out=json --out=raw \
--out=highstate --out=key --out=txt --no-color --out-indent= "
if [ ${COMP_CWORD} -gt 2 ]; then
if [ ${COMP_CWORD} -gt 2 ]
then
pprev="${COMP_WORDS[COMP_CWORD-2]}"
fi
if [ ${COMP_CWORD} -gt 3 ]; then
if [ ${COMP_CWORD} -gt 3 ]
then
ppprev="${COMP_WORDS[COMP_CWORD-3]}"
fi
if [[ "${cur}" == -* ]] ; then
if [[ "${cur}" == -* ]]
then
COMPREPLY=($(compgen -W "${opts}" -- ${cur}))
return 0
fi
if [ "${cur}" = "=" ] && [[ "${prev}" == --* ]]; then
if [ "${cur}" = "=" ] && [[ "${prev}" == --* ]]
then
cur=""
fi
if [ "${prev}" = "=" ] && [[ "${pprev}" == --* ]]; then
if [ "${prev}" = "=" ] && [[ "${pprev}" == --* ]]
then
prev="${pprev}"
fi
@ -217,7 +247,12 @@ _saltkey(){
complete -F _saltkey salt-key
_saltcall(){
function _saltcall()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local cur prev opts _salt_coms pprev ppprev
COMPREPLY=()
cur="${COMP_WORDS[COMP_CWORD]}"
@ -226,21 +261,26 @@ _saltcall(){
-m --module-dirs= -g --grains --return= --local -c --config-dir= -l --log-level= \
--out=pprint --out=yaml --out=overstatestage --out=json --out=raw \
--out=highstate --out=key --out=txt --no-color --out-indent= "
if [ ${COMP_CWORD} -gt 2 ]; then
if [ ${COMP_CWORD} -gt 2 ]
then
pprev="${COMP_WORDS[COMP_CWORD-2]}"
fi
if [ ${COMP_CWORD} -gt 3 ]; then
if [ ${COMP_CWORD} -gt 3 ]
then
ppprev="${COMP_WORDS[COMP_CWORD-3]}"
fi
if [[ "${cur}" == -* ]] ; then
if [[ "${cur}" == -* ]]
then
COMPREPLY=($(compgen -W "${opts}" -- ${cur}))
return 0
fi
if [ "${cur}" = "=" ] && [[ ${prev} == --* ]]; then
if [ "${cur}" = "=" ] && [[ ${prev} == --* ]]
then
cur=""
fi
if [ "${prev}" = "=" ] && [[ ${pprev} == --* ]]; then
if [ "${prev}" = "=" ] && [[ ${pprev} == --* ]]
then
prev="${pprev}"
fi
@ -270,7 +310,12 @@ _saltcall(){
complete -F _saltcall salt-call
_saltcp(){
function _saltcp()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local cur prev opts target prefpart postpart helper filt pprev ppprev
COMPREPLY=()
cur="${COMP_WORDS[COMP_CWORD]}"
@ -281,15 +326,18 @@ _saltcp(){
-R --range -C --compound -I --pillar \
--out=pprint --out=yaml --out=overstatestage --out=json --out=raw \
--out=highstate --out=key --out=txt --no-color --out-indent= "
if [[ "${cur}" == -* ]] ; then
if [[ "${cur}" == -* ]]
then
COMPREPLY=($(compgen -W "${opts}" -- ${cur}))
return 0
fi
if [ "${cur}" = "=" ] && [[ "${prev}" == --* ]]; then
if [ "${cur}" = "=" ] && [[ "${prev}" == --* ]]
then
cur=""
fi
if [ "${prev}" = "=" ] && [[ "${pprev}" == --* ]]; then
if [ "${prev}" = "=" ] && [[ "${pprev}" == --* ]]
then
prev=${pprev}
fi

21
completion/available/sdkman.completion.bash
View File

@ -7,9 +7,11 @@ function _sdkman_complete() {
COMPREPLY=()
if [ "$COMP_CWORD" -eq 1 ]; then
if [ "$COMP_CWORD" -eq 1 ]
then
mapfile -t COMPREPLY < <(compgen -W "install uninstall rm list ls use default home env current upgrade ug version broadcast help offline selfupdate update flush" -- "${COMP_WORDS[COMP_CWORD]}")
elif [ "$COMP_CWORD" -eq 2 ]; then
elif [ "$COMP_CWORD" -eq 2 ]
then
case "${COMP_WORDS[COMP_CWORD - 1]}" in
"install" | "i" | "uninstall" | "rm" | "list" | "ls" | "use" | "u" | "default" | "d" | "home" | "h" | "current" | "c" | "upgrade" | "ug")
CANDIDATES="${SDKMAN_CANDIDATES_CSV//,/${IFS:0:1}}"
@ -30,7 +32,8 @@ function _sdkman_complete() {
*) ;;
esac
elif [ "$COMP_CWORD" -eq 3 ]; then
elif [ "$COMP_CWORD" -eq 3 ]
then
case "${COMP_WORDS[COMP_CWORD - 2]}" in
"uninstall" | "rm" | "use" | "u" | "default" | "d" | "home" | "h")
_sdkman_candidate_local_versions "${COMP_WORDS[COMP_CWORD - 1]}"
@ -50,20 +53,22 @@ function _sdkman_complete() {
function _sdkman_candidate_local_versions() {
CANDIDATE_VERSIONS=$(__sdkman_cleanup_local_versions "$1")
CANDIDATE_VERSIONS=$(__sdkman_cleanup_local_versions "${1}")
}
function _sdkman_candidate_all_versions() {
candidate="$1"
candidate="${1}"
CANDIDATE_LOCAL_VERSIONS=$(__sdkman_cleanup_local_versions "$candidate")
if [[ "${SDKMAN_OFFLINE_MODE:-false}" == "true" ]]; then
if [[ "${SDKMAN_OFFLINE_MODE:-false}" == "true" ]]
then
CANDIDATE_VERSIONS=$CANDIDATE_LOCAL_VERSIONS
else
# sdkman has a specific output format for Java candidate since
# there are multiple vendors and builds.
if [ "$candidate" = "java" ]; then
if [ "$candidate" = "java" ]
then
CANDIDATE_ONLINE_VERSIONS="$(__sdkman_list_versions "$candidate" | grep " " | grep "\." | cut -c 62-)"
else
CANDIDATE_ONLINE_VERSIONS="$(__sdkman_list_versions "$candidate" | grep " " | grep "\." | cut -c 6-)"
@ -79,7 +84,7 @@ function _sdkman_candidate_all_versions() {
function __sdkman_cleanup_local_versions() {
__sdkman_build_version_csv "$1" | tr ',' ' '
__sdkman_build_version_csv "${1}" | tr ',' ' '
}

3
completion/available/sqlmap.completion.bash
View File

@ -79,7 +79,8 @@ then
;;
esac
if [[ "$cur" == * ]]; then
if [[ "$cur" == * ]]
then
COMPREPLY=( $( compgen -W '-h --help -hh --version -v -d -u --url -l -x -m -r -g -c --method \
--data --param-del --cookie --cookie-del --load-cookies \
--drop-set-cookie --user-agent --random-agent --host --referer \

15
completion/available/ssh.completion.bash
View File

@ -5,7 +5,8 @@ export COMP_WORDBREAKS=${COMP_WORDBREAKS/\:/}
_sshcomplete() {
local CURRENT_PROMPT="${COMP_WORDS[COMP_CWORD]}"
if [[ ${CURRENT_PROMPT} == *@* ]] ; then
if [[ ${CURRENT_PROMPT} == *@* ]]
then
local OPTIONS="-P ${CURRENT_PROMPT/@*/}@ -- ${CURRENT_PROMPT/*@/}"
else
local OPTIONS=" -- ${CURRENT_PROMPT}"
@ -17,20 +18,24 @@ _sshcomplete() {
awk '{for (i=2; i<=NF; i++) print $i}' |
sed -Ee "s|^([^/~])|$HOME/.ssh/\1|" -e "s|^~/|$HOME/|")
do
if [ -r "$fl" ]; then
if [ -r "$fl" ]
then
COMPREPLY=( ${COMPREPLY[@]} $(compgen -W "$(grep -i ^Host "$fl" |grep -v '[*!]' | awk '{for (i=2; i<=NF; i++) print $i}' )" ${OPTIONS}) )
fi
done
# parse all hosts found in .ssh/known_hosts
if [ -r "$HOME/.ssh/known_hosts" ]; then
if grep -v -q -e '^ ssh-rsa' "$HOME/.ssh/known_hosts" ; then
if [ -r "$HOME/.ssh/known_hosts" ]
then
if grep -v -q -e '^ ssh-rsa' "$HOME/.ssh/known_hosts"
then
COMPREPLY=( ${COMPREPLY[@]} $(compgen -W "$( awk '{print $1}' "$HOME/.ssh/known_hosts" | grep -v ^\| | cut -d, -f 1 | sed -e 's/\[//g' | sed -e 's/\]//g' | cut -d: -f1 | grep -v ssh-rsa)" ${OPTIONS}) )
fi
fi
# parse hosts defined in /etc/hosts
if [ -r /etc/hosts ]; then
if [ -r /etc/hosts ]
then
COMPREPLY=( ${COMPREPLY[@]} $(compgen -W "$( grep -v '^[[:space:]]*$' /etc/hosts | grep -v '^#' | awk '{for (i=2; i<=NF; i++) print $i}' )" ${OPTIONS}) )
fi

12
completion/available/svn.completion.bash
View File

@ -6,13 +6,15 @@
_command_exists svn || return
# Don't handle completion if it's already managed
if _completion_exists svn; then
if _completion_exists svn
then
_log_warning "completion already loaded - this usually means it is safe to stop using this completion"
return 0
fi
_svn_bash_completion_xcrun_svn=
if _command_exists xcrun; then
if _command_exists xcrun
then
_svn_bash_completion_xcrun_svn="$(xcrun --find svn)"
fi
_svn_bash_completion_paths=(
@ -25,7 +27,8 @@ _svn_bash_completion_paths=(
# Load the first completion file found
_svn_bash_completion_found=false
for _comp_path in "${_svn_bash_completion_paths[@]}"; do
if [[ -r "$_comp_path" ]]; then
if [[ -r "$_comp_path" ]]
then
_svn_bash_completion_found=true
# shellcheck disable=SC1090 # don't follow
source "$_comp_path"
@ -34,7 +37,8 @@ for _comp_path in "${_svn_bash_completion_paths[@]}"; do
done
# Cleanup
if [[ "${_svn_bash_completion_found}" == false ]]; then
if [[ "${_svn_bash_completion_found}" == false ]]
then
_log_warning "no completion files found - please try enabling the 'system' completion instead."
fi
unset "${!_svn_bash_completion@}"

24
completion/available/system.completion.bash
View File

@ -7,7 +7,8 @@
# BASH_IT_LOAD_PRIORITY: 325
# Bash-completion is too large and complex to expect to handle unbound variables throughout the whole codebase.
if shopt -qo nounset; then
if shopt -qo nounset
then
__bash_it_restore_nounset=true
shopt -uo nounset
else
@ -15,14 +16,18 @@ else
fi
# shellcheck disable=SC1090 disable=SC1091
if [[ -r "${BASH_COMPLETION:-}" ]]; then
if [[ -r "${BASH_COMPLETION:-}" ]]
then
source "${BASH_COMPLETION}"
elif [[ -r /etc/bash_completion ]]; then
elif [[ -r /etc/bash_completion ]]
then
source /etc/bash_completion
# Some distribution makes use of a profile.d script to import completion.
elif [[ -r /etc/profile.d/bash_completion.sh ]]; then
elif [[ -r /etc/profile.d/bash_completion.sh ]]
then
source /etc/profile.d/bash_completion.sh
elif _bash_it_homebrew_check; then
elif _bash_it_homebrew_check
then
: "${BASH_COMPLETION_COMPAT_DIR:=${BASH_IT_HOMEBREW_PREFIX}/etc/bash_completion.d}"
case "${BASH_VERSION}" in
1* | 2* | 3.0* | 3.1*)
@ -31,7 +36,8 @@ elif _bash_it_homebrew_check; then
3.2* | 4.0* | 4.1*)
# Import version 1.x of bash-completion, if installed.
BASH_COMPLETION="${BASH_IT_HOMEBREW_PREFIX}/opt/bash-completion@1/etc/bash_completion"
if [[ -r "$BASH_COMPLETION" ]]; then
if [[ -r "$BASH_COMPLETION" ]]
then
source "$BASH_COMPLETION"
else
unset BASH_COMPLETION
@ -39,14 +45,16 @@ elif _bash_it_homebrew_check; then
;;
4.2* | 5* | *)
# homebrew/versions/bash-completion2 (required for projects.completion.bash) is installed to this path
if [[ -r "${BASH_IT_HOMEBREW_PREFIX}/opt/bash-completion@2/etc/profile.d/bash_completion.sh" ]]; then
if [[ -r "${BASH_IT_HOMEBREW_PREFIX}/opt/bash-completion@2/etc/profile.d/bash_completion.sh" ]]
then
source "${BASH_IT_HOMEBREW_PREFIX}/opt/bash-completion@2/etc/profile.d/bash_completion.sh"
fi
;;
esac
fi
if [[ ${__bash_it_restore_nounset:-false} == "true" ]]; then
if [[ ${__bash_it_restore_nounset:-false} == "true" ]]
then
shopt -so nounset
fi
unset __bash_it_restore_nounset

7
completion/available/test_kitchen.completion.bash
View File

@ -1,13 +1,14 @@
__kitchen_instance_list () {
function __kitchen_instance_list () {
# cache to .kitchen.list.yml
if [[ .kitchen.yml -nt .kitchen.list.yml || .kitchen.local.yml -nt .kitchen.list.yml ]]; then
if [[ .kitchen.yml -nt .kitchen.list.yml || .kitchen.local.yml -nt .kitchen.list.yml ]]
then
# update list if config has updated
kitchen list --bare > .kitchen.list.yml
fi
cat .kitchen.list.yml
}
__kitchen_options () {
function __kitchen_options () {
cur="${COMP_WORDS[COMP_CWORD]}"
prev="${COMP_WORDS[COMP_CWORD-1]}"
COMPREPLY=()

51
completion/available/tmux.completion.bash
View File

@ -4,13 +4,15 @@
# See: http://www.debian-administration.org/articles/317 for how to write more.
# Usage: Put "source bash_completion_tmux.sh" into your .bashrc
_tmux_expand ()
function _tmux_expand ()
{
[ "$cur" != "${cur%\\}" ] && cur="$cur"'\';
if [[ "$cur" == \~*/* ]]; then
if [[ "$cur" == \~*/* ]]
then
eval cur=$cur;
else
if [[ "$cur" == \~* ]]; then
if [[ "$cur" == \~* ]]
then
cur=${cur#\~};
COMPREPLY=($( compgen -P '~' -u $cur ));
return ${#COMPREPLY[@]};
@ -18,12 +20,13 @@ _tmux_expand ()
fi
}
_tmux_filedir ()
function _tmux_filedir ()
{
local IFS='
';
_tmux_expand || return 0;
if [ "$1" = -d ]; then
if [ "${1}" = -d ]
then
COMPREPLY=(${COMPREPLY[@]} $( compgen -d -- $cur ));
return 0;
fi;
@ -47,7 +50,8 @@ function _tmux_complete_window() {
local sessions
sessions="$(tmux -q list-sessions 2>/dev/null | sed -re 's/([^:]+:).*$/\1/')"
if [[ -n "${session_name}" ]]; then
if [[ -n "${session_name}" ]]
then
sessions="${sessions}
$(tmux -q list-windows -t "${session_name}" 2>/dev/null | sed -re 's/^([^:]+):.*$/'"${session_name}"':\1/')"
fi
@ -56,7 +60,7 @@ function _tmux_complete_window() {
COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "${sessions}" -- "${cur}") )
}
_tmux() {
function _tmux() {
local cur prev
local i cmd cmd_index option option_index
local opts=""
@ -64,20 +68,24 @@ _tmux() {
cur="${COMP_WORDS[COMP_CWORD]}"
prev="${COMP_WORDS[COMP_CWORD-1]}"
if [ ${prev} == -f ]; then
if [ ${prev} == -f ]
then
_tmux_filedir
else
# Search for the command
local skip_next=0
for ((i=1; $i<=$COMP_CWORD; i++)); do
if [[ ${skip_next} -eq 1 ]]; then
if [[ ${skip_next} -eq 1 ]]
then
#echo "Skipping"
skip_next=0;
elif [[ ${COMP_WORDS[i]} != -* ]]; then
elif [[ ${COMP_WORDS[i]} != -* ]]
then
cmd="${COMP_WORDS[i]}"
cmd_index=${i}
break
elif [[ ${COMP_WORDS[i]} == -f ]]; then
elif [[ ${COMP_WORDS[i]} == -f ]]
then
skip_next=1
fi
done
@ -85,21 +93,26 @@ _tmux() {
# Search for the last option command
skip_next=0
for ((i=1; $i<=$COMP_CWORD; i++)); do
if [[ ${skip_next} -eq 1 ]]; then
if [[ ${skip_next} -eq 1 ]]
then
#echo "Skipping"
skip_next=0;
elif [[ ${COMP_WORDS[i]} == -* ]]; then
elif [[ ${COMP_WORDS[i]} == -* ]]
then
option="${COMP_WORDS[i]}"
option_index=${i}
if [[ ${COMP_WORDS[i]} == -- ]]; then
if [[ ${COMP_WORDS[i]} == -- ]]
then
break;
fi
elif [[ ${COMP_WORDS[i]} == -f ]]; then
elif [[ ${COMP_WORDS[i]} == -f ]]
then
skip_next=1
fi
done
if [[ $COMP_CWORD -le $cmd_index ]]; then
if [[ $COMP_CWORD -le $cmd_index ]]
then
# The user has not specified a command yet
COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "$(tmux start-server \; list-commands | cut -d' ' -f1)" -- "${cur}") )
else
@ -129,7 +142,8 @@ _tmux() {
-t) _tmux_complete_session "${cur}" ;;
-[n|d|s]) options="-d -n -s -t --" ;;
*)
if [[ ${COMP_WORDS[option_index]} == -- ]]; then
if [[ ${COMP_WORDS[option_index]} == -- ]]
then
_command_offset ${option_index}
else
options="-d -n -s -t --"
@ -174,7 +188,8 @@ _tmux() {
fi # command specified
fi # not -f
if [[ -n "${options}" ]]; then
if [[ -n "${options}" ]]
then
COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "${options}" -- "${cur}") )
fi

15
completion/available/vagrant.completion.bash
View File

@ -23,7 +23,7 @@
# SOFTWARE.
__pwdln() {
function __pwdln() {
pwdmod="${PWD}/"
itr=0
until [[ -z "$pwdmod" ]];do
@ -33,7 +33,7 @@ __pwdln() {
echo -n $(($itr-1))
}
__vagrantinvestigate() {
function __vagrantinvestigate() {
if [ -f "${PWD}/.vagrant" -o -d "${PWD}/.vagrant" ];then
echo "${PWD}/.vagrant"
return 0
@ -50,7 +50,7 @@ __vagrantinvestigate() {
return 1
}
_vagrant() {
function _vagrant() {
cur="${COMP_WORDS[COMP_CWORD]}"
prev="${COMP_WORDS[COMP_CWORD-1]}"
commands="box cloud destroy global-status halt help hostmanager init login package plugin port powershell provision push rdp reload resume scp snapshot ssh ssh-config status suspend up upload validate vbguest version winrm winrm-config"
@ -119,7 +119,8 @@ _vagrant() {
action="${COMP_WORDS[COMP_CWORD-2]}"
case "$action" in
"up")
if [ "$prev" == "--no-provision" ]; then
if [ "$prev" == "--no-provision" ]
then
COMPREPLY=($(compgen -W "${vm_list}" -- ${cur}))
return 0
fi
@ -135,7 +136,8 @@ _vagrant() {
esac
;;
"snapshot")
if [ "$prev" == "restore" ]; then
if [ "$prev" == "restore" ]
then
COMPREPLY=($(compgen -W "${vm_list}" -- ${cur}))
return 0
fi
@ -149,7 +151,8 @@ _vagrant() {
prev="${COMP_WORDS[COMP_CWORD-2]}"
case "$action" in
"snapshot")
if [ "$prev" == "restore" ]; then
if [ "$prev" == "restore" ]
then
local snapshot_list="$(vagrant snapshot list ${cur} 2>/dev/null | awk '{ORS=" "} /==>/ {next} {print}')"
COMPREPLY=($(compgen -W "${snapshot_list}" -- ${cur}))
return 0

3
completion/available/vault.completion.bash
View File

@ -2,6 +2,7 @@
cite "about-completion"
about-completion "vault completion"
if _binary_exists vault; then
if _binary_exists vault
then
complete -C vault vault
fi

46
completion/available/virtualbox.completion.bash
View File

@ -1,10 +1,10 @@
#!/usr/bin/bash
_vboxmanage_realopts() {
function _vboxmanage_realopts() {
echo $(vboxmanage|grep -i vboxmanage|cut -d' ' -f2|grep '\['|tr -s '[\[\|\]\n' ' ')
echo " "
}
__vboxmanage_startvm() {
function __vboxmanage_startvm() {
RUNNING=$(vboxmanage list runningvms | cut -d' ' -f1 | tr -d '"')
TOTAL=$(vboxmanage list vms | cut -d' ' -f1 | tr -d '"')
@ -12,7 +12,8 @@ __vboxmanage_startvm() {
for VM in $TOTAL; do
MATCH=0;
for RUN in $RUNNING "x"; do
if [ "$VM" == "$RUN" ]; then
if [ "$VM" == "$RUN" ]
then
MATCH=1
fi
done
@ -21,11 +22,12 @@ __vboxmanage_startvm() {
echo $AVAILABLE
}
__vboxmanage_list() {
function __vboxmanage_list() {
INPUT=$(vboxmanage list | tr -s '[\[\]\|\n]' ' ' | cut -d' ' -f4-)
PRUNED=""
if [ "$1" == "long" ]; then
if [ "${1}" == "long" ]
then
for WORD in $INPUT; do
[ "$WORD" == "-l" ] && continue;
[ "$WORD" == "--long" ] && continue;
@ -40,9 +42,10 @@ __vboxmanage_list() {
}
__vboxmanage_list_vms() {
function __vboxmanage_list_vms() {
VMS=""
if [ "x$1" == "x" ]; then
if [ "x$1" == "x" ]
then
SEPARATOR=" "
else
SEPARATOR=$1
@ -56,9 +59,10 @@ __vboxmanage_list_vms() {
echo $VMS
}
__vboxmanage_list_runningvms() {
function __vboxmanage_list_runningvms() {
VMS=""
if [ "$1" == "" ]; then
if [ "${1}" == "" ]
then
SEPARATOR=" "
else
SEPARATOR=$1
@ -73,7 +77,7 @@ __vboxmanage_list_runningvms() {
}
__vboxmanage_controlvm() {
function __vboxmanage_controlvm() {
echo "pause resume reset poweroff savestate acpipowerbutton"
echo "acpisleepbutton keyboardputscancode guestmemoryballoon"
echo "gueststatisticsinterval usbattach usbdetach vrde vrdeport"
@ -93,7 +97,7 @@ __vboxmanage_controlvm() {
}
__vboxmanage_default() {
function __vboxmanage_default() {
realopts=$(_vboxmanage_realopts)
opts=$realopts$(vboxmanage | grep -i vboxmanage | cut -d' ' -f2 | grep -v '\[' | sort | uniq)
pruned=""
@ -113,23 +117,28 @@ __vboxmanage_default() {
MATCH=0
for OPT in "${COMP_WORDS[@]}"; do
# opts=$(echo ${opts} | grep -v $OPT);
if [ "$OPT" == "$WORD" ]; then
if [ "$OPT" == "$WORD" ]
then
MATCH=1
break;
fi
if [ "$OPT" == "-v" ] && [ "$WORD" == "--version" ]; then
if [ "$OPT" == "-v" ] && [ "$WORD" == "--version" ]
then
MATCH=1
break;
fi
if [ "$OPT" == "--version" ] && [ "$WORD" == "-v" ]; then
if [ "$OPT" == "--version" ] && [ "$WORD" == "-v" ]
then
MATCH=1
break;
fi
if [ "$OPT" == "-q" ] && [ "$WORD" == "--nologo" ]; then
if [ "$OPT" == "-q" ] && [ "$WORD" == "--nologo" ]
then
MATCH=1
break;
fi
if [ "$OPT" == "--nologo" ] && [ "$WORD" == "-q" ]; then
if [ "$OPT" == "--nologo" ] && [ "$WORD" == "-q" ]
then
MATCH=1
break;
fi
@ -144,7 +153,7 @@ __vboxmanage_default() {
return 0
}
_vboxmanage() {
function _vboxmanage() {
# vboxmanage | grep -i vboxmanage | cut -d' ' -f2 | sort | uniq
local cur p1 p2 p3 p4 opts
COMPREPLY=()
@ -199,7 +208,8 @@ _vboxmanage() {
esac
for VM in $(__vboxmanage_list_vms); do
if [ "$VM" == "$prev" ]; then
if [ "$VM" == "$prev" ]
then
pprev=${COMP_WORDS[COMP_CWORD-2]}
# echo "previous: $pprev"
case $pprev in

10
completion/available/wpscan.completion.bash
View File

@ -2,12 +2,18 @@
_command_exists wpscan || return
function __wpscan_completion() {
function __wpscan_completion()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
local _opt_
local OPTS=('--help' '--hh' '--version' '--url' '--ignore-main-redirect' '--verbose' '--output' '--format' '--detection-mode' '--scope' '--headers' '--user-agent' '--vhost' '--random-user-agent' '--user-agents-list' '--http-auth' '--max-threads' '--throttle' '--request-timeout' '--connect-timeout' '--disable-tlc-checks' '--proxy' '--proxy-auth' '--cookie-string' '--cookie-jar' '--cache-ttl' '--clear-cache' '--server' '--cache-dir' '--update' '--no-update' '--wp-content-dir' '--wp-plugins-dir' '--wp-version-detection' '--main-theme-detection' '--enumerate' '--exclude-content-based' '--plugins-list' '--plugins-detection' '--plugins-version-all' '--plugins-version-detection' '--themes-list' '--themes-detection' '--themes-version-all' '--themes-version-detection' '--timthumbs-list' '--timthumbs-detection' '--config-backups-list' '--config-backups-detection' '--db-exports-list' '--db-exports-detection' '--medias-detection' '--users-list' '--users-detection' '--passwords' '--usernames' '--multicall-max-passwords' '--password-attack' '--stealthy')
COMPREPLY=()
for _opt_ in "${OPTS[@]}"; do
if [[ "$_opt_" == "$2"* ]]; then
if [[ "$_opt_" == "${2}"* ]]
then
COMPREPLY+=("$_opt_")
fi
done

3
docs/installation.rst
View File

@ -36,7 +36,8 @@ To achieve this, you can add this snippet in your ``.bash_profile``\ :
.. code-block::
if [ -f ~/.bashrc ]; then
if [ -f ~/.bashrc ]
then
. ~/.bashrc
fi

8
hooks/check-clean-files-txt.sh
View File

@ -2,7 +2,8 @@
file=$1
# Should only be run on clean_files.txt
if [ "$file" != "clean_files.txt" ]; then
if [ "$file" != "clean_files.txt" ]
then
echo "Please run this script on clean_files.txt only!"
exit 1
fi
@ -14,12 +15,13 @@ function compare_lines() {
[[ $line =~ "#" ]] && continue
[[ $line == "" ]] && continue
# Actual check
if [[ $prev > $line ]]; then
if [[ $prev > $line ]]
then
echo "$line should be before $prev"
exit 1
fi
prev=$line
done <<< "$1"
done <<< "${1}"
}
# We compare using the legacy way

6
hooks/dot-bash.sh
View File

@ -4,7 +4,8 @@ exit_code=0
for file in "$@"; do
# Confirm file is not executable
#
if [[ -x "${file}" ]]; then
if [[ -x "${file}" ]]
then
echo "Bash include file \`${file}\` should not be executable"
exit_code=1
fi
@ -12,7 +13,8 @@ for file in "$@"; do
# Confirm expected schellcheck header
#
LINE1="$(head -n 1 "${file}")"
if [[ "${LINE1}" != "# shellcheck shell=bash" ]]; then
if [[ "${LINE1}" != "# shellcheck shell=bash" ]]
then
echo "Bash include file \`${file}\` has bad/missing shellcheck header"
exit_code=1
fi

6
hooks/dot-sh.sh
View File

@ -4,7 +4,8 @@ exit_code=0
for file in "$@"; do
# Confirm file is executable
#
if [[ ! -x "${file}" ]]; then
if [[ ! -x "${file}" ]]
then
echo "Bash file \`${file}\` is not executable"
exit_code=1
fi
@ -12,7 +13,8 @@ for file in "$@"; do
# Confirm expected #! header
#
LINE1="$(head -n 1 "${file}")"
if [[ "${LINE1}" != "#!/usr/bin/env bash" ]]; then
if [[ "${LINE1}" != "#!/usr/bin/env bash" ]]
then
echo "Bash file \`${file}\` has bad/missing #! header"
exit_code=1
fi

95
install.sh
View File

@ -2,7 +2,12 @@
# bash-it installer
# Show how to use this installer
function _bash-it_show_usage() {
function _bash-it_show_usage()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
echo -e "\n$0 : Install bash-it"
echo -e "Usage:\n$0 [arguments] \n"
echo "Arguments:"
@ -15,13 +20,20 @@ function _bash-it_show_usage() {
}
# enable a thing
function _bash-it_load_one() {
function _bash-it_load_one()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
file_type=$1
file_to_enable=$2
mkdir -p "$BASH_IT/${file_type}/enabled"
dest="${BASH_IT}/${file_type}/enabled/${file_to_enable}"
if [ ! -e "${dest}" ]; then
if [ ! -e "${dest}" ]
then
ln -sf "../available/${file_to_enable}" "${dest}"
else
echo "File ${dest} exists, skipping"
@ -29,7 +41,13 @@ function _bash-it_load_one() {
}
# Interactively enable several things
function _bash-it_load_some() {
function _bash-it_load_some()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
file_type=$1
single_type=$(echo "$file_type" | sed -e "s/aliases$/alias/g" | sed -e "s/plugins$/plugin/g")
enable_func="_enable-$single_type"
@ -56,33 +74,58 @@ function _bash-it_load_some() {
}
# Back up existing profile
function _bash-it_backup() {
function _bash-it_backup()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
test -w "$HOME/$CONFIG_FILE" \
&& cp -aL "$HOME/$CONFIG_FILE" "$HOME/$CONFIG_FILE.bak" \
&& echo -e "\033[0;32mYour original $CONFIG_FILE has been backed up to $CONFIG_FILE.bak\033[0m"
}
# Back up existing profile and create new one for bash-it
function _bash-it_backup_new() {
function _bash-it_backup_new()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
_bash-it_backup
sed "s|{{BASH_IT}}|$BASH_IT|" "$BASH_IT/template/bash_profile.template.bash" > "$HOME/$CONFIG_FILE"
echo -e "\033[0;32mCopied the template $CONFIG_FILE into ~/$CONFIG_FILE, edit this file to customize bash-it\033[0m"
}
# Back up existing profile and append bash-it templates at the end
function _bash-it_backup_append() {
function _bash-it_backup_append()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
_bash-it_backup
(sed "s|{{BASH_IT}}|$BASH_IT|" "$BASH_IT/template/bash_profile.template.bash" | tail -n +2) >> "$HOME/$CONFIG_FILE"
echo -e "\033[0;32mBash-it template has been added to your $CONFIG_FILE\033[0m"
}
function _bash-it_check_for_backup() {
if ! [[ -e "$HOME/$BACKUP_FILE" ]]; then
function _bash-it_check_for_backup()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
if ! [[ -e "$HOME/$BACKUP_FILE" ]]
then
return
fi
echo -e "\033[0;33mBackup file already exists. Make sure to backup your .bashrc before running this installation.\033[0m" >&2
if [[ -z "${overwrite_backup}" ]]; then
if [[ -z "${overwrite_backup}" ]]
then
while [[ -z "${silent}" ]]; do
read -e -n 1 -r -p "Would you like to overwrite the existing backup? This will delete your existing backup file ($HOME/$BACKUP_FILE) [y/N] " RESP
case $RESP in
@ -99,9 +142,11 @@ function _bash-it_check_for_backup() {
esac
done
fi
if [[ -z "${overwrite_backup}" ]]; then
if [[ -z "${overwrite_backup}" ]]
then
echo -e "\033[91mInstallation aborted. Please come back soon!\033[m"
if [[ -n "${silent}" ]]; then
if [[ -n "${silent}" ]]
then
echo -e "\033[91mUse \"-f\" flag to force overwrite of backup.\033[m"
fi
exit 1
@ -110,10 +155,17 @@ function _bash-it_check_for_backup() {
fi
}
function _bash-it_modify_config_files() {
function _bash-it_modify_config_files()
{
############ STACK_TRACE_BUILDER #####################
Function_Name="${FUNCNAME[0]}"
Function_PATH="${Function_PATH}/${Function_Name}"
######################################################
_bash-it_check_for_backup
if [[ -z "${silent}" ]]; then
if [[ -z "${silent}" ]]
then
while [[ -z "${append_to_config}" ]]; do
read -e -n 1 -r -p "Would you like to keep your $CONFIG_FILE and append bash-it templates at the end? [y/N] " choice
case $choice in
@ -130,7 +182,8 @@ function _bash-it_modify_config_files() {
esac
done
fi
if [[ -n "${append_to_config}" ]]; then
if [[ -n "${append_to_config}" ]]
then
# backup/append
_bash-it_backup_append
else
@ -173,12 +226,14 @@ done
shift $((OPTIND - 1))
if [[ -n "${silent}" && -n "${interactive}" ]]; then
if [[ -n "${silent}" && -n "${interactive}" ]]
then
echo -e "\033[91mOptions --silent and --interactive are mutually exclusive. Please choose one or the other.\033[m"
exit 1
fi
if [[ -n "${no_modify_config}" && -n "${append_to_config}" ]]; then
if [[ -n "${no_modify_config}" && -n "${append_to_config}" ]]
then
echo -e "\033[91mOptions --no-modify-config and --append-to-config are mutually exclusive. Please choose one or the other.\033[m"
exit 1
fi
@ -196,7 +251,8 @@ esac
BACKUP_FILE=$CONFIG_FILE.bak
echo "Installing bash-it"
if [[ -z "${no_modify_config}" ]]; then
if [[ -z "${no_modify_config}" ]]
then
_bash-it_modify_config_files
fi
@ -213,7 +269,8 @@ cite _about _param _example _group _author _version
# shellcheck source=./lib/helpers.bash
source "$BASH_IT/lib/helpers.bash"
if [[ -n $interactive && -z "${silent}" ]]; then
if [[ -n $interactive && -z "${silent}" ]]
then
for type in "aliases" "plugins" "completion"; do
echo -e "\033[0;32mEnabling ${type}\033[0m"
_bash-it_load_some "$type"

9
lib/appearance.bash
View File

@ -7,10 +7,13 @@ export CLICOLOR
# Load the theme
# shellcheck disable=SC1090
if [[ -n "${BASH_IT_THEME:-}" ]]; then
if [[ -f "${BASH_IT_THEME}" ]]; then
if [[ -n "${BASH_IT_THEME:-}" ]]
then
if [[ -f "${BASH_IT_THEME}" ]]
then
source "${BASH_IT_THEME}"
elif [[ -f "$CUSTOM_THEME_DIR/$BASH_IT_THEME/$BASH_IT_THEME.theme.bash" ]]; then
elif [[ -f "$CUSTOM_THEME_DIR/$BASH_IT_THEME/$BASH_IT_THEME.theme.bash" ]]
then
source "$CUSTOM_THEME_DIR/$BASH_IT_THEME/$BASH_IT_THEME.theme.bash"
else
source "$BASH_IT/themes/$BASH_IT_THEME/$BASH_IT_THEME.theme.bash"

12
lib/command_duration.bash
View File

@ -45,11 +45,13 @@ function _command_duration() {
local -i current_time_deciseconds="$((10#${current_time##*.}))"
current_time_deciseconds="${current_time_deciseconds:0:1}"
if [[ "${command_start_seconds:-0}" -gt 0 ]]; then
if [[ "${command_start_seconds:-0}" -gt 0 ]]
then
# seconds
command_duration="$((current_time_seconds - command_start_seconds))"
if ((current_time_deciseconds >= command_start_deciseconds)); then
if ((current_time_deciseconds >= command_start_deciseconds))
then
deciseconds="$((current_time_deciseconds - command_start_deciseconds))"
else
((command_duration -= 1))
@ -59,12 +61,14 @@ function _command_duration() {
command_duration=0
fi
if ((command_duration >= COMMAND_DURATION_MIN_SECONDS)); then
if ((command_duration >= COMMAND_DURATION_MIN_SECONDS))
then
minutes=$((command_duration / 60))
seconds=$((command_duration % 60))
_dynamic_clock_icon "${command_duration}"
if ((minutes > 0)); then
if ((minutes > 0))
then
printf "%s %s%dm %ds" "${COMMAND_DURATION_ICON:-}" "${COMMAND_DURATION_COLOR:-}" "$minutes" "$seconds"
else
printf "%s %s%d.%01ds" "${COMMAND_DURATION_ICON:-}" "${COMMAND_DURATION_COLOR:-}" "$seconds" "$deciseconds"

248
lib/helpers.bash
View File

@ -14,7 +14,8 @@ BASH_IT_LOAD_PRIORITY_SEPARATOR="---"
# To use this in Bash-it for inline replacements with `sed`, use the following syntax:
# sed "${BASH_IT_SED_I_PARAMETERS[@]}" -e "..." file
# shellcheck disable=SC2034 # expected for this case
if sed --version > /dev/null 2>&1; then
if sed --version > /dev/null 2>&1
then
# GNU sed accepts "long" options
BASH_IT_SED_I_PARAMETERS=('-i')
else
@ -29,7 +30,8 @@ function _command_exists() {
_example '$ _command_exists ls && echo exists'
_group 'lib'
local msg="${2:-Command '$1' does not exist}"
if type -t "$1" > /dev/null; then
if type -t "${1}" > /dev/null
then
return 0
else
_log_debug "$msg"
@ -44,7 +46,8 @@ function _binary_exists() {
_example '$ _binary_exists ls && echo exists'
_group 'lib'
local msg="${2:-Binary '$1' does not exist}"
if type -P "$1" > /dev/null; then
if type -P "${1}" > /dev/null
then
return 0
else
_log_debug "$msg"
@ -59,7 +62,8 @@ function _completion_exists() {
_example '$ _completion_exists gh && echo exists'
_group 'lib'
local msg="${2:-Completion for '$1' already exists}"
if complete -p "$1" &> /dev/null; then
if complete -p "${1}" &> /dev/null
then
_log_debug "$msg"
return 0
else
@ -68,9 +72,11 @@ function _completion_exists() {
}
function _bash_it_homebrew_check() {
if _binary_exists 'brew'; then
if _binary_exists 'brew'
then
# Homebrew is installed
if [[ "${BASH_IT_HOMEBREW_PREFIX:-unset}" == 'unset' ]]; then
if [[ "${BASH_IT_HOMEBREW_PREFIX:-unset}" == 'unset' ]]
then
# variable isn't set
BASH_IT_HOMEBREW_PREFIX="$(brew --prefix)"
else
@ -173,11 +179,14 @@ function bash-it() {
esac
# pluralize component if necessary
if ! _is_function "$func"; then
if _is_function "${func}s"; then
if ! _is_function "$func"
then
if _is_function "${func}s"
then
func="${func}s"
else
if _is_function "${func}es"; then
if _is_function "${func}es"
then
func="${func}es"
else
echo "oops! $component is not a valid option!"
@ -187,7 +196,8 @@ function bash-it() {
fi
fi
if [[ "$verb" == "enable" || "$verb" == "disable" ]]; then
if [[ "$verb" == "enable" || "$verb" == "disable" ]]
then
# Automatically run a migration if required
_bash-it-migrate
@ -195,7 +205,8 @@ function bash-it() {
"$func" "$arg"
done
if [[ -n "${BASH_IT_AUTOMATIC_RELOAD_AFTER_CONFIG_CHANGE:-}" ]]; then
if [[ -n "${BASH_IT_AUTOMATIC_RELOAD_AFTER_CONFIG_CHANGE:-}" ]]
then
_bash-it-reload
fi
else
@ -211,7 +222,8 @@ function _is_function() {
_example '$ _is_function ls && echo exists'
_group 'lib'
local msg="${2:-Function '$1' does not exist}"
if LC_ALL=C type -t "$1" | _bash-it-fgrep -q 'function'; then
if LC_ALL=C type -t "${1}" | _bash-it-fgrep -q 'function'
then
return 0
else
_log_debug "$msg"
@ -258,7 +270,8 @@ function _bash-it_update_migrate_and_restart() {
_about 'Checks out the wanted version, pops directory and restart. Does not return (because of the restart!)'
_param '1: Which branch to checkout to'
_param '2: Which type of version we are using'
if git checkout "${1?}" &> /dev/null; then
if git checkout "${1?}" &> /dev/null
then
echo "Bash-it successfully updated."
echo ""
echo "Migrating your installation to the latest ${2:-} version now..."
@ -280,7 +293,8 @@ function _bash-it-update-() {
local silent word DIFF version TARGET revision status revert log_color RESP
for word in "$@"; do
if [[ "${word}" == "--silent" || "${word}" == "-s" ]]; then
if [[ "${word}" == "--silent" || "${word}" == "-s" ]]
then
silent=true
fi
done
@ -288,27 +302,32 @@ function _bash-it-update-() {
pushd "${BASH_IT?}" > /dev/null || return
DIFF=$(git diff --name-status)
if [[ -n "$DIFF" ]]; then
if [[ -n "$DIFF" ]]
then
echo -e "Local changes detected in bash-it directory. Clean '$BASH_IT' directory to proceed.\n$DIFF"
popd > /dev/null || return
return 1
fi
if [[ -z "$BASH_IT_REMOTE" ]]; then
if [[ -z "$BASH_IT_REMOTE" ]]
then
BASH_IT_REMOTE="origin"
fi
git fetch "$BASH_IT_REMOTE" --tags &> /dev/null
if [[ -z "$BASH_IT_DEVELOPMENT_BRANCH" ]]; then
if [[ -z "$BASH_IT_DEVELOPMENT_BRANCH" ]]
then
BASH_IT_DEVELOPMENT_BRANCH="master"
fi
# Defaults to stable update
if [[ -z "${1:-}" || "$1" == "stable" ]]; then
if [[ -z "${1:-}" || "${1}" == "stable" ]]
then
version="stable"
TARGET=$(git describe --tags "$(git rev-list --tags --max-count=1)" 2> /dev/null)
if [[ -z "$TARGET" ]]; then
if [[ -z "$TARGET" ]]
then
echo "Can not find tags, so can not update to latest stable version..."
popd > /dev/null || return
return
@ -321,14 +340,17 @@ function _bash-it-update-() {
revision="HEAD..${TARGET}"
status="$(git rev-list "${revision}" 2> /dev/null)"
if [[ -z "${status}" && "${version}" == "stable" ]]; then
if [[ -z "${status}" && "${version}" == "stable" ]]
then
revision="${TARGET}..HEAD"
status="$(git rev-list "${revision}" 2> /dev/null)"
revert=true
fi
if [[ -n "${status}" ]]; then
if [[ -n "${revert}" ]]; then
if [[ -n "${status}" ]]
then
if [[ -n "${revert}" ]]
then
echo "Your version is a more recent development version ($(git log -1 --format=%h HEAD))"
echo "You can continue in order to revert and update to the latest stable version"
echo ""
@ -338,7 +360,8 @@ function _bash-it-update-() {
git log --no-merges --format="${log_color}%h: %s (%an)" "${revision}"
echo ""
if [[ -n "${silent}" ]]; then
if [[ -n "${silent}" ]]
then
echo "Updating to ${TARGET}($(git log -1 --format=%h "${TARGET}"))..."
_bash-it_update_migrate_and_restart "$TARGET" "$version"
else
@ -356,7 +379,8 @@ function _bash-it-update-() {
esac
fi
else
if [[ "${version}" == "stable" ]]; then
if [[ "${version}" == "stable" ]]
then
echo "You're on the latest stable version. If you want to check out the latest 'dev' version, please run \"bash-it update dev\""
else
echo "Bash-it is up to date, nothing to do!"
@ -394,11 +418,13 @@ function _bash-it-migrate() {
done
done
if [[ -n "${BASH_IT_AUTOMATIC_RELOAD_AFTER_CONFIG_CHANGE:-}" ]]; then
if [[ -n "${BASH_IT_AUTOMATIC_RELOAD_AFTER_CONFIG_CHANGE:-}" ]]
then
_bash-it-reload
fi
if [[ "$migrated_something" == "true" ]]; then
if [[ "$migrated_something" == "true" ]]
then
echo ""
echo "If any migration errors were reported, please try the following: reload && bash-it migrate"
fi
@ -412,13 +438,15 @@ function _bash-it-version() {
pushd "${BASH_IT?}" > /dev/null || return
if [[ -z "${BASH_IT_REMOTE:-}" ]]; then
if [[ -z "${BASH_IT_REMOTE:-}" ]]
then
BASH_IT_REMOTE="origin"
fi
BASH_IT_GIT_REMOTE="$(git remote get-url "$BASH_IT_REMOTE")"
BASH_IT_GIT_URL="${BASH_IT_GIT_REMOTE%.git}"
if [[ "$BASH_IT_GIT_URL" == *"git@"* ]]; then
if [[ "$BASH_IT_GIT_URL" == *"git@"* ]]
then
# Fix URL in case it is ssh based URL
BASH_IT_GIT_URL="${BASH_IT_GIT_URL/://}"
BASH_IT_GIT_URL="${BASH_IT_GIT_URL/git@/https://}"
@ -426,7 +454,8 @@ function _bash-it-version() {
current_tag="$(git describe --exact-match --tags 2> /dev/null)"
if [[ -z "$current_tag" ]]; then
if [[ -z "$current_tag" ]]
then
BASH_IT_GIT_VERSION_INFO="$(git log --pretty=format:'%h on %aI' -n 1)"
TARGET="${BASH_IT_GIT_VERSION_INFO%% *}"
echo "Version type: dev"
@ -500,7 +529,8 @@ function _bash-it-profile-save() {
done
local profile_path="${BASH_IT}/profiles/${name}.bash_it" RESP
if [[ -s "$profile_path" ]]; then
if [[ -s "$profile_path" ]]
then
echo -e "${echo_yellow?}Profile '$name' already exists.${echo_reset_color?}"
while true; do
read -r -e -n 1 -p "Would you like to overwrite existing profile? [y/N] " RESP
@ -525,8 +555,10 @@ function _bash-it-profile-save() {
for subdirectory in "plugins" "completion" "aliases"; do
echo "Saving $subdirectory configuration..."
for f in "${BASH_IT}/$subdirectory/available"/*.bash; do
if _bash-it-component-item-is-enabled "$f"; then
if [[ -z "${component_exists:-}" ]]; then
if _bash-it-component-item-is-enabled "$f"
then
if [[ -z "${component_exists:-}" ]]
then
# This is the first component of this type, print the header
component_exists="yes"
something_exists="yes"
@ -538,7 +570,8 @@ function _bash-it-profile-save() {
fi
done
done
if [[ -z "${something_exists:-}" ]]; then
if [[ -z "${something_exists:-}" ]]
then
echo "It seems like no configuration was enabled.."
echo "Make sure to double check that this is the wanted behavior."
fi
@ -549,7 +582,7 @@ function _bash-it-profile-save() {
echo "Load the profile by invoking \"bash-it profile load $name\""
}
_bash-it-profile-load-parse-profile() {
function _bash-it-profile-load-parse-profile() {
_about 'Internal function used to parse the profile file'
_param '1: path to the profile file'
_param '2: dry run- only check integrity of the profile file'
@ -567,7 +600,8 @@ _bash-it-profile-load-parse-profile() {
to_enable=("${BASH_IT}/$subdirectory/available/$component.${subdirectory%s}"*.bash)
# Ignore botched lines
if [[ ! -e "${to_enable[0]}" ]]; then
if [[ ! -e "${to_enable[0]}" ]]
then
echo -e "${echo_orange?}Bad line(#$num) in profile, aborting load...${line[*]}${echo_reset_color?}"
bad="bad line"
break
@ -582,7 +616,7 @@ _bash-it-profile-load-parse-profile() {
[[ -z ${bad:-} ]]
}
_bash-it-profile-list() {
function _bash-it-profile-list() {
about 'lists all profiles from the "profiles" directory'
_group 'lib'
local profile
@ -594,58 +628,64 @@ _bash-it-profile-list() {
done
}
_bash-it-profile-rm() {
function _bash-it-profile-rm() {
about 'Removes a profile from the "profiles" directory'
_group 'lib'
local name="${1:-}"
if [[ -z $name ]]; then
if [[ -z $name ]]
then
echo -e "${echo_orange?}Please specify profile name to remove...${echo_reset_color?}"
return 1
fi
# Users should not be allowed to delete the default profile
if [[ $name == "default" ]]; then
if [[ $name == "default" ]]
then
echo -e "${echo_orange?}Can not remove the default profile...${echo_reset_color?}"
return 1
fi
local profile_path="${BASH_IT}/profiles/$name.bash_it"
if [[ ! -f "$profile_path" ]]; then
if [[ ! -f "${profile_path}" ]]
then
echo -e "${echo_orange?}Could not find profile '$name'...${echo_reset_color?}"
return 1
fi
command rm "$profile_path"
command rm "${profile_path}"
echo "Removed profile '$name' successfully!"
}
_bash-it-profile-load() {
function _bash-it-profile-load() {
_about 'loads a configuration from the "profiles" directory'
_group 'lib'
local name="${1:-}"
if [[ -z $name ]]; then
if [[ -z $name ]]
then
echo -e "${echo_orange?}Please specify profile name to load, not changing configuration...${echo_reset_color?}"
return 1
fi
local profile_path="${BASH_IT}/profiles/$name.bash_it"
if [[ ! -f "$profile_path" ]]; then
echo -e "${echo_orange?}Could not find profile '$name', not changing configuration...${echo_reset_color?}"
if [[ ! -f "${profile_path}" ]]
then
echo -e "${echo_orange?}Could not find profile '${name}', not changing configuration...${echo_reset_color?}"
return 1
fi
echo "Trying to parse profile '$name'..."
if _bash-it-profile-load-parse-profile "$profile_path" "dry"; then
echo "Profile '$name' parsed successfully!"
echo "Trying to parse profile '${name}'..."
if _bash-it-profile-load-parse-profile "$profile_path" "dry"
then
echo "Profile '${name}' parsed successfully!"
echo "Disabling current configuration..."
_disable-all
echo ""
echo "Enabling configuration based on profile..."
_bash-it-profile-load-parse-profile "$profile_path"
_bash-it-profile-load-parse-profile "${profile_path}"
echo ""
echo "Profile '$name' enabled!"
echo "Profile '${name}' enabled!"
else
false # failure
fi
@ -675,10 +715,10 @@ function _bash-it-describe() {
_example '$ _bash-it-describe "plugins" "a" "plugin" "Plugin"'
local subdirectory preposition file_type column_header f enabled enabled_file
subdirectory="$1"
preposition="$2"
file_type="$3"
column_header="$4"
subdirectory="${1}"
preposition="${2}"
file_type="${3}"
column_header="${4}"
printf "%-20s %-10s %s\n" "$column_header" 'Enabled?' 'Description'
for f in "${BASH_IT?}/$subdirectory/available"/*.*.bash; do
@ -688,10 +728,10 @@ function _bash-it-describe() {
_bash-it-component-item-is-enabled "${file_type}" "${enabled_file}" && enabled='x'
printf "%-20s %-10s %s\n" "$enabled_file" "[${enabled:- }]" "$(metafor "about-$file_type" < "$f")"
done
printf '\n%s\n' "to enable $preposition $file_type, do:"
printf '%s\n' "$ bash-it enable $file_type <$file_type name> [$file_type name]... -or- $ bash-it enable $file_type all"
printf '\n%s\n' "to disable $preposition $file_type, do:"
printf '%s\n' "$ bash-it disable $file_type <$file_type name> [$file_type name]... -or- $ bash-it disable $file_type all"
printf '\n%s\n' "to enable ${preposition} ${file_type}, do:"
printf '%s\n' "$ bash-it enable ${file_type} <$file_type name> [${file_type} name]... -or- $ bash-it enable ${file_type} all"
printf '\n%s\n' "to disable ${preposition} ${file_type}, do:"
printf '%s\n' "$ bash-it disable ${file_type} <$file_type name> [${file_type} name]... -or- $ bash-it disable ${file_type} all"
}
function _on-disable-callback() {
@ -701,8 +741,9 @@ function _on-disable-callback() {
_group 'lib'
local callback="${1}_on_disable"
if _command_exists "$callback"; then
"$callback"
if _command_exists "${callback}"
then
"${callback}"
fi
}
@ -755,7 +796,8 @@ function _disable-thing() {
local file_type="${2?}"
local file_entity="${3:-}"
if [[ -z "$file_entity" ]]; then
if [[ -z "$file_entity" ]]
then
reference "disable-$file_type"
return
fi
@ -763,9 +805,10 @@ function _disable-thing() {
local f suffix _bash_it_config_file plugin
suffix="${subdirectory/plugins/plugin}"
if [[ "$file_entity" == "all" ]]; then
if [[ "$file_entity" == "all" ]]
then
# Disable everything that's using the old structure and everything in the global "enabled" directory.
for _bash_it_config_file in "${BASH_IT}/$subdirectory/enabled"/*."${suffix}.bash" "${BASH_IT}/enabled"/*".${suffix}.bash"; do
for _bash_it_config_file in "${BASH_IT}/${subdirectory}/enabled"/*."${suffix}.bash" "${BASH_IT}/enabled"/*".${suffix}.bash"; do
rm -f "$_bash_it_config_file"
done
else
@ -774,25 +817,28 @@ function _disable-thing() {
# node.plugin.bash
# Either one will be matched by this glob
for plugin in "${BASH_IT}/enabled"/[[:digit:]][[:digit:]][[:digit:]]"${BASH_IT_LOAD_PRIORITY_SEPARATOR}${file_entity}.${suffix}.bash" "${BASH_IT}/$subdirectory/enabled/"{[[:digit:]][[:digit:]][[:digit:]]"${BASH_IT_LOAD_PRIORITY_SEPARATOR}${file_entity}.${suffix}.bash","${file_entity}.${suffix}.bash"}; do
if [[ -e "${plugin}" ]]; then
if [[ -e "${plugin}" ]]
then
rm -f "${plugin}"
plugin=
break
fi
done
if [[ -n "${plugin}" ]]; then
printf '%s\n' "sorry, $file_entity does not appear to be an enabled $file_type."
if [[ -n "${plugin}" ]]
then
printf '%s\n' "sorry, ${file_entity} does not appear to be an enabled ${file_type}."
return
fi
fi
_bash-it-component-cache-clean "${file_type}"
if [[ "$file_entity" == "all" ]]; then
_bash-it-component-pluralize "$file_type" file_type
printf '%s\n' "$file_entity ${file_type} disabled."
if [[ "$file_entity" == "all" ]]
then
_bash-it-component-pluralize "${file_type}" file_type
printf '%s\n' "${file_entity} ${file_type} disabled."
else
printf '%s\n' "$file_entity disabled."
printf '%s\n' "${file_entity} disabled."
fi
}
@ -830,7 +876,7 @@ function _enable-completion() {
_example '$ enable-completion git'
_group 'lib'
_enable-thing "completion" "completion" "${1?}" "$BASH_IT_LOAD_PRIORITY_COMPLETION"
_enable-thing "completion" "completion" "${1?}" "${BASH_IT_LOAD_PRIORITY_COMPLETION}"
}
function _enable-thing() {
@ -847,7 +893,8 @@ function _enable-thing() {
local file_entity="${3:-}"
local load_priority="${4:-500}"
if [[ -z "$file_entity" ]]; then
if [[ -z "$file_entity" ]]
then
reference "enable-$file_type"
return
fi
@ -855,23 +902,26 @@ function _enable-thing() {
local _bash_it_config_file to_enable to_enables enabled_plugin local_file_priority use_load_priority
local suffix="${subdirectory/plugins/plugin}"
if [[ "$file_entity" == "all" ]]; then
if [[ "$file_entity" == "all" ]]
then
for _bash_it_config_file in "${BASH_IT}/$subdirectory/available"/*.bash; do
to_enable="${_bash_it_config_file##*/}"
_enable-thing "$subdirectory" "$file_type" "${to_enable%."${file_type/alias/aliases}".bash}" "$load_priority"
_enable-thing "$subdirectory" "$file_type" "${to_enable%."${file_type/alias/aliases}".bash}" "${load_priority}"
done
else
to_enables=("${BASH_IT}/$subdirectory/available/$file_entity.${suffix}.bash")
if [[ ! -e "${to_enables[0]}" ]]; then
printf '%s\n' "sorry, $file_entity does not appear to be an available $file_type."
to_enables=("${BASH_IT}/$subdirectory/available/${file_entity}.${suffix}.bash")
if [[ ! -e "${to_enables[0]}" ]]
then
printf '%s\n' "sorry, ${file_entity} does not appear to be an available ${file_type}."
return
fi
to_enable="${to_enables[0]##*/}"
# Check for existence of the file using a wildcard, since we don't know which priority might have been used when enabling it.
for enabled_plugin in "${BASH_IT}/$subdirectory/enabled"/{[[:digit:]][[:digit:]][[:digit:]]"${BASH_IT_LOAD_PRIORITY_SEPARATOR}${to_enable}","${to_enable}"} "${BASH_IT}/enabled"/[[:digit:]][[:digit:]][[:digit:]]"${BASH_IT_LOAD_PRIORITY_SEPARATOR?}${to_enable}"; do
if [[ -e "${enabled_plugin}" ]]; then
printf '%s\n' "$file_entity is already enabled."
if [[ -e "${enabled_plugin}" ]]
then
printf '%s\n' "${file_entity} is already enabled."
return
fi
done
@ -882,12 +932,12 @@ function _enable-thing() {
local_file_priority="$(awk -F': ' '$1 == "# BASH_IT_LOAD_PRIORITY" { print $2 }' "${BASH_IT}/$subdirectory/available/$to_enable")"
use_load_priority="${local_file_priority:-$load_priority}"
ln -s "../$subdirectory/available/$to_enable" "${BASH_IT}/enabled/${use_load_priority}${BASH_IT_LOAD_PRIORITY_SEPARATOR}${to_enable}"
ln -s "../${subdirectory}/available/${to_enable}" "${BASH_IT}/enabled/${use_load_priority}${BASH_IT_LOAD_PRIORITY_SEPARATOR}${to_enable}"
fi
_bash-it-component-cache-clean "${file_type}"
printf '%s\n' "$file_entity enabled with priority $use_load_priority."
printf '%s\n' "$file_entity enabled with priority ${use_load_priority}."
}
function _help-completions() {
@ -903,8 +953,9 @@ function _help-aliases() {
_example '$ alias-help'
_example '$ alias-help git'
if [[ -n "${1:-}" ]]; then
case "$1" in
if [[ -n "${1:-}" ]]
then
case "${1}" in
custom)
alias_path='custom.aliases.bash'
;;
@ -912,7 +963,7 @@ function _help-aliases() {
alias_path="available/${1}.aliases.bash"
;;
esac
metafor alias < "${BASH_IT}/aliases/$alias_path" | sed "s/$/'/"
metafor alias < "${BASH_IT}/aliases/${alias_path}" | sed "s/$/'/"
else
local f
@ -921,7 +972,8 @@ function _help-aliases() {
_help-list-aliases "$f"
done
if [[ -e "${BASH_IT}/aliases/custom.aliases.bash" ]]; then
if [[ -e "${BASH_IT}/aliases/custom.aliases.bash" ]]
then
_help-list-aliases "${BASH_IT}/aliases/custom.aliases.bash"
fi
fi
@ -932,7 +984,7 @@ function _help-list-aliases() {
file="$(_bash-it-get-component-name-from-path "${1?}")"
printf '\n\n%s:\n' "${file}"
# metafor() strips trailing quotes, restore them with sed..
metafor alias < "$1" | sed "s/$/'/"
metafor alias < "${1}" | sed "s/$/'/"
}
function _help-plugins() {
@ -946,22 +998,23 @@ function _help-plugins() {
while read -ra func; do
defn="$(declare -f "${func[2]}")"
group="$(metafor group <<< "$defn")"
if [[ -z "$group" ]]; then
if [[ -z "$group" ]]
then
group='misc'
fi
about="$(metafor about <<< "$defn")"
_letterpress "$about" "${func[2]}" >> "$grouplist.$group"
echo "$grouplist.$group" >> "$grouplist"
_letterpress "${about}" "${func[2]}" >> "${grouplist}.${group}"
echo "${grouplist}.${group}" >> "${grouplist}"
done < <(declare -F)
# clear progress message
printf '\r%s\n' ' '
while IFS= read -r gfile; do
printf '%s\n' "${gfile##*.}:"
cat "$gfile"
cat "${gfile}"
printf '\n'
rm "$gfile" 2> /dev/null
done < <(sort -u "$grouplist") | less
rm "$grouplist" 2> /dev/null
rm "${gfile}" 2> /dev/null
done < <(sort -u "${grouplist}") | less
rm "${grouplist}" 2> /dev/null
}
function _help-profile() {
@ -1003,8 +1056,10 @@ function pathmunge() {
example 'pathmunge /path/to/dir is equivalent to PATH=/path/to/dir:$PATH'
example 'pathmunge /path/to/dir after is equivalent to PATH=$PATH:/path/to/dir'
if [[ -d "${1:-}" && ! $PATH =~ (^|:)"${1}"($|:) ]]; then
if [[ "${2:-before}" == "after" ]]; then
if [[ -d "${1:-}" && ! $PATH =~ (^|:)"${1}"($|:) ]]
then
if [[ "${2:-before}" == "after" ]]
then
export PATH="$PATH:${1}"
else
export PATH="${1}:$PATH"
@ -1029,7 +1084,8 @@ function _bash-it-find-in-ancestor() (
# To keep things simple, we do not search the root dir.
while [[ "${PWD}" != '/' ]]; do
for kin in "$@"; do
if [[ -r "${PWD}/${kin}" ]]; then
if [[ -r "${PWD}/${kin}" ]]
then
printf '%s' "${PWD}"
return "$?"
fi

24
lib/log.bash
View File

@ -31,8 +31,10 @@ function _bash-it-log-prefix-by-path() {
component_name="${component_name##[[:digit:]][[:digit:]][[:digit:]]"${BASH_IT_LOAD_PRIORITY_SEPARATOR:----}"}"
# best-guess for files without a type
if [[ "${component_type:-${component_name}}" == "${component_name}" ]]; then
if [[ "${component_directory}" == *'vendor'* ]]; then
if [[ "${component_type:-${component_name}}" == "${component_name}" ]]
then
if [[ "${component_directory}" == *'vendor'* ]]
then
component_type='vendor'
else
component_type="${component_directory##*/}"
@ -59,7 +61,8 @@ function _bash-it-log-message() {
local color="${1-${echo_cyan:-}}"
local level="${2:-TRACE}"
local message="${level%: }: ${prefix%: }: ${3?}"
if _has_colors; then
if _has_colors
then
printf '%b%s%b\n' "${color}" "${message}" "${echo_normal:-}"
else
printf '%s\n' "${message}"
@ -72,8 +75,9 @@ function _log_debug() {
: _example '$ _log_debug "Loading plugin git..."'
: _group 'log'
if [[ "${BASH_IT_LOG_LEVEL:-0}" -ge "${BASH_IT_LOG_LEVEL_INFO?}" ]]; then
_bash-it-log-message "${echo_green:-}" "DEBUG: " "$1"
if [[ "${BASH_IT_LOG_LEVEL:-0}" -ge "${BASH_IT_LOG_LEVEL_INFO?}" ]]
then
_bash-it-log-message "${echo_green:-}" "DEBUG: " "${1}"
fi
}
@ -83,8 +87,9 @@ function _log_warning() {
: _example '$ _log_warning "git binary not found, disabling git plugin..."'
: _group 'log'
if [[ "${BASH_IT_LOG_LEVEL:-0}" -ge "${BASH_IT_LOG_LEVEL_WARNING?}" ]]; then
_bash-it-log-message "${echo_yellow:-}" " WARN: " "$1"
if [[ "${BASH_IT_LOG_LEVEL:-0}" -ge "${BASH_IT_LOG_LEVEL_WARNING?}" ]]
then
_bash-it-log-message "${echo_yellow:-}" " WARN: " "${1}"
fi
}
@ -94,7 +99,8 @@ function _log_error() {
: _example '$ _log_error "Failed to load git plugin..."'
: _group 'log'
if [[ "${BASH_IT_LOG_LEVEL:-0}" -ge "${BASH_IT_LOG_LEVEL_ERROR?}" ]]; then
_bash-it-log-message "${echo_red:-}" "ERROR: " "$1"
if [[ "${BASH_IT_LOG_LEVEL:-0}" -ge "${BASH_IT_LOG_LEVEL_ERROR?}" ]]
then
_bash-it-log-message "${echo_red:-}" "ERROR: " "${1}"
fi
}

18
lib/preexec.bash
View File

@ -40,19 +40,23 @@ function __check_preexec_conflict() {
function safe_append_prompt_command() {
local prompt_re prompt_er f
if [[ "${bash_preexec_imported:-${__bp_imported:-missing}}" == "defined" ]]; then
if [[ "${bash_preexec_imported:-${__bp_imported:-missing}}" == "defined" ]]
then
# We are using bash-preexec
__bp_trim_whitespace f "${1?}"
if ! __check_precmd_conflict "${f}"; then
if ! __check_precmd_conflict "${f}"
then
precmd_functions+=("${f}")
fi
else
# Match on word-boundaries
prompt_re='(^|[^[:alnum:]_])'
prompt_er='([^[:alnum:]_]|$)'
if [[ ${PROMPT_COMMAND} =~ ${prompt_re}"${1}"${prompt_er} ]]; then
if [[ ${PROMPT_COMMAND} =~ ${prompt_re}"${1}"${prompt_er} ]]
then
return
elif [[ -z ${PROMPT_COMMAND} ]]; then
elif [[ -z ${PROMPT_COMMAND} ]]
then
PROMPT_COMMAND="${1}"
else
PROMPT_COMMAND="${1};${PROMPT_COMMAND}"
@ -63,10 +67,12 @@ function safe_append_prompt_command() {
function safe_append_preexec() {
local prompt_re f
if [[ "${bash_preexec_imported:-${__bp_imported:-missing}}" == "defined" ]]; then
if [[ "${bash_preexec_imported:-${__bp_imported:-missing}}" == "defined" ]]
then
# We are using bash-preexec
__bp_trim_whitespace f "${1?}"
if ! __check_preexec_conflict "${f}"; then
if ! __check_preexec_conflict "${f}"
then
preexec_functions+=("${f}")
fi
else

9
lib/preview.bash
View File

@ -6,7 +6,8 @@ function _bash-it-preview() {
local BASH_IT_THEME BASH_IT_LOG_LEVEL
local themes IFS=$'\n' cur
if [[ $# -gt '0' ]]; then
if [[ $# -gt '0' ]]
then
themes=("$@")
else
themes=("${BASH_IT?}/themes"/*/*.theme.bash)
@ -14,7 +15,8 @@ function _bash-it-preview() {
themes=("${themes[@]%.theme.bash}")
fi
if [[ ${COMP_CWORD:-} -gt '0' ]]; then
if [[ ${COMP_CWORD:-} -gt '0' ]]
then
cur="${COMP_WORDS[COMP_CWORD]}"
read -d '' -ra COMPREPLY < <(compgen -W "all${IFS}${themes[*]}" -- "${cur}")
return
@ -28,7 +30,8 @@ function _bash-it-preview() {
done
}
if [[ -n "${BASH_PREVIEW:-}" ]]; then
if [[ -n "${BASH_PREVIEW:-}" ]]
then
_bash-it-preview "${BASH_PREVIEW}" "$@"
unset BASH_PREVIEW #Prevent infinite looping
fi

41
lib/search.bash
View File

@ -57,7 +57,8 @@ function _bash-it-search() {
local BASH_IT_SEARCH_USE_COLOR="${BASH_IT_SEARCH_USE_COLOR:=true}"
local -a BASH_IT_COMPONENTS=('aliases' 'plugins' 'completions')
if [[ $# -eq 0 ]]; then
if [[ $# -eq 0 ]]
then
_bash-it-search-help
return 0
fi
@ -81,7 +82,8 @@ function _bash-it-search() {
esac
done
if [[ ${#args} -gt 0 ]]; then
if [[ ${#args} -gt 0 ]]
then
for component in "${BASH_IT_COMPONENTS[@]}"; do
_bash-it-search-component "${component}" "${args[@]}"
done
@ -174,7 +176,7 @@ function _bash-it-is-partial-match() {
}
function _bash-it-component-term-matches-negation() {
local match="$1"
local match="${1}"
shift
local negative
for negative in "$@"; do
@ -199,7 +201,8 @@ function _bash-it-search-component() {
local component_singular action action_func
local -a search_commands=('enable' 'disable')
for search_command in "${search_commands[@]}"; do
if _bash-it-array-contains-element "--${search_command}" "$@"; then
if _bash-it-array-contains-element "--${search_command}" "$@"
then
component_singular="${component/es/}" # aliases -> alias
component_singular="${component_singular/ns/n}" # plugins -> plugin
@ -224,12 +227,16 @@ function _bash-it-search-component() {
for term in "${terms[@]}"; do
local search_term="${term:1}"
if [[ "${term:0:2}" == "--" ]]; then
if [[ "${term:0:2}" == "--" ]]
then
continue
elif [[ "${term:0:1}" == "-" ]]; then
elif [[ "${term:0:1}" == "-" ]]
then
negative_terms+=("${search_term}")
elif [[ "${term:0:1}" == "@" ]]; then
if _bash-it-array-contains-element "${search_term}" "${component_list[@]:-}"; then
elif [[ "${term:0:1}" == "@" ]]
then
if _bash-it-array-contains-element "${search_term}" "${component_list[@]:-}"
then
exact_terms+=("${search_term}")
fi
else
@ -248,7 +255,8 @@ function _bash-it-search-component() {
local -a matches=()
for match in "${total_matches[@]}"; do
local -i include_match=1
if [[ ${#negative_terms[@]} -gt 0 ]]; then
if [[ ${#negative_terms[@]} -gt 0 ]]
then
_bash-it-component-term-matches-negation "${match}" "${negative_terms[@]:-}" && include_match=0
fi
((include_match)) && matches+=("${match}")
@ -276,7 +284,8 @@ function _bash-it-search-result() {
[[ -n "${line}" ]] && matches+=("$line")
done < <(_bash-it-array-dedup "${@}")
if [[ "${BASH_IT_SEARCH_USE_COLOR}" == "true" ]]; then
if [[ "${BASH_IT_SEARCH_USE_COLOR}" == "true" ]]
then
color_component='\e[1;34m'
color_enable='\e[1;32m'
suffix_enable=''
@ -292,14 +301,16 @@ function _bash-it-search-result() {
color_off=''
fi
if [[ "${#matches[@]}" -gt 0 ]]; then
if [[ "${#matches[@]}" -gt 0 ]]
then
printf "${color_component}%13s${color_sep}${color_off} " "${component}"
for match in "${matches[@]}"; do
enabled=0
_bash-it-component-item-is-enabled "${component}" "${match}" && enabled=1
if ((enabled)); then
if ((enabled))
then
match_color="${color_enable}"
suffix="${suffix_enable}"
opposite_suffix="${suffix_disable}"
@ -315,8 +326,10 @@ function _bash-it-search-result() {
len="${#matched}"
printf '%b' "${match_color}${matched}" # print current state
if [[ "${action}" == "${compatible_action}" ]]; then
if [[ "${action}" == "enable" && "${BASH_IT_SEARCH_USE_COLOR}" == "true" ]]; then
if [[ "${action}" == "${compatible_action}" ]]
then
if [[ "${action}" == "enable" && "${BASH_IT_SEARCH_USE_COLOR}" == "true" ]]
then
_bash-it-flash-term "${len}" "${matched}"
else
_bash-it-erase-term "${len}" "${matched}"

37
lib/utilities.bash
View File

@ -40,7 +40,8 @@ function _bash-it-get-component-type-from-path() {
# $ _bash-it-array-contains-element apple "@{fruits[@]}" && echo 'contains apple'
# contains apple
#
# $ if _bash-it-array-contains-element pear "${fruits[@]}"; then
# $ if _bash-it-array-contains-element pear "${fruits[@]}"
then
# echo "contains pear!"
# fi
# contains pear!
@ -87,7 +88,8 @@ function _bash-it-component-help() {
local component file func
_bash-it-component-pluralize "${1}" component
_bash-it-component-cache-file "${component}" file
if [[ ! -s "${file?}" || -z "$(find "${file}" -mmin -300)" ]]; then
if [[ ! -s "${file?}" || -z "$(find "${file}" -mmin -300)" ]]
then
func="_bash-it-${component?}"
"${func}" | _bash-it-egrep '\[[x ]\]' >| "${file}"
fi
@ -106,9 +108,11 @@ function _bash-it-component-singularize() {
local _result="${2:-${FUNCNAME[0]//-/_}}"
local _component_to_single="${1?${FUNCNAME[0]}: component name required}"
local -i len="$((${#_component_to_single} - 2))"
if [[ "${_component_to_single:${len}:2}" == 'ns' ]]; then
if [[ "${_component_to_single:${len}:2}" == 'ns' ]]
then
_component_to_single="${_component_to_single%s}"
elif [[ "${_component_to_single}" == "aliases" ]]; then
elif [[ "${_component_to_single}" == "aliases" ]]
then
_component_to_single="${_component_to_single%es}"
fi
printf -v "${_result?}" '%s' "${_component_to_single}"
@ -119,9 +123,11 @@ function _bash-it-component-pluralize() {
local _component_to_plural="${1?${FUNCNAME[0]}: component name required}"
local -i len="$((${#_component_to_plural} - 1))"
# pluralize component name for consistency
if [[ "${_component_to_plural:${len}:1}" != 's' ]]; then
if [[ "${_component_to_plural:${len}:1}" != 's' ]]
then
_component_to_plural="${_component_to_plural}s"
elif [[ "${_component_to_plural}" == "alias" ]]; then
elif [[ "${_component_to_plural}" == "alias" ]]
then
_component_to_plural="${_component_to_plural}es"
fi
printf -v "${_result?}" '%s' "${_component_to_plural}"
@ -131,7 +137,8 @@ function _bash-it-component-cache-clean() {
local component="${1:-}"
local cache
local -a components=('aliases' 'plugins' 'completions')
if [[ -z "${component}" ]]; then
if [[ -z "${component}" ]]
then
for component in "${components[@]}"; do
_bash-it-component-cache-clean "${component}"
done
@ -143,24 +150,24 @@ function _bash-it-component-cache-clean() {
# Returns an array of items within each compoenent.
function _bash-it-component-list() {
local IFS=$'\n' component="$1"
local IFS=$'\n' component="${1}"
_bash-it-component-help "${component}" | awk '{print $1}' | sort -u
}
function _bash-it-component-list-matching() {
local component="$1"
local component="${1}"
shift
local term="$1"
local term="${1}"
_bash-it-component-help "${component}" | _bash-it-egrep -- "${term}" | awk '{print $1}' | sort -u
}
function _bash-it-component-list-enabled() {
local IFS=$'\n' component="$1"
local IFS=$'\n' component="${1}"
_bash-it-component-help "${component}" | _bash-it-fgrep '[x]' | awk '{print $1}' | sort -u
}
function _bash-it-component-list-disabled() {
local IFS=$'\n' component="$1"
local IFS=$'\n' component="${1}"
_bash-it-component-help "${component}" | _bash-it-fgrep -v '[x]' | awk '{print $1}' | sort -u
}
@ -174,7 +181,8 @@ function _bash-it-component-list-disabled() {
function _bash-it-component-item-is-enabled() {
local component_type item_name each_file
if [[ -f "${1?}" ]]; then
if [[ -f "${1?}" ]]
then
item_name="$(_bash-it-get-component-name-from-path "${1}")"
component_type="$(_bash-it-get-component-type-from-path "${1}")"
else
@ -184,7 +192,8 @@ function _bash-it-component-item-is-enabled() {
for each_file in "${BASH_IT}/enabled"/*"${BASH_IT_LOAD_PRIORITY_SEPARATOR?}${item_name}.${component_type}"*."bash" \
"${BASH_IT}/${component_type}"*/"enabled/${item_name}.${component_type}"*."bash" \
"${BASH_IT}/${component_type}"*/"enabled"/*"${BASH_IT_LOAD_PRIORITY_SEPARATOR?}${item_name}.${component_type}"*."bash"; do
if [[ -f "${each_file}" ]]; then
if [[ -f "${each_file}" ]]
then
return 0
fi
done

9
plugins/available/autojump.plugin.bash
View File

@ -5,10 +5,13 @@ about-plugin 'Autojump configuration, see https://github.com/wting/autojump for
# Only supports the Homebrew variant, Debian and Arch at the moment.
# Feel free to provide a PR to support other install locations
# shellcheck disable=SC1090
if _bash_it_homebrew_check && [[ -s "${BASH_IT_HOMEBREW_PREFIX}/etc/profile.d/autojump.sh" ]]; then
if _bash_it_homebrew_check && [[ -s "${BASH_IT_HOMEBREW_PREFIX}/etc/profile.d/autojump.sh" ]]
then
source "${BASH_IT_HOMEBREW_PREFIX}/etc/profile.d/autojump.sh"
elif _command_exists dpkg && dpkg -s autojump &> /dev/null; then
elif _command_exists dpkg && dpkg -s autojump &> /dev/null
then
source "$(dpkg-query -S autojump.sh | cut -d' ' -f2)"
elif _command_exists pacman && pacman -Q autojump &> /dev/null; then
elif _command_exists pacman && pacman -Q autojump &> /dev/null
then
source "$(pacman -Ql autojump | grep autojump.sh | cut -d' ' -f2)"
fi

40
plugins/available/aws.plugin.bash
View File

@ -9,19 +9,24 @@ function awskeys {
about 'helper function for AWS credentials file'
group 'aws'
if [[ ! -f "${AWS_SHARED_CREDENTIALS_FILE}" ]]; then
if [[ ! -f "${AWS_SHARED_CREDENTIALS_FILE}" ]]
then
echo "AWS credentials file not found"
return 1
fi
if [[ $# -eq 1 ]] && [[ "$1" = "list" ]]; then
__awskeys_list "$2"
elif [[ $# -eq 1 ]] && [[ "$1" = "unset" ]]; then
__awskeys_unset "$2"
elif [[ $# -eq 2 ]] && [[ "$1" = "show" ]]; then
__awskeys_show "$2"
elif [[ $# -eq 2 ]] && [[ "$1" = "export" ]]; then
__awskeys_export "$2"
if [[ $# -eq 1 ]] && [[ "${1}" = "list" ]]
then
__awskeys_list "${2}"
elif [[ $# -eq 1 ]] && [[ "${1}" = "unset" ]]
then
__awskeys_unset "${2}"
elif [[ $# -eq 2 ]] && [[ "${1}" = "show" ]]
then
__awskeys_show "${2}"
elif [[ $# -eq 2 ]] && [[ "${1}" = "export" ]]
then
__awskeys_export "${2}"
else
__awskeys_help
fi
@ -40,7 +45,8 @@ function __awskeys_help {
function __awskeys_get {
local ln=$(grep -n "\[ *$1 *\]" "${AWS_SHARED_CREDENTIALS_FILE}" | cut -d ":" -f 1)
if [[ -n "${ln}" ]]; then
if [[ -n "${ln}" ]]
then
tail -n +${ln} "${AWS_SHARED_CREDENTIALS_FILE}" | grep -F -m 2 -e "aws_access_key_id" -e "aws_secret_access_key"
tail -n +${ln} "${AWS_SHARED_CREDENTIALS_FILE}" | grep -F -m 1 "aws_session_token"
fi
@ -48,7 +54,8 @@ function __awskeys_get {
function __awskeys_list {
local credentials_list="$((grep -E '^\[ *[a-zA-Z0-9_-]+ *\]$' "${AWS_SHARED_CREDENTIALS_FILE}"; grep "\[profile" "${AWS_CONFIG_FILE}" | sed "s|\[profile |\[|g") | sort | uniq)"
if [[ -n $"{credentials_list}" ]]; then
if [[ -n $"{credentials_list}" ]]
then
echo -e "Available credentials profiles:\n"
for profile in ${credentials_list}; do
echo " $(echo ${profile} | tr -d "[]")"
@ -61,7 +68,8 @@ function __awskeys_list {
function __awskeys_show {
local p_keys="$(__awskeys_get $1)"
if [[ -n "${p_keys}" ]]; then
if [[ -n "${p_keys}" ]]
then
echo "${p_keys}"
else
echo "Profile $1 not found in credentials file"
@ -69,15 +77,17 @@ function __awskeys_show {
}
function __awskeys_export {
if [[ $(__awskeys_list) == *"$1"* ]]; then
if [[ $(__awskeys_list) == *"${1}"* ]]
then
local p_keys=( $(__awskeys_get $1 | tr -d " ") )
if [[ -n "${p_keys}" ]]; then
if [[ -n "${p_keys}" ]]
then
for p_key in ${p_keys[@]}; do
local key="${p_key%=*}"
export "$(echo ${key} | tr [:lower:] [:upper:])=${p_key#*=}"
done
fi
export AWS_PROFILE="$1"
export AWS_PROFILE="${1}"
else
echo "Profile $1 not found in credentials file"
fi

36
plugins/available/base.plugin.bash
View File

@ -5,9 +5,11 @@ about-plugin 'miscellaneous tools'
function ips() {
about 'display all ip addresses for this host'
group 'base'
if _command_exists ifconfig; then
if _command_exists ifconfig
then
ifconfig | awk '/inet /{ gsub(/addr:/, ""); print $2 }'
elif _command_exists ip; then
elif _command_exists ip
then
ip addr | grep -oP 'inet \K[\d.]+'
else
echo "You don't have ifconfig or ip command installed!"
@ -27,7 +29,8 @@ function myip() {
group 'base'
list=("http://myip.dnsomatic.com/" "http://checkip.dyndns.com/" "http://checkip.dyndns.org/")
for url in "${list[@]}"; do
if res="$(curl -fs "${url}")"; then
if res="$(curl -fs "${url}")"
then
break
fi
done
@ -42,7 +45,8 @@ function pickfrom() {
group 'base'
local file=${1:-}
local -i n=0 length
if [[ ! -r "$file" ]]; then
if [[ ! -r "$file" ]]
then
reference "${FUNCNAME[0]}" && return
fi
length="$(wc -l < "$file")"
@ -67,11 +71,13 @@ function passgen() {
# Create alias pass to passgen when pass isn't installed or
# BASH_IT_LEGACY_PASS is true.
if ! _command_exists pass || [[ "${BASH_IT_LEGACY_PASS:-}" == true ]]; then
if ! _command_exists pass || [[ "${BASH_IT_LEGACY_PASS:-}" == true ]]
then
alias pass=passgen
fi
if _command_exists markdown && _command_exists browser; then
if _command_exists markdown && _command_exists browser
then
function pmdown() {
about 'preview markdown file in a browser'
param '1: markdown file'
@ -127,21 +133,25 @@ function t() {
local todotxt="${XDG_STATE_HOME:-~/.local/state}/bash_it/todo.txt"
if _bash-it-component-item-is-enabled plugin todo; then
if _bash-it-component-item-is-enabled plugin todo
then
todo.sh "$@"
return
elif [[ ! -f "${todotxt}" && -f ~/.t ]]; then
elif [[ ! -f "${todotxt}" && -f ~/.t ]]
then
mv -vn ~/.t "${todotxt}" # Verbose, so the user knows. Don't overwrite, just in case.
fi
if [[ "$#" -eq 0 ]]; then
if [[ "$#" -eq 0 ]]
then
cat "${todotxt}"
else
echo "$@" >| "${todotxt}"
fi
}
if _command_exists mkisofs; then
if _command_exists mkisofs
then
function mkiso() {
about 'creates iso from current dir in the parent dir (unless defined)'
param '1: ISO name'
@ -155,7 +165,8 @@ if _command_exists mkisofs; then
local destpath="${2:-../}"
local srcpath="${3:-${PWD}}"
if [[ ! -f "${destpath%/}/${isoname}.iso" ]]; then
if [[ ! -f "${destpath%/}/${isoname}.iso" ]]
then
echo "writing ${isoname}.iso to ${destpath} from ${srcpath}"
mkisofs -V "${isoname}" -iso-level 3 -r -o "${destpath%/}/${isoname}.iso" "${srcpath}"
else
@ -174,7 +185,8 @@ function buf() {
cp -a "${filename}" "${filename}_${filetime}"
}
if ! _command_exists del; then
if ! _command_exists del
then
function del() {
about 'move files to hidden folder in tmp, that gets cleared on each reboot'
param 'file or folder to be deleted'

6
plugins/available/basher.plugin.bash
View File

@ -4,8 +4,10 @@ about-plugin 'initializes basher, the shell package manager'
# https://github.com/basherpm/basher
if ! _command_exists basher; then
if [[ -x "$HOME/.basher/bin/basher" ]]; then
if ! _command_exists basher
then
if [[ -x "$HOME/.basher/bin/basher" ]]
then
pathmunge "$HOME/.basher/bin"
else
_log_warning 'basher not found'

48
plugins/available/battery.plugin.bash
View File

@ -3,32 +3,42 @@ about-plugin 'display info about your battery charge level'
function ac_adapter_connected() {
local batteries
if _command_exists upower; then
if _command_exists upower
then
IFS=$'\n' read -d '' -ra batteries < <(upower -e | grep -i BAT)
upower -i "${batteries[0]:-}" | grep 'state' | grep -q 'charging\|fully-charged'
elif _command_exists acpi; then
elif _command_exists acpi
then
acpi -a | grep -q "on-line"
elif _command_exists pmset; then
elif _command_exists pmset
then
pmset -g batt | grep -q 'AC Power'
elif _command_exists ioreg; then
elif _command_exists ioreg
then
ioreg -n AppleSmartBattery -r | grep -q '"ExternalConnected" = Yes'
elif _command_exists WMIC; then
elif _command_exists WMIC
then
WMIC Path Win32_Battery Get BatteryStatus /Format:List | grep -q 'BatteryStatus=2'
fi
}
function ac_adapter_disconnected() {
local batteries
if _command_exists upower; then
if _command_exists upower
then
IFS=$'\n' read -d '' -ra batteries < <(upower -e | grep -i BAT)
upower -i "${batteries[0]:-}" | grep 'state' | grep -q 'discharging'
elif _command_exists acpi; then
elif _command_exists acpi
then
acpi -a | grep -q "off-line"
elif _command_exists pmset; then
elif _command_exists pmset
then
pmset -g batt | grep -q 'Battery Power'
elif _command_exists ioreg; then
elif _command_exists ioreg
then
ioreg -n AppleSmartBattery -r | grep -q '"ExternalConnected" = No'
elif _command_exists WMIC; then
elif _command_exists WMIC
then
WMIC Path Win32_Battery Get BatteryStatus /Format:List | grep -q 'BatteryStatus=1'
fi
}
@ -39,22 +49,28 @@ function battery_percentage() {
local command_output batteries
if _command_exists upower; then
if _command_exists upower
then
IFS=$'\n' read -d '' -ra batteries < <(upower -e | grep -i BAT)
command_output="$(upower --show-info "${batteries[0]:-}" | grep percentage | grep -o '[0-9]\+' | head -1)"
elif _command_exists acpi; then
elif _command_exists acpi
then
command_output=$(acpi -b | awk -F, '/,/{gsub(/ /, "", $0); gsub(/%/,"", $0); print $2}')
elif _command_exists pmset; then
elif _command_exists pmset
then
command_output=$(pmset -g ps | sed -n 's/.*[[:blank:]]+*\(.*%\).*/\1/p' | grep -o '[0-9]\+' | head -1)
elif _command_exists ioreg; then
elif _command_exists ioreg
then
command_output=$(ioreg -n AppleSmartBattery -r | awk '$1~/Capacity/{c[$1]=$3} END{OFMT="%05.2f"; max=c["\"MaxCapacity\""]; print (max>0? 100*c["\"CurrentCapacity\""]/max: "?")}' | grep -o '[0-9]\+' | head -1)
elif _command_exists WMIC; then
elif _command_exists WMIC
then
command_output=$(WMIC PATH Win32_Battery Get EstimatedChargeRemaining /Format:List | grep -o '[0-9]\+' | head -1)
else
command_output="no"
fi
if [[ "${command_output}" != "no" ]]; then
if [[ "${command_output}" != "no" ]]
then
printf "%02d" "${command_output:--1}"
else
echo "${command_output}"

6
plugins/available/blesh.plugin.bash
View File

@ -2,13 +2,15 @@
cite about-plugin
about-plugin 'load ble.sh, the Bash line editor!'
if [[ ${BLE_VERSION-} ]]; then
if [[ ${BLE_VERSION-} ]]
then
_log_warning "ble.sh is already loaded!"
return
fi
_bash_it_ble_path=${XDG_DATA_HOME:-$HOME/.local/share}/blesh/ble.sh
if [[ -f $_bash_it_ble_path ]]; then
if [[ -f $_bash_it_ble_path ]]
then
# shellcheck disable=1090
source "$_bash_it_ble_path" --attach=prompt
else

3
plugins/available/boot2docker.plugin.bash
View File

@ -3,7 +3,8 @@ about-plugin 'Helpers to get Docker setup correctly for boot2docker'
# Note, this might need to be different if you have an older version
# of boot2docker, or its configured for a different IP
if [[ "$OSTYPE" == 'darwin'* ]]; then
if [[ "$OSTYPE" == 'darwin'* ]]
then
export DOCKER_HOST="tcp://192.168.59.103:2376"
export DOCKER_CERT_PATH="~/.boot2docker/certs/boot2docker-vm"
export DOCKER_TLS_VERIFY=1

18
plugins/available/browser.plugin.bash
View File

@ -9,8 +9,10 @@ function browser() {
example '$ ron -5 man/rip.5.ron | browser'
group 'browser'
if [ -t 0 ]; then
if [ -n "$1" ]; then
if [ -t 0 ]
then
if [ -n "${1}" ]
then
open $1
else
reference browser
@ -29,8 +31,10 @@ function wmate() {
example '$ wmate google.com'
group 'browser'
if [ -t 0 ]; then
if [ -n "$1" ]; then
if [ -t 0 ]
then
if [ -n "${1}" ]
then
wget -qO- $1 | /usr/bin/mate
TIDY=`/usr/bin/osascript << EOT
@ -66,8 +70,10 @@ function raw() {
example '$ raw google.com'
group 'browser'
if [ -t 0 ]; then
if [ -n "$1" ]; then
if [ -t 0 ]
then
if [ -n "${1}" ]
then
wget -qO- $1 | browser
else
reference raw

3
plugins/available/cht-sh.plugin.bash
View File

@ -2,7 +2,8 @@ cite about-plugin
about-plugin 'Simplify `curl cht.sh/<query>` to `cht.sh <query>`'
# Play nicely if user already installed cht.sh cli tool
if ! _command_exists cht.sh ; then
if ! _command_exists cht.sh
then
function cht.sh () {
about 'Executes a cht.sh curl query using the provided arguments'
param ' [ ( topic [sub-topic] ) | ~keyword ] [ :list | :help | :learn ]'

3
plugins/available/cmd-returned-notify.plugin.bash
View File

@ -7,7 +7,8 @@ function precmd_return_notification() {
local current_time
current_time="$(_shell_duration_en)"
local -i command_duration="$((${current_time%.*} - ${command_start%.*}))"
if [[ "${command_duration}" -gt "${NOTIFY_IF_COMMAND_RETURNS_AFTER:-5}" ]]; then
if [[ "${command_duration}" -gt "${NOTIFY_IF_COMMAND_RETURNS_AFTER:-5}" ]]
then
printf '\a'
fi
return 0

10
plugins/available/colors.plugin.bash
View File

@ -121,18 +121,18 @@ function __color_rgb() {
}
function __color() {
color="$1"
color="${1}"
shift
case "$1" in
case "${1}" in
fg | bg)
side="$1"
side="${1}"
shift
;;
*) side="fg" ;;
esac
case "$1" in
case "${1}" in
normal | bright)
mode="$1"
mode="${1}"
shift
;;
*) mode=normal ;;

3
plugins/available/direnv.plugin.bash
View File

@ -2,6 +2,7 @@
cite about-plugin
about-plugin 'load direnv, if you are using it: https://direnv.net/'
if _command_exists direnv; then
if _command_exists direnv
then
eval "$(direnv hook bash)"
fi

Some files were not shown because too many files have changed in this diff Show More