mercurialCommencer avec mercurial


Remarques

Mercurial est un système de contrôle de version distribué, open source moderne. Vous avez peut-être entendu parler de git, qui est un peu plus populaire aujourd'hui; git et mercurial sont très comparables et offrent surtout des fonctionnalités similaires.

Les développeurs utilisent Mercurial pour suivre les modifications apportées au code source de leurs applications. Il peut être utilisé pour suivre les modifications apportées à un répertoire de fichiers, même si, comme la plupart des systèmes de contrôle de source, il fait mieux lorsque ces fichiers sont des fichiers texte (par opposition à des fichiers binaires). Mercurial permet également à plusieurs développeurs de travailler simultanément sur le même répertoire du code source et gère le processus de suivi des modifications de chaque développeur, puis de fusion de ces modifications.

Versions

Mercurial suit un plan de publication basé sur le temps et publie une version majeure tous les trois mois, en février, mai, août et novembre. Une version mineure est publiée chaque mois restant. Notez que Mercurial n'utilise pas de version sémantique, donc il n'y a pas de différence significative entre 2.9.2 (la dernière des 2.9 versions) et 3.0.

La rétrocompatibilité est une exigence essentielle pour Mercurial. Il est donc généralement simple de mettre à niveau vos installations Mercurial au besoin. C'est une bonne idée cependant de le faire au moins une fois tous les trois mois, car certaines fonctionnalités peuvent rendre les anciens clients incapables de fonctionner sur les nouveaux référentiels.

Les notes de mise à jour des projets détaillent ce qui change entre les versions, tandis que les notes de mise à niveau offrent des indications claires sur ce que les utilisateurs doivent savoir lors de la mise à niveau.

Une sélection de versions remarquables:

Version Remarques Rendez-vous amoureux
3.5 Supprime la prise en charge de Python 2.4 et 2.5 2015-07-31
2.1 Introduit des "phases" de modifications pour permettre la modification de l'historique sécurisé 2012-02-01
1,9 Introduit une API de serveur de commandes pour une meilleure intégration des applications 2011-07-01
1,7 Un nouveau format de référentiel prend en charge les noms de fichiers peu courants 2010-11-01

Ramification

Lorsque nous commençons notre travail, nous devons décider s'il s'agit d'un domaine de travail distinct sur lequel nous travaillons ou si cela fait partie d'un secteur de travail existant. S'il existe, nous pouvons travailler à partir de cette branche. Si c'est nouveau, nous allons créer une nouvelle branche.

Notre workflow est alors:

  • hg branch MyNewFeature
  • travail Travail travail
  • hg commit -m "committing my changes"
  • travail Travail travail
  • hg commit -m "more changes"

À ce stade, nous voulons pousser notre travail vers le serveur distant. Mais avant de pousser les modifications (ignorez cela si c'est une nouvelle branche que vous n'avez pas encore poussée), nous devons vérifier s'il y a des modifications entrantes dans cette branche. Nous pouvons vérifier cela avec:

hg incoming -b .
 

S'il y a des changesets entrants sur notre branche, nous devons effectuer un tirage et rebaser nos modifications en haut de la liste des modifications.

hg pull -b . --rebase
 

Une fois que cela est fait ou s'il n'y a pas de changesets entrants, nous pouvons continuer avec le Push.

Nous ne voulons que pousser notre travail actuel, pas tout ce que nous avons fait. Je ne pousse jamais vraiment mon référentiel entier, mais mon travail actuel. Le raisonnement est que pousser l'ensemble du référentiel suppose que j'intègre plusieurs lignes de travail. Mais je veux seulement intégrer mon travail actuel, et je veux seulement travailler sur une seule ligne à la fois.

Si c'est la première fois que je pousse cette branche:

hg push -b . --new-branch
 

Si j'ai déjà poussé cette branche:

hg push -b .
 

La commande «-b.» Signifie simplement pousser la branche en cours, et rien d'autre.

Pour changer entre les branches de travail :

hg update myBranchName
 

Commencer

Voir aussi le tutoriel Mercurial

Créer un référentiel Mercurial

Un référentiel Mercurial est simplement un répertoire (appelé "répertoire de travail") contenant un répertoire .hg avec des métadonnées sur le contenu du référentiel. Cela rend Mercurial très léger et facile à utiliser. Pour créer un nouveau référentiel, lancez simplement:

$ hg init project
 

project est le nom du répertoire que vous souhaitez créer. Cela crée un répertoire de project avec un répertoire project/.hg contenant le référentiel lui-même.

   $ cd project
   $ echo Hello World > hello.txt
   $ hg stat
   ? hello.txt
 

Nous venons de créer un fichier hello.txt dans le référentiel et avons lancé hg status (ou stat for short) pour voir l'état actuel de notre référentiel. Comme vous pouvez le voir, hello.txt est annoté par un ? , ce qui signifie que Mercurial n'en est pas encore conscient. La commande add enregistre ce nouveau fichier avec Mercurial pour qu’il soit inclus dans le prochain commit.

