Come cd automaticamente dopo il clone di git?

Voglio automaticamente cdla directory creata dal clonecomando dopo aver fatto git clonequalcosa.

Importante: non voglio alterare la sintassi del comando (ad es. Usare un alias / funzione) perché interromperebbe i completamenti zsh che ottengo automaticamente dal Pretzoprogetto.

EDIT : il motivo per cui non ho scelto una risposta come corretta, è perché non è stata data alcuna risposta che soddisfacesse la condizione sopra.

Uso ZSH, ma è accettabile anche una risposta in qualsiasi altra shell.

Crea una funzione:

gclonecd() {
  git clone "$1" && cd "$(basename "$1" .git)"
}

(Funziona per collegamenti sia con che senza ".git")

git cloneaccetta un ulteriore argomento: la directory da usare. Puoi farlo clonare nella directory di lavoro corrente con git clone URL . Quindi, non è necessario cambiare la directory di lavoro; ci sei già.

Se vuoi davvero che il gitcomando cambi effettivamente la directory di lavoro, puoi cambiarlo in una funzione che chiama il reale gitquando necessario:

git()
{
   local tmp=$(mktemp)
   local repo_name

   if [ "$1" = clone ] ; then
     /usr/bin/git "$@" | tee $tmp
     repo_name=$(awk -F\' '/Cloning into/ {print $2}' $tmp)
     rm $tmp
     printf "changing to directory %s\n" "$repo_name"
     cd "$repo_name"
   else
     /usr/bin/git "$@"
   fi
}

Se si fornisce il nome locale del repository, è davvero facile usare $ _ :

git clone git@github.com:npm/npm.git npm-local-dir && cd $_

Ma se non vuoi riscrivere nomi lunghi, è un po 'brutto ma fattibile con sed:

git clone git@github.com:pckujawa/pattern-rec.git && 
cd `echo $_ | sed -n -e 's/^.*\/\([^.]*\)\(.git\)*/\1/p'`

EDIT: Beh, stavo per ringraziare Manav (commento sotto) per il terse

git clone foo/bar && cd !$:t

ma non funziona in zsh (qualcosa su come zsh fa le espansioni fa sì che non tratti il ​​primo comando come input per !$). Ho dovuto cercare cosa ha !$:tfatto ( Avanzando in Bash Shell | $ {me: -whatever} ). !$prende l'ultima parte del comando precedente e :t"Rimuovi tutti i componenti principali del nome file, lasciando la coda." Buone informazioni, ma vorrei poterlo far funzionare con zsh (ho provato noglobsenza successo).

EDIT: Invece di usare sedo !$:t(che non funziona in zsh, per me comunque), ho trovato altre due opzioni (una adattando https://unix.stackexchange.com/users/5685/frederik-deweerdt la risposta con https : //unix.stackexchange.com/users/129926/ commento di Henry -n):

git clone git@github.com:npm/npm.git && cd $(basename $_ .git)

o

git clone git@github.com:npm/npm.git && cd ${${_%%.git*}##*/}

Una soluzione semplice per qualsiasi shell POSIX è specificare la directory in cui clonare esplicitamente (qualsiasi percorso del filesystem) e riutilizzarla:

git clone <repository> <directory> &&
cd "$_"

e

cd -

quando hai fatto.

Potresti fare qualcosa del tipo:

clone_check() {
  (($? != 0)) && return
  local cmd=$history[$((HISTCMD-1))]
  cmd=("${(@Q)${(z)cmd}}")
  if [[ $cmd = "git clone "* ]]; then
    local dir
    if (($#cmd == 3)); then
      dir=${cmd[3]:t}
      dir=${dir%.git}
      dir=${dir#*:}
    elif (($#cmd > 3)); then
      dir=$cmd[-1]
    else
      return
    fi
    print -r CDing into $dir > /dev/tty
    cd -- $dir
  fi
}
precmd_functions+=(clone_check)

È abbastanza semplicistico. È un precmdhook (eseguito prima di ogni prompt), che controlla se appariva l'ultima riga di comando git clone .../somethingo git clone .../something dir, indovina la directory da quella e cd in essa.

Non funziona se hai inserito git clone foo; whatevero whatever; git clone fooo git clone --option repo...

Ecco un adattamento della risposta sopra per OSX

• mktemp richiede un parametro aggiuntivo
• git clonescrive per STDERRimpostazione predefinita (vedi questo )

Funzione:

function git {
   local tmp=$(mktemp -t git)
   local repo_name

   if [ "$1" = clone ] ; then
     command git "$@" --progress 2>&1 | tee $tmp
     repo_name=$(awk -F\' '/Cloning into/ {print $2}' $tmp)
     rm $tmp
     printf "changing to directory %s\n" "$repo_name"
     cd "$repo_name"
   else
     command git "$@"
   fi
}

Io non lo consiglio, ma si poteva utilizzare questo one-liner:

echo 'project' | xargs -I % sh -c 'git clone https://github.com/username/%.git && cd %'

Includilo nella shell:

git(){
  case "$1" in clone) git-clone "${@:2}";; *) command git "$@";; esac
}
git-clone(){ 
   local tgt 
   tgt=$(command git clone "$@" 2> >(tee /dev/stderr |head -n1 | cut -d \' -f2)) ||
      return $?
   cd "$tgt"
}

Questo funziona facendo sparpagliare furtivamente il bersaglio della clonazione dall'errore standard di git e cd'penetrare nel bersaglio se (e solo se) la clonazione ha avuto successo.

Accetta tutti gli argomenti e le opzioni che fa il normale git clone.

O puoi usare il wrapper git e non devi preoccuparti dei tuoi completamenti, oppure puoi sbarazzarti del wrapper git e ricollegare i tuoi git clonecompletamenti git-clone.