mercurialAan de slag met mercurial


Opmerkingen

Mercurial is een modern, open-source, gedistribueerd versiebeheersysteem. Je hebt misschien gehoord van git, dat tegenwoordig iets populairder is; git en Mercurial zijn zeer vergelijkbaar en bieden grotendeels vergelijkbare functionaliteit.

Ontwikkelaars gebruiken Mercurial om wijzigingen in de broncode van hun applicaties bij te houden. Het kan worden gebruikt om wijzigingen in elke map met bestanden bij te houden, hoewel het, zoals de meeste bronbesturingssystemen, het het beste doet wanneer deze bestanden tekstbestanden zijn (in tegenstelling tot binaire bestanden). Met Mercurial kunnen meerdere ontwikkelaars tegelijkertijd aan dezelfde map met broncode werken en beheert het het proces van het bijhouden van de wijzigingen van elke ontwikkelaar en het vervolgens samenvoegen van die wijzigingen.

versies

Mercurial volgt een tijdgebaseerd releaseplan en publiceert elke drie maanden een grote release, in februari, mei, augustus en november. Een resterende release wordt elke resterende maand gepubliceerd. Merk op dat Mercurial geen sematische versie gebruikt, daarom is er geen significant verschil tussen 2.9.2 (de laatste van de 2.9 releases) en 3.0.

Achterwaartse compatibiliteit is een cruciale vereiste voor Mercurial, daarom is het over het algemeen veilig om eenvoudig uw Mercurial-installaties te upgraden indien nodig. Het is echter een goed idee om dit ten minste om de drie maanden te doen, omdat sommige functies ervoor kunnen zorgen dat oude clients niet in nieuwere repositories kunnen werken.

De projecten geven toelichting vrij over wat er tussen de versies verandert, terwijl de upgrade-opmerkingen duidelijke aanwijzingen bieden over waar gebruikers op moeten letten bij het upgraden.

Een selectie van opmerkelijke versies:

Versie Notes Datum
3.5 Drops-ondersteuning voor Python 2.4 en 2.5 2015/07/31
2.1 Introduceert wijzigingenset "fasen" die aanpassing van de veilige geschiedenis mogelijk maken 2012-02-01
1.9 Introduceert een Command Server API ter ondersteuning van betere applicatie-integratie 2011-07-01
1.7 Nieuw repository-formaat ondersteunt ongewone bestandsnamen 2010-11-01

vertakking

Wanneer we voor het eerst met ons werk beginnen, moeten we beslissen of dit een apart werkgebied is waar we aan werken, of dat dit deel uitmaakt van een bestaande lijn van werk. Als het bestaat, kunnen we vanaf die tak werken. Als het nieuw is, beginnen we een nieuwe tak.

Onze workflow is dan:

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

Op dit punt willen we ons werk uitbreiden naar de externe server. Maar voordat we de wijzigingen pushen (negeer dit als het een nieuwe branch is die je nog niet eerder hebt gepusht), moeten we controleren of er een inkomende wijziging in deze branch is. We kunnen dit controleren met:

hg incoming -b .
 

Als er binnenkomende wijzigingensets in onze branche zijn, moeten we een pull uitvoeren en onze wijzigingen opnieuw bovenaan de lijst met wijzigingen plaatsen.

hg pull -b . --rebase
 

Zodra dit is gebeurd of als er geen inkomende wijzigingensets zijn, kunnen we doorgaan met de Push.

We willen alleen ons huidige werk pushen, niet alles wat we ooit hebben gedaan. Ik push echt nooit mijn hele repository, maar mijn huidige werk. De redenering is dat het pushen van de hele repository ervan uitgaat dat ik meerdere werkregels integreer. Maar ik wil alleen mijn huidige werklijn integreren en ik wil slechts in één lijn tegelijk werken.

Als dit de eerste keer is dat ik deze tak push:

hg push -b . --new-branch
 

Als ik deze branch al heb gepusht:

hg push -b .
 

De "-b." commando betekent gewoon de huidige branch pushen, en niets anders.

Wisselen tussen de werkende takken :

hg update myBranchName
 

Ermee beginnen

Zie ook de Mercurial Tutorial

Een Mercurial Repository maken

Een Mercurial-repository is gewoon een map (de "werkmap" genoemd) die een .hg map met metagegevens over de inhoud van de repository bevat. Dit maakt Mercurial zeer licht en gemakkelijk in gebruik. Om een nieuwe repository te maken, voer je eenvoudig uit:

$ hg init project
 

Waar project de naam is van de map die u wilt maken. Dit maakt een project samen met een project/.hg map die de repository zelf bevat.

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

