Jump to content

Git pour les nuls

From mediawiki.org
This page is a translated version of the page Git for dummies and the translation is 100% complete.

Ceci est un aide-mémoire très clair et simple qui décrit tout ce dont vous avez besoin pour utiliser le gestionnaire de contenu Git et Gerrit . Il doit vous donner au moins le savoir minimal nécéssaire pour faire vos push sur tous les dépôts majeurs que nous utilisons, y compris ceux de GitHub et des autres sites.

Si vous êtes un expert de Git, votre aide est bienvenue pour améliorer ce manuel, d'autant qu'il reste extrêmement simple.

Installer Git

Windows

Télécharger l'installeur ici : https://git-scm.com/download/win installe une version de terminal similaire à celle de Linux

Git va installer un M-SYS complet avec une version terminal appelée git bash et une version IHM. Il est fortement recommandé d'utiliser git bash pour tout, et ce guide ne couvre aucun IHM client de Git.

MacOS

Il doit y avoir un paquet sur https://git-scm.com/download/mac, ou vous pourriez le compiler vous-même !

Linux

Pour une raison insondable, le package git sur Debian et Ubuntu est appelé git-core et git ne se relie pas à lui. Obtenir git-core permettra de l'installer.

Pour les autres distributions, voir https://git-scm.com .

Configuration

Pour installer il vous faut :

  • un compte sur gerrit Wikimedia ou tout autre hébergeur de dépôt git
  • une adresse courriel
  • votre clé publique et clé privée

Terminologie

VCS

Abbréviation du terme générique Version control system. Git est l'un des nombreux VCS.

Git

Gestionnaire de contenu créé par Linus Torvalds. Git, contrairement à beaucoup d'autres VCS est distribué, cela signifie que chacun possède une copie de l'ensemble du dépôt, au lieu d'accéder à un serveur central.

Branche

Cela vous permet de diverger de la ligne principale de développement et de continuer à travailler sans vous préoccuper de cette ligne principale. Habituellement, vous voulez faire toutes vos modifications dans votre propre branche au lieu de les écrire dans la branche master.

Révision

Lorsque vous validez vos modifications par un commit, une nouvelle révision (comprendre version) est créée. L'historique dans Git est formée de versions. Chaque version possède un message de commit et un identifiant unique.

Remote

Dépôt hébergé sur un système distant, généralement accessible par ssh ou https.

Dépôt

Base de tout contenu qui est géré par Git.

Origin

Dans Git, l'alias par défaut pour le dépôt distant que vous avez cloné est appelé origin. Si vous clonez le dépôt foo à partir du serveur http://bar/foo.git sera votre origine.

Master

