1er commit

De la docs au format Mkdocs
This commit is contained in:
2018-09-16 14:48:15 +02:00
commit e82296ba06
140 changed files with 17082 additions and 0 deletions

View File

@@ -0,0 +1,249 @@
# Session de travail avec GIT
I. On développe dans la branche **master**.
=> <u>HEAD pointe sur la branche **master**</u>
Penser à valider la copie de travail avant de changer de branche.
```bash
$ git commit -a -m 'validation'
```
II. On bascule dans la branche prob53 que l'on crée en même temps.
```bash
$ git checkout -b prob53
Switched to a new branch "prob53"
```
=> <u>HEAD pointe sur la branche **prob53**</u>
III. On réalise une modification ...
```bash
$ vim index.html
$ git commit -a -m 'ajout d'un pied de page [problème 53]'
```
… avant de retourner dans la branche **master**:
```bash
$ git checkout master
Switched to branch "master"
```
=> <u>HEAD pointe sur la branche **master**</u>
IV. On a un correctif à réaliser. On crée donc une nouvelle branche **correctif**:
```bash
$ git checkout -b 'correctif'
Switched to a new branch "correctif"
```
On réalise le correctif:
```bash
$ vim index.html
$ git commit -a -m "correction d'une adresse mail incorrecte"
[correctif]: created 3a0874c: "correction d'une adresse mail incorrecte"
1 files changed, 0 insertions(+), 1 deletions(-)
```
=> <u>HEAD pointe sur la branche **correctif**</u>
V. On réalise des tests sur le projet pour s'assurer que la correction est efficace.
Si tout est ok, il est temps de la fusionner dans la branche **master** pour la déployer en production:
```bash
$ git checkout master
$ git merge correctif
Updating f42c576..3a0874c
Fast forward
LISEZMOI | 1 -
1 files changed, 0 insertions(+), 1 deletions(-)
```
=> <u>HEAD pointe sur la branche **master**</u>
*Git a réalisé un Fast forward*
VI. **master** et **correctif** pointent sur le même commit, on peut supprimer la branche **correctif**:
```bash
$ git branch -d correctif
Deleted branch correctif (3a0874c).
```
VII. On rebascule sur la branche **prob53** pour continuer à travailler sur le problème:
```bash
$ git checkout prob53
Switched to branch "prob53"
$ vim index.html
$ git commit -a -m 'Nouveau pied de page terminé [problème 53]'
[prob53]: created ad82d7a: "Nouveau pied de page terminé [problème 53]"
1 files changed, 1 insertions(+), 0 deletions(-)
```
=> <u>HEAD pointe sur la branche prob53</u>
*Les travaux réalisés dans correctif ne sont pas contenu dans les fichiers de la branche **prob53**.*
Si vous avez besoin de les y rapatrier, vous pouvez fusionner la branche master dans la branche **prob53** en lançant la commande `git merge master`.
VIII. ... suite du développement ...
IX. Les travaux sur la branche **prob53** sont terminés et prêt à être fusionnés avec **master**:
```bash
$ git checkout master
$ git merge prob53
Merge made by recursive.
README | 1 +
1 files changed, 1 insertions(+), 0 deletions(-)
```
=> HEAD pointe sur la branche **master**
*Git a réalisé une simple fusion à trois sources et créer un <u>commit de fusion</u>.*
X. Le travail a été fusionné, on n'a plus besoin de la branche **prob53**. On peut l'effacer et <u>fermer manuellement le ticket</u> dans l'outil de suivi de faits techniques:
```bash
$ git branch -d prob53
```
### APPENDIX:
#### Conflits:
Si on modifie différemment la même partie du même fichier dans les deux branches que l'on souhaite fusionner, Git ne sera pas capable de réaliser proprement la fusion.
```bash
$ git merge prob53
Auto-merging index.html
CONFLICT (content): Merge conflict in index.html
Automatic merge failed; fix conflicts and then commit the result.
```
Git n'a pas automatiquement créé le *commit* du fusion.
Il a arrêté le processus le temps que vous résolviez le conflit. Lancez `git status` pour voir à tout moment après l'apparition du conflit de fusion quels fichiers n'ont pas été fusionnés :
```bash
[master*]$ git status
index.html: needs merge
# On branch master
# Changes not staged for commit:
# (use "git add <file>..." to update what will be committed)
# (use "git checkout -- <file>..." to discard changes in working directory)
#
# unmerged: index.html
#
```
Tout ce qui comporte des conflits de fusion et n'a pas été résolu est listé comme `unmerged`.
Git ajoute des marques de conflit standard dans les fichiers qui comportent des conflits:
```html
<<<<<<< HEAD:index.html
<div id="footer">contact : email.support@github.com</div>
=======
<div id="footer">
please contact us at support@github.com
</div>
>>>>>>> prob53:index.html
```
Au-dessus de la ligne ======= : version dans HEAD (master)
Au-dessous de la ligne ======= : version dans prob53
```html
<div id="footer">
please contact us at email.support@github.com
</div>
```
… résout le conflit.
Après avoir résolu chacune de ces sections dans chaque fichier comportant un conflit, lancez `git add` sur chaque fichier pour le marquer comme résolu.
Si vous souhaitez utiliser un outil graphique pour résoudre ces problèmes, vous pouvez lancer `git mergetool` qui démarre l'outil graphique de fusion approprié et vous permet de naviguer dans les conflits :
```bash
$ git mergetool
This message is displayed because 'merge.tool' is not configured.
See 'git mergetool --tool-help' or 'git help config' for more details.
'git mergetool' will now attempt to use one of the following tools:
opendiff kdiff3 tkdiff xxdiff meld tortoisemerge gvimdiff diffuse diffmerge ecmerge p4merge araxis bc3 codecompare vimdiff emerge
Merging:
index.html
Normal merge conflict for 'index.html':
{local}: modified file
{remote}: modified file
Hit return to start merge resolution tool (opendiff):
```
Après avoir quitté l'outil de fusion, Git vous demande si la fusion a été réussie. Si vous répondez par la positive à l'outil, il indexe le fichier pour le marquer comme résolu.
Vous pouvez lancer à nouveau la commande `git status` pour vérifier que tous les conflits ont été résolus :
```bash
$ git status
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# modified: index.html
#
```
Si cela vous convient et que vous avez vérifié que tout ce qui comportait un conflit a été indexé, vous pouvez taper la commande `git commit` pour finaliser le *commit* de fusion.
```bash
Merge branch 'prob53'
Conflicts:
index.html
#
# It looks like you may be committing a MERGE.
# If this is not correct, please remove the file
# .git/MERGE_HEAD
# and try again.
#
```

