Dokuwiki

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Git ======
__**Tuto :**__
  * https://git-scm.com/book/fr/v2
  * https://www.grafikart.fr/formations/git
  * https://education.github.com/git-cheat-sheet-education.pdf
  * http://cdiese.fr/git-en-5-min/
  * https://delicious-insights.com/fr/articles/bien-utiliser-git-merge-et-rebase/

===== .gitignore =====
Créer un fichier ''.gitignore'' pour ignorer certains fichiers, répertoires, extensions :
<code git .gitignore>
*
!*/
*.swp
*.swo
!.gitignore
!README.md
!/dir2/
/dir2/dir1/passwd
!/dir1/dir2/file2
</code>

===== Outils =====
==== ungit ====
  * [[https://github.com/FredrikNoren/ungit|Officiel]]
  * [[https://www.grafikart.fr/formations/git/ungit|Tuto]]

==== gitkraken ====
  * [[https://support.gitkraken.com/how-to-install|Officiel]]
  * [[https://www.grafikart.fr/formations/git/gitkraken|Tuto]]

==== Astuces ====
  * Affiche la liste, taille et attributs des fichiers :
<xtermrtf>
$ git ls-tree --full-tree -rl HEAD
</xtermrtf>

  * Affiche la racine du projet géré par git :
<xtermrtf>
$ git rev-parse --show-toplevel
/home/gigix/test-github/gigix
</xtermrtf>

  * Affiche tous les changements sur un fichier :
    * pour touts les [[#commit]] :
<xtermrtf>
$ git rev-list --all --abbrev-commit | xargs git grep -n mon_fichier
</xtermrtf>
    * pour les 10 derniers [[#commit]] :
<xtermrtf>
$ git rev-list --abbrev-commit --all --max-count=10 | xargs git grep -n mon-fichier
</xtermrtf>
    * pour tous les fichiers xml du répertoire dir1 :
<xtermrtf>
$ git rev-list --all --abbrev-commit | xargs -I{} git grep dir1 {} -- ".xml"
</xtermrtf>

  * Vérifie si un fichier match avec le fichier [[#gitignore|.gitignore]] :
<xtermrtf>
$ git check-ignore -v dir11/file
.gitignore:1:* dir11/file
</xtermrtf>

  * Affiche la [[#branch|branche]] courante :
<xtermrtf>
$ git rev-parse --abbrev-ref HEAD
master
</xtermrtf>

  * Remplace tous les nom et email d'un auteur par un autre pour l'ensemble des [[#commit]] :
<xtermrtf>
$ git filter-branch --commit-filter '                                                                                      
         if [ "$GIT_AUTHOR_NAME" = "root" ];
         then
                 GIT_AUTHOR_NAME="Ghislain LE MEUR";
                 GIT_COMMITTER_NAME="Ghislain LE MEUR";
                 GIT_AUTHOR_EMAIL="gigi206@users.noreply.github.com";
                 GIT_COMMITTER_EMAIL="gigi206@users.noreply.github.com"; 
                 git commit-tree "$@";
         else
                 git commit-tree "$@";
         fi' -f HEADt commit-tree "$@";
         fi' HEAD
</xtermrtf>

  * Efface ''mydir/myfile'' pour l'ensemble des [[#commit]] :
<xtermrtf>
$ git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch mydir/myfile' --prune-empty --tag-name-filter cat -- --all
$ git push origin --force --all
$ git push origin --force --tags
$ git for-each-ref --format='delete %(refname)' refs/original | git update-ref --stdin
$ git reflog expire --expire=now --all
$ git gc --prune=now
</xtermrtf>

==== Configuration ====
  * Désactiver le pager :
<xtermrtf>
$ git config --global --replace-all core.pager "less -F -X"
</xtermrtf>

===== Subcommand =====
==== aide ====
Affiche l'aide :
<xtermrtf>
$ git help <module>
$ git help config
</xtermrtf>

==== config ====
Gère la configuration locale ou globale des projets git.
**__Options :__**
  * **--global** : pour tous les repo git (fichier ''/home/gigix/.gitconfig'')
  * **--local** : pour le repo courant (par défaut dans le répertoire ''.git/config'' du projet)

  * Pousser une configuration :
<xtermrtf>
$ git config --global user.name "GigiX"
$ git config --global user.email gigixdvelannes.com
</xtermrtf>

  * Voir la configuration :
<xtermrtf>
$ git config -l --global 
$ git config -l --local
</xtermrtf>

  * Editer la configuration :
<xtermrtf>
$ git config -e --global 
$ git config -e --local
</xtermrtf>

<xtermrtf>
$ git remote set-url origin https://github.com/gigi206/test.git
</xtermrtf>

  * Afficher la configuration d'une variable :
<xtermrtf>
$ git config --get remote.origin.url
</xtermrtf>

==== init ====
Initialise un nouveau projet git :
  * Créer un repo local git pour gérer notre projet :
<xtermrtf>
$ git init
</xtermrtf>

  * Créer un repo local pour accueillir les [[#push]] : 
<xtermrtf>
$ git init --bare
</xtermrtf>

==== remote ====
Gère les remotes.
  * Lister les remote :
<xtermrtf>
$ git remote -v
origin	https://github.com/gigi206/test.git (fetch)
origin	https://github.com/gigi206/test.git (push)
</xtermrtf>

  * Ajoute un remote :
<xtermrtf>
$ git remote add origin /home/gigix/test-repo
$ git remote add upstream https://github.com/gigi206/vim-gigix.git
</xtermrtf>

  * Supprimer un remote :
<xtermrtf>
$ git remote remove origin /home/gigix/test-repo
</xtermrtf>

  * Renommer un remote :
<xtermrtf>
$ git remote rename origin test
</xtermrtf>

<note>
En principe on appelle **origin** le repo sur lequel on envoie les [[#push]] et **upstream** le dépôt que l'on a forké pour par exemple envoyé un **pull request**.
</note>

==== clone ====
Clone un projet.
  * Copie un repo distant :
<xtermrtf>
$ git clone https://github.com/gigi206/vim-gigix.git myclonerepo
</xtermrtf>

  * Copie le dépôt avec les 10  derniers [[#commit]] (utile pour récupérer les gros dépôts) :
<xtermrtf>
$ git clone --depth 10 https://github.com/gigi206/vim-gigix.git
</xtermrtf>

==== status ====
Afficher l'état de notre copie de travail :
<xtermrtf>
$ git status
$ git status -s
</xtermrtf>

==== add ====
  * Ajoute un fichier à l'index :
<xtermrtf>
$ git add mon_fichier
</xtermrtf>

  * Ajoute tous les fichiers à l'index :
<xtermrtf>
$ git add --all
$ git add -A
</xtermrtf>

  * Ajouter le répertoire courant :
<xtermrtf>
$ git add .
</xtermrtf>

==== rm ====
  * Supprimer un fichier à l'index :
<xtermrtf>
$ git rm mon_fichier
</xtermrtf>

  * Supprimer les fichier de l'index :
<xtermrtf>
$ git rm --cached monfichier
</xtermrtf>

  * Supprimer tous les fichiers d'un répertoire :
<xtermrtf>
$ git rm -r mon_repertorie
</xtermrtf>

==== mv ====
Renomme un fichier, dossier ou lien de l'espace de travail :
<xtermrtf>
$ git mv file1 file2
</xtermrtf>

==== commit ====
Gère les révisions localement uniquement.
  * Envoie de tous les fichiers trackés :
<xtermrtf>
$ git commit -a -m 'mon message'
</xtermrtf>

  * Envoie d'un fichier :
<xtermrtf>
$ git commit -m 'mon message' mon-fichier
</xtermrtf>

  * Changer l'auteur :
<xtermrtf>
$ git commit --author "GigiX" -m "message"
</xtermrtf>

  * Modifie le dernier commit en ajoutant nos modifications actuelles au derniers commit et en modifiant son message (ne crée pas une nouvelle entrée dans [[#log|l'historique]] :
<xtermrtf>
$ git add -A
$ git commit --amend –m "message"
</xtermrtf>

==== push ====
Envoie les [[#commit]], [[#branch|branches]], [[#tag|tags]] au [[#remote]]
  * Envoyer ses modifications de la [[#branch|branche]] master au [[#remote]] origin:
<xtermrtf>
$ git push -u origin master
</xtermrtf>

  * Envoyer toutes ses [[#branch|branches]] et [[#tag|tags]] :
<xtermrtf>
$ git push --all --tags
</xtermrtf>

==== fetch ====
Met à jour le répertoire local depuis un [[#remote]] :
<xtermrtf>
$ git fetch origin master
$ git fetch --all
</xtermrtf>

==== pull ====
  * Récupérer les modifications du [[#remote]] :
<xtermrtf>
$ git pull
</xtermrtf>

  * Pull avec un [[#rebase]] à la place d'un [[#merge]] :
<xtermrtf>
$ git pull --rebase
</xtermrtf>

<note>
Un [[#pull]] équivaut à faire un [[#fetch]] suivi d'un merge [[#merge]].
Pour que git fasse toujours un [[#rebase]] à la place d'un [[#merge]], il faut ajouter la [[#config|configuration]] ci-dessous :
<xtermrtf>
$ git config --global branch.autosetuprebase always
</xtermrtf>
</note>

  * Pull avec un [[#rebase]] sur le dernier [[#commit]] uniquement pour préserver le graph [[#log|d'historique]] :
<xtermrtf>
$ git pull --rebase=preserve
</xtermrtf>

<note>
Pour que git fasse toujours un **preserve**, on peut ajouter à la configuration de git :
<xtermrtf>
$ git config --global pull.rebase = preserve
</xtermrtf>
</note>

  * Sans **fast-forward** (l'équivalent d'un [[#merge]] dans [[#log|l'historique]]) :
<xtermrtf>
$ git pull --no-ff
</xtermrtf>

  * En forçant le **fast-forward** (l'équivalent d'un [[#rebase]] dans [[#log|l'historique]]) :
<xtermrtf>
$ git pull --ff-only
</xtermrtf>

==== cherry-pick ====
Récupère seulement un seul [[#commit]] effectué sur une autre branche complètement séparée de la branche courante. Elle permet d’appliquer les modifications correspondant à un seul [[#commit]] sans effectuer de [[#merge]] ou [[#rebase]].

  * Se placer dans la branche sur laquelle on veut appliquer le [[#commit]], par exemple **//master//** :
<xtermrtf>
$ git checkout master
$ git cherry-pick <SHA-1>
</xtermrtf>

<note>
Il n’est pas nécessaire d’effectuer un [[#commit]] après cette étape, [[#cherry-pick]] effectue lui-même un [[#commit]]. Cette fonctionnalité est très pratique par exemple lorsqu'on a corrigé un bug sur la branche dev et qu'on veut pousser cette correction sur la branche master.
</note>

==== stash ====
Imaginons, vous avez des modifications en cours de création et vous avez envie de les mettre de côté temporairement, plutôt que de [[#commit]] les différentes modifications vous pouvez les stocker grâce à **stash**.

  * Backup les modifications courantes :
<xtermrtf>
$ git stash -u
$ git stash save -u mon message
</xtermrtf>

  * Ramène les modifications dans une nouvelle [[#branch|branche]] :
<xtermrtf>
$ git stash branch gigix
</xtermrtf>

  * Restaure les dernières modifications sauvegardées en **stash** :
<xtermrtf>
$ git stash apply
$ git stash apply stash@{1}
</xtermrtf>

  * Supprime le backup :
<xtermrtf>
$ git stash drop
$ git stash drop stash@{1}
</xtermrtf>

  * Restaure et supprime le backup :
<xtermrtf>
$ git stash drop
$ git stash drop stash@{1}
</xtermrtf>

  * Affiche ce qui a été sauvegardé : 
<xtermrtf>
$ git stash pop
$ git stash pop stash@{1}
</xtermrtf>

  * Voir l'ensemble des modifications sauvegardées :
<xtermrtf>
$ git stash list
</xtermrtf>

==== log ====
Affiche les révisions, auteurs, date, diff des [[#commit]].
  * Affiche les logs des [[#commit]] :
<xtermrtf>
$ git log --oneline                                                                                                       
$ git log --raw --oneline -10
$ git log --stat
$ git log -p
$ git log --graph --decorate --oneline
$ git log --author="GigiX" -p hello.py
$ git log master..origin/master # Permet de voir les commits entre ma branche master et celle du remote
$ git log 852e094^..852e094 -p
$ git log 852e094..HEAD --oneline
$ git log 852e094..HEAD -L 2,6:mon_fichier
$ git log --grep=gigix
$ git log --since="1 month" --until="1 day" --oneline
$ git log --graph --abbrev-commit --decorate --date=relative --all
$ git log --graph --topo-order --decorate --oneline --all
$ git log --graph --topo-order --decorate --oneline --boundary test..master
$ git log --graph --full-history --all --color --pretty=format:"%x1b[31m%h%x09%x1b[32m%d%x1b[0m%x20%s"
</xtermrtf>

  * Rechercher un fichier et ses révisions (même supprimé) :
<xtermrtf>
$ git log --all --full-history -- test
</xtermrtf>

  * Ajouter un alias pour les logs (celui que j'utilise) :
<xtermrtf>
$ git config --global alias.lg 'log --graph --full-history --color --oneline --format="%x1B[33m%h%x1B[32m%d %x1B[0m%s %x1B[36m(%an %cr)%x1B[0m"'
$ git config --global alias.lga 'log --graph --full-history --color --oneline --all --format="%x1B[33m%h%x1B[32m%d %x1B[0m%s %x1B[36m(%an %cr)%x1B[0m"'
$ git lg --all
$ git lga
$ git lg --first-parent mybranch
$ git lg --parents mybranch
</xtermrtf>

==== reflog ====
Affiche les logs des [[#rebase]], [[#merge]], etc...

<xtermrtf>
$ git reflog
</xtermrtf>

==== show ====
  * Affiche les différences sur les fichier pour un [[#commit]] ou affiche un fichier pour un [[#commit]] donné :
<xtermrtf>
$ git show 651bb22                                                                                                        
$ git show 651bb22:README.md
$ git show --topo-order --decorate --oneline
$ git show --topo-order --decorate --oneline --all
</xtermrtf>

==== blame ====
  * Affiche un fichier ligne par ligne avec son [[#commit]] et son auteur.
<xtermrtf>
$ git blame myfile 
$ git blame -n myfile
$ git blame -L 3,6 -C myfile
</xtermrtf>

==== diff ====
  * Affiche la différence entre 2 [[#commit]] :
<xtermrtf>
$ git diff HEAD^^
$ diff 8084b3f..edeaa87                                                                     
$ git diff 26e5423:.gitignore  3c99fa1:.gitignore
$ git diff 3c99fa1..26e5423 dir1/dir2/file2
</xtermrtf>

  * Comparer avec l'index :
<xtermrtf>
$ git diff --cached
</xtermrtf>

  * Créer et appliquer un patch :
<xtermrtf>
$ git diff 2d8de18..17dc028 > path
$ git apply patch
$ git diff
</xtermrtf>
Ou (utilise plutôt [[#revert]]) :
<xtermrtf>
$ git diff 2d8de18..17dc028 | patch
$ git status
</xtermrtf>
==== difftool ====
Utilise un outil tiers comme vim pour afficher les [[#diff]] (comme **vimdiff** par exemple).
<xtermrtf>
$ git difftool  HEAD^..HEAD -t vimdiff
</xtermrtf>

<note tips>
Ajouter la configuration ci-dessous pour ne pas avoir à spécifier à chaque fois ''-t vimdiff'' :
<xtermrtf>
$ git config --global alias.vimdiff difftool
</xtermrtf>
</note>

==== branch ====
Gère les branches.
  * Crée la branche gigix :
<xtermrtf>
$ git branch gigix 
</xtermrtf>

  * Détruit la branche gigix localement :
<xtermrtf>
$ git branch -d gigix
</xtermrtf>

  * Détruit la branche distante gigix sur le remote origin :
<xtermrtf>
$ git push -u origin -d gigix
</xtermrtf>

  * Renommer une branche :
<xtermrtf>
$ git branch -m gigix new
</xtermrtf>

  * Liste les branches :
<xtermrtf>
$ git branch -vv --all
</xtermrtf>

==== checkout ====
Change de [[#branch|branche]] ou restaure un fichier d'un autre [[#commit]].
  * Se positionner sur une révision ou branche pour l'explorer :
<xtermrtf>
$ git checkout HEAD^^
$ git checkout 8084b3f
$ git checkout master
$ git checkout mabranche
</xtermrtf>

  * Restaurer un fichier d'un ancien [[#commit]] :
<xtermrtf>
$ git checkout 8084b3f 1
</xtermrtf>

  * Créer la [[#branch|branche]] **gigix** et se positionner dessus :
<xtermrtf>
$ git checkout -b gigix
</xtermrtf>

==== revert ====
  * Annule seulement les [[#commit]] sélectionnés (n'altère pas [[#log|l'historique]]) :
<xtermrtf>
$ git revert 416515b
$ git revert 7db7d1c..852e094
$ git revert 17dc028 --no-commit
</xtermrtf>

==== reset ====
Retourne à un ancien [[#commit]] et supprime le [[#log]].
  * Déplace le **HEAD** sur un [[#commit]] sans rien faire d'autre (ne touche pas à l'index, ni au répertoire de travail) :
<xtermrtf>
$ git reset --soft 181d77f
$ git log --graph --topo-order --decorate --oneline --all --color
$ git status
$ git diff --cached
$ git commit -m "message"
</xtermrtf>

  * L'option **--mixed** est l'option par défaut (il n'est donc pas nécessaire de la spécifier). Il déplace le **HEAD** et l'index :

    * Sur une révision complète :
<xtermrtf>
$ git reset --mixed 181d77f
$ git log --graph --topo-order --decorate --oneline --all --color
$ git status
$ git diff
$ git commit -a -m "message"
</xtermrtf>

    * Seulement sur un fichier :
<xtermrtf>
$ git reset 181d77f myfile
$ git log --graph --topo-order --decorate --oneline --all --color
$ git status
$ git diff
$ git commit -a -m "message"
</xtermrtf>

    * Enlève le travail de l'index (donné avec **git add**) :
<xtermrtf>
$ git reset
</xtermrtf>

<note warn>
L'option **--hard** supprimera vos fichiers et votre [[#log|historique]]. L'ensemble de votre travail sera donc perdu. Utiliser [[#reset]] avec précaution !
</note>

  * L'option **--hard** déplace le **HEAD**, l'index et l'espace de travail (vous perdrez donc votre travail en cours) :
<xtermrtf>
$ git reset --hard 181d77f
</xtermrtf>

    * Remet l'espace de travail à l'état du dernier [[#commit]] :
<xtermrtf>
$ git reset --hard
</xtermrtf>

==== clean ====
Supprime les fichiers non trackés.

  * Mode intéractif :
<code>
$ git clean -i
</code>

  * Simule :
<code>
$ git clean -n
</code>

  * supprime les fichiers :
<code>
$ git clean -f
</code>


==== rebase ====
Rapatrie les [[#commit]] d'une autre [[#branch|branche]] dans celle courante.

  * Si la [[#branch|branche]] **test** est en avance et qu'on souhaite mettre [[#branch|branche]] courante au même niveau que **test** :
<xtermrtf>
$ git rebase -i test
</xtermrtf>

  * Si l'on souhaite éditer, ou fusionner les 3 [[#commit]] précédents :
<xtermrtf>
$ git rebase -i HEAD~3
</xtermrtf>

<note>
Les [[#commit]] sont indiqués du plus vieux au plus récent (l’ordre est inversé).
</note>

  * Rejoue les modifications de dev sur le sommet de la branche master :
<xtermrtf>
$ git rebase master dev
#ou
$ git rebase -i master dev
#On peut ensuite avancer master au niveau de dev et supprimer dev
$ git checkout master
$ git merge dev --ff-only
$ git branch -d dev
</xtermrtf>

  * Récupérer une sous branche d'une branche dans master :
Prenons le cas ci-dessous :
{{ :tuto:linux:interesting-rebase-1.png?nolink |}}

Pour fusionner la sous-branche client de server dans master, on fera :
<xtermrtf>
$ git rebase --onto master server client
</xtermrtf>

Ce qui donnera :
{{ :tuto:linux:interesting-rebase-2.png?nolink |}}

==== merge ====
Fusionne 2 [[#branch|branche]] et garde une trace dans [[#log|l'historique]].

  * Merge la [[#branch|branche]] test sur celle courante :
<xtermrtf>
$ git merge test
</xtermrtf>

  * Merge avec fast forward (équivaut à un [[#rebase]]) :
<xtermrtf>
$ git merge test --ff-only
</xtermrtf>

  * Merge sans fast forward :
<xtermrtf>
$ git merge test --no-ff
</xtermrtf>

  * Merge une branche dans une autre sans modifier l'historique (exemple : merge la branche gigix dans la branche master) :
<xtermrtf>
$ git checkout master
$ git merge --squash gigix
$ git diff --staged
$ git commit -a -m "New feature gigix"
#Si on souhaite supprimer gigix
$ git push origin -d gigix
</xtermrtf>

==== shortlog ====
Affiche les statistiques.
  * Affiche le [[#commit]] par utilisateur :
<xtermrtf>
$ git shortlog -sn
</xtermrtf>

==== archive ====
Créer une archive du dépôt git.
  * Affiche les formats de compressions :
<xtermrtf>
$ git archive -l
</xtermrtf>

  * Compresser le dépôt courant :
<xtermrtf>
$ git archive --format=tar.gz -o gigix.tar.gz master
$ git archive --format=tar.gz -o gigix.tar.gz HEAD^1
</xtermrtf>

==== tag ====
Gère les tags.

  * Affiche les tags :
<xtermrtf>
$ git tag
$ git tag -n
$ git tag -l -n
</xtermrtf>

  * Crée le tag **test** :
<xtermrtf>
$ git tag test 6452b46
</xtermrtf>

  * Crée un tag annoté :
<xtermrtf>
$ git tag -a test 6452b46 -m "gigix"
</xtermrtf>

  * Supprime le tag **test** :
<xtermrtf>
$ git tag -d test
</xtermrtf>

==== grep ====
Recherche dans les fichiers :
<xtermrtf>
$ git grep --all-match -e "^gigix$" -e "modif"
$ git grep -i 'gigix' $(git rev-list --all --abbrev-commit)
</xtermrtf>

==== bisect ====
Trouver par recherche dichotomique la modification qui a introduit un bug :
  * [[https://www.youtube.com/watch?v=842RnLfqb3g|Tuto git bisect]]