¿Cómo consigo completar bash para trabajar con alias?

Caso en punto:

Estoy en Mac con bash v3.2.17, estoy usando git instalado a través de macports con la variante bash_completion.

Cuando escribo git checkout m<tab>. por ejemplo, lo completo a master.

Sin embargo, tengo un alias git checkout, gco. Cuando escribo gco m<tab>, no se completa automáticamente el nombre de la sucursal.

Idealmente, me gustaría que el autocompletado funcione mágicamente para todos mis alias. ¿Es posible? De lo contrario, me gustaría personalizarlo manualmente para cada alias. Entonces, ¿cómo hago?

Como se indicó en los comentarios anteriores,

complete -o default -o nospace -F _git_checkout gco

Ya no funcionará. Sin embargo, hay una __git_completefunción en git-completar.bash que se puede usar para configurar la finalización de alias de esta manera:

__git_complete gco _git_checkout

Me encontré con este problema también y se me ocurrió este fragmento de código. Esto le dará automáticamente la finalización de todos los alias. Ejecútelo después de declarar todo (o cualquier) alias.

# wrap_alias takes three arguments:
# $1: The name of the alias
# $2: The command used in the alias
# $3: The arguments in the alias all in one string
# Generate a wrapper completion function (completer) for an alias
# based on the command and the given arguments, if there is a
# completer for the command, and set the wrapper as the completer for
# the alias.
function wrap_alias() {
  [[ "$#" == 3 ]] || return 1

  local alias_name="$1"
  local aliased_command="$2"
  local alias_arguments="$3"
  local num_alias_arguments=$(echo "$alias_arguments" | wc -w)

  # The completion currently being used for the aliased command.
  local completion=$(complete -p $aliased_command 2> /dev/null)

  # Only a completer based on a function can be wrapped so look for -F
  # in the current completion. This check will also catch commands
  # with no completer for which $completion will be empty.
  echo $completion | grep -q -- -F || return 0

  local namespace=alias_completion::

  # Extract the name of the completion function from a string that
  # looks like: something -F function_name something
  # First strip the beginning of the string up to the function name by
  # removing "* -F " from the front.
  local completion_function=${completion##* -F }
  # Then strip " *" from the end, leaving only the function name.
  completion_function=${completion_function%% *}

  # Try to prevent an infinite loop by not wrapping a function
  # generated by this function. This can happen when the user runs
  # this twice for an alias like ls='ls --color=auto' or alias l='ls'
  # and alias ls='l foo'
  [[ "${completion_function#$namespace}" != $completion_function ]] && return 0

  local wrapper_name="${namespace}${alias_name}"

  eval "
function ${wrapper_name}() {
  let COMP_CWORD+=$num_alias_arguments
  args=( \"${alias_arguments}\" )
  COMP_WORDS=( $aliased_command \${args[@]} \${COMP_WORDS[@]:1} )
  $completion_function
  }
"

  # To create the new completion we use the old one with two
  # replacements:
  # 1) Replace the function with the wrapper.
  local new_completion=${completion/-F * /-F $wrapper_name }
  # 2) Replace the command being completed with the alias.
  new_completion="${new_completion% *} $alias_name"

  eval "$new_completion"
}

# For each defined alias, extract the necessary elements and use them
# to call wrap_alias.
eval "$(alias -p | sed -e 's/alias \([^=][^=]*\)='\''\([^ ][^ ]*\) *\(.*\)'\''/wrap_alias \1 \2 '\''\3'\'' /')"

unset wrap_alias

En git-completion.bashhay una línea:

complete -o default -o nospace -F _git git

Mirando esa línea (y la función _git) puede agregar esta línea a su .bash_profile:

complete -o default -o nospace -F _git_checkout gco

He alias g = 'git', y combinado con mis alias git escribo cosas como

$ g co <branchname>

La solución más simple para mi caso de uso específico fue agregar una sola línea para completar git.

Justo debajo de esta línea:

__git_complete git _git

Agregué esta línea para manejar mi solo alias 'g':

__git_complete g _git

Idealmente, me gustaría que el autocompletado funcione mágicamente para todos mis alias. ¿Es posible?

Sí, es posible con el proyecto de alias completo (en Linux). El soporte para Mac es experimental, pero los usuarios han informado de éxito.

También podría intentar usar alias Git. Por ejemplo, en mi ~/.gitconfigarchivo, tengo una sección que se ve así:

[alias]
        co = checkout

Entonces podría escribir git co m<TAB>, y eso debería expandirse a git co master, que es el git checkoutcomando.

Esta página del foro muestra una solución.

Pon estas líneas en tu .bashrco .bash_profile:

# Author.: Ole J
# Date...: 23.03.2008
# License: Whatever

# Wraps a completion function
# make-completion-wrapper <actual completion function> <name of new func.>
#                         <command name> <list supplied arguments>
# eg.
#   alias agi='apt-get install'
#   make-completion-wrapper _apt_get _apt_get_install apt-get install
# defines a function called _apt_get_install (that's $2) that will complete
# the 'agi' alias. (complete -F _apt_get_install agi)
#
function make-completion-wrapper () {
    local function_name="$2"
    local arg_count=$(($#-3))
    local comp_function_name="$1"
    shift 2
    local function="
function $function_name {
    ((COMP_CWORD+=$arg_count))
    COMP_WORDS=( "$@" \${COMP_WORDS[@]:1} )
    "$comp_function_name"
    return 0
}"
    eval "$function"
}

# and now the commands that are specific to this SO question

alias gco='git checkout'

# we create a _git_checkout_mine function that will do the completion for "gco"
# using the completion function "_git"
make-completion-wrapper _git _git_checkout_mine git checkout

# we tell bash to actually use _git_checkout_mine to complete "gco"
complete -o bashdefault -o default -o nospace -F _git_checkout_mine gco

Esta solución es similar al script de balshetzer , pero solo esta realmente funciona para mí. (El guión de balshetzer tuvo problemas con algunos de mis alias).

Una opción más es usar el ~/.bash_completionarchivo. Para crear el gcoalias para git checkoutsimplemente poner esto allí:

_xfunc git __git_complete gco _git_checkout

Luego ~/.bashrc, debe poner solo el alias:

alias gco='git checkout'

Dos lineas. Eso es.

Explicación:

Se ~/bash_completionobtiene al final del script principal bash_completion. En gentoo encontré el guión principal en/usr/share/bash-completion/bash_completion .

El _xfunc gitbit se encarga de obtener el git-completionarchivo por usted para que no necesite agregar nada más ~/.bashrc.

La respuesta aceptada requiere que la copie .git-completion.shy la obtenga de su ~/.bashrcarchivo, lo que me parece poco convincente.

PD: Todavía estoy tratando de descubrir cómo no generar el git-completionscript completo en mi entorno bash. Comenta o edita si encuentras la manera.

Solo tiene que encontrar el completecomando y duplicar la línea que tiene el nombre de alias.

Tengo alias d-m="docker-machine". En palabras, d-mserá el alias para docker-machine.

Entonces, en Mac (a través de brew), los archivos de finalización están en cd `brew --prefix`/etc/bash_completion.d/.
Para mi caso, edité el archivo llamado docker-machine.
Todo el camino al fondo había:

complete -F _docker_machine docker-machine

Así que acabo de agregar otra línea, con mi alias:

complete -F _docker_machine docker-machine
complete -F _docker_machine d-m

Primero, busque el comando de finalización original. Ejemplo:

$ complete | grep git

complete -o bashdefault -o default -o nospace -F __git_wrap__git_main git

Ahora agréguelos a su script de inicio (por ejemplo, ~ / .bashrc):

# copy the original statement, but replace the last command (git) with your alias (g)
complete -o bashdefault -o default -o nospace -F __git_wrap__git_main g

# load dynamically loaded completion functions (may not be required)
_completion_loader git

La _completion_loaderlínea puede no ser requerida. Pero para algunas situaciones, la función de finalización solo se carga dinámicamente después de escribir el comando y presionar TABla primera vez. Por lo tanto, si no ha utilizado el comando original y prueba el alias + TAB, puede obtener un error como "bash: complete: function '_docker' not found".

Hay muchas respuestas a esta pregunta y, como yo, apuesto a muchos lectores confundidos. Para mi caso, también tuve el requisito de que mis archivos dot funcionaran en múltiples plataformas con diferentes versiones de Git. Tampoco lo hago, alias g=gitsino que lo he gdefinido como una función

Para lograr esto, tuve que juntar diferentes respuestas aquí en una sola solución. Aunque esto ya reitera las respuestas, pensé que alguien en mi bote podría encontrar esta compilación útil como lo habría hecho cuando llegué a esta pregunta.

Esto supone la finalización de Git más antigua y más reciente, los valores predeterminados de Ubuntu y brew install giten MacOS. En el último caso, las terminaciones instaladas en brew no estaban siendo procesadas por bash (algo que diagnosticaré más adelante).

# Alias g to git

g() {
  if [[ $# > 0 ]]; then
    git "$@"
  else
    git status -sb
  fi
}

# Preload git completion in Ubuntu which is normally lazy loaded but we need
# the __git_wrap__git_main function available for our completion.
if [[ -e /usr/share/bash-completion/completions/git ]]; then
  source /usr/share/bash-completion/completions/git
elif [[ -e /usr/local/etc/bash_completion.d/git-completion.bash ]]; then
  source /usr/local/etc/bash_completion.d/git-completion.bash
fi

if command_exists __git_complete; then
  __git_complete g _git
elif command_exists __git_wrap__git_main; then
  complete -o bashdefault -o default -o nospace -F __git_wrap__git_main g
fi

Si usa alias g='git', agrego esta línea de código en.bash_aliases

complete -o default -o nospace -F _git g