Plusieurs méthodes d'accès pour récupérer un dépôt : HTTP(S), Git, file.
~~~{.bash}
$ git clone https://git.example.com/path/projet
$ git clone git://git.example.com/path/projet.git
$ git clone file:///path/projet
~~~
### Travailler sur un dépôt local
Ajouter un nouveau fichier :
~~~{.bash}
$ touch main.c
$ git add main.c
$ git commit -v
~~~
Modification d'un fichier existant :
~~~{.bash}
$ vi main.c
$ git add main.c
$ git commit -v
~~~
*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* :
~~~{.bash}
$ git checkout -b myfeature master
~~~
Pour passer d'une branche à une autre dans son dépôt local :
~~~{.bash}
$ git checkout myfeature
$ git checkout master
~~~
Travailler sur la branche *myfeature* puis merger son travail dans *master* :
~~~{.bash}
$ git checkout master
$ git merge --no-ff myfeature
~~~
Pousser une branche locale vers le dépôt référencé comme distant :
~~~{.bash}
$ git push origin myfeature
~~~
Supprimer une branche locale et distante :
~~~{.bash}
$ git branch -d myfeature
$ git push origin :myfeature
~~~
## Commandes avancées
### Modifier l'historique
/!\\ Les modifications de l'historique ne doivent avoir lieu que si il n'a pas déjà été pushé vers un dépôt partagé !
Modifier son dernier message de commit :
~~~{.bash}
$ git commit --amend
~~~
Modifier son dernier commit :
~~~{.bash}
$ vi main.c
$ git add main.c
$ git commit --amend
~~~
Modifier son avant-dernier commit :
~~~{.bash}
$ git rebase -i HEAD^^
… remplacer "pick" par "edit" pour le commit à modifier
$ vi main.c
$ git add main.c
$ git commit --amend
$ git rebase --continue
~~~
*Note* : On peut remonter au Nième commit en utilisant *HEAD~N*
### Piquer un commit dans une autre branche
~~~{.bash}
$ git cherry-pick <SHA1ducommit>
~~~
### gitignore
Créer un fichier `.gitignore` à la racine pour ignorer certains fichiers/chemins :
~~~
$ cat .gitignore
test.php
htdocs/foo/bar
toto/titi*
~~~
*Note* : le fichier .gitignore se commit dans le dépôt
### Ranger temporairement son travail (git stash)
Cela permet d'avoir un buffer pour mettre "en pause" des modifications non commitées :
~~~{.bash}
…hack…hack…
$ git stash save
~~~
On peut lister ce buffer :
~~~{.bash}
$ git stash list
stash@{0}: WIP on dev: fb1fa70… m
stash@{1}: WIP on dev: fb1fa70… m
~~~
Et ré-appliquer les modifications stockées :
~~~{.bash}
$ git stash apply stash@{0}
~~~
Pour purger le buffer sans l'appliquer :
~~~{.bash}
$ git stash clear
~~~
### Echanger des commits sous forme de patchs Git
Pour transmettre ses 3 derniers commits, on peut générer 3 patches qui contiendront les diffs ainsi que les messages de commit :
~~~{.bash}
$ git format-patch -3
~~~
Si l'on a ces 3 patches, on peut les appliquer sur son dépôt local ainsi :
~~~{.bash}
$ git am 000*.patch
~~~
## Workflow de travail
Il existe plusieurs workflows possibles en travaillant avec Git.