Wikilivres

« Git/Premiers pas » : différence entre les versions

Navigation interactive dans l’historique
← Modification précédenteModification suivante →
Contenu supprimé Contenu ajouté
VisuelWikicode
Aucun résumé des modifications
git init est déplacé dans un chapitre précédent ; beaucoup de contenu déplacé vers des chapitres car c'est prématuré ici ; j'ai refais un chapitre pas à pas qui détaille bien (sorties git log) chaque étape ajout/modif/suppression
Ligne 1 :
{{git}}
[[Image:Git operations.svg|thumb|upright=2|Représentation des opérations Git.]]
Les premières commandes sont la création d'un dépôt, y soumettre des fichiers, les refuser, en retirer, et visualiser les fichiers d'une soumission.
 
Nous allons maintenant entré dans le vif du sujet et faire une première modification dans le code source d'une application.
== Créer un dépôt ==
Créer un nouveau dépôt Git s'effectue en deux commandes : <code>git-init</code>, et <code>git-clone</code>. Exemple :
$ git init depot1
Créer le répertoire vide :
# /home/utilisateur/depot1/.git/ sur Linux.
# C:/Users/utilisateur/depot1/.git/ sur Windows.
On peut naviguer dedans en Unix :
$ cd depot1
$ ls -a
. .. .git
 
Cette première expérience va nous permettre de découvrir plusieurs notions importantes : l'espace de travail et l'index.
Pour transformer un répertoire existant en dépôt :
$ cd $depot2
$ git init
 
== Préalable ==
Le dépôt Git est donc contenu dans le sous-répertoire <code>.git</code>.
 
On reprend l'exemple précédent.
{{Remarque|pour que Git soit positionné dans le répertoire de votre choix à chaque ouverture, sous Windows faire un clic droit sur le raccourci, puis modifier le chemin du champ "démarrer dans".}}
 
<source lang="bash">
== Ajouter et soumettre des fichiers ==
git clone https://gerrit.wikimedia.org/r/p/test/mediawiki/extensions/examples.git
Au lieu de soumettre chaque fichier modifié, Git permet à l'utilisateur de les ajouter dans une zone appelée "l'index". Tout ce qui s'y trouve se retrouve soumis. Pour en lister le contenu il existe <code>git status</code> ou <code>git diff --staged</code>.
cd examples
</source>
 
Faisons d'abord un
Ajoutons un fichier texte (créé avec {{w|vim}}) dedans :
<source lang=bash>
# Création du fichier
$ vim fichier.txt
Test Git Wikilivres.
 
<source lang="bash">
# Vérification de l'index
$ git statusbranch
# On branch master
#
# Initial commit
#
# Untracked files:
# (use "git add <file>..." to include in what will be committed)
#
# fichier.txt
nothing added to commit but untracked files present (use "git add" to track)
</source>
 
qui va nous répondre
Cela montre que nus utilisons une branche appelée "master" et qu'il y a un fichier que Git ne suit pas. Pour ce faire Git ajoute une note d'aide tout en bas proposant de l'inclure avec <code>git add fichier.txt</code> :
 
<source lang=bash>
<pre>
$ git add fichier.txt
* master
$ git status
</pre>
# On branch master
 
#
Git nous indique qu'il existe une seule branche appelée <tt>master</tt> et que c'est sur cette branche que nous travaillons comme l'indique l'astérisque en face de <tt>master</tt>.
# Initial commit
 
#
Cela nous est confirmé par
# Changes to be committed:
 
# (use "git rm --cached <file>..." to unstage)
<source lang="bash">
#
git status
# new file: fichier.txt
#
</source>
 
qui nous répond
Le fichier inclus est maintenant prêt à être soumis :
 
<source lang=bash>
<pre>
$ git commit -m 'Soumission 1'
# On branch master
[master (root-commit) be8bf6d] Soumission 1
nothing to commit, working directory clean
1 files changed, 1 insertions(+), 0 deletions(-)
</pre>
create mode 100644 fichier.txt
 
Vous pouvez faire un
 
