Git - Mémo en ligne de commande

 

Version de Git

git --version

 

1. Configuration de Git

Affectation du nom associé à toutes les opérations de commit

git config --global user.name "<votre nom>"

 Affectation de l'e-mail associé à toutes les opérations de commit

git config --global user.email "<votre@mail>"

Activation de la colorisation sur la sortie standard

git config --global color.ui true # default auto

Modification des lignes CRLF en LF lors de l'extraction du code

git config --global core.autocrlf true

Réalisation d'un rebase lors d'un pull

git config --global pull.rebase true

 

2. Création des dépôts

git init <nom-projet>
git init --bare <nom-projet> # Crée un dépôt nu

Récupération du projet versionné

git clone <url>

 

3. Gestion des modifications

Afficher l'état du dépôt et les fichiers modifiés/ajoutés/supprimés

git status

Résumé des modifications sur un fichier (différences)

git diff # Parcours tous les fichiers locaux et affiche les modifications
git diff <fichier> # Affiche uniquement le diff du fichier
git diff > diff-saved.txt # Sauvegarde les diff pour être lue par un IDE
git diff --staged # pareil que --cached : Affiche les modifications indexées pour la validation.

git diff --color-words # Comparaison ligne par ligne avec le mode color
git diff --word-diff # [=<mode>] Affiche un diff par mot. Par défaut le mode est "plain". Possible : color, plain, porcelain, none
git diff --word-diff-regex=. # Permet de définir ce qu'est un mot. Ici chaque caractère est considéré comme étant un mot
git diff --color-words --word-diff-regex=. # Combinaison d'une comparaison par caractère et de l'affichage par couleur.

Supprimer les modifications d'un fichier

git checkout <fichier>

# Nouvelle commande
git restore <fichier>

Ajouter un fichier pour validation

git add <fichier1> <fichier2>
git add *.sh # Ajoute tous les fichier *.sh du répertoire courant uniquement
git add \*.sh # Ajoute tous les fichier *.sh du répertoire courant et ses sous-répertoires
git add . # Ajoute tous les fichiers du répertoire courant et ses sous-répertoires

Enlever un fichier ajouté pour validation

git restore --staged <fichier>

Supprimer un fichier/dossier

git rm <fichier>

git rm --cached <fichier> # Désindexe le fichier, mais le conserve dans l'arbre de travail.

Déplacer un fichier/dossier et/ou modifier son nom

git mv <fichier> <nouveau-nom> # Peut être un dossier et/ou un nouvel emplacement.

Valider les modifications

git commit -m "message du commit"

 

4. Regrouper des modifications (branche)

Git propose l'utilisation de branches afin de regrouper les modifications afin de ne pas travailler au même endroit.

Lister les branches existantes

git branch # Affiche toutes les branches
git branch -a # Affiche toutes les branches suivies et locales

Créer une branche

git branch <nom-branche>

Créer une branche à partir d'une autre

git branch <nom-branche> <depuis-branche>

Envoyer la branche dans le remote GIT repo (dépôt GIT en réseau)

git push --set-upstream origin <nom-branche>

Renommer/déplacer une branche

git branch -m <old-branche> <nouveau-nom-ou-emplacement> # Rename branch locally
git push origin :<old-branche> # Delete the old branch    
git push --set-upstream origin <nouveau-nom-ou-emplacement> # Push the new branch, set local branch to track the new remote

Changer de branche

git checkout <nom-branche>

# Nouvelle commande
git switch <nom-branche>

# Revenir à la branche précédente
git switch -

Fusionner deux branches

git checkout <nom-branche-destination> # Se positionner sur la branche de destination
git merge <nom-branche-sources> # Merger : Combine les commits de <nom-branche-sources> avec celles de <nom-branche-destination> dans la branche <nom-branche-destination>

Supprimer une branche

git branch -d <nom-branche> # En local
git push -d origin <nom-branche> # Sur le dépôt distant

 Appliquer un commit issue d'une autre branche

git cherry-pick <commit>

 

