150 lines
8.6 KiB
Markdown
150 lines
8.6 KiB
Markdown
#TP5 Activité de groupe : Découverte de Git sous Linux
|
||
|
||
## Objectif de l'activite
|
||
Cette activite a pour but de decouvrir les commandes de base de Git sous Linux, dans un contexte
|
||
collaboratif. Les etudiants travailleront par groupes pour developper un mini-projet en C, tout en utilisant les
|
||
fonctionnalites principales de Git : clone d'un depot distant, commits, branches, fusions, resolution de conflits
|
||
et push vers Gitea.
|
||
|
||
Etape 1 - Création et Recuperation du projet depuis Gitea
|
||
|
||
***
|
||
Attention tout ce qui est entre *truc* dans être modifier pour corespondre au nommage de vos fichiers et projets
|
||
***
|
||
|
||
Créer en compte pour chaque membre de groupe sur https://gitea.apf-bi.ovh (avec votre addresse unilim)
|
||
Créer un depot publique sur le gitea avec l'un des comptes juste créer (le nommer en accord avec votre groupe de TP: MIX-1-toto-tata)
|
||
|
||
Chaque groupe commence par cloner un depot depuis le gitea sur sa machine virtuelle linux (la lancer avec l'icone xubuntu du bureau. identifiant eleve mdp eleve).
|
||
|
||
```
|
||
git clone http://gitea.apf-bi.ovh/*<utilisateur>*/*projet-git.git*
|
||
```
|
||
|
||
Ensuite il faudra déclarer votre identité
|
||
```
|
||
git config --global user.email "you@example.com"
|
||
git config --global user.name "Your Name"
|
||
```
|
||
Ensuite placez vous dans le dossier du projet, ajoutez un fichier source en C (un membre du binome le fait pour iniitalisé votre dépot), et realisent un premier commit suivi d'un push vers Gitea:
|
||
|
||
```
|
||
cd *projet-git*
|
||
nano main.c
|
||
git add main.c
|
||
git commit -m "Initial commit avec fichier main.c"
|
||
git push origin main
|
||
```
|
||
|
||
Etape 2 - Travail en branches
|
||
Chaque membre du groupe cree sa propre branche pour ajouter une fonction au programme C. Attention il faut que le membre du binome n'ayant pas fait le commit-push initial de re-cloner le dépot d'abord avec un git clone. Pour se faire il faut donc faire:
|
||
|
||
```
|
||
git checkout -b *feature-nom*
|
||
```
|
||
Chaque membre de binome modifie main.c pour ajouter une fonction ou un commentaire (à l'aide de l'éditeur de texte en ligne de commande nano par exemple)
|
||
Ensuite chaque membre effectue un commit sur sa branche et pousse la branche sur le serveur Gitea. En faisant:
|
||
|
||
```
|
||
git add main.c
|
||
git commit -m "Ajout de la fonction X"
|
||
git push origin feature-nom
|
||
```
|
||
|
||
Etape 3 - Fusion des branches
|
||
Les membres du groupe fusionnent leurs branches dans la branche principale en local, puis synchronisent le
|
||
depot avec Gitea. Des conflits peuvent survenir et devront etre resolus manuellement.
|
||
|
||
|
||
```
|
||
git checkout main
|
||
git pull origin main
|
||
git merge feature-nom
|
||
```
|
||
|
||
En cas de conflit :
|
||
```
|
||
git status
|
||
git diff
|
||
```
|
||
|
||
Resoudre manuellement les conflits, puis reprendre le processus de commit-push :
|
||
```
|
||
git add main.c
|
||
git commit -m "Resolution de conflit"
|
||
git push origin main
|
||
```
|
||
|
||
|
||
Etape 4 - Consultation de l'historique
|
||
Les etudiants consultent l'historique des commits et visualisent la structure du projet.
|
||
|
||
git log --oneline --graph --all
|
||
|
||
***
|
||
|
||
Fichier C de depart (main.c)
|
||
```
|
||
#include <stdio.h>
|
||
int main() {
|
||
printf("Bonjour, Git !\n");
|
||
return 0;
|
||
}
|
||
```
|
||
#Memo git (crédit develloppez.com)
|
||
Commande Git Description succinte
|
||
|1. |git branch |newBranch Crée dans le repo local la nouvelle branche newBranch qui est un fork de la branche courante.
|
||
2. git branch -m locBranch Renomme la branche courante avec le nouveau nom locBranch.
|
||
3. git branch -d locBranch Supprime la branche locBranch du repo local.
|
||
4. git branch -u origin/remBranch Ordonne à la branche courante de traquer la branche distante remBranch.
|
||
5. git branch --track locBranch origin/remBranch Similaire à la commande numéro 4, à la différence qu'on explicite la branche locale qui traque : locBranch.
|
||
6. git branch -v Liste les branches sur le repo local.
|
||
7. git branch -v -a Liste les branches sur le repo distant.
|
||
8. git branch -r | wc -l Compte le nombre de branches effectivement présentes sur le repo distant.
|
||
9. git branch --merged Liste toutes les branches ayant subies un merge vers d’autres branches.
|
||
10. git branch --no-merged Liste toutes les branches n’ayant jamais subies un merge.
|
||
11. git log Affiche l’historique des commits effectués sur la branche courante avec leurs SHA1 (très verbeux).
|
||
12. git log --pretty=oneline Affiche l’historique des commits effectués sur la branche courante, chaque commit tenant uniquement sur une ligne.
|
||
13. git log --name-status HEAD^..HEAD Liste tous les commits récents effectués, mais non encore pushés.
|
||
14. git tag nomTag Crée un tag de nom nomTag sur la branche courante.
|
||
15. git show nomTag Donne les détails sur le tag nomTag de la branche courante.
|
||
16. git tag Liste tous les tags placés sur la branche courante.
|
||
17. git stash Remet en cache (appelé Remise) les modifications sur la branche courante.
|
||
18. git stash list Liste tous les stash sur le repo local.
|
||
19. git stash show Permet de voir la liste des fichiers modifiés du dernier stash.
|
||
20. git stash apply Applique le tout dernier stash dans la pile des stash du cache de git.
|
||
21. git stash apply stash@{n} Applique le stash numéro n dans la pile des stash du cache de git.
|
||
22. git stash pop Supprime le tout dernier stash dans la pile des stash du cache de git.
|
||
23. git stash pop stash@{n} Supprime le stash numéro n dans la pile des stash du cache de git.
|
||
24. git clone urlRepoDistant Clone le projet du repo distant vers un repo local (répertoire courant).
|
||
25. git clone urlDistant pathRepoLocal Clone le projet du repo distant en précisant le répertoire pathRepoLocal qui constituera le repo local.
|
||
26. git remote prune origin Supprime toutes les branches mergées et inutiles sur le repo distant.
|
||
27. git fetch origin --prune Similaire à la commande numéro 26.
|
||
28. git remote update origin --prune Synchronise le repo local à partir du repo distant.
|
||
29. git push origin –-delete remBranch Supprime la branche de nom remBranch du repo distant.
|
||
30. git push -u origin newBranch Pousse la branche locale courante sur le repo distant au nom de newBranch.
|
||
31. git push --set-upstream origin newBranch Similaire à la commande numéro 30.
|
||
32. git push Pousse les commits de la branche locale courante vers celle distante traquée.
|
||
33. git fetch Actualise et vérifie si la branche locale courante est iso ou non à celle du repo distant.
|
||
34. git pull Réalise la commande 33 et en même temps récupère en local, les éventuels commits présents sur celle distante trackée.
|
||
35. git checkout locBranch Changement de branche : passage de la branche courante à la branche locBranch.
|
||
36. git checkout -b locBranch origin/rembranch Créer à partir de la branche distante rembranch, la branche locale locBranch et switcher vers cette dernière.
|
||
37. git checkout --track origin/rembranch Similaire à la commande numéro 36. Ici locBranch a le même nom que rembranch.
|
||
38. git cherry-pick commit-sha1 Commit sur la branche courante, un commit identifié par commit-sha1 effectué ailleurs.
|
||
39. git merge locbranch Merge la branche de nom locbranch dans la branche courante (pas de perte d'historique).
|
||
40. git rebase locbranch Rebase la branche de nom locbranch dans la branche courante (perte d'historique).
|
||
41. git reset --hard HEAD^ Force l'annulation du dernier commit avec suppression de l'historique.
|
||
42. git revert HEAD^ .. HEAD Crée un commit inverse annulant le dernier commit pushé sur le repo distant.
|
||
43. git revert commit-sha1 Crée le commit inverse annulant un commit précisé par son commit-sha1.
|
||
44. git config --global clef val Affecte la valeur val au champ clef de la config global git.
|
||
45. git config --global --unset clef Supprime la clef de la configuration globale de git.
|
||
46. git config --list Liste tous les paramètres (clef = valeur) de la config global git.
|
||
47. git checkout -- pathToFile Annule les modifications en cours effectuées sur le fichier pathToFile.
|
||
48. git rm --cahed pathToFile Deplace le fichier pathToFile de la zone d'index vers le working set.
|
||
49. git diff pathToFile Compare les modification en cours du fichier pathToFile par rapport à sa version sur le repo local.
|
||
50. git add pathToFile Ajoute le fichier modifié pathToFile dans la zone d'index pour qu'il soit prêt à être commité.
|
||
51. git commit -m "commentaire" Commit dans le repo local tous les fichiers présents dans la zone d'index en ajoutant un commentaire propre obligatoire.
|
||
52. git init Marque le répertoire courant comme étant un repo local Git. Concrètement crée le dossier .git dans ce répertoire.
|
||
53. git branch --merged | xargs git branch -d Supprime sur le repo local toutes les branches qui ont été mergée dans une autre branche.
|
||
54. git remote add origin pathToRemoteProject.git Indique à un repo git local vierge, quel est le repo distant dont il en est l'image.
|
||
55. git remote set-url origin pathToRemoteProject.git Change sur un repo git local non vierge, l'url du repo distant dont il en est l'image. |