Pré-requis: Les commandes de base, ainsi que la gestion des conflits avec Git sont assimilés. L’environnement de simulation multi-développeur est mis en place (cf. articles précédents).
1. Création d’un nouveau projet de démonstration.
Le projet
conjparler permet de conjuguer le verbe “Parler”. On se propose de le gérer avec Git. On va initialiser son dépôt sur le serveur, ensuite le développeur DEV1 se chargera de sa création.
cd /serveurgit
git init --bare conjparler.git
Ceci initialise le dépôt du projet côté serveur.
cd /pcdev1
git clone /serveurgit/conjparler.git
cd conjparler
git config --local user.name DEV1
git config --local user.email DEV1@server.com
Ceci permet à DEV1 de récupérer une copie de travail locale du projet, cette copie est bien entendu encore vide.
DEV1 crée les deux fichiers
conjugue_parler.sh et
parler_present dans cette copie de travail:
vi conjugue_parler.sh
vi parler_present
Le contenu du fichier
conjugue_parler.sh est:
#!/bin/bash
source parler_present
Le contenu du fichier
parler_present est:
echo "Je parle"
echo "Tu parles"
echo "Il parle
Rendre le fichier
conjugue_parler.sh exécutable et ajouter le tout au dépôt de Git local, puis envoyer sur le serveur.
chmod +x conjugue_parler.sh
git add .
git commit -m "Creation du projet conjparler"
git push
2. Création d’une branche de travail.
De son côté DEV2 récupère une copie locale de
conjparler:
cd /pcdev2
git clone /serveurgit/conjparler.git
cd conjparler
git config --local user.name DEV2
git config --local user.email DEV2@server.com
DEV2 est chargé d’ajouter une fonctionnalité importante au projet: la conjugaison au passé composé du verbe parler. Afin d’
isoler ses travaux de l’éxistant de manière qu’il n’introduit aucun risque de dysfonctionnement, il décide de créer une branche dans laquelle il effectuera ses travaux.
git branch passecompose
Pour vérifier la création de la nouvelle branche et basculer sur celle-ci:
git branch
git checkout passecompose
git branch
La commande
git branch, permet de lister les branches existantes. La branche dont le nom est précédé d’une étoile dans cette liste est
la branche active. Une seule branche est active à la fois. Toute modification effectuée dans les fichiers est
localisée dans la branche active uniquement. C’est tout l’intérêt des branches.
DEV2 effectue alors ses modifications: création d’un fichier
parler_passe dont le contenu est:
echo "J'ai parlé"
echo "Tu asparlé"
echo "Il a parlé"
Il modifie également le fichier
conjugue_parler.sh de manière que son contenu devienne (ajout des deux dernières lignes):
#!/bin/bash
source parler_present
echo ""
source parler_passe
Ensuite DEV2 valide ses modifcations:
git add .
git commit -m "Ajout de la conjugaison au passé composé"
Pour vérifier l’isolation entre les deux branches, on peut basculer sur master et verifier le contenu du fichier
conjugue_parler.sh
git checkout master
cat conjugue_parler.sh
ls -l
Rien, donc, n’a été modifié dans la branche master. Vous pouvez également re-basculer sur la branche passecompose et re-vérifier les contenus.
A ce stade, DEV2 peut même publier la branche passecompose pour partager ses travaux avec les autres développeurs:
git checkout passecompose
git push --set-upstream origin passecompose
3. Travail simultané sur les deux branches.
Simultanément aux travaux effectués sur la branche passecompose, DEV1 peut continuer ses travaux sur la branche principale master. Il va compléter la conjugaison au présent. Le contenu du fichier
parler_present devient:
echo -e "Je parle\t\tNous parlons"
echo -e "Tu parles\t\tVous parlez"
echo -e "Il parle\t\tIls parlent"
A l’exécution cela donne (commande :
./conjugue_parler.sh):
Je parle Nous parlons
Tu parles Vous parlez
Il parle Ils parlent
Content du résultat DEV1 valide son travail:
git commit -am "Ajout du présent au pluriel"
Ensuite il avance encore dans ses travaux et améliore la présentation. Le contenu du fichier
parler_present devient:
echo ""
echo -e "\t\tPRESENT"
echo -e "\t\t-------"
echo -e "Je parle\t\tNous parlons"
echo -e "Tu parles\t\tVous parlez"
echo -e "Il parle\t\tIls parlent"
Puis valide les nouvelles modifications:
git commit -am "Bien présenter le résultat"
Et pose même un tag pour marquer une version d’évolution et publie ces évolutions:
git tag -a v0.1 -m "Version 0.1"
git push
git push --tags
De son côté DEV2 (
cd /devpc2) poursuit les évolutions et modifie le fichier parler_passe de manière que son contenu devient:
echo ""
echo -e "\t\tPASSE"
echo -e "\t\t-------"
echo -e "J'ai parlé\t\tNous avons parlé"
echo -e "Tu asparlé\t\tVous avez parlé"
echo -e "Il a parlé\t\tIls ont parlé"
Ensuite valide et pose un tag:
git commit -am "Améliorer la présentation"
git tag -a v0.2 -m "Version 0.2"
git push
git push --tags
4. Fusion des branches
DEV2 décide également de fusionner les deux branches pour obtenir un fonctionnement global de l’application.
La fusion doit se faire dans la branche principale master:
git checkout master
git pull
git merge passecompose
La première commande permet de basculer sur la branche master. Le seconde met à jour cette branche depuis le dépôt distant (serveur). Enfin la troisième permet de
fusionner le contenu de ‘passecompose’ dans la branche master. On peut le constater par la commande:
git log --decorate --graph
L’exécution du script (
./conjugue_parler.sh) donne le résultat:
PRESENT
-------
Je parle Nous parlons
Tu parles Vous parlez
Il parle Ils parlent
PASSE
-------
J'ai parlé Nous avons parlé
Tu asparlé Vous avez parlé
Il a parlé Ils ont parlé
Il s’agit bien du résultat
final et fusionné des travaux de DEV1 et DEV2 qui ont été effectués de
manière séparée dans deux branches différentes. C’est une illustration de l’utilisation principale des branches et de la manière de la mener. L’utilisation de cette technique est
intimement liée au découpage fonctionnel du projet. Sans un découpage fonctionnel bien fait, il est difficle d’utiliser les branches avec efficacité. Mais bien utilisée, cette technique permet également d’obtenir
une documentation de l’historique des évolutions ainsi que la possibilité de
retrouver ces situations historiques de manière très simple.
5. Suppression des branches
La branche
passecompose n’est plus utile, maintenant que son contenu a été fusionné avec la branche master. Pour garder un état propre du projet,; il faut la supprimer. Pour cela DEV2 utilise les commandes:
git checkout master
git branch -d passecompose
On bascule d’abord sur la branche master (pour ne pas scier la branche sur laquelle on est assi), ensuite on demande la suppression (
git branch -d). Le résultat dans le cas de DEV2 est toutefois decevant:
C’est une erreur courante qui se produit lorsqu’on on essaie de supprimer une branche qui
n’est pas synchronisée avec le dépôt distant (suite au merge). Il convient donc de synchronier la branche passecompose avant de la supprimer:
git checkout passecompose
git push
git checkout master
git branch -d passecompose
La suppression est alors effectuée sans problème. Bien entendu cette suppression
n’entraine pas la disparition de la branche de l’historique. Un test simple de visualisation des log permet de s’en rendre compte.]]>
Si le sous-menu “Maven project” n’apparaît pas dans votre version d’eclipse, utiliser le sous-menu “Other..” qui donne accès à cette fonctionnalité. Ce menu affiche la fenêtre:
Il suffit de clicker sur “Next”, car on souhaite utiliser un archetype de création de projet.
Un archetype Maven est un assitant qui facilite la création d’un gabarit de projet. Sélectionner “quickstart” qui permet la création d’un projet autonome simple.
Saisir le “Groupe Id” (généralement le domaine de l’oganisme pour l’unicité universelle) et l'”Artifact Id” (généralement le nom de l’application). Après cliquer sur “Finish” pour créer le projet.
Le nouveau projet est prêt à l’emploi, il est exécutable immédiatement et sans aucune modification (mais bien entendu ne fait rien d’autre que d’afficher “Hello world”).
Dans le menu “Team“, sélectionner le sous-menu “Share project“, ceci lance la procédure d’integration du projet à Git.
Sélectionner la case à cocher “Use or create repository in parent folder of project“, l’affichage devient:
Ensuite utiliser le bouton “Create repository“..
A l’étape suivante, il faut cocher l’unique projet à prendre en compte et ensuite utiliser le bouton “Finish“.
Cette procédure permet de mettre le projet calcul sous le contrôle de Git.
On reconnait notamment les commandes:
Tout d’abord il faut ajouter les fichiers à l’index. On sélectionne les fichiers puis on utilise le menu contextuel (click droit) “Add to index“. Bien entendu on aurait pu utiliser le menu de cette fonctionnalité dès le départ, mais on procédant ainsi, on fait tout dans la même fenêtre (équivalent de “git commit -a“)
Enfin, on saisit le message du commit et on actionne le bouton “Commit“. Ceci valide les fichiers sélectionnés dans le dépôt local de Git.]]>