Branche par défaut de Git qui est généralement créée à la création du dépôt, mais elle n'a pas besoin de l'être. C'est un nom très commun pour une branche par défaut d'un dépôt mais pas nécessairement. (Tout comme le superutilisateur dans Linux, n'a pas besoin d'être appelé root, mais c'est presque toujours le cas).

Gerrit

Système de relecture construit au-dessus de Git. Il permet aux développeurs expérimentés de relire les modifications apportés par d'autres personnes et de les fusionner dans la branche master.

Guide

Télécharger le dépôt : clone

Extraction initiale - appelée clone. Récupère un dépôt distant sur un serveur distant et le sauvegarde dans un dossier local.

git clone <repository goes here>

Exemple

# Télécharger une copie en lecture seule (push non autorisé) de huggle en utilisant http
git clone https://github.com/huggle/huggle3-qt-lx
# Télécharger une copie de huggle en lecture seule à l'aide de http dans le dossier foobar
git clone https://github.com/huggle/huggle3-qt-lx foobar

Mettre à jour le dépôt téléchargé : pull

  • mettre à jour votre copie du dépôt avec la version présente sur le serveur distant
git pull
  • mise à jour qui fusionnent automatiquement les éléments - appelé rebase; met à jour le dépôt et le fusionne avec vos commit
git pull --rebase
Corriger les conflits

Il arrive souvent de rencontrer un conflit de modification. C'est ennuyeux, mais Git a un assez bon mécanisme pour les gérer. Il existe une commande magique

git mergetool

Vous pouvez également installer un troisième éditeur tel que kdiff3 qui ouvrira une belle IHM pouvant vous aider à fusionner; mergetool vous demandera ensuite quel éditeur vous souhaitez utiliser.

Si vous utilisez Gerrit : Cette commande ne fonctionne pas pour télécharger de nouvelles versions d'un ensemble de corrections Gerrit. Pour ce cas d'utilisation, il est probablement plus facile d'exécuter simplement git review -d <number> où <number> est le numéro de la modification Gerrit pour télécharger les corrections d'une nouvelle branche, et travailler dessus à la place. Notez que si vous avez déjà utilisé git review -d pour télécharger un ensemble de corrections et y avoir apporté des modifications, mais que vous n'avez pas encore téléversé les modifications dans Gerrit, l'exécution de la commande à nouveau détruirait toutes les modifications locales, donc vous devez d'abord utiliser git checkout -b branch_name pour copier les modifications locales sur une nouvelle branche si vous voulez les conserver.

Vérifier ce qui a été modifié : diff

Pour voir ce qui a été modifié avant votre commit, faire :

git diff

Pour voir ce que vous avez modifié après votre commit, faire :

# comparer le HEAD actuel au commit précédent, ce qui signifie que l'on compare simplement ce qui fait partie du commit avec ce qu'il y avait précédemment
git diff HEAD^1
# comparer avec tous les ID donnés
git diff <commit-id>

Créez votre propre branche

Vous pouvez voir toutes les branches qui ont été extraites pour votre copie locale en utilisant

git branch

Si vous souhaitez créer une nouvelle branche en réalisant un fork à partir de la branche sur laquelle vous vos trouvez, utiliser

git checkout -b <branch_name>

Si vous souhaitez pousser votre branche dans l'origine

git push origin <branch_name>

Enregistrer les modifications : commit

Contrairement à svn, le commit est effectué localement et doit ensuite être envoyé au serveur (en utilisant git push) ou pour une relecture de code (en utilisant git review).

Vous devez indiquer les fichiers du commit Même si vous changez le fichier, il ne sera pas validé, sauf si vous demandez Git de le faire. Vous pouvez utiliser la commande git add qui fera le commit des modifications

# ajouter un fichier pour le 'commit'
git add file2
# si vous avez décidé de ne pas faire de ''commit'' sur file2, vous pouvez annuler le ''git add'' en faisant ''git reset file2''
# Ou sur toutes les modifications en attente avec juste : ''git reset'' (mais cela ne modifiera pas les fichiers sur le disque)
git add file.cpp
# faire le commit des fichiers marqués uniquement par git add
git commit
# ou validez aussi tous les fichiers suivis par git et qui ont été modifiés
git commit -a
Si vous voulez annuler le commit, la chose la plus facile à faire est de supprimer le message de commit de l'éditeur, sauvegarder et quitter. Git n'autorisera pas un commit dont le message est vide

Si vous voulez modifier le commit que vous venez de faire, faites

git commit --amend
# par exemple si vous avez oublié d'ajouter important_thing.c
git add important_thing.c
git commit --amend

Ceci va modifier le contenu du commit existant; si vous avez déjà fait un push dessus, alors vous ne pouvez pas faire de nouveaux push sur le distant parce que vous allez modifier une modification déjà faite. Faites ceci uniquement si le push n'a pas encore été exécuté.

Une fois le commit fait sur vos modifications, vous pouvez réaliser le push.

Fusionner les commit multiples : squash

Gerrit n'aime pas trop de commit dans un push, il faut donc parfois faire un commit de plusieurs éléments (cette action est dénommée squashing).

# sauvegarder le dépôt complètement
cp -r . /tmp/backup
# demander à git de fusionner les deux derniers 'commit' (HEAD avec l'avant dernier 'commit')
git rebase -i HEAD~1
# laissez le choix près du message que vous voulez garder, modifiez tous les messages que vous voulez fusionner avec 'squash'
# quelques fois il est nécessaire de faire cela
git rebase
# maintenant vous pouvez essayer à nouveau le push
git-review -R
# ou
git push

Afficher l'état d'une branche : git status

git status

Afficher le journal des commit d'une branche : log

git log

Pressez q pour quitter cette vue.

Téléverser ses commit, branches ou balises sur le serveur : push

Si tout se passe bien

En entrant git push, tout doit normalement fonctionner. Malheureusement cela fonctionne rarement.

En cas de problème

  • Vous êtes rejeté parce que vous n'avez pas les droits :
    • Il est possible qu'il manque le nom d'utilisateur dans l'URL; chaque fois que vous utilisez ssh, vous devez spécifier votre nom d'utilisateur (petrb@server.com)
    • Vous avez extrait en utilisant http
      • Vous pouvez modifier l'URL dans .git/config
    • Vous n'avez en réalité aucun droit
      • Vous devez contacter le propriétaire du dépôt
  • Vous avez oublié certaines accroches
    • Gerrit a besoin de l'accroche commit-msg (il est possible que cela ne soit plus nécessaire)
scp -p -P 29418 username@gerrit.wikimedia.org:hooks/commit-msg .git/hooks/
git commit --amend
  • Des mises à jour ont été faites et vous n'êtes pas synchronisé.
git pull --rebase
  • Vous utilisez une mauvaise commande pour faire le push
    • Quelques fois vous devez utiliser ce qui suit (si vous savez pourquoi, expliquez-le) :
git push origin HEAD:refs/publish/master
  • Certains dépôts ont leur propre système
git push-for-review-production
  • Certains dépôts nécessitent git review
git-review -R

Si vous utilisez git-review vous devez avoir un fichier .gitreview dans le dépôt; si ce n'est pas le cas, créez-le :

[gerrit]
host=gerrit.wikimedia.org
port=29418
project=  vous ajoutez ici un chemin relatif; exemple : labs/toollabs.git
defaultbranch=master
defaultrebase=0

Réinitialisation du dépôt : reset et stash

C'est très difficile pour Git d'annuler les modifications ou les réinitialisations que vous avez faites au dépôt pour le remettre dans l'état original qu'il avait lorsque vous l'avez cloné. Dans svn, il suffit simplement de supprimer les fichiers et d'exécuter svn up pour les restaurer. Dans Git, cela n'a aucun effet.

Il y a beaucoup de façons de réinitialiser le dépôt pour qu'il retrouve son état d'origine, mais le plus simple est de le supprimer et de le recloner à nouveau. Dans le cas d'un gros dépôt, vous ne voudrez certainement pas perdre votre temps et essayer ceci :

# réinitialisation logicielle - va réinitaliser tous les 'git add <partout ici>' - mais ne va pas annuler les modifications faites aux fichiers
git reset
# annuler tous les fichiers sur lesquels vous avez fait le 'commit' pour les remettre à la version qu'ils avaient après le dernier 'commit' - cela va annuler toutes les modifications que vous aurez apportées dans le 'commit' le plus récent
git stash
# réinitialisation matérielle
git reset --hard origin/master
# si vous voulez annuler toutes les modifications apportées à tous les fichiers et supprimer tous les fichiers qui ont été ajoutés depuis le dernier 'commit',
# restaure tous les fichiers que vous avez supprimés; ce que vous voulez c'est de réinitialiser le dépôt à l'état qu'il avait quand vous l'avez cloné.
# ou validé, aller sur la racine du dépôt (où se trouve '.git') et tout supprimer sauf '.git'
rm -r *
git stash

Spécificités Gerrit

Installer git review

Ubuntu / Debian

sudo apt-get install git-review

Télécharger un ensemble de corrections de gerrit

git review -d 31337

Ceci télécharge le contenu de https://gerrit.wikimedia.org/r/c/31337/ dans une nouvelle branche et déclare celle-ci comme étant la branche courante.

Rebaser un ensemble de corrections sur le master

Essayez d'abord de cliquer sur Rebase dans Gerrit. En cas d'échec, vérifiez que le commit a été fait sur tous les éléments, puis exécutez

git checkout master
git pull
git checkout branch_name
git rebase master

Suivez les instructions sur l'écran.

Exemples

# configurer git
git config --global user.email some.guy@example.org
git config --global user.name Petrb

#########################################
# GERRIT
#########################################

# obtenir un dépôt
git clone https://gerrit.wikimedia.org/r/mediawiki/core.git mediawiki
cd mediawiki
# maintenant faites quelques modifications suivies du 'commit' :
git commit -a
# maintenant faire le push
git-review -R

#######################################
# GITHUB
#######################################

# obtenir un dépôt
git clone git@github.com:huggle/huggle3-qt-lx hg
cd hg
# extraire la nouvelle branche
git checkout -b feature
# maintenant, faites quelques modifications et validez-les :
git commit -a
# maintenant faire le push
git push origin feature

Voir aussi