WikiTeki /  Git / Développeur

Page présentant les manipulations à faire dans une perspective de développeur.

Remplacer « projet » par le nom de votre projet.

Instructions suivantes fonctionnent avec Ubuntu 8.04 (Hardy Heron) et Git 1.5.4.3.

Préalables

Fournir sa clé SSH à l'un des administrateurs de git.auf.org (MoussaNombré, JeanChristopheAndré ou ThomasNoël).

Installer le paquet git-core.

Créer un nouveau projet

• Contacter un administrateur de git.auf.org pour config du nouveau projet.
• Projet public ou privé. [détailler]
• Créer son projet localement

• Configurer ce que git doit ignorer : .gitignore

• Créer un git local avec tous les fichiers du projet

  $ cd projet
  $ git init
  $ git add .

• Faire le premier commit local du projet

  $ git commit -a -m "Première version : mise en route du suivi."

• Créer la première version du projet sur le serveur

  $ git remote add origin gitosis@git.auf:projet.git
  $ git push origin master

• Supprimer (sauvegarder) la copie locale du projet (incluant le répertoire racine)
• Participer au développement du projet

Participer à un projet

• Importer localement la version du serveur une première fois

  $ git clone gitosis@git.auf:projet.git

  Note: on n'a pas besoin de créer le répertoire du projet. Il sera automatiquement créé. Cette commande doit donc être lancée dans le répertoire parent.

• Pour les fois suivantes, vérifier le statut des fichiers par rapport au dernier commit

  $ git status

• Éditer localement les fichiers
• Informer le git local de vos modifications (important car sinon git ignore certaines modifications telles que l'ajout de fichier)

  $ git add fichier

• ou encore

  $ git rm fichier

• (pour supprimer une arboresence, écrire le nom du répertoire à supprimer ainsi que -r [récursif]) mais aussi

  $ git add .

• cependant attention : cette dernière commande pourrait annuler des git rm fait auparavant (on peut éviter ce problème en faisant des git commit réguliers)

• Commiter localement les modifications faites

  $ git commit -a -m "Ma contribution du moment."

  Note: pour laisser un commentaire plus substantiel, omettre le paramètre -m... un éditeur texte sera lancé : la première ligne servira pour les logs, le reste pour le détail.

• Vérifier si vous avez bien la dernière version du serveur.

  $ git pull

  Si vous transmettez vos modifications au serveur mais que vous n'avez pas la dernière version à jour du serveur : votre version s'ajoute au serveur et votre git local vous invite à télécharger cette dernière version (et à régler les éventuels conflits)... Vaut mieux faire un « pull » avant, plutôt que de mettre une version sur le serveur sans être sûr que celle-ci inclut déjà la dernière modification.
• Transmettre au serveur vos modifications

  $ git push

Étiquetter une version

• Lorsque votre contribution correspond à une version stable, l'identifier en y apposant une étiquette avec le nom de la version. [détailler]
• Ajouter une étiquette

  $ git tag -a -m "Commentaire etiquette" nom_etiquette

• Lister toutes les étiquettes

  $ git tag -l 

• Supprimer une étiquette

  $ git tag -d nom_etiquette

  Les étiquettes sont locales et ne seront pas transmises au serveur lors d'un push à moins de le spécifier explicitement.

  $ git push --tags

  Note: ce push ne transmet pas les commit au serveur, seulement les tags.

Utiliser des branches

Les branches permettent d'expérimenter plusieurs voies.

• Créer une branche

  $ git branch experimental

  Note: le contenu initial de cette nouvelle branche est le dernier commit (HEAD) de la branche en cours.

• Lister les branches (celle en cours marquée par un astérisque)

  $ git branch
    experimental
  * master

  Note: créer une branche ne vous déplace pas dans celle-ci.

• Changer de branche

  $ git checkout experimental
  $ git branch
  * experimental
    master

• Fusionner des branches

  $ git merge master

  Note: fusionne la branche en cours (ici : experimental) avec celle passée en paramètre (ici : master).

Ignorer des fichiers ou des dossiers

http://www.kernel.org/pub/software/scm/git/docs/gitignore.html

On peut lister les fichiers à ignorer dans le fichier .gitignore (à la racine du projet). Ce fichier pourra éventuellement être suivi par git et être partagé par tous les développeurs. Par exemple, pour ignorer les fichiers .pyc et .pyo, on rajoute la ligne suivante dans le fichier .gitignore:

*.pyc
*.pyo

Pour ignorer les fichiers de façon locale (par exemple si votre éditeur de texte crée des fichiers tampons commençant par '~'), on rajoutera les règles d'exclusion plutôt dans le fichier .git/info/exclude

~*

Workflow

Pour les développements plus substantiels...

Développement

• Travailler localement dans la branche dev du projet (ou une autre branche, ex.: dev.user ou dev.fonctionnalite)

  $ git checkout dev
  $ git branch dev.auth
  $ git checkout dev.auth
  (edit, commit)
  $ git checkout dev
  $ git merge dev.auth

  • Vérifier : lors du clone du projet, seulement la branche master existe localement...

    $ git clone gitosis@git.auf:projet.git test
    $ git branch
    * master
    $ git branch -r
      origin/HEAD
      origin/dev
      origin/master

  • ... pour l'instant, créer les branches locales et puller le contenu distant

    $ git branch dev
    $ git checkout dev
    $ git pull origin dev

• Transmettre au serveur vos modifications dans la branche correspondante

  $ git push origin dev

  • Pour éviter de saisir destination :

    $ git config branch.dev.remote origin
    $ git config branch.dev.merge refs/heads/dev
    $ git push
    $ git pull

  • ... mais il semblerait que si la branche distante n'existe pas, il faille d'abord la créer avec :

    $ git push origin dev

• Lorsqu'une version est stable, l'étiqueter

  $ git tag -a v2.4 -m "Commentaire etiquette"

Test

• Promouvoir dans la branche test la dernière version de la branch dev

  $ git checkout test
  $ git merge dev

• Déployer dans l'environnement de test (admin système)
• si les test sont concluants, promouvoir dans la branche master

  $ git checkout master
  $ git merge test

Production

• Déployer dans l'environnement de production (admin système)