We hebben zojuist een hello.txt bestand in de repository gemaakt en de hg status (of kortweg stat ) uitgevoerd om de huidige status van onze repository te bekijken. Zoals je kunt zien is hello.txt geannoteerd met een ? , wat betekent dat Mercurial zich er nog niet van bewust is. De opdracht add registreert dit nieuwe bestand bij Mercurial, zodat het wordt opgenomen in de volgende commit.

$ hg add hello.txt
 

Nu Mercurial op de hoogte is van een gewijzigd bestand, kun je diff om precies te zien wat er is gewijzigd sinds de laatste commit - in dit geval voegen we de volledige inhoud van 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
 

En als we er blij mee zijn en klaar zijn om onze wijzigingen in te checken, kunnen we commit :

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

Merk op dat we een commit-bericht met -m - als u niet opgeeft -m Mercurial zal een teksteditor starten waarin u een commit-bericht kunt invoeren. Dit is handig als u een langer bericht met meerdere regels wilt geven.

Nadat u uw wijzigingen hebt doorgevoerd, worden deze niet meer weergegeven als u hg stat uitvoert, omdat de repository nu is gesynchroniseerd met de inhoud van de werkmap. Je kunt log om een lijst met commits te zien, en -v bevat extra details zoals de bestanden die elke commit heeft aangeraakt:

$ 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.
 

Installatie en instellingen

Je kunt Mercurial downloaden van de website van het project, en er zijn grafische hulpprogramma's voor Windows, Linux en OSX als je dat liever hebt dan een opdrachtregelinterface. De meeste Unix-pakketbeheerders omvatten Mercurial, bijvoorbeeld op Debian / Ubuntu:

$ apt-get install mercurial
 

U kunt controleren of Mercurial is geïnstalleerd door het uitvoeren van:

$ hg --version
 

Opstelling

Mercurial werkt direct, maar u zult Mercurial waarschijnlijk willen configureren om te weten wie u bent voordat u verder gaat. Om een gebruikersnaam aan uw commits te koppelen, bewerkt u ~/.hgrc (of mercurial.ini in uw thuismap op Windows) en voegt u de volgende regels toe:

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

Als je dit niet wilt doen, kun je altijd een gebruikersnaam opgeven wanneer je vastlegt met de vlag -u , bijvoorbeeld:

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

Duwen en trekken

Mercurial maakt het gemakkelijk om uw werk te delen en bijdragen van andere ontwikkelaars binnen te halen. Dit omvat drie belangrijke stappen; klonen , trekken en duwen .

Clone

Om een externe repository naar uw lokale schijf te kopiëren, "kloon" u deze. Om dit te doen, geeft u eenvoudig de externe URL door waaruit u wilt klonen. Om de Mercurial-broncode te klonen, voert u eenvoudig uit:

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

Hiermee wordt een lokale hg directory gemaakt met een kopie van de Mercurial-repository die u kunt bouwen, bewerken en vastleggen (hoewel u uw commits niet terug naar de bovenliggende repository kunt publiceren).

Trekken

Nadat u een repository hebt uitgecheckt, wilt u deze gesynchroniseerd houden terwijl anderen wijzigingen daarin publiceren. U kunt nieuwe wijzigingen verwijderen door eenvoudigweg te draaien:

$ hg pull
 

Hiermee worden nieuwe commits binnengehaald, maar wordt je werkmap niet bijgewerkt, zodat je geen wijzigingen direct ziet. Om te updaten van de inhoud van de werkmap run:

$ hg up
 

Hiermee wordt uw werkmap bijgewerkt tot de tip (meest recente) revisie in de repository.

U kunt ook uitvoeren:

$ hg pull -u
 

Om nieuwe wijzigingen aan te brengen en de werkmap in één stap bij te werken.

Duwen

Ervan uitgaande dat u schrijftoegang hebt tot de externe repository, kunt u commits die u lokaal naar de externe repository hebt gemaakt net zo gemakkelijk publiceren met:

$ hg push
 

Hiermee worden je wijzigingen geüpload zolang er geen andere commits zijn geweest sinds de laatste keer dat je hebt getrokken. Als je push wordt afgewezen omdat het "extra heads zou creëren", betekent dit dat je die nieuwe wijzigingen moet invoeren en ze met je eigen wijzigingen moet samenvoegen.

$ 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
 

Meestal is dit alles wat u hoeft te doen, omdat Mercurial uw wijzigingen automatisch samenvoegt, maar soms moet u samenvoegconflicten handmatig oplossen (zie onderwerp over samenvoegen). Indien nodig kunt u een samenvoeging altijd annuleren en teruggaan naar een schone werkmap met:

$ hg up -c
 

Maar onthoud dat dit een vernietigende operatie is; wijzigingen in de werkmap worden gewist.