mercurialKomma igång med mercurial


Anmärkningar

Mercurial är ett modernt, distribuerat versionskontrollsystem med öppen källkod. Du kanske har hört talas om git, som är något mer populärt idag; git och Mercurial är mycket jämförbara och erbjuder mestadels liknande funktioner.

Utvecklare använder Mercurial för att hålla reda på ändringar i källkoden för sina applikationer. Det kan användas för att hålla reda på ändringar i valfri filkatalog, även om det, som de flesta källkontrollsystem, gör det bäst när dessa filer är textfiler (i motsats till binära filer). Mercurial tillåter också flera utvecklare att arbeta på samma katalog med källkod samtidigt, och det hanterar processen att hålla reda på varje utvecklings förändringar och sedan slå samman dessa ändringar.

versioner

Mercurial följer en tidsbaserad utgivningsplan och publicerar en större utgåva var tredje månad, i februari, maj, augusti och november. En mindre utgåva publiceras varje kvarvarande månad. Observera att Mercurial inte använder sematisk versionering, därför finns det ingen signifikant skillnad mellan 2.9.2 (den sista av 2.9-versionerna) och 3.0.

Bakåtkompatibilitet är ett kritiskt krav för Mercurial, därför är det i allmänhet säkert att bara uppgradera dina Mercurial-installationer efter behov. Det är dock en god idé att göra det minst en gång var tredje månad, eftersom vissa funktioner kan göra att gamla klienter inte kan arbeta på nyare förvar.

Projekten släpper anteckningar med detaljer om vad som ändras mellan versioner, medan uppgraderingsanteckningarna ger tydlig vägledning om vad användare måste vara medvetna om vid uppgradering.

Ett urval av anmärkningsvärda versioner:

Version anteckningar Datum
3,5 Droppar stöd för Python 2.4 och 2.5 2015/07/31
2,1 Introducerar ändringssatta "faser" som möjliggör säker historikmodifiering 2012-02-01
1,9 Introducerar ett Command Server API för att stödja bättre applikationsintegration 2011-07-01
1,7 Nytt arkivformat stöder ovanliga filnamn 2010-11-01

Förgrening

När vi först påbörjar vårt arbete måste vi bestämma om detta är ett separat arbetsområde vi arbetar med, eller är det en del av en befintlig arbetslinje. Om det finns, kan vi arbeta med den grenen. Om det är nytt, startar vi en ny filial.

Vårt arbetsflöde är då:

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

Just nu vill vi driva vårt arbete till fjärrservern. Men innan du trycker på ändringarna (ignorera detta om det är en ny gren som du inte har drivit förut) måste vi kontrollera om det finns någon inkommande förändring av grenen. Vi kan kontrollera detta med:

hg incoming -b .
 

Om det finns några inkommande ändringsuppsättningar på vår gren, måste vi göra en dragning och omfasera våra ändringar till toppen av listan över ändringar.

hg pull -b . --rebase
 

När detta är gjort eller om det inte finns några inkommande ändringar, kan vi fortsätta med Push.

Vi vill bara driva vårt nuvarande arbete, inte allt vi någonsin har gjort. Jag driver verkligen aldrig hela mitt förvar, utan min nuvarande arbetslinje. Resonemanget är att genom att driva hela förvaret antas att jag integrerar flera arbetslinjer. Men jag vill bara integrera min nuvarande arbetslinje och jag vill bara arbeta i en rad åt gången.

Om det här är första gången jag driver denna gren:

hg push -b . --new-branch
 

Om jag redan har drivit denna gren:

hg push -b .
 

"-B." kommando betyder att bara trycka på den nuvarande grenen och inte något annat.

Så här byter du mellan arbetsgrenarna :

hg update myBranchName
 

Komma igång

Se även Mercurial Tutorial

Skapa ett Mercurial-arkiv

Ett Mercurial-förvar är helt enkelt en katalog (benämnd "fungerande katalog") som innehåller en .hg katalog med metadata om innehållet i förvaret. Detta gör Mercurial mycket lätt och lätt att använda. För att skapa ett nytt arkiv kör du bara:

$ hg init project
 

Där project är namnet på den katalog du vill skapa. Detta skapar en project tillsammans med ett project/.hg katalog som innehåller själva förvaret.

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

