*Note* : on peut éviter de faire `git add` et faire uniquement `git commit -a` si l'on est sûr qu'aucun autre fichier n'a été modifié (mais c'est une mauvaise habitude que l'on déconseille).
Voir l'état du dépôt local (fichiers non commités, etc.) :
~~~{.bash}
$ git status
~~~
Voir les derniers commits du dépôt local :
~~~{.bash}
$ git log
~~~
### pull/pusher avec un dépôt distant
Si l'on a cloné un dépôt existant, un lien est automatiquement créé entre le dépôt local créé et le dépôt distant (référencé comme *origin*).
Pour récupérer en local les derniers changements du dépôt distant :
~~~{.bash}
$ git pull --rebase origin
~~~
*Note* : l'option `--rebase` est désormais le défaut mais par pédagogie on conseille de la mettre explicitement.
Pour envoyer ses modifications locales vers le dépôt référencé comme distant :
~~~{.bash}
$ git push origin
~~~
### Gestion des branches
Par défaut, certains outils utilisent une branche nommée *master*.
Cette branche existe donc souvent au sein d'un dépôt, mais il faut
garder en tête que c'est une convention, rien n'oblige en avoir une.
Lister les branches existantes et connaître sa branche courante :
~~~{.bash}
$ git branch -a
~~~
Créer une branche *myfeature* à partir de la branche *master* :
Voir les modifications locales non commitées et non stagées :
~~~{.bash}
$ git diff
~~~
Voir les modifications locales *stagées* (avec *git add*) :
~~~{.bash}
$ git diff --staged
~~~
Voir les modifications entre deux commits, ou entre deux branches :
~~~{.bash}
$ git diff HEAD~8..HEAD^^
$ git diff myfeature..master
~~~
### git fetch/pull
`git pull` est une commande qui effectue un rappatriement des données (`git fetch`) puis l'intégration de ces données via `git rebase` (par défaut) ou `git merge`.
Dans certains cas il est pratique de faire un simple `git fetch`, notamment si l'on veut faire des manipulations complexes ou si l'on veut avoir toutes les données pour travailler hors ligne sans rien changer à l'état actuel de sa *working copy*.
### git push
Pour pousser toutes ses branches d'un coup (déconseillé) :
~~~{.bash}
$ git-push --all origin
~~~
Si l'on a une branche local nommée *foo* et que l'on veut la pousser dans la branche *bar* du dépôt distant :
~~~{.bash}
$ git push origin foo:bar
~~~
/!\\ Attention, il ne faut jamais modifier un historique qui a été pushé vers un dépôt partagé. Néanmoins dans certaines situations exceptionnelles (un mot de passe ou un email qui aurait été mis par erreur) on peut être amené à faire un `push --force` :
~~~{.bash}
$ git push -f origin
~~~
Il faudra ensuite que chaque utilisateur fasse confiance (ou vérifie) les modifications d'historiques puis acceptent d'écraser leur dépôt local :
~~~{.bash}
$ git fetch
$ git reset origin
~~~
### git branch
Pour créer une branche et switcher directement dans cette nouvelle branche, on utilise l'option `-b` :
~~~{.bash}
$ git branch -b myfeature master
~~~
Une branche est en fait la création une déviation, un commit qui a deux *enfants*.
On peut ainsi créer une branche à partir de n'importe quel commit :
Pour supprimer la branche *foo* sur un dépôt distant non cloné :
~~~{.bash}
$ git push ssh://git.example.com/projet.git :foo
~~~
Pour récupérer une nouvelle branche depuis le dépôt référencé comme distant :
~~~{.bash}
$ git remote update
~~~
### git clean/reset
/!\\ Certaines commandes peuvent provoquer une perte de données !
Pour supprimer toutes les modifications non commitées et les fichiers/répertoires non trackés :
~~~{.bash}
$ git reset --hard
$ git clean -f -d
~~~
On peut aussi `git reset` sur des commits précédents (*HEAD^*,*HEAD~N*,*<SHA1>*).
Ou même sur une branche distante comme *origin/master* par exemple (pratique si l'historique de la branche distante a été modifié).
### git add
Pour ajouter tout un répertoire et son contenu :
~~~{.bash}
$ git add foo/
~~~
Pour choisir ce que l'on veut ajouter pour le prochain commit :
~~~{.bash}
$ git add -p
~~~
### git merge
Un merge consiste à créer un commit qui aura deux parents, et permet ainsi de fusionner deux branches existantes.
Quand un merge est très simple, c'est à dire que cela rajoute simplement des commits sur une branche qui n'a pas bougé entre temps, on n'a même pas besoin de créer un commit pour fusionner, on appelle cela un merge **fast-forward**. Cela se fait automatiquement avec la commande `git merge`. Notons que l'on peut vouloir tout de même avoir un commit pour marquer le coup, et forcer un commit de merge avec l'option `git merge --no-ff`.
Quand un merge n'est pas simple, Git peut adopter plusieurs stratégies (resolve, recursive, ours, theirs, patience, etc.). Il est probable que cela génère des conflits qui devront être résolus manuellement.
### git apply
`git apply` permet d'appliquer un diff.
On peut utiliser une option pour exclure l'application de certain fichier du diff :
On peut gérer des hooks à différents moments (pre-commit, post-commit, pre-push, post-push, etc.),
par exemple pour générer des emails de notification.
Voir dans le répertoire `.git/hooks/`.
### dépôt "bare"
Un dépôt classique possède un répertoire `.git/` qui contient toutes les données et meta-données, ainsi qu'une *working copy* de la branche courante.
Quand on crée un dépôt ayant vocation à servir de dépôt central, il est préférable de ne pas avoir de *working copy* : il s'agira alors d'un **bare repository** que l'on peut initier avec la commande :
La plomberie de Git consiste à réaliser des commandes bas niveau
manipulant tout ce qui se trouve dans le répertoire `.git/` d'un dépôt.
Les données brutes sont dans le répertoires `.git/objects/` qui contient
de nombreux fichiers : à chaque commit correspond fichier nommé en fonction
de l'empreinte SHA1 du commit et contenant les données compressées.
Les données comprennent notamment la référence au(x) commit(s) *parent*
ce qui permet de d'avoir des liens entre les commits.
Observons `.git/refs/` qui contient des pseudos-pointeurs (fichier contenant un SHA1 ou une autre référence) :
- un tag est simplement un pointeur vers un commit ;
- une branche est également un pointeur vers un commit, la différence est qu'il se déplace à chaque nouveau commit dans la branche ;
Directement dans `.git/` on a également *HEAD* (et *FETCH_HEAD*, *ORIG_HEAD*) qui sont aussi des pseudo-pointeurs, qui changent notamment quand on change de branche ou pendant un *rebase*.
Si l'on veut mettre à jour ces pseudo-pointeurs, il faut utiliser `git update-ref`.
Observons `.git/logs/` qui contient l'historique de ce qui a été fait dans le dépôt.
Cet historique est notamment accessible avec la commande `git reflog`.