377
docs/Divers/git/git.md Normal file
View File

@@ -0,0 +1,377 @@
# git
### Créer un repo git
Sur le serveur (DS916), aller dans le dossier Repo:
```bash
dsm916> cd /volume1/Repositories/
dsm916> git init -bare wp2012.git
```
Sur le client (Mac), se mettre dans le dossier source:
```bash
bruno@macbook-pro:~/ git init
bruno@macbook-pro:~/ git remote -v
bruno@macbook-pro:~/ git remote add origin ssh:dsm916/volume1/Repositories/wp2012.git
bruno@macbook-pro:~/ git remote add origin bruno@dsm916:/volume1/Repositories/wp2012.git
bruno@macbook-pro:~/ git add *
bruno@macbook-pro:~/ git commit -m "Created my repo"
bruno@macbook-pro:~/ git push -all origin
```
ssh:dsm916/volume1/Repositories/shell_scripts.git
### Démarrage:
Les fichiers peuvent avoir 3 états:
1. <u>Validé</u> signifie que les données sont stockées en sécurité dans votre base de données locale.
2. <u>Modifié</u> signifie que vous avez modifié le fichier mais qu'il n'a pas encore été validé en base.
3. <u>Indexé</u> signifie que vous avez marqué un fichier modifié dans sa version actuelle pour qu'il fasse partie du prochain instantané du projet.
Ce qui induit les 3 sections d'un projey git:
1. Le <u>répertoire Git</u> est l'endroit où Git stocke les méta-données et la base de données des objets de votre projet. C'est la partie la plus importante de Git, et c'est ce qui est copié lorsque vous clonez un dépôt depuis un autre ordinateur.
2. Le <u>répertoire de travail</u> (working copy) est une extraction unique d'une version du projet. Ces fichiers sont extraits depuis la base de données compressée dans le répertoire Git et placés sur le disque pour pouvoir être utilisés ou modifiés.
3. La <u>zone d'index</u> est un simple fichier, généralement situé dans le répertoire Git, qui stocke les informations concernant ce qui fera partie du prochain instantané.
#### Fichier de config:
Pour l'utilisateur: `~/.gitconfig`
#### Configurer git:
```bash
$ git config --global user.name "Bruno 21"
# --global Pour l'utilisateur (~/.gitconfig)
# paramètres: user.email, core.editor, merge.tool
$ git config --list
credential.helper=osxkeychain
user.name=Bruno 21
user.email=bruno@clicclac.info
filter.lfs.clean=git-lfs clean -- %f
filter.lfs.smudge=git-lfs smudge -- %f
filter.lfs.process=git-lfs filter-process
filter.lfs.required=true
```
#### Aide git:
```bash
$ git help <verbe>
$ git <verbe> --help
$ man git-<verbe>
$ git help config
```
### Démarrer un dépôt Git:
#### [Initialisation d'un dépôt Git dans un répertoire existant](https://git-scm.com/book/fr/v1/Les-bases-de-Git-D%C3%A9marrer-un-d%C3%A9p%C3%B4t-Git#Initialisation-d'un-d%C3%A9p%C3%B4t-Git-dans-un-r%C3%A9pertoire-existant)
Se placer dans le répertoire:
```bash
$ git init
```
Ajouter les fichiers à suivre:
```bash
$ git add *.php
```
Valider:
```bash
$ git commit m 'version initiale du projet'
```
#### [Cloner un dépôt existant:](https://git-scm.com/book/fr/v1/Les-bases-de-Git-D%C3%A9marrer-un-d%C3%A9p%C3%B4t-Git#Cloner-un-d%C3%A9p%C3%B4t-existant)
```bash
$ git clone git://github.com/depot/projet.git
```
Crée un répertoire <u>grit</u> contenant les données du dépôt ainsi qu'un répertoire .git
```bash
$ git clone git://github.com/depot/projet.git mondossier
```
Crée un clone du depot dans le dossier mondossier
### Enregistrer des modifications dans le dépôt:
#### [Vérifier l'état des fichiers](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Enregistrer-des-modifications-dans-le-d%C3%A9p%C3%B4t#V%C3%A9rifier-l'%C3%A9tat-des-fichiers)
```bash
$ git status
On branch master
Your branch is ahead of 'origin/master' by 1 commit.
(use "git push" to publish your local commits)
nothing to commit, working tree clean
```
1 commit en attente de push.
#### [Placer de nouveaux fichiers sous suivi de version](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Enregistrer-des-modifications-dans-le-d%C3%A9p%C3%B4t#Placer-de-nouveaux-fichiers-sous-suivi-de-version)
```bash
$ git add LISEZMOI
```
#### [Ignorer des fichiers](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Enregistrer-des-modifications-dans-le-d%C3%A9p%C3%B4t#Ignorer-des-fichiers)
Les fichiers ajoutés à <u>.gitignore</u> ne seront pas sous suivi de version.
```bash
$ cat .gitignore
.DS_STore
```
#### [Inspecter les modifications indexées et non indexées](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Enregistrer-des-modifications-dans-le-d%C3%A9p%C3%B4t#Inspecter-les-modifications-index%C3%A9es-et-non-index%C3%A9es)
Pour visualiser ce qui a été modifié mais pas encore indexé, tapez:
```bash
$ git diff
```
#### [Valider vos modifications](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Enregistrer-des-modifications-dans-le-d%C3%A9p%C3%B4t#Valider-vos-modifications)
```bash
$ git commit
```
Ouvre l'éditeur de texte pour renseigner le message de validation.
```bash
$ git commit -m "Correction d'un bug"
```
Le message est dans la commande.
```bash
$ git commit -a -m "Correction d'un bug"
```
Ordonne à Git de placer automatiquement tout fichier déjà en suivi de version dans la zone d'index avant de réaliser la validation, évitant ainsi d'avoir à taper les commandes `git add`
#### [Effacer des fichiers](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Enregistrer-des-modifications-dans-le-d%C3%A9p%C3%B4t#Effacer-des-fichiers)
```bash
$ git rm LISEZMOI
```
#### [Déplacer des fichiers](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Enregistrer-des-modifications-dans-le-d%C3%A9p%C3%B4t#D%C3%A9placer-des-fichiers)
```bash
$ git mv nom_origine nom_cible
```
### Visualiser l'historique des validations:
```bash
$ git log
# -p montre les différences entre chaque validation
# -2 les deux entrées les plus récentes
$ git log --pretty=format:"%h - %an, %ar : %s"
```
### Annuler des actions:
#### [Modifier le dernier *commit*](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Annuler-des-actions#Modifier-le-dernier-commit)
```bash
$ git commit -m 'validation initiale'
$ git add fichier_oublie
$ git commit --amend
```
#### [Désindexer un fichier déjà indexé](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Annuler-des-actions#D%C3%A9sindexer-un-fichier-d%C3%A9j%C3%A0-index%C3%A9)
```bash
$ git reset HEAD benchmarks.rb
$ git status
```
#### [Réinitialiser un fichier modifié](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Annuler-des-actions#R%C3%A9initialiser-un-fichier-modifi%C3%A9)
Ramener le fichier à son état du dernier instantané (ou lors du clonage, ou dans l'état dans lequel vous l'avez obtenu dans votre copie de travail)
```bash
$ git checkout -- benchmarks.rb
$ git status
```
### Dépot distants:
#### [Afficher les dépôts distants](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Travailler-avec-des-d%C3%A9p%C3%B4ts-distants#Afficher-les-d%C3%A9p%C3%B4ts-distants)
```bash
$ git remote -v
```
#### [Récupérer et tirer depuis des dépôts distants](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Travailler-avec-des-d%C3%A9p%C3%B4ts-distants#R%C3%A9cup%C3%A9rer-et-tirer-depuis-des-d%C3%A9p%C3%B4ts-distants)
```bash
$ git fetch [nom-distant]
```
#### [Pousser son travail sur un dépôt distant](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Travailler-avec-des-d%C3%A9p%C3%B4ts-distants#Pousser-son-travail-sur-un-d%C3%A9p%C3%B4t-distant)
```bash
$ git push origin master
```
#### [Inspecter un dépôt distant](https://git-scm.com/book/fr/v1/Les-bases-de-Git-Travailler-avec-des-d%C3%A9p%C3%B4ts-distants#Inspecter-un-d%C3%A9p%C3%B4t-distant)
```bash
$ git remote show origin
```
### Etiquettes:
#### Lister les étiquettes
```bash
$ git tag
$ git tag -l 'v1.4.2.*'
```
#### Créer des étiquettes annotées
```bash
$ git tag -a v1.4 -m 'my version 1.4'
# -a étiquette
# -m message d'étiquetage
```
../..
### Branches:
https://git-scm.com/book/fr/v1/Les-branches-avec-Git-Ce-qu-est-une-branche
#### Gérer les branches
```bash
$ git branch # Permet de lister les branches
$ git branch -v # Visualiser les dernières validations sur chaque branche
$ git branch <branche> # Permet de créer une nouvelle branche <branche>
$ git branch -m <branche> # Renomme la branche courante en <branche>
$ git branch -d <branche> # Permet de supprimer une branche
$ git branch -D <branche> # Supprime la branche même si elle n'a pas été fusionnée
$ git branch --merged # Quelles branches ont déjà été fusionnées dans votre branche actuelle ?
$ git branch --no-merged # Branches qui contiennent des travaux qui n'ont pas encore été fusionnés
```
**master** est la branche par défaut.
**HEAD** est un pointeur qui indique la branche courante.
`$ git branch <branche>` crée une nouvelle branche mais ne fait pas basculer la <u>copie de travail</u> vers celle-ci.
#### Passer d'une branche à l'autre
```bash
$ git checkout <branche>
$ git checkout -b <branche> # sauter sur une branche qui n'existe pas en la créant au préalable
```
Le pointeur **HEAD** pointe désormais sur <branche>
La <u>copie de travail</u> a basculée sur la nouvelle branche:
- la nouvelle branche pointera sur les nouveaux commit
- la branche **master** pointera sur le dernier commit au moment du checkout.
#### Fusionner les branches
Merge permet de ramener une branche sur une autre et ainsi de la fusionner. La fusion de 2 branche se fait toujours à partir de la branche principale.
- La branche "source" sera affectée en récupérant l'historique de la branche ou un commit de fusion
- La branche fusionnée ne sera pas affectée
```bash
$ git merge <branche>
```
https://git-scm.com/book/fr/v1/Les-branches-avec-Git-Brancher-et-fusionner%C2%A0%3A-les-bases
#### Les branches distantes
#### Rebaser
#### => [Session de travail avec git](git-session.md) <=
http://www.ntu.edu.sg/home/ehchua/programming/howto/Git_HowTo.html

8
docs/Divers/git/index.md Normal file
View File

@@ -0,0 +1,8 @@
# Divers
[git](git.md)
[Session de travail avec git](git-session.md)