Git : le memo

Bonjour, Dans cet article un mémento des commandes git les plus courantes, et quelques autres commandes bien utiles.

Commandes principales

Récupérer un dépot git

• git clone <adresse_du_site>

Ou: initialiser un dépôt git à partie d'un répertoire local

• git init

Note : il faudra ensuite ajouter le dépôt distant (voir commandes avancées).

Envoyer ses modifications

• 1. Sélection des modifications a ajouter : git add <fichiers_à_ajouter>
     1. Ajouter toutes les modifications (y compris les nouveaux fichiers) :
        git add -A
     2. Mode interactif :
        git add -p.
        Dans ce mode, il vous est demandé pour chaque modification si vous voulez l'ajouter : répondre y pour oui, n pour non. D'autres options avancées sont possibles, notamment s pour séparer la proposition en plusieurs propositions (voir documentation).
  2. Créer un commit avec les modifications ajoutées précédemment :
     git commit -m "message du commit"
  3. Envoi du commit sur le dépôt distant :
     git push origin <branch_name>.
     Note : origin est le nom par défaut du dépôt sous git. Vous pouvez en ajouter de nouveaux ou changer son nom (voir commandes avancées). Remplacer <branch> par la branche active. Par défaut, c'est master.

Note : vous pouvez ajouter plusieurs séries de modifications et en faire des commits locaux avant d'envoyer le tout sur le serveur. Pratique notamment si on travaille hors connexion ou dans les moments où on risque de casser momentanément le code (ça évite d'embêter les copains !).

Récupérer les modifications depuis le dépôt distant

• git pull <repo_name> <branch>. Remplacer <branch> par la branche active (par défaut : master) et <repo_name> par le nom du dépôt distant (par défaut : origin).

Statut

Pour connaître le statut des différents fichiers :
git status

S'afficher ainsi :

• Les fichiers dans le stash (ajoutés via un git add mais non commitées) - en vert
• Les modifications non ajoutées dans le stash (pas de git add)
• Les fichiers non ajoutés au suivi

Les branches

• Créer une nouvelle branche :
  git checkout -b <branch_name>

• Basculer sur une branche déjà existante (localement ou sur le dépôt distant) : 
  git checkout <branch_name>.
  Si la branche est présente uniquement sur le dépôt distant, il peut être préalablement nécessaire de mettre à jour l'arbre local :
  git fetch <branch_name>.

• Connaître la liste des branches locales et distantes :
  git branch -a
• Connaître la liste des branches locales :
  git branch

• Supprimer une branche localement :
  git branch -d <branch_name>
• Supprimer une branche sur le dépôt distant :
  git push <repo_name> --delete <branch_name>

• Fusionner 2 branches :
  1. Se placer dans la branche cible (voir ci-dessus)
  2. git merge <branch_name>
     Ou bien pour fusionner avec une branche distante :
     git merge <repo_name> <branch_name>

Commandes avancées

Les dépôts distants

• Connaître la liste des dépôts distants :
  git remote -v

• Modifier l'URL d'un dépôt distant :
  git remote set-url <repo_name> <new_url>
  Exemple : git remote set-url origin ssh://....

• Ajouter un nouveau dépôt distant :
  git remote add <repo_name> <repo_url>

• Supprimer un dépôt distant :
  git remote remove <repo_name>
  Note : ceci supprime la référence locale vers le dépôt, pas le dépôt lui-même.

Tags

• Ajouter un tag :
  git tag <tag_name>

• Pousser les tags sur le dépôt distant :
  git push <repo_name> --tags

• Récupérer les tags depuis le dépôt distant :
  git fetch <repo_name> --tags

• Supprimer un tag localement :
  git tag -d <tag_name>

• Supprimer un tag sur le dépôt distant :
  git push <repo_name> <tag_name> --delete

• Lister les tags :
  git tag

Ignorer des fichiers / dossiers

Il est possible d'ignorer certains fichiers ou dossiers. Pour cela, créer un fichier .gitignore et les mentionner à l'intérieur. Ce fichier peut être créer à la racine du dépôt ou dans n'importe quel sous-dossier.

Les fichiers et dossiers mentionnés utilisent le chemin relatif à partir du dossier dans lequel se situe le fichier .gitignore.

Il faut ensuite ajouter le fichier .gitignore au stash et le commiter.

Exceptions :

Il est parfois nécessaire d'indiquer des fichiers dans le gitignore à ne pas ignorer. Il faut précéder alors c'est fichiers d'un point d'exclamation. Par exemple, si on veut ignorer tous les fichiers d'un dossier sauf les fichiers qui portent l'extension ".py", on ajoutera ceci dans le fichier .gitignore :

*
!*.py

Sous-modules

• Ajouter un sous-module à un dépôt git :
  git submodule add <url-to-submodule> <local-directory>
  Note: local-directory n'est utile que si vous voulez changer le nom par défaut (nom du dépôt du sous-module)
• Ajouter un sous-module à un dépôt git, en suivant une certaine branche du sous-module :
  git submodule add -b <branch_name> <url-to-submodule> <local-directory>
  Exemple : git submodule add -b master git://... lib
• Penser ensuite à faire un commit puis un push pour envoyer ces modifications sur le serveur.

• Cloner un dépôt git avec tous ses sous-modules :
  git clone --recursive <url>

• Mettre à jour un dépôt parent pour récupérer ses sous-modules (si vous avez fait un git clone sans l'option --recursive par exemple) :
  git submodule update --remote --init

• Mettre à jour tous les sous-modules d'un dépôt (équivalent à faire un git pull pour chaque sous-module, mais en 1 seule commande) :
  git submodule update --recursive --remote

Note : dans le dépôt parent, le sous-module peut apparaître dans les modifications non validées avec la mention "contenu non suivi". Ce n'est pas gênant, il faut l'ignorer.