Comment cd automatiquement après le clone de git?

Je souhaite accéder automatiquement cdau répertoire créé par la clonecommande après git clonequelque chose.

Important: je ne souhaite pas modifier la syntaxe de la commande (par exemple, utiliser un alias / une fonction), car cela briserait les compléments zsh que je recevrais automatiquement du Pretzoprojet.

EDIT : La raison pour laquelle je n’ai retenu aucune réponse comme étant correcte, c’est qu’aucune réponse n’a été donnée qui soit conforme à la condition ci-dessus.

J'utilise ZSH, mais une réponse dans un autre shell est également acceptable.

Créer une fonction:

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

(Fonctionne pour les liens avec et sans ".git")

git cloneprend un argument supplémentaire: le répertoire à utiliser. Vous pouvez le faire cloner dans le répertoire de travail actuel avecgit clone URL . Ensuite, il n'est pas nécessaire de changer de répertoire de travail; vous êtes déjà là.

Si vous voulez vraiment que la gitcommande change réellement le répertoire de travail, vous pouvez la changer pour une fonction qui appelle le réel gitsi nécessaire:

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
}

Si vous fournissez le nom local du référentiel, c'est très simple avec $ _ :

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

Mais si vous ne voulez pas retaper des noms longs, c'est un peu moche mais faisable avec sed:

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

EDIT: Eh bien, je vais remercier Manav (commentaire ci-dessous) pour le terse

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

mais cela ne fonctionne pas dans zsh (quelque chose sur la façon dont zsh fait des expansions fait qu'il ne traite pas la première commande comme une entrée !$). Je devais regarder ce !$:tqui se passait ( Avancer dans le shell Bash | $ {me:-importe quoi} ). !$saisit la dernière partie de la commande précédente et :t"supprime tous les composants de nom de fichier principaux en laissant la queue". Bonne information, mais j'aimerais pouvoir le faire fonctionner avec zsh (j'ai essayé noglobsans succès).

EDIT: Au lieu d’utiliser sedor !$:t(qui ne fonctionne pas dans zsh, pour moi en tout cas), j’ai trouvé deux autres options (l’une adaptant https://unix.stackexchange.com/users/5685/frederik-deweerdt avec https : //unix.stackexchange.com/users/129926/ Commentaire dehenrik-n ):

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

ou

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

Une solution simple pour tout shell POSIX consiste à spécifier le répertoire à cloner explicitement (n'importe quel chemin de système de fichiers) et à le réutiliser:

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

et

cd -

quand tu as fini.

Vous pourriez faire quelque chose comme:

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)

C'est assez simpliste. C'est un precmdcrochet (exécuté avant chaque invite), qui vérifie si la dernière ligne de commande ressemble à git clone .../somethingou git clone .../something dir, devine le répertoire à partir de celui-ci et y est inséré.

Cela ne fonctionne pas si vous entrez git clone foo; whateverou whatever; git clone fooou git clone --option repo...

Voici une adaptation de la réponse ci-dessus pour OSX

• mktemp nécessite un paramètre supplémentaire
• git cloneécrit STDERRpar défaut (voir ceci )

Une fonction:

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
}

Je ne le recommanderais pas, mais vous pouvez utiliser ce one-liner:

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

Incluez ceci dans votre 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"
}

Cela fonctionne en éliminant subrepticement la cible de clonage de l'erreur standard de git et cd l'incroyant dans la cible si (et seulement si) le clonage a été un succès.

Il accepte tous les arguments et options proposés par le standard git clone.

Soit vous pouvez utiliser le wrapper git sans avoir à vous soucier de vos achèvements, soit vous pouvez vous en débarrasser et rewire vos git cloneachèvements git-clone.