$ hg add hello.txt
 

Maintenant que Mercurial a connaissance d'un fichier modifié, vous pouvez exécuter diff pour voir exactement ce qui a changé depuis le dernier commit - dans ce cas, nous ajoutons le contenu complet de hello.txt :

$ hg diff
diff -r 000000000000 hello.txt
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/hello.txt Sat Jul 23 01:38:44 2016 -0400
@@ -0,0 +1,1 @@
+Hello
 

Et une fois que nous sommes heureux avec eux et prêts à vérifier nos changements, nous pouvons exécuter commit :

$ hg commit -m "Created a hello world file."
 

Notez que nous avons inclus un message de validation avec -m - si vous ne spécifiez pas -m Mercurial lancera un éditeur de texte dans lequel vous pourrez entrer un message de validation. Ceci est utile si vous souhaitez fournir un message multiligne plus long.

Une fois que vous avez validé vos modifications, elles n'apparaissent plus si vous exécutez hg stat car le référentiel est maintenant synchronisé avec le contenu du répertoire de travail. Vous pouvez exécuter le log pour afficher une liste de validations, et -v inclut des détails supplémentaires, tels que les fichiers touchés par chaque validation:

$ hg log -v
changeset:   0:b4c06cc77a42
tag:         tip
user:        Michael Diamond@Aodh <dimo414@gmail.com>
date:        Sat Jul 23 01:44:23 2016 -0400
files:       hello.txt
description:
Created a hello world file.
 

Installation et configuration

Vous pouvez télécharger Mercurial à partir du site Web du projet, et il existe des utilitaires graphiques pour Windows, Linux et OSX si vous préférez une interface de ligne de commande. La plupart des gestionnaires de paquets Unix incluent Mercurial, par exemple sur Debian / Ubuntu:

$ apt-get install mercurial
 

Vous pouvez vérifier que Mercurial est installé en exécutant:

$ hg --version
 

Installer

Mercurial fonctionne parfaitement, mais vous voudrez probablement configurer Mercurial pour savoir qui vous êtes avant d'aller plus loin. Pour associer un nom d'utilisateur à vos commits, éditez ~/.hgrc (ou mercurial.ini dans votre répertoire personnel sous Windows) et ajoutez les lignes suivantes:

[ui]
username = Your Name <your@email.address>
 

Si vous ne voulez pas faire cela, vous pouvez toujours spécifier un nom d'utilisateur lorsque vous validez avec l'indicateur -u , par exemple:

$ hg commit -u "Your Name <your@email.address>"
 

Pousser et tirer

Mercurial facilite le partage de votre travail et la contribution des autres développeurs. Cela implique trois étapes clés; cloner , tirer et pousser .

Cloner

Pour copier un référentiel distant sur votre disque local, vous le "clonez". Pour ce faire, transmettez simplement l'URL distante à partir de laquelle vous souhaitez cloner. Pour cloner le code source Mercurial, lancez simplement:

$ hg clone https://selenic.com/hg
 

Cela crée un répertoire hg local contenant une copie du référentiel Mercurial que vous pouvez créer, modifier et valider (bien que vous ne puissiez pas publier vos commits dans le référentiel parent).

tirer

Une fois que vous avez extrait un référentiel, vous souhaitez le garder synchronisé au fur et à mesure que les autres utilisateurs le modifient. Vous pouvez supprimer de nouvelles modifications en exécutant simplement:

$ hg pull
 

Cela amène de nouveaux commits mais ne met pas à jour votre répertoire de travail, vous ne verrez donc pas les modifications immédiatement. Pour mettre à jour le contenu du répertoire de travail, exécutez:

$ hg up
 

Qui met à jour votre répertoire de travail vers la révision de pointe (la plus récente) dans le référentiel.

Vous pouvez également exécuter:

$ hg pull -u
 

Pour extraire de nouvelles modifications et mettre à jour le répertoire de travail en une seule étape.

Pousser

En supposant que vous ayez un accès en écriture au référentiel distant, vous pouvez publier tous les commits que vous avez effectués localement sur le référentiel distant tout aussi facilement avec:

$ hg push
 

Cela télécharge vos modifications tant qu'il n'y a pas eu d'autres commits depuis la dernière fois que vous avez tiré. Si votre push est rejetée parce qu'elle serait « créer des têtes supplémentaires » qui signifie que vous devez tirer dans ces nouveaux changements et les fusionner avec votre propre.

$ hg pull
$ hg merge  # this creates a new changeset merging your changes with the remote changes
$ hg commit -m "Merged in remote changes"
$ hg push
 

La plupart du temps, c'est tout ce que vous devez faire puisque Mercurial gère la fusion de vos modifications automatiquement, mais vous devrez parfois résoudre manuellement les conflits de fusion (voir la rubrique concernant la fusion). Si vous en avez besoin, vous pouvez toujours annuler une fusion et revenir à un répertoire de travail propre avec:

$ hg up -c
 

Mais rappelez-vous que c'est une opération destructrice; tout changement dans le répertoire de travail sera effacé.