<source lang="bash">
git log
</source>
 
Pour voir quel est l'auteur et la date de la dernière modification : cela nous servira de repère pour la suite.
{{Remarque|en lançant <code>git commit</code> tout court, l'éditeur de texte (<code>$EDITOR</code>) s'ouvre automatiquement pour inviter à saisir un commentaire de soumission.}}
 
=== ExclureAjouter desun fichiersfichier ===
Souvent il y a des fichiers dans l'espace de travail qui ne sont pas souhaitables dans le dépôt. Par exemple, <tt>emacs</tt> crée automatiquement une copie des fichiers éditer avec, avec un suffixe tilde, comme <tt>fichier1~</tt>. Il faut donc éviter manuellement de les soumettre.
 
Commençons par une modification simple : l'ajout d'un fichier. Cela peut être une première étape si vous avez créer un dépôt vide.
Pour dire à Git d'ignorer certain fichiers, il est possible de créer un fichier <tt>.gitignore</tt>. Chaque ligne y représente une spécification (avec wildcards) des fichiers à ignorer. Des commentaires peuvent être ajoutés dedans sur les lignes débutant par un blanc ou un dièse :
 
Par exemple, créons un fichier <tt>mon_nouveau_fichier.txt</tt> avec un petit texte dedans.
 
<source lang="bash">
echo "Ceci est un test de git" > mon_nouveau_fichier.txt
</source>
 
Voyons la façon dont git perçoit ce nouveau fichier
 
<source lang="bash">
git status
</source>
 
<pre>
# On branch master
# Ignorer les backups emacs :
# Untracked files:
*~
# (use "git add <file>..." to include in what will be committed)
#
# mon_nouveau_fichier.txt
nothing added to commit but untracked files present (use "git add" to track)
</pre>
 
Il nous indique qu'on est toujours sur la branche <tt>master</tt>, qu'il y a un fichier <tt>mon_nouveau_fichier.txt</tt> mais qu'il n'est pas suivi (« untracked ») par git.
# Ignorer le répertoire ''cache'' :
 
app/cache
Comme nous voulons intégrer ce fichier au projet, on ne peut pas encore faire le <tt>commit</tt> cat <tt>commit<tt> n'envoit que les fichiers qui sont *tracked*, c'est à dire dans l'index (*staging*). Ajoutons le fichier, comme git nous le suggère, avec <tt>add</tt>
 
<source lang="bash">
git add mon_nouveau_fichier.txt
</source>
 
On refait un
 
<source lang="bash">
git status
</source>
 
Et, cette fois, git nous répond
 
<pre>
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# new file: mon_nouveau_fichier.txt
#
</pre>
 
Le fichier <tt>mon_nouveau_fichier.txt</tt> sera bien intégré dans notre prochain <tt>commit</tt>. Allons-y :
===Choisir ses messages de soumission===
Les bonnes pratiques sont <ref>http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html</ref> :
# 50 caractères maximum pour le titre, résumant les changements.
# Selon le contexte, la première ligne est traitée comme le sujet d'un email et le reste séparé par une ligne blanche, comme le corps du message.
# Utiliser le présent des verbes.
# Les listes à puces sont autorisées, typiquement avec un moins ou une astérisque.
# Le corps du message doit comprendre des lignes de 72 caractères maximum pour plusieurs raisons :
#* <code>git format-patch --stdout</code> convertit une série de soumission en une série d'emails.
#* Le log Git ne revient pas automatiquement à la ligne, sans retour chariot il est donc étalé sur une seule ligne donc difficile à lire. Le nombre 72 est le résultat du calcul des 80 du terminal (selon la {{w|nétiquette}} des mails), moins les 4 de l'indentation et les 4 de sa symétrie à droite.
 
<source lang="bash">
git commit -m "mon premier commit"
</source>
 
Remarquons ici qu'avec <tt>-m</tt>, nous avons choisi de préciser le message de commit directement sur la ligne de commande. En lançant <code>git commit</code> tout court, l'éditeur de texte (<code>$EDITOR</code>) s'ouvre automatiquement pour inviter à saisir un commentaire de soumission.
Les utilisateurs de Vim peuvent rencontrer ce prérequis lors de l'installation de vim-git, ou bien en le définissant dans la configuration des messages de soumission Git :
:set textwidth=72
 
<pre>
Ceux de {{w|TextMate}} peuvent ajuster l'option colonne "Wrap" du menu "view", puis utiliser ^Q pour revenir à la ligne des paragraphes (s'assurer qu'il y a une ligne blanche après pour éviter le mélange avec les commentaires). Voici une commande shell pour ajouter 72 au menu afin de ne pas avoir à le faire glisser à chaque fois :
[master 17eaa3e] mon premier commit
$ defaults write com.macromates.textmate OakWrapColumns '( 40, 72, 78 )'
1 file changed, 1 insertion(+)
create mode 100644 mon_nouveau_fichier.txt
</pre>
 
Constatons immédiatement l'effet de ce commit :
Ces résumés peuvent ensuite être lus via :
* <code>git log --pretty=oneline</code> affiche une courte liste des historiques avec identifiants et résumés.
* <code>git rebase --interactive</code> fournit les résumés de ses propres soumissions.
* Si l'option de configuration <tt>merge.summary</tt> est définie, les sommaires de toutes les soumissions seront fusionnés.
* <code>git shortlog</code> n'affiche que les résumés des précédentes soumissions.
* <code>git format-patch</code>, <code>git send-email</code>.
* <code>git reflog</code>, un historique local est accessible pour aider à retrouver d'éventuels erreurs.
* <code>gitk</code>, une inerface graphique qui a une colonne résumé.
* Gitweb et d'autres interfaces web comme [http://github.com GitHub] affichent également les résumés.
 
<source lang="bash">
La distinction sujet/corps de texte de Git permet donc un confort de recherche d'historique par rapport à d'autres logiciels similaires comme Subversion.
git log
</source>
 
Notre dernier commit apparaît, en premier de la liste (c'est le plus récent).
== Supprimer des fichiers ==
 
<source lang=bash>
<pre>
$ echo 'test de suppression Git pour Wikilivres' >> fichier.txt
commit 17eaa3e060b29d708a87867dcb725b7ec64ffaeb
$ git status
Author: Michel Boudran <michel.boudran@fr.wikibooks.org>
# On branch master
Date: Tue Jul 22 22:00:39 2014 +0200
# Changed but not updated:
 
# (use "git add <file>..." to update what will be committed)
mon premier commit
# (use "git checkout -- <file>..." to discard changes in working directory)
 
#
</pre>
# modified: fichier.txt
 
#
Avec
no changes added to commit (use "git add" and/or "git commit -a")
 
<source lang="bash">
git log --graph
</source>
 
On voit clairement que notre commit est lié au commit précédent.
Bien que Git n'impose pas la soumission de tous les fichier, c'est chose commune. On peut le faire sans les réajouter auparavant avec <code>git commit -a</code> :
$ git commit -a -m 'Soumission 2'
[master '''e633787'''] Soumission 2
1 files changed, 1 insertions(+), 0 deletions(-)
 
== Modifier un fichier ==
Les caractères en gras ci-dessus sont une abréviation de l'identifiant unique de l'objet Git (en l'occurrence une soumission). Chaque objet est haché en {{w|SHA-1}}. L'identifiant complet est en fait <tt>e6337879cbb42a2ddfc1a1602ee785b4bfbde518</tt>, mais généralement les huit premiers caractères suffisent à l'identifier à coup sûr.
 
Faisons une autre modification. Par exemple, modifions le fichier <tt>mon_nouveau_fichier.txt</tt> en ajoutant une ligne.
Pour supprimer des fichiers, utiliser <code>rm</code> (de l'anglais {{wt|remove}}) :
 
<source lang=bash>
<source lang="bash">
$ git rm fichier.txt
echo "Une seconde ligne pour un second test de git" >> mon_nouveau_fichier.txt
rm 'fichier.txt'
$ git status
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# deleted: fichier.txt
#
$ ls -a
. .. .git
</source>
 
Voyons ce que git nous dit :
{{attention|Cela efface le fichier du disque dur. Pour ne l'enlever que du dépôt, utiliser <code>git rm --cached</code>.}}
 
<source lang=bash>
<source lang="bash">
$ git commit -m 'Removed fichier.txt'
git status
[master b7deafa] Removed fichier.txt
1 files changed, 0 insertions(+), 2 deletions(-)
delete mode 100644 fichier.txt
</source>
 
<pre>
=== Annuler une soumission ===
# On branch master
Utiliser <code>git revert</code> avec ''HEAD'' pour désigner la dernière soumission effectuée :
# Your branch is ahead of 'origin/master' by 1 commit.
<source lang=bash>
# (use "git push" to publish your local commits)
$ git revert HEAD
#
Finished one revert.
# Changes not staged for commit:
[master 47e3b6c] Revert "Soumission 2"
# (use "git add <file>..." to update what will be committed)
1 files changed, 0 insertions(+), 1 deletions(-)
# (use "git checkout -- <file>..." to discard changes in working directory)
$ ls -a
#
. .. fichier.txt .git
# modified: mon_nouveau_fichier.txt
#
no changes added to commit (use "git add" and/or "git commit -a")
</pre>
 
Git nous indique bien que le fichier a été modifié, voyons le résumé de ces modifications telles qu'elles sont perçues par git :
 
<source lang="bash">
git diff
</source>
 
<pre>
Pour signifier d'autres soumissions que la dernière :
diff --git a/mon_nouveau_fichier.txt b/mon_nouveau_fichier.txt
* <code>git revert HEAD^</code> : l'avant dernière.
index a031263..762359c 100644
* <code>git revert HEAD~5</code> : la cinquième moins récente.
--- a/mon_nouveau_fichier.txt
* <code>git revert e6337879</code> : la soumission n°e6337879.
+++ b/mon_nouveau_fichier.txt
@@ -1 +1,2 @@
Ceci est un test de git
+Une seconde ligne pour un second test de git
</pre>
 
Git nous montre la ligne qui a été ajoutée (le « + » en début de ligne).
=== Nettoyer les changements non soumis ===
Pour effacer les changements en cours en rétablissement les états de la dernière soumission :
$ git reset --hard HEAD
ou
$ git reset --hard e6337879
 
On va maintenant faire le commit. Comme précédemment, il faut au ajouter le fichier au *staging* :
Pour ne toucher qu'un seul fichier :
$ git checkout fichier.txt
 
<source lang="bash">
=== Récupérer une version de fichier ===
git add mon_nouveau_fichier.txt
Il faut d'abord récupérer l'identifiant de la version avec <code>git log</code> :
<source lang=bash>
$ git log
commit 47e3b6cb6427f8ce0818f5d3a4b2e762b72dbd89
Author: NomUtilisateur <NomEmail@exemple.com>
Date: Sat Mar 6 22:24:00 2010 -0400
Revert "Soumission 2"
This reverts commit e6337879cbb42a2ddfc1a1602ee785b4bfbde518.
commit e6337879cbb42a2ddfc1a1602ee785b4bfbde518
Author: NomUtilisateur <NomEmail@exemple.com>
Date: Sat Mar 6 22:17:20 2010 -0400
My second commit
commit be8bf6da4db2ea32c10c74c7d6f366be114d18f0
Author: NomUtilisateur <NomEmail@exemple.com>
Date: Sat Mar 6 22:11:57 2010 -0400
My first commit
</source>
 
{{remarque|
Ensuite pour lire la version, utiliser <code>git show</code> :
Si vous voulez ajouter au staging tous les changements qui ont été effectués (fichiers ajoutés, modifiés, supprimés), il vous suffit de faire
<source lang=bash>
 
$ git show e6337879cbb42a2ddfc1a1602ee785b4bfbde518:fichier.txt
<source lang="bash">
Test Git Wikilivres.
git add --all
test de suppression Git pour Wikilivres
</source>
}}
 
== Exemple pratique ==
Avec un compte Google gratuit il est possible d'utiliser {{w|Google Code}} :
# Sur https://code.google.com/, cliquer sur ''{{lang|en|Create a new project}}'', puis remplir les champs.
# Dans Git, lancer la commande montrée par Google : <code>git clone https://xxx@code.google.com/p/yyy/</code>.
# Copier les fichiers dans le répertoire ainsi créé.
# Les uploader sur le serveur en utilisant le mot de passe présent sur <code><nowiki>https://code.google.com/hosting/settings</nowiki></code> :
<source lang="bash">
$ git add *status
$ git commit -m 'Soumission 1'
$ git config --global push.default simple
$ git push
Password for 'https://xxx@code.google.com':
Counting objects: 634, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (624/624), done.
Writing objects: 100% (634/634), 2.17 MiB | 81.00 KiB/s, done.
Total 634 (delta 67), reused 0 (delta 0)
remote: Scanning pack: 100% (634/634), done.
remote: Storing objects: 100% (634/634), done.
remote: Processing commits: 100% (1/1), done.
To https://xxx@code.google.com/p/yyyy/
* [new branch] master -> master
</source>
Les codes sont ensuite publiés en ligne : <code><nowiki>https://code.google.com/p/yyy/source/browse/</nowiki></code>.
 
<pre>
==Références==
# On branch master
<references/>
# Your branch is ahead of 'origin/master' by 1 commit.
# (use "git push" to publish your local commits)
#
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# modified: mon_nouveau_fichier.txt
#
</pre>
 
 
<source lang="bash">
git commit -m "ma première modification"
</source>
 
</pre>
[master 5556307] ma première modification
1 file changed, 1 insertion(+)
<pre>
 
Remarquez le code « 5556307 » : il s'agit d'une abréviation de l'identifiant unique de l'objet Git (en l'occurrence une soumission). Chaque objet est haché en {{w|SHA-1}}. L'identifiant complet est en fait <tt>5556307824d8d0425b38c9da696b84430e30f09f</tt>, mais généralement les huit premiers caractères suffisent à l'identifier à coup sûr.
 
</source lang="bash">
git log --graph
</source>
 
<pre>
* commit 5556307824d8d0425b38c9da696b84430e30f09f
| Author: Michel Boudran <michel.boudran@fr.wikibooks.org>
| Date: Tue Jul 22 22:18:08 2014 +0200
|
| ma première modification
|
* commit 17eaa3e060b29d708a87867dcb725b7ec64ffaeb
| Author: Michel Boudran <michel.boudran@fr.wikibooks.org>
| Date: Tue Jul 22 22:00:39 2014 +0200
|
| mon premier commit
|
</pre>
 
On voit bien que nos deux <tt>commits</tt> se succèdent.
 
== Supprimer un fichier ==
 
<source lang="bash">
git rm mon_nouveau_fichier.txt
git status
</source>
 
<pre>
# On branch master
# Your branch is ahead of 'origin/master' by 2 commits.
# (use "git push" to publish your local commits)
#
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# deleted: mon_nouveau_fichier.txt
#
</pre>
 
Il n'est pas nécessaire de faire un add.
 
<source lang="bash">
git commit -m "ma première suppression de fichier"
</source>
 
<pre>
[master 77ea581] ma première suppression de fichier
1 file changed, 2 deletions(-)
delete mode 100644 mon_nouveau_fichier.txt
</pre>
 
== Continuer ==
 
Vous maîtrisez désormais le strict minimum pour travailler avec git. Vous pouvez ajouter, modifier et supprimer des fichier et enregistrer les changements dans votre dépôt local ainsi que consulter l'historique des modifications. Cela reste toutefois une vision simpliste de la gestion de projet et nous verrons dans la suite comment exploiter les branches locales et comment partager votre travail avec d'autres contributeurs en publiant vos modifications sur un dépôt distant et en récupérant les modifications des autres contributeurs.
 
[[en:Git/Introduction]]
Récupérée de « https://fr.wikibooks.org/wiki/Git/Premiers_pas »