Vi skapade precis en hello.txt fil i förvaret och körde hg status (eller stat för kort) för att se den aktuella statusen för vårt förvar. Som du kan se hello.txt kommenteras med en ? , vilket betyder att Mercurial ännu inte är medveten om det. add registrerar denna nya fil med Mercurial så att den kommer att inkluderas i nästa åtagande.

$ hg add hello.txt
 

Nu när Mercurial är medveten om en ändrad fil kan du köra diff att se exakt vad som har ändrats sedan det senaste åtagandet - i det här fallet lägger vi till hela innehållet i 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
 

Och när vi är nöjda med dem och är redo att kolla in våra ändringar kan vi köra commit :

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

Observera att vi inkluderade ett åtagandemeddelande med -m - om du inte anger -m Mercurial kommer att starta en textredigerare kan du ange ett åtagandemeddelande i. Det är användbart om du vill tillhandahålla ett längre med flera linjer.

När du har gjort dina ändringar visas de inte längre om du kör hg stat eftersom förvaret nu är synkroniserat med innehållet i arbetskatalogen. Du kan köra log att se en lista över åtaganden, och -v innehåller ytterligare detaljer som de filer som varje begär rörde:

$ 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 och installation

Du kan ladda ner Mercurial från projektets webbplats, och det finns grafiska verktyg för Windows, Linux och OSX om du föredrar det framför ett kommandoradsgränssnitt. De flesta Unix-pakethanter inkluderar Mercurial, till exempel på Debian / Ubuntu:

$ apt-get install mercurial
 

Du kan verifiera att Mercurial är installerad genom att köra:

$ hg --version
 

Uppstart

Mercurial fungerar ut ur lådan, men du kommer sannolikt att konfigurera Mercurial att veta vem du är innan du går vidare. För att associera ett användarnamn med dina åtaganden, redigera ~/.hgrc (eller mercurial.ini i din hemkatalog i Windows) och lägg till följande rader:

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

Om du inte vill göra detta kan du alltid ange ett användarnamn när du begår med -u flaggan, t.ex.

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

Skjuta och dra

Mercurial gör det enkelt att dela ditt arbete och att dra in bidrag från andra utvecklare. Detta innebär tre viktiga steg; kloning , dra och skjuta .

Klona

För att kopiera ett fjärrlager till din lokala skiva "klonar" du den. För att göra det passerar du bara den fjärradress du vill klona från. För att klona Mercurial-källkoden kör du bara:

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

Detta skapar en lokal hg katalog som innehåller en kopia av Mercurial-arkivet som du kan bygga, redigera och förbinda dig till (även om du inte kan publicera dina åtaganden tillbaka till moderförvaret).

Dra

När du har checkat ut ett arkiv, vill du hålla det synkroniserat eftersom andra publicerar ändringar i det. Du kan dra nya ändringar genom att bara köra:

$ hg pull
 

Detta hämtar nya åtaganden men uppdaterar inte din arbetskatalog, så att du inte ser några ändringar omedelbart. För att uppdatera innehållet i arbetskatalogkörningen:

$ hg up
 

Vilken uppdaterar din arbetskatalog till tipset (senaste) revisionen i förvaret.

Du kan också köra:

$ hg pull -u
 

För att dra in nya ändringar och uppdatera arbetskatalogen i ett steg.

Skjuta på

Förutsatt att du har skrivåtkomst till fjärrlagret kan du publicera alla åtaganden du gjort lokalt till fjärrlagret lika enkelt med:

$ hg push
 

Detta laddar upp dina ändringar så länge det inte har gjorts några andra åtaganden sedan förra gången du drog. Om din push avvisas eftersom det skulle "skapa ytterligare huvuden" betyder det att du måste dra in de nya förändringarna och slå samman dem med dina egna.

$ 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
 

Det mesta av tiden är det allt du behöver göra eftersom Mercurial hanterar sammanslagning av dina ändringar automatiskt, men ibland måste du lösa sammanslagningskonflikter manuellt (se fusionera ämne). Om du behöver kan du alltid avbryta en sammanslagning och återgå till en ren fungerande katalog med:

$ hg up -c
 

Men kom ihåg att detta är en destruktiv operation; eventuella ändringar i arbetskatalogen raderas.