5. Modifier des commits

 Modifier le commentaire du dernier commit

git commit --amend -m "Nouveau commentaire"

Supprimer des commits

git log # permet de récupérer le numéro du commit (hash)

# Se positionne sur le commit, marque les changements pour validation et les mets dans l'espace de travail.
git reset --soft <commit>

# Se positionne sur l'avant dernier commit, marque les changements pour validation et les mets dans l'espace de travail.
git reset --soft HEAD^

# Supprime de l'arbre les commits après <commit>, mais garde les modifications sans les ajouter pour validation.
git reset <commit>

# Supprime les modifications non validées
git reset --hard

# Supprime les commits après <commit> et les modifications non validées.
git reset --hard <commit>

Annuler des modification

# Ajoute un commit inversant les changement du <commit>
git revert <commit>

git revert <commit> --no-commit # Ne commit pas les changements (ajoute à l'index de stagging et au répertoire de travail) : utile si plusieurs revert

Modifier les commentaires, les fichiers ou fusionner des commits

git rebase -i <commit> # Ouvre une interface permettant de réaliser des modifications sur les commits

 

6. Les tags

Git propose l'utilisation des tags afin de d'appliquer un "tampon" à une version ou à état du code source de l'application.

Création d'un tag "léger"

git tag <nom-tag> # Exemple de nom du tag : v1.4

Création d'un tag "annoté" (ajout d'informations contextuelles comme le nom du créateur du tag, son e-mail et la date ou encore une description)

git tag -a <nom-tag> # Exemple de nom du tag : v1.4
git tag -a <nom-tag> -m "<description-tag>"
git tag -a <nom-tag> <référence-commit>
git tag -a -f <nom-tag> <référence-commit> # Force (remplace) le tag existant portant le même nom

Lister les tags

git tag
git tag -l *-rc*

Soumettre un tag au dépôt distant

git push origin <nom-tag>

Suppression d'un tag

git tag -d <nom-tag> # En local
git push --delete origin <nom-tag> # Sur le dépôt distant

Récupération d'un tag

git checkout v1.4

 

7. Analyser l'historique des versions

Récupération des commits (historique) de la branche courante

git log # Affiche l'historique des versions de la branche courante

# Historique sur une seule ligne
git log --graph --pretty=format:'%C(yellow)%h%C(auto)%d%Creset %s %C(white)- %an, %ar%Creset'

git log --stat # Affiche l'historique et les fichiers impactés dans chaque commit

git log <commit> # Historique à partir du <commit>

git log --folow <fichier> # Historique des modification du fichier.

Afficher le message de log et les diff d'un commit :

git show <commit>

Vérifier les différences entre deux branches

git diff <branch-A> <branche-B>

git diff <branch-A> <branche-B> > diff.txt # Différences mises dans un fichier

 

8. Synchroniser un dépôt

 Récupérer les mises à jour (historique) du dépôt localement sans les intégrer

git fetch <depot>

Récupérer et intégrer les mises à jour (historique) du dépôt localement

git pull <depot>

Fusionner deux ou plusieurs branches ensemble

git merge <brancheA> <brancheB>

Envoyer les commits de la branche locale vers le dépôt git distant

git push

 

9. Répertoire de travail "impropre"

Git permet de stocker ses travaux de manière temporaire afin de pouvoir y revenir plus tard. Cela permet notamment de réaliser des pull alors que nous n'avons pas terminé une modification.

Sauvegarde des travaux temporairement :

git stash # Sauvegarde les fichiers modifiés en suivi de version

git stash push -m "Message d'information" # Sauvegarde avec un message

Lister les travaux temporaires

git stash list # Liste les travaux temporaires

git stash list --stat # Liste les travaux temporaires avec la liste des fichiers impactées

Appliquer le premier travail et le supprimer

git stash pop

Appliquer le travaux 3 sans le supprimer

git stash list # permet d'avoir les identifiants des travaux temporaires
git stash apply # Applique le premier travaux temporaire sans le supprimer.
git stash apply stash@{3} # Applique le travaux temporaire 3.

