Come posso ottenere il completamento bash per lavorare con gli alias?

Caso in questione:

Sono un mac con bash v3.2.17, sto usando git installato tramite macports con la variante bash_completion.

Quando scrivo git checkout m<tab>. per esempio, lo ottengo completato master.

Tuttavia, ho un alias git checkout, gco. Quando scrivo gco m<tab>, non ottengo il nome del ramo completato automaticamente.

Idealmente, mi piacerebbe che il completamento automatico funzionasse magicamente per tutti i miei alias. È possibile? In caso contrario, vorrei personalizzarlo manualmente per ogni alias. Quindi, come posso fare?

Come indicato nei commenti sopra,

complete -o default -o nospace -F _git_checkout gco

non funzionerà più. Tuttavia, c'è una __git_completefunzione in git-completamento.bash che può essere usata per impostare il completamento per alias in questo modo:

__git_complete gco _git_checkout

Ho riscontrato anche questo problema e ho trovato questo frammento di codice. Questo ti darà automaticamente il completamento per tutti gli alias. Eseguilo dopo aver dichiarato tutto (o qualsiasi) 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

In git-completion.bashc'è una linea:

complete -o default -o nospace -F _git git

Guardando quella linea (e la funzione _git) puoi aggiungere questa linea al tuo .bash_profile:

complete -o default -o nospace -F _git_checkout gco

Ho alias g = 'git', e in combinazione con i miei alias git scrivo cose come

$ g co <branchname>

La soluzione più semplice per il mio caso d'uso specifico era quella di aggiungere una sola riga al completamento di git.

Proprio sotto questa linea:

__git_complete git _git

Ho aggiunto questa riga per gestire il mio singolo alias 'g':

__git_complete g _git

Idealmente, mi piacerebbe che il completamento automatico funzionasse magicamente per tutti i miei alias. È possibile?

Sì, è possibile con il progetto alias completo (su Linux). Il supporto per Mac è sperimentale ma gli utenti hanno segnalato il successo.

Puoi anche provare a usare gli alias Git. Ad esempio, nel mio ~/.gitconfigfile, ho una sezione che assomiglia a questa:

[alias]
        co = checkout

Quindi potresti digitare git co m<TAB>, e quello dovrebbe espandersi a git co master, che è il git checkoutcomando.

Questa pagina del forum mostra una soluzione.

Inserisci queste righe nel tuo .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

Questa soluzione è simile alla sceneggiatura di balshetzer , ma solo questa funziona davvero per me. (la sceneggiatura di balshetzer ha avuto problemi con alcuni dei miei alias.)

Un'altra opzione è utilizzare il ~/.bash_completionfile. Per creare l' gcoalias per git checkoutinserire semplicemente questo:

_xfunc git __git_complete gco _git_checkout

Quindi ~/.bashrcdevi inserire solo lo pseudonimo:

alias gco='git checkout'

Due linee. Questo è tutto.

Spiegazione:

Il ~/bash_completionottiene di provenienza alla fine dello script bash_completion principale. In gentoo ho trovato lo script principale in /usr/share/bash-completion/bash_completion.

Il _xfunc gitbit si occupa di reperire il git-completionfile per te, quindi non è necessario inserire altro ~/.bashrc.

La risposta accettata richiede di copiarla .git-completion.she reperirla dal tuo ~/.bashrcfile che trovo zoppo.

PS: Sto ancora cercando di capire come non generare l'intero git-completionscript nel mio ambiente bash. Commenta o modifica se trovi un modo.

Devi solo trovare il completecomando e duplicare la riga con il nome alias invece.

Io ho alias d-m="docker-machine". A parole, d-msarà lo pseudonimo di docker-machine.

Quindi su Mac (via brew), i file di completamento sono presenti cd `brew --prefix`/etc/bash_completion.d/.
Per il mio caso ho modificato il file chiamato docker-machine.
In fondo c'era:

complete -F _docker_machine docker-machine

Quindi ho appena aggiunto un'altra riga, con il mio alias:

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

Innanzitutto, cerca il comando di completamento originale. Esempio:

$ complete | grep git

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

Ora aggiungili al tuo script di avvio (ad es. ~ / .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

Il _completion_loader linea potrebbe non essere richiesta. Ma per alcune situazioni, la funzione di completamento viene caricata in modo dinamico solo dopo aver digitato il comando e premuto TABla prima volta. Quindi se non hai usato il comando originale e provi l'alias + TAB, potresti ricevere un errore come "bash: completamento: funzione '_docker' non trovata".

Ci sono molte risposte a questa domanda e come me scommetto molti lettori confusi. Per il mio caso avevo anche avuto il requisito di far funzionare i miei dotfile su più piattaforme con diverse versioni di Git. Anch'io no alias g=gitma invece l'ho fattog definito una funzione.

Per raggiungere questo obiettivo ho dovuto mettere insieme diverse risposte qui in un'unica soluzione. Anche se questo ribadisce già le risposte, ho pensato che qualcuno nella mia barca potesse trovare questa raccolta utile come avrei fatto quando sono arrivato a questa domanda.

Ciò presuppone il completamento Git più vecchio e più recente, le impostazioni predefinite di Ubuntu e brew install gitsu MacOS. Nel caso successivo i completamenti installati sulla birra non venivano elaborati da bash (qualcosa che verrà diagnosticato in seguito).

# 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

Se usi alias g='git', aggiungo questa riga di codice.bash_aliases

complete -o default -o nospace -F _git g