Git est l'un des logiciels de contrôle de version distribués les plus largement utilisés sur Linux parmi les développeurs pour faciliter la coordination sur un même projet.
Si vous n'êtes pas familier avec Git, il est recommandé de lire ce guide d'introduction sur l'installation et la prise en main de Git. Jusqu'à présent, seules les fonctions de base ont été présentées. Il s'agit notamment de la préparation de l'espace de travail et de la création des différents référentiels, par le biais de fichiers "stage" et "commit" des modifications, ainsi que de toute éventuelle suppression ou renommage de fichier.
L'étape suivante est pour comprendre comment se déplacer entre les différentes versions du projet. Comme le suggère la nature du logiciel, en effet, la possibilité de créer de nouveaux référentiels infinis, à partir d'un travail préexistant, crée inévitablement une chaîne de chemins différents, tous issus du même projet.
L'objectif de ce guide est donc d'expliquer comment gérer correctement le versioning d'un projet, en se déplaçant entre les différentes branches (branching), tout en fusionnant les différentes branches et en restaurant les versions précédentes. Ce guide est valable pour les principales distributions Linux et a été testé sur Ubuntu 18.04.
Utiliser les branches Git
La création de branches est l'une des fonctionnalités les plus puissantes de Git. Les branches sont utilisées pour implémenter des fonctions différentes et indépendantes les unes des autres à partir de la même racine. La branche principale d'un projet est générée lorsqu'un "dépôt" est créé et est étiqueté comme "maître".
La première chose à faire pour apprendre à se déplacer dans les différentes branches d'un dépôt est d'utiliser la commande "git checkout", suivie de la branche sur laquelle travailler :
$ git checkout <branch> Par exemple, pour se déplacer et travailler sur la branche principale, utilisez la commande suivie de "master", comme indiqué ci-dessous :
$ git checkout master Une fois la branche de création de votre dépôt indiquée, les fichiers seront amenés à la dernière étape de la branche choisie dans le dossier de travail. Ensuite, toute modification future apportée créera une nouvelle version du projet pour cette branche particulière.
Créer une nouvelle branche avec Git
Pour créer une nouvelle branche avec Git, il suffit d'utiliser la commande "git branch" suivie du nom à donner à la branche créée :
$ git branch <nome_ramo> Le déplacement vers la branche nouvellement créée n'est pas automatique. Donc, pour travailler sur la branche nouvellement créée, utilisez la commande "git checkout":
$ git checkout <nome_ramo> À ce stade, chaque commit fera référence à la branche nouvellement créée.
Dans la figure 1, les opérations suivantes sont effectuées :
- Passer à la branche "master" ;
- Création d'une nouvelle branche (Test0) ;
- Déplacer vers la branche nouvellement créée ;
- Ajout d'un fichier (BranchTest) ;
- Validation des modifications ;
- Revenir à la branche "maître".
Fig. 1 - Exemple de création de branche et de validation sur Ubuntu 18.04
Rechercher et supprimer des branches Git
La commande "git branch" sans rien suivi publiera simplement une liste de toutes les branches existantes.
$ git branch Pour supprimer une branche utilisez la commande "git branch", dans ce cas suivie de l'argument "-d" et du nom de la branche à supprimer :
$ git branch -d <nome_ramo> La figure 2 montre un exemple de liste de branches et de suppression de la branche nouvellement créée (Test0).
Fig. 2 - Exemple de liste de branches et d'élimination sur Ubuntu 18.04
Comme le montre la figure, lorsque vous essayez de supprimer une branche sur laquelle des modifications ont été apportées, Git renverra une erreur. Puisque la branche n'a pas été jointe (fusion de branches), pour éviter de perdre tout le travail effectué par erreur, cela évitera son élimination.
Il sera toujours possible de supprimer la branche en utilisant l'argument "-D" :
$ git branch -D <nome_ramo> Fusionner les branches Git
Le but des branches est de créer des flux de travail parallèles et indépendants afin d'expérimenter de nouvelles fonctionnalités sans affecter le projet principal (par exemple des versions "release", "beta" ou "fix").
Pour cette raison, le les succursales sont conçues pour avoir une courte durée de vie, ce qui aboutit à la fusion avec une autre succursale.
Les branches peuvent être fusionnées en utilisant la commande "git merge" suivie du nom de la branche à fusionner.
$ git merge <ramo_da_unire>
Évidemment, la fusion doit avoir lieu entre deux branches. La commande "git merge" fusionne la branche indiquée dans la syntaxe avec celle sur laquelle vous vous trouvez actuellement. Ainsi, pour effectuer la "fusion", assurez-vous, via "git checkout", d'être sur la branche avec laquelle vous souhaitez fusionner.
Ainsi, la commande "git merge" indiquée ne laissera aucune trace de la fusion dans l'historique du "référentiel".
Très souvent, il peut être nécessaire de garder une trace de la fusion pour qu'il suffise d'utiliser simplement l'argument "--no-ff". De cette façon, Git fera automatiquement un nouveau commit pour identifier la "fusion" à l'avenir :
$ git merge --no-ff <ramo_da_unire> La fusion de deux branches n'implique pas l'élimination de la branche qui a été fusionnée avec celle indiquée. Au lieu de cela, il continuera d'exister. Pour le supprimer définitivement, procédez à l'élimination à l'aide de la commande "git branch -d".
La figure 3 montre un exemple de fusion entre les branches. En particulier, les opérations effectuées sont :
- Passer à la branche "master" ;
- Liste des succursales ;
- Fusion de la branche "Br01" ;
- Suppression de la branche "Br01".
Fig. 3 - Exemple de branches fusionnées sur Ubuntu 18.04
Pour obtenir une liste montrant uniquement les branches non fusionnées avec la branche actuelle, utilisez la commande "git branch" suivie de l'argument "--no-merged".
$ git branch --no-merged Résolution des conflits
Lorsque deux branches sont fusionnées, Git détermine automatiquement lequel des deux commits parents est le meilleur et fusionne avec lui.
Git peut ne pas être en mesure de décider automatiquement quelle version des fichiers conserver lors de cette opération et notifiera donc un conflit.
Si cette situation se produit, résolvez le conflit manuellement et validez les modifications apportées. Alternativement, la fusion des branches n'aura pas lieu.
L'exemple suivant illustre le mieux cette occurrence. Puisqu'il considère deux branches différentes où deux versions différentes du même fichier sont enregistrées, une fois fusionnées, Git affichera l'avertissement suivant :
CONFLICT (content): Merge conflict in <filename>
Automatic merge failed; fix conflicts and then commit the result.
Pour résoudre le problème, allez dans le dossier où se trouve le fichier en conflit, modifiez-le et faites un "add" ultérieur avec "commit". En cas de fichier texte, Git signalera les sections incriminées dans le fichier en insérant la section présente uniquement dans la première branche et entre "=" entre "<<<<<<<" et "=======" ======"et">>>>>>> "celui présent uniquement dans le second.
En modifiant manuellement le fichier et en exécutant la commande "git add" suivie du " git commit", les deux branches fusionneront finalement, comme le montre la figure 4.
Dans l'exemple illustré à la figure 4, les branches non jointes ont également été contrôlées pour s'assurer que la "fusion" a été correctement effectuée.
Fig. 4 - Exemple de résolution de conflit et de fusion sur Ubuntu 18.04
En effet, après le commit, la branche "Br03" n'apparaît plus dans la liste des branches déconnectées, prouvant que la fusion avec la branche "Br04" a réussi.
Gestion des balises Git
Les "tags" ne sont que des étiquettes à attacher aux différents "commits" afin de remonter des informations utiles sur la version et sur le projet sur lequel vous travaillez.
Pour afficher les balises dans un "dépôt", utilisez la commande "git tag" :
$ git tag Il existe deux types de balises différentes dans Git :"annotées" et "légères". Les premiers sont utilisés pour indiquer les informations complètes sur la version, telles que "checksum", le nom du développeur, la date / heure et tout commentaire. Les seconds sont de simples pointeurs vers un commit.
La commande "git tag" suivie du texte d'identification de la version créera une balise "légère". La syntaxe est illustrée ci-dessous :
$ git tag <Nome_Versione> L'utilisation de l'argument "-a", à la place, conduit à la version d'une balise "annotée" :
$ git tag -a <Nome_Versione> -m <Commento> Enfin, pour visualiser un tag, utilisez la commande "git show" comme indiqué ci-dessous :
$ git show <Nome_Versione> Les commandes que nous venons d'examiner permettent d'ajouter des "tags" uniquement au dernier commit. Pour ajouter une balise à un commit plus ancien, indiquez après la commande "git tag" également l'identifiant (Checksume) du commit auquel se référer. La syntaxe complète est présentée ci-dessous :
$ git tag -a <Nome_Versione> <Checksum_Commit> Pour suivre la "somme de contrôle" des différents commits effectués, utilisez la commande "git log".
$ git log --pretty=oneline Une fois la commande lancée, une liste dans l'ordre chronologique des différents "checksums" des commits s'affichera sur le terminal suivi du commentaire saisi lors de la phase "commit" des modifications.