Supprimer un travail temporaire

git stash list # permet d'avoir les identifiants des travaux temporaires
git stash drop stash@{3} # Supprime le travaux temporaire 3.
git stash drop # Supprime tous les travaux.

 

10. Gestion des patch

Un patch peut service de sauvegarde, être envoyé par mail ou sur un site pour être appliqué. C'est une façon confortable d'appliquer une modification de code sur de l'existant et de voir les modifications réalisées.

Créer un patch sans commit

git add fichierA fichierB # Ajouter les fichier que vous souhaitez ajouter dans le patch.
git diff --staged --binary > fichier.patch # Binary s'il y a des binaires

Appliquer un patch sans commit

git apply --check fichier.patch # Vérifier s'il y a des erreurs dans le patch et s'il peut être appliqué
git apply fichier.patch # Appliquer le patch

Créer un patch à partir d'un ou plusieurs commits

git format-patch -1 HEAD # -1 ou -X , X étant le nombre de commit à partir de HEAD voulant être patché

Appliquer un patch avec commit

git am < fichier.patch

 

11. Les fichiers dans git

Lors d'un clone git, on retrouve en plus des sources de notre application un dossier .git. Ce dossier contient l'historique local (Cf. reflog). Il permet d'assurer le bon fonctionnement de git en local.

La configuration de git est stocké dans le fichier .gitconfig qui se trouve en général dans le répertoire utilisateur de la machine. On y retrouve le nom, l'adresse mail de la personne qui commit, des configurations ainsi que des alias (raccourcis).

Pour éviter que certains fichiers ne soient commités et polluent le dépôt git, il est nécessaire de créer un fichier .gitignore. Ci-dessous, un exemple de son contenu :

*.log
*.bak
*.class

Avec cela, git ignorera tous les fichiers dont le nom se terminera par .log, .bak et .class.

Les dossiers vides ne sont pas commités par git. Il est alors nécessaire de mettre un fichier vide ".gitkeep" par exemple et de le commiter. Une fois le dossier rempli par d'autres objets, le fichier ".gitkeep" peut alors être supprimé.

 

 12. Récupérer des commits effacés (seulement si le dépôt local est toujours existant)

# Sur le dépot local (car l'historique des actions est conservé)
git reflog # Récupérer le hash du commit voulu ou l'état du git voulu
git co <commit>

# Si vous voullez recréer une nouvelle branche à partir de l'emplacement ou vous vous situez
git switch -c <nom-branche>

 

 13. Rapatrier le contenu du master sur sa branche (master -> branche)

# Vous perdrez la version et l'historique de la branche du dépôt distant pour celle que vous avez en local. Pensez à faire des sauvegardes, une mauvaise manœuvre peut casser le dépôt distant.


git checkout <nom-branche> # Se positionner dans la branche à merger
git pull --all # Récupérer les dernières sources
git rebase origin/master # Récupération des commits du master, puis les commits de la branche sont appliqués
git rebase -i origin/master # En mode interactif (si changement à réaliser)
# Si conflit, modifier les fichiers et les vérifier. Ensuite, les ajouter pour validation (git add). Puis git rebase --continue.
git push --force-with-lease # Envoie la nouvelle arborescence comprenant le master.

 

14. Merger sur le master le contenu de sa branche (branche -> master)

# Vous perdrez la version et l'historique de la branche du dépôt distant pour celle que vous avez en local. Pensez à faire des sauvegardes, une mauvaise manœuvre peut casser le dépôt distant.


git checkout origin/master # Se positionner sur le master
git pull --all # Récupérer les dernières sources
git merge <nom-branche> # merge de la branche dans le master
# Si conflit, modifier les fichiers et les vérifier. Ensuite, les ajouter pour validation (git add). Puis git merge --continue.

# Autres merges
git merge <nom du tag> # merge du tag dans la branche
# Merge avec message pour le commit. --no-ff : Crée un commit dans tous les cas.
git merge --no-ff <nom-branche> -m "message du commit"

# Crée le merge mais ne fait pas le commit. Les changements sont dans l'arbre de travail et à l'état d'index.
git merge --squash <nom-branche>

 

15. Exemple de fichier de configuration .gitconfig

[user]
    name = <votre nom>
    email = <votre@mail>
[web]
    browser = google-chrome
[color]
    ui = auto
[color "branch"]
    current = yellow bold
    local = green bold
    remote = cyan bold
[color "diff"]
    meta = yellow bold
    frag = magenta bold
    old = red bold
    new = green bold
    whitespace = red reverse
[color "status"]
    added = green bold
    changed = yellow bold
    untracked = red bold
[delta]
    features = line-numbers decorations
    line-numbers = true
[delta "decorations"]
    minus-style = red bold normal
    plus-style = green bold normal
    minus-emph-style = white bold red
    minus-non-emph-style = red bold normal
    plus-emph-style = white bold green
    plus-non-emph-style = green bold normal
    file-style = yellow bold none
    file-decoration-style = yellow box
    hunk-header-style = magenta bold
    hunk-header-decoration-style = magenta box
    minus-empty-line-marker-style = normal normal
    plus-empty-line-marker-style = normal normal
    line-numbers-right-format = "{np:^4}│ "
[alias]
    ci = commit
    co = checkout
    log = log
    l = log --oneline
    lg = log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit
    st = status -s -b
    pl = !git stash save && git pull && git stash pop
    plco = !git pull && git co $1 && git pull
    rebdev = !git stash save && git pull && git co develop && git pull && git co - && git rebase origin/develop && git stash pop
    rebidev = !git stash save && git pull && git co develop && git pull && git co - && git rebase origin/develop -i && git stash pop
[pull]
    rebase = true
[diff]
    tool = winmerge
[rebase]
    autoStash = true
[difftool "winmerge"]
    cmd = "'C:/Program Files (x86)/WinMerge/WinMergeU.exe'" -e "$LOCAL" "$REMOTE"
[core]
  editor = 'C:/Program Files (x86)/Notepad++/notepad++.exe' -multiInst -notabbar -nosession -noPlugin

Pour les 4 dernières lignes il est nécessaire d'avoir au préalable installé Notepad++ et WinMerge.

Il est important de modifier dans ce fichier les variable suivantes : <Prenom>, <Nom> et <Adresse mail>.

Vous disposerez des raccourcis suivant :

• git pull => stash les modifications en cours, récupère les dernières versions du dépôt, puis rapplique le stash précédemment sauvegardé
• git co => Réalise un git checkout
• git l => Affiche les logs avec une ligne par commit
• git lg => Affiche les logs avec une ligne par commit, avec l'affichage de l'arbre des commits
• git st => git status
• git rebdev => rebase la branche en cours à partir de la branche develop
• git rebidev => rebase la branche en cours à partir de la branche develop avec le mode interface

Ce fichier, permet, lors d'un git pull, de réaliser un "rebase" à la place d'un "merge". Avec ce "rebase", il est possible de mettre à jour sa branche sans avoir à créer un commit de "merge".

 

16. Exemple de fichier de configuration .gitignore

Le fichier .gitignore permet de ne pas présenter à l'utilisateur certains fichiers pour le pas les commiter et polluer le dépôt Git.

# Compiled class file
*.class

# Log file
*.log

# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar

# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
replay_pid*

# Eclipse m2e generated files
# Eclipse Core
.project
# JDT-specific (Eclipse Java Development Tools)
.classpath

# Eclipse autre
/.metadata/
**/.settings

# Tomcat
/Servers/
/.idea/

# Maven
**/target/

# DBeaver
**/.dbeaver/
**/Scripts/

 

17. Conclusion

Git permet de travailler facilement à plusieurs sur un même projet. Cependant attention à réaliser souvent des rebase de votre branche locale afin de résoudre au plutôt les conflits. En effet, une vieille branche est difficile à remettre à jour.