Outils pour utilisateurs

Outils du site


informatique:git

Git

# Ajouter un dépôt distant
git remote add <nom> <url>

Configuration

Il est possible de modifier les préférences en utilisant soit git directement soit en modifiant son fichier de configuration.

En ligne de commande

git config --global user.name "Nom et prénom de l'utilisateur" # Nom de l'utilisateur
git config --global user.email "Adresse email de l'utilisateur" # Adresse email de l'utilisateur
git config --global color.ui "auto" # Colorisation des résultats
git config --global core.editor vim # Choix de l'éditeur par défaut
git config --global help.autocorrect 1 # Auto-correction des commandes
git config --global core.autocrlf false # Non conversion du caractère de fin de ligne
git config --global commit.template <filename> # Utilisation d'un modèle de message pour la validation
git config --global alias.st 'status' # Création d'un alias de la fonction "status"

Pour supprimer un élément de la configuration, il suffit d'ajouter l'option --unset lors de l'utilisation de la commande. Par exemple :

git config --global --unset user.name

En utilisant --global, la configuration s'applique à l'utilisateur courant. Il est possible de changer ce comportement en utilisant d'autres options :

  • Avec --system, la configuration s'applique à tous les utilisateurs de la machine.
  • Avec --local, la configuration s'applique au dépôt courant. Dans ce cas, il faut bien sur se trouver dans un répertoire géré par git.

Avec un fichier de configuration

Le fichier a modifier est le fichier .gitconfig à la racine du répertoire de l'utilisateur. Il est généré automatiquement lors de l'utilisation des commandes de configuration.

[user]
        email = Adresse email de l'utilisateur
        name = Nom et prénom de l'utilisateur
[core]
        editor = vim 
        autocrlf = false
[color]
        ui = auto
[help]
        autocorrect = 1
[alias]
        st = status
[commit]
        template = <filename>

Pour supprimer un élément de la configuration, il suffit de l'enlever du fichier de configuration.

En modifiant le fichier .gitconfig, la configuration s'applique à l'utilisateur courant. Il est possible de changer ce comportement en modifiant d'autres fichiers :

  • En modifiant le fichier /etc/gitconfig, la configuration s'applique à tous les utilisateurs de la machine.
  • En modifiant le fichier .git/config, la configuration s'applique au dépôt courant. Dans ce cas, il faut bien sur se trouver dans un répertoire géré par git.

Lorsque l'autocorrection des commandes est activée, git essaye de trouver une correspondance dans les commandes existantes. S'il existe plusieurs possibilités, elles seront affichées à l'utilisateur. S'il n'existe qu'une seule possibilité, elle sera exécutée automatiquement.

Lorsqu'un fichier modèle de message est utilisé pour la validation, celui-ci est affiché à chaque validation. Les lignes de commentaires 1) ne seront pas utilisées lors de la validation. Cela permet de :

  • donner des indications sur ce que doit contenir le message de validation,
  • faciliter la rédaction du message de validation en y intégrant les données obligatoires automatiquement.

Des alias pour gagner du temps

En plus de raccourcir certaines commandes, les alias permettent aussi de combiner des actions répétitives en une seule commande. Voici les alias que j'utilise actuellement.

.gitconfig
[alias]
        ; List aliases
        alias = !git config --get-regexp '^alias\\.' | sed --expression s/^alias\\.// --expression s/\\ /\\\\t\\ / | sort
        ; Amend content to the last commit
	amend = commit --amend --no-edit
        ; Check for whitespace errors
        check = diff --check HEAD
        ; Fixup a commit into another
        fixup = !sh -c 'git stash --keep-index && SHA=$(git rev-parse $1) && git commit --fixup $SHA && GIT_SEQUENCE_EDITOR=: git rebase --interactive --autosquash $SHA~ && git stash pop' -
        ; Show file names
        list-file = !sh -c 'git diff-tree --no-commit-id --name-only -r ${1:-HEAD}' -
	; Show branch ordered by last working time
	last-work = branch --sort='-committerdate' --format='%(color:green)%(committerdate:relative)%(color:reset) %(refname:short)' --color=always
        ; Retrieve a MR locally (gitlab)
        mr = !sh -c 'git fetch ${2:-origin} merge-requests/$1/head:mr/$1 && git checkout mr/$1' -
        ; Show log on oneline
        oneline = log --oneline --abbrev-commit --graph
        ; Retrieve a PR locally (github)
        pr = !sh -c 'git fetch ${2:-origin} pull/$1/head:pr/$1 && git checkout pr/$1' -
        ; Prune local tags that don't exist on remote
        pt = !git tag -l | xargs git tag -d && git fetch -t
        ; Remove local MRs (gitlab)
        rmmr = !git checkout master && git branch --list 'mr/*' --format '%(refname:lstrip=2)' | xargs git branch -D

La commande :, utilisée comme éditeur dans la variable GIT_SEQUENCE_EDITOR, fait partie des commandes incluses dans Bash. Voir ici pour plus d'informations.

Prompt personnalisé

Vérifier ce que j'ai fait à la maison

export GIT_PS1_SHOWDIRTYSTATE=1
export GIT_PS1_SHOWSTASHSTATE=1
export GIT_PS1_SHOWUNTRACKEDFILES=1
export GIT_PS1_SHOWUPSTREAM=verbose
export GIT_PS1_DESCRIBE_STYLE=branch
export GIT_PS1_SHOWCOLORHINTS=1
export PROMPT_COMMAND='__git_ps1 "\[\033[1;32m\]\u@\h:\[\033[1;34m\]\w\[\033[1;m\]" " \\\$ "'

Utilisation

Aide

Il existe de nombreux outils fournis avec git. L'ensemble de ceux décrit ici ne représentent qu'une petite partie des possibilités de Git. Pour apprendre à connaître Git, la curiosité est de mise et quelques commandes existent pour l'aider :

# Afficher la liste et l'usage des commandes les plus communes
git help
 
# Afficher la liste et l'usage de l'ensemble des commandes
git help --all
 
# Afficher la liste des guides
git help --guides
 
# Afficher l'aide d'une commande ou un guide
git help <command>

Journal d'évènement

L'ensemble de ces commandes sont utilisables pour un fichier particulier en ajoutant -- <file_path> à la fin de la commande.

# Afficher le journal d'évènement
git log
 
# Afficher le journal d'évènement avec les statistiques
git log --stat
 
# Afficher le journal d'évènement des n dernières révisions
git log -n
 
# Afficher le journal d'évènement sur une ligne
git log --oneline
 
# Afficher le journal d'évènement entre 2 révisions
git log <commit>..<commit>
 
# Afficher l'historique condensé des révisions
git log --pretty=oneline --abbrev-commit --graph --decorate
 
# Afficher la liste des étiquettes par date
git log --date-order --graph --tags --simplify-by-decoration --pretty=format:'%ai %h %d'

Révisions

  • Révisionner du code
# Ajouter les fichiers à révisionner
git add <file1> <file2>
 
# Révisionner les modifications en saisissant un message dans l'éditeur de texte par défaut
git commit
# Révisionner les modifications en saisissant un titre uniquement sans ouvrir l'éditeur de texte par défaut
git commit -m <title>
# Révisionner les modifications en saisissant un titre et un message sans ouvrir l'éditeur de texte par défaut
git commit -m <title> -m <message>
 
# Il est aussi possible de faire tout ça automatiquement (ce n'est pas recommandé)
git commit -a -m <title> -m <message>
  • Annuler l'ajout d'un fichier dans l'index
git reset HEAD <file>
  • Modifier le nom de l'utilisateur de la dernière révision
# Attention, l'utilisation de cette commande est déconseillée si le code a été partagé.
git commit --amend --reset-author
  • Modifier la dernière révision 2)
# Attention, l'utilisation de cette commande est déconseillée si le code a été partagé.
git commit --amend
  • Modifier une ancienne révision 3)
# Pour modifier la révision bbc643cd
git rebase --interactive bbc643cd^
# À ce moment, l'éditeur de texte par défaut va s'ouvrir pour sélectionner les révisions à modifier.
# Changer pick pour edit en face des révisions à modifier.
 
# Faire les changements nécessaire et ajouter les fichiers.
git add <file1> <file2>
 
# Appliquer les changements
git commit --amend
 
# Poursuivre l'application des changements
git rebase --continue
  • Supprimer la dernière révision
# Si la révision n'a pas été partagée et que l'on veut conserver les modifications
git reset --soft HEAD~1
 
# Si la révision n'a pas été partagée et que l'on veut supprimer les modifications
git reset --hard HEAD~1
 
# Si la révision a été partagée
git revert HEAD

Branches

  • Afficher les branches
# Locales
git branch
# Distantes
git branch -r
# Toutes
git branch -a
# Déjà disponibles dans la branche courante
git branch --merged
# Pas encore disponibles dans la branche courante
git branch --no-merged
  • Créer une branche locale
# La manière rapide
git checkout -b <branch>
 
# La manière détaillée
git branch <branch>
git checkout <branch>
  • Récupérer une branche distante
# Récupérer la liste des branches distantes disponibles
git fetch origin
# Récupérer la liste des branches distantes disponibles en supprimant les branches supprimées - version longue
git fetch --prune origin
# Récupérer la liste des branches distantes disponibles en supprimant les branches supprimées - version courte
git fetch -p origin
 
# Création d'une branche locale à partir de la branche distante
git checkout -b <branch> origin/<branch>
  • Changer le nom d'une branche locale
git branch -m <old-branch> <new-branch>
  • Supprimer une branche locale
# Supprimer une branche qui a été fusionnée
git branch -d <branch>
# Forcer la suppression d'une branche
git branch -D <branch>
  • Supprimer une branche distante
# La manière compréhensible
git push --delete origin <branch>
# La manière moins compréhensible au premier abord
git push origin :refs/remote/origin/<branch>
# et son raccourci
git push origin :<branch>
  • Lier une branche existante à une branche distante
# Syntaxe courte
git branch -u <remote_branch> <local_branch>
 
# Syntaxe longue
git branch --set-upstream-to <remote_branch> <local_branch>
  • Supprimer les branches locales obsolètes
git remote prune origin
  • Comparer un fichier entre 2 branches
git diff <branch_1> <branch_2> -- <fichier>
 
# Avec cette syntaxe, la référence peut être une branche, un tag, un commit, ...
git diff <reference_1>..<reference_2> <fichier>
  • Pousser une branche
# Quand les références des branches sont identiques
git push <remote> <branch>
 
# Quand les références des branches sont différentes
git push <remote> <src/branch>:<dst/branch>
  • Afficher le point d'origine d'une branche
git merge-base HEAD <branch>
  • Revenir à la branche précédente
git checkout -

Étiquettes

  • Lister les étiquettes
git tag
  • Créer une étiquette à usage privé ou temporaire (étiquette légère)
git tag <tagname>
  • Créer une étiquette à usage public (étiquette annotée)
git tag -a <tagname>
  • Créer une étiquette distante

Il faut que l'étiquette existe déjà localement pour pouvoir la créer sur un dépôt distant.

# Pour créer une seul étiquette
git push origin <tagname>
# Pour créer toutes les étiquettes
git push --tags
  • Supprimer étiquette distante 4)
# La manière compréhensible
git push --delete origin <tagname>
# La manière moins compréhensible au premier abord
git push origin :refs/tags/<tagname>
# et son raccourci
git push origin :<tagname>
  • Remplacer étiquette légère par étiquette annotée 5)
# Récupérer le code associé à l'étiquette
git checkout <tagname>
 
# Supprimer l'étiquette locale
git tag -d <tagname>
 
# Créer l'étiquette annotée antidatée à la date de la révision
GIT_COMMITTER_DATE="$(git show --format=%aD | head -1)" git tag -a <tagname>
 
# Supprimer l'étiquette distante
git push origin :refs/tags/<tagname>
 
# Créer l'étiquette distante
git push --tags

Notes

  • Ajouter une note sur un révision
# Sans espace de nom
git notes add -m <message> <commit>
 
# Avec espace de nom
git notes --ref=<namespace> add -m <message> <commit>
  • Voir une note
# Sans espace de nom
git log
 
# Avec espace de nom (les caractères de remplacement sont supportés)
git log --show-notes=<namespace>
  • Éditer une note
# Sans espace de nom
git notes edit <commit>
 
# Avec espace de nom
git notes --ref=<namespace> edit <commit>

Divers

  • Créer et appliquer un patch 6)
# Création d'un fichier patch
git format-patch <commit.1>..<commit.2> --stdout > <file.patch>
 
# Création d'un fichier patch en changeant le chemin d'accès aux fichiers
git format-patch <commit.1>..<commit.2> --src-prefix="a/new/path/" --dst-prefix="b/new/path/" --stdout > <file.patch>
 
# Vérification du patch
git apply --check <file.patch>
 
# Application des modifications apportées par le patch
git apply <file.patch>
 
# Application des commits apportés par le patch
git am <file.patch>
  • Modifier l'historique
git rebase -i <commit>
  • Ajouter des fichiers à l'index
git add -i
  • Récupérer un fichier d'un révision particulière
git checkout <treeish> -- <path>
  • Afficher un fichier d'un révision particulière
git show <treeish>:<file>
  • Voir les modifications effectuées
# Modifications des fichiers du répertoire de travail
git diff
# Modification des fichiers de la zone de transit
git diff --staged
git diff --cached
# Vérification des erreurs de caractères blancs
git diff --check
 
# Modification entre deux branches
git diff <branch>..<branch>
# Modification entre deux branches (nom et statut)
git diff --name-status <branch>..<branch>
# Modification entre deux branches (nom seulement)
git diff --name-only <branch>..<branch>

Il est possible de filtrer les résultats sur le type de changement en utilisant --diff-filter. Cette option prend une ou plusieurs valeurs dans la liste suivante :

  • A pour les fichiers ajoutés.
  • D pour les fichiers supprimés.
  • M pour les fichiers modifiés.
  • R pour les fichiers déplacés.
# Mettre de côté toutes les modifications
git stash
# Mettre de côté toutes les modifications à l'exception de celles présentent dans l'index
git stash --keep-index
# Lister les réserves de code
git stash list
# Appliquer la dernière réserve de code
git stash apply
# Supprimer la dernière réserve de code
git stash drop
# Afficher les modifications contenues dans le "stash"
git stash show -p stash@{0}
  • Afficher la liste des fichiers d'une révision
git diff-tree --no-commit-id --name-only -r <treeish>
  • Dupliquer un projet
# Duplique un projet dans un répertoire éponyme créé automatiquement
git clone <project>
 
# Duplique un projet dans un répertoire sélectionné
git clone <project> <folder>
  • Créer une archive d'un projet
git archive --format=tar.gz <treeish> > <file>
  • Dupliquer un dépôt 7)
# Faire un clone brut du projet
git clone --bare <old-repository>
 
# Faire un miroir du projet
cd old-repository
git push --mirror <new-repository>
 
# Suppression du clone brut
cd -
rm -rf old-repository
  • Afficher la liste des branches actives
# Sans filtre
git ls-remote --heads origin
 
# Avec un filtre simple
git ls-remote --heads origin master
 
# Avec un filtre complexe
git ls-remote --heads origin master develop release\*
  • Afficher la liste des fichiers gérés
git ls-tree -r master --name-only

Liens utiles

Humour

  1. En cas d'incendie et le script qui va avec.
  2. sur xkcd.com encore
informatique/git.txt · Dernière modification: 2021/11/22 06:31 de alexis