Differences between revisions 14 and 15
Revision 14 as of 2010-04-27 14:16:37
Size: 26709
Editor: Tovim
Comment:
Revision 15 as of 2010-04-27 19:11:07
Size: 24624
Editor: Tovim
Comment:
Deletions are marked like this. Additions are marked like this.
Line 181: Line 181:
__ Práce v různých klonech__ __ Práce s klony__
Line 240: Line 240:
Aktivací vestavěného lokálního serveru na portu 8000 umožníme ostatním na síti přístup do našeho počítače: Aktivací vestavěného lokálního serveru na portu 800 umožníme ostatním na síti přístup do našeho počítače:
Line 245: Line 245:
Zkusme nyní ve vlastním webovém serveru zadat adresu ''http://localhost:8000''. Otevře se nám stránka s pěkným přístupem k tomu repozitáři, u kterého byl server aktivován. Zkusme nyní ve vlastním webovém serveru zadat adresu ''http://localhost:8000/''. Otevře se nám stránka s pěkným přístupem k tomu repozitáři, u kterého byl server aktivován.
Line 255: Line 255:
Z bezpečnostních důvodů je možné provádět pouze 'pull', nikoliv 'push'. Z bezpečnostních důvodů je možné přes tento server provádět pouze 'pull', nikoliv 'push'.
Line 261: Line 261:
Změny pošleme jako specielní oprávkové soubory s příponou 'diff'. Změny pošleme jako specielní oprávkové soubory s příponou `.diff`.
Line 292: Line 292:
 $ hg help bundle # pěkné ale složité  $ hg help bundle # poněkud složitější
Line 301: Line 301:
Základním pravidlem dobrého chování je to, že u takového repozitáře nevytváříme dvě čela. Základním pravidlem dobrého chování je to, že u takového repozitáře nevytváříme dvě čela.  
Line 304: Line 305:
Line 306: Line 308:
Popíšeme si podrobněji postup na serveru

Otherwise you first need to setup a BitBucket Account. Just signup at [http://bitbucket.org BitBucket]. After signing up (and login) hover your mouse over "Repositories". There click the item at the bottom of the opening dialog which say "Create new".

Give it a name and a description. If you want to keep it hidden from the public, select "private"

 $ firefox http://bitbucket.org
 

Now your repository is created and you see instructions for ''push''ing to it. for that you'll use a command similar to the following (just with a different URL)

 $ hg push https://bitbucket.org/ArneBab/hello/
 

(Replace the URL with the URL of your created repository. If your username is "Foo" and your repository is named "bar", the URL will be https://bitbucket.org/Foo/bar/)

Mercurial will ask for your BitBucket name and password, then ''push'' your code.

Voili?1, your code is online.

<div class="note">

Note:

 You can also [http://bitbucket.org/help/UsingSSH use SSH for pushing to BitBucket]. </div>

Now it's time to tell all your colleagues to sign up at BitBucket, too.

After that you can click the "Admin" tab of your created repository and add the usernames of your colleagues on the right side under "Permission: Writers". Now they are allowed to ''push'' code to the repository.

(If you chose to make the repository private, you'll need to add them to "Permission: Readers", too)

If one of you now wants to publish changes, he'll simply ''push'' them to the repository, and all others get them by ''pull''ing.

Publish your changes

 $ hg push https://bitbucket.org/ArneBab/hello/
 

Pull others changes into your local repository

 $ hg pull https://bitbucket.org/ArneBab/hello/
 

People who join you in development can also just ''clone'' this repository, as if one of you were using ''hg serve''
Popíšeme si podrobněji postup na serveru [[http://bitbucket.org|BitBucket]], kde se zapíšeme jako uživatel.

Po přihlášení si vytvoříme nový repozitář tak, že přejedeme kurzorem přes nápis ''Repositories'' a vybereme ''Create new''. Zadáme nazev repozitáře a popis jeho účelu. Chceme-li uzavřít přístup široké veřejnosti, označíme jej jako ''private''.

Poté v repozitáři poklepneme na záložku ''Admin'', kde můžeme v části ''Permissions:Readers'' a ''Permissions:Writers'' zapsat uživatelská jména svých kolegů, čímž jim umožníme provádět ''push'' do našeho repozitáře.

Řekněme, že naše uživatelské jméno je "ozon" a název repozitáře je "foo". Potom adresa našeho repozitáře bude ''https://bitbucket.org/ozon/foo''.

Při volání našeho repozitáře (například)
{{{
$ hg incoming https://bitbucket.org/ozon/foo
}}}
jsme žádání o zadání uživatelského jména a hesla pro BitBucket.

S tímto repozitářem zacházíme stejně jako s lokálním repozítářem. Můžeme si z něho pořídit také lokální kopii (hello):
{{{
Line 353: Line 325:
   That local repository will automatically be configured to pull/push from/to the online repository, so new contributors can just use ''hg push'' and ''hg pull'' without an URL.

<div class="note">

Note:

 To make this workflow more scalable, each one of you can have his own BitBucket repository and you can simply ''pull'' from the others repositories. That way you can easily establish workflows in which certain people act as integrators and finally ''push'' checked code to a shared pull repository from which all others pull. </div><div class="note">

Note:

 You can also use this workflow with a shared server instead of BitBucket, either via SSH or via a shared directory. An example for an SSH URL with Mercurial is be ssh://user@example.com/path/to/repo. When using a shared directory you just push as if the repository in the shared directory were on your local drive. </div>

== Summary ==

Now let's take a step back and look where we are.

With the commands you already know, a bit reading of ''hg help &lt;command&gt;'' and some evil script-fu you can already do almost everything you'll ever need to do when working with source code history. So from now on almost everything is convenience, and that's a good thing.

First this is good, because it means, that you can now use most of the concepts which are utilized in more complex workflows.

Second it aids you, because convenience lets you focus on your task instead of focusing on your tool. It helps you concentrate on the coding itself. Still you can always go back to the basics, if you want to.

A short summary of what you can do which can also act as a short check, if you still remember the meaning of the commands.

=== create a project ===
 }}}

Do konfiguračního souboru naklonovaného repozitáře se automaticky načte adresa on-line repozitáře, takže ji při jeho volání nemusíme zadávat.

<!> Variantně lze dohodnout, že každý člen kolektivu má na BitBucket otevřený svůj repozitář, do kterého posílá své změny. Určený administrátor potom tyto změny podle svého uvážení stahuje do ''centrálního'' repozitáře, z něhož si ostatní aktuální změny stahují.


<!> You can also use this workflow with a shared server instead of BitBucket, either via SSH or via a shared directory. An example for an SSH URL with Mercurial is be ssh://user@example.com/path/to/repo. When using a shared directory you just push as if the repository in the shared directory were on your local drive. </div>

== Shrnutí ==

Jak bylo již řečeno na začátku, tento text nevysvětluje podrobnosti, což je někdy právě to, čeho je nám třeba. Můžeme-li trochu anglicky, je dobré zkusit nápovědu k jednotlivým příkazům
{{{
$ hg help <příkaz>
}}}

Popsané postupy si ještě stručně připomeneme.

=== založit projekt ===

{{{
Line 383: Line 348:
 $ (add some files)  $ (přidat nějaké soubory)
Line 386: Line 351:
 (enter the commit message)
 

=== do nonlinear development ===

 $ (do some changes)
 $ hg commit
 (enter the commit message)
 (napsat komentář komitu)
}}}

=== větveprůběh ===

{{{
$ (proveď nějaké změny)
 $ hg commit
 (napiš komentář komitu)
Line 395: Line 361:
 $ (do some changes)
 $ hg commit
 (enter the commit message)
 $ (proveď nějaké změny)
 $ hg commit
 (napiš komentář komitu)
Line 399: Line 365:
 $ (optionally hg resolve)
 $ hg commit
 (enter the commit message)
 

=== use feature clones ===
 $ (případně s použitím hg resolve)
 $ hg commit
 (napiš komentář komitu)
}}}

=== rozděle do klonů ===

{{{
Line 409: Line 376:
 $ (do some changes)
 $ hg commit
 (enter the commit message)
 $ (proveď nějaké změny)
 $ hg commit
 (napiš komentář komitu)
Line 414: Line 381:
 

=== share your repository via the integrated webserver ===

 $ hg serve &amp;
}}}

=== využití integrovaného serveru ===

{{{

 $ hg serve
Line 421: Line 389:
 

=== export changes to files ===
}}}

=== export změn do souboru ===

{{{
Line 426: Line 395:
 $ (do some changes)
 $ hg commit
 (enter the commit message)
 $ (proveď nějaké změny)
 $ hg commit
 (napiš komentář komitu)
Line 430: Line 399:
 

=== import changes from files ===
}}}

=== import změn ze souboru ===

{{{
Line 436: Line 406:
   === pull changes from a served repository (hg serve still runs on project) ===
}}}

=== stáhnout změny z repozitáře s aktivním serverem (hg serve) ===

{{{
Line 442: Line 413:
 

=== Use shared repositories on BitBucket ===
}}}

=== použití společného repo na BitBucket ===

{{{
Line 448: Line 420:
 (enter name and password in the prompt)  (zadat jméno a heslo)
Line 450: Line 422:
   Let's move on towards useful features and a bit more advanced workflows.

= Advanced workflows =

== Backing out bad revisions ==

=== Use Case ===

When you routinely pull code from others, it can happen that you overlook some bad change. As soon as others pull that change from you, you have little chance to get completely rid of it.

To resolve that problem, Mercurial offers you the ''backout'' command. Backing out a change means, that you tell Mercurial to create a commit which reverses the bad change. That way you don't get rid of the bad code in history, but you can remove it from new revisions.

<div class="note">

Note:

 The basic commands don't directly rewrite history. If you want to do that, you need to activate some of the extensions which are shipped with mercurial. We'll come to that later on. </div>

=== Workflow ===

Let's assume the bad change was revision 3, and you already have one more revision in your repository. To remove the bad code, you can just ''backout'' of it. This creates a new change which reverses the bad change. After backing out, you can then merge that new change into the current code.
 }}}


= Pokročilé průběhy =

== Anulování špatných revizí ==

=== Popis případu ===

Při stahování kódu z jiných repozitářů se může stát, že přehlédneme chybný changeset. Poté, co si jej jiní od nás stáhli, máme malou šanci, že se jej někdy úplně zbavíme.

Pro řešení tohoto problému nabízí Mercurial příkaz ''backout''. Tento příkaz vytváří nový changeset, který je dítětem anulovaného changesetu a který ruší špatný changeset. Záznam špatného changesetu v historii nezrušíme, ale můžeme jej odebrat z nových revizí.

<!> Základní příkazy historii nepřepisují. Máme-li takovou potřebu, musíme aktivovat některou extenzi, která je součástí instalace Mercurialu. K tomuto tématu se dostaneme později.

=== Průběh ===

Řekněme, že špatnou změnou byla revize 3. Špatný kód se pokusíme odstranit příkazem ''backout''. Tím vytvoříme novou změnu, která vytěsní tu starou. Protože provádíme změnu starší revize, vytvoříme další čelo, které musíme sloučit se stávajícím.

{{{
Line 476: Line 444:
 (potentially resolve conflicts)
 $ hg commit
 (enter commit message. For example: "merged backout")
 (případně vyřešíme konflikty)
 $ hg commit
 (komentář komitu, např: "merged backout")
}}}

A je to. Odvolali jsme špatnou změnu. Je stále zaznamenáno, že existovala (podle zásady "nepřepisovat historii, pokud to není nezbytné"), ale již neovlivňuje budoucí kód.

== Kolektivní vývoj variant ==

Nyní, když si umíme předávat změny a v případě potřeby je anulovat, můžeme postoupit dále: pomocí Mercurialu koordinovat vývoj kódu.

The first part is an easy way to develop features together, without requiring every developer to keep track of several feature clones.

=== Popis případu ===

Chceme-li rozdělit náš projekt do několika variant, potřebujeme vědět, kdo na čem pracuje a kde se jeho práce ukládá.

Mercurial to umožňuje svými "pojmenovanými větvemi". Ty jsou součástí hlavního repozitáře, takže jsou přístupné každému účastníkovi. Zároveň se změny komitované v jisté větvi nemísí se změnami v hlavní (default) větvi, takže jsou variace ukládány odděleně, dokud nejsou s hlavní větví sloučeny.



=== Průběh ===

Když někdo v naší skupině chce začít pracovat na variantě tak, aby nerušil ostatní, může vytvořit pojmenovanou větev a své změny ukládat zde. Když se někdo chce připojit, nic mu nebrání; připojuje své změny na konec větve. Po ukončení vývoje varianty lze pojmenovanou větev sloučit s hlavní větví.


__Práce v pojmenované větvi__

Vytvoření pojmenované větve:
{{{
 $ hg branch ferari
 (proveď nějaké změny)
 $ hg commit # větev se nadál jmenuje ferari
 (napiš komentář komitu)
 }}}

Můžeme používat příkazy ''commit, pull, push, merge, ...'' jako kdybychom pracovali v samostatném repozitáři.
{{{
 $ hg update default # nás přenese k poslední revizi před 'ferari'
  ...
 $ hg update ferari # nás vrátí k poslední revizi úseku 'ferari'
 }}}
Line 481: Line 488:
That's it. You reversed the bad change. It's still recorded that it was once there (following the principle "don't rewrite history, if it's not really necessary"), but it doesn't affect future code anymore.

== Collaborative feature development ==

Now that you can share changes and reverse them if necessary, you can go one step further: Using Mercurial to help in coordinating the coding.

The first part is an easy way to develop features together, without requiring every developer to keep track of several feature clones.

=== Use Case ===

When you want to split your development into several features, you need to keep track of who works on which feature and where to get which changes.

Mercurial makes this easy for you by providing named branches. They are a part of the main repository, so they are available to everyone involved. At the same time, changes committed on a certain branch don't get mixed with the changes in the default branch, so features are kept separate, until they get merged into the default branch.

<div class="note">

Note:

 Cloning a repository always puts you onto the default branch at first. </div>

=== Workflow ===

When someone in your group wants to start coding on a feature without disturbing the others, he can create a named branch and commit there. When someone else wants to join in, he just updates to the branch and commits away. As soon as the feature is finished, someone merges the named branch into the default branch.

===== Working in a named branch =====

Create the branch

 $ hg branch feature1
 (do some changes)
 $ hg commit
 (write commit message)
 

Update into the branch and work in it

 $ hg update feature1
 (do some changes)
 $ hg commit
 (write commit message)
 

Now you can ''commit'', ''pull'', ''push'' and ''merge'' (and anything else) as if you were working in a separate repository. If the history of the named branch is linear and you call "hg merge", Mercurial asks you to specify an explicit revision, since the branch in which you work doesn't have anything to merge.

===== Merge the named branch =====

When you finished the feature, you ''merge'' the branch back into the default branch.
__Sloučení pojmenované větve__

Po ukončení alternativního vývoje pojmenovanou větev ukončíme ''sloučením''.
{{{
Line 530: Line 493:
 $ hg merge feature1
 $ hg commit
 (write commit message)
 

And that's it. Now you can easily keep features separate without unnecessary bookkeeping.

<div class="note">

Note:

 Named branches stay in history as permanent record after you finished your work. If you don't like having that record in your history, please have a look at some of the advanced [http://www.selenic.com/mercurial/wiki/Workflows workflows]. </div>

== Tagging revisions ==

=== Use Case ===

Since you can now code separate features more easily, you might want to mark certain revisions as fit for consumption (or similar). For example you might want to mark releases, or just mark off revisions as reviewed.

For this Mercurial offers tags. Tags add a name to a revision and are part of the history. You can tag a change years after it was committed. The tag includes the information when it was added, and tags can be pulled, pushed and merged just like any other committed change.

<div class="note">

Note:

 A tag must not contain the char ":", since that char is used for specifying multiple revisions - see "hg help revisions". </div><div class="note">

Note:

 To securely mark a revision, you can use the [http://www.selenic.com/mercurial/wiki/GpgExtension gpg extension] to sign the tag. </div>

=== Workflow ===

Let's assume you want to give revision 3 the name "v0.1".

Add the tag
 $ hg merge ferari
 $ hg commit
 (napiš komentář komitu)
}}}

<!> Ukončená pojmenovaná větev je natrvalo zapsaná do historie. Pokud ji tam mít nechcete, lze to řešit způsobem, popsaným v [http://www.selenic.com/mercurial/wiki/Workflows workflows].

== Označování revizí ==

=== Popis případu ===

Pro označení revizí uživatelem se v Mercurialu používají ''tagy''. Připojení tagu k revizi lze provést i dodatečně. Zadání tagu vytváří samostatný changeset generovaný automatickým komitem se standardním koomentářem.

<!> Tag nesmí obsahovat znak ":", protože tento znak se používá pro vymezení rozsahu revizí - viz "hg help revisions".

<!> K bezpečnému označení revizí lze použít [[http://www.selenic.com/mercurial/wiki/GpgExtension| gpg extenzi]].

=== Průběh ===

Řekněme, že cheme revizi 3 dát jméno otto

Přidáme tag:
{{{
Line 568: Line 517:
   See all tags
}}}

Prohlédneme si všechny tagy:
{{{
Line 573: Line 522:
   When you look at the log you'll now see a line in changeset 3 which marks the Tag. If someone wants to ''update'' to the tagged revision, he can just use the name of your tag

 $ hg update v0.1
 

Now he'll be at the tagged revision and can work from there.

== Removing history ==

=== Use Case ===

At times you will have changes in your repository, which you really don't want in it.
}}}

Když se podíváme na záznam (log), uvidíme v revizi 3 další řádek s názvem tagu. Chceme-li aktualizovat pracovní adresář k označené revizi, použijeme její tag:
{{{
 $ hg update otto
}}}


== Odstranění historie ==

=== Popis případu ===

Někdy máme v repozitáři takové změny, které vůbec nepotřebujeme a

Průběhová schemata v Mercurialu

V Mercurialu lze realizovat mnoho různých průběhových schemat. V tomto textu se s některými seznámíme, přičemž budeme postupovat od jednodušších ke složitějším. Účelem této pomůcky je usnadnit začátečníkům práci se sledováním verzí (verzování). Použité pojmy nejsou vysvětlovány, neboť existuje řada jiných výtečných textů (Základy Mercurialu a Za kulisami), které tak činí.

Podrobnější popis se základními pojmy naleznete v tutorialu o používání Mercurialu - CzechTutorial. Opravdu podrobný a velmi čtivý popis Mercurialu obsahuje kniha B. O´Raillyho Mercurial:The Definitive Guide.

<!> Tento průvodce nevyžaduje žádnou předchozí znalost VCS (i když uživatelé Subversion se budou patrně brzo cítit doma). Zkušenosti s konzolou příkazového řádku budou prospěšné, protože CLI budeme používat.

Základní průběhová schemata

Osamělý vývojář s jednoduchou historií

Popis případu

První průběhové schema je nejsnadnější. Chceme zaznamenávat změny a mít možnost se kdykoliv ke kterékoliv vrátit a prohlédnout si ji.

Průběh

Jako první krok bychom měli zadat své jméno. V textovém editoru otevřeme soubor ~/.hgrc, přidáme sekci ui (user interaction) a zapíšeme jméno, případně s e-mailovou adresou:

 [ui]
 username = Mr. Johnson <hali@beli.cz>

Nyní vytvoříme adresář, ve kterém budeme pracovat (včetně složky .hg):

 $ hg init baboon        

Přejdeme do adresáře, vytvoříme nějaké soubory a přidáme je ke sledování:

 $ cd baboon
 $ (vytvoření souborů)
 $ hg add

<!> Můžeme také vstoupit do existujícího adresáře se soubory a tam vytvořit složku (repozitář) .hg:

 $ cd project
 $ hg init

Případně můžeme přidat ke sledování jenom určité soubory místo všech souborů v adresáři. Následujícím příkazem například přikážeme sledování souborů file10, file11 a file12:

 $ hg add file0* 

Přidané soubory se staly "kandidáty pro registraci". Vlastní zápis změn do repozitáře provádíme jejich předáním příkazem 'commit':

$ hg commit

Vyskočí textový editor a žádá si zápis komentáře komitu. Po uložení a zavření editoru máme změny předané.

<!> Komentář komitu lze zadat zároveň s jeho příkazem (zde zkráceným):

 $ hg ci -m "Komentář"

Přítomnost nekomitovaných změn v pracovním adresáři zjistíme příkazem:

 $ hg status

případně rozdíl mezi dvěmi verzemi souboru:

 $ hg diff

Při přemístění a kopírování souborů pomocí příkazů Mercurialu nemusíme změny "uvádět na kandidátskou listinu" příkazy hg add, hg remove nebo hg addremove. Nezapomeneme však předat změny repozitáři, to jest provést příkaz commit:

 $ hg cp orig kopie
 $ hg ci -m "stručný komentář"
 
 $ hg mv orig sloha/rupie  # přemístit lze jen uvnitř kořenového adresáře
 $ hg ci -m "sloha je název adresáře"

Máme nyní dva nové soubory 'kopie' a 'rupie' a Mercurial o nich ví.

Výpis seznamu všech zaznamenaných změn vyvoláme příkazem:

 $ hg log

Informace o changesetu (revizi) obsahuje ID, jméno komitenta, datum a čas komitu a komentář.

Pokud nás zajímá jenom určitá revize, použijeme přepínač -r (--revision). Aby se nám také zobrazil diff určené revize, přidáme přepínač -p (--patch):

 $ hg log -p -r 3

Osamělý vývojář s větvenou historií

Popis případu

Druhé průběhové schema je stále velmi jednoduché: jste sám a chcete aby Mercurial zaznamenával vaše změny, přičemž je možné, že se budete chtít někdy vrátit ke starší revizi a dodatečně ji upravit.

Průběh

Otevření nového projektu, případně založení nového repozitáře, případně další práci v pracovním adresáři provádíme známým způsobem:

 $ hg init projekt
 $ cd projekt
 $ (přidáme soubory)
 $ hg add                    # zařadíme je ke sledování
 $ (provedeme nějaké změny)
 $ hg diff                   # prohlédneme si je
 $ hg ci -m "zápecí"         # předáme je repozitáři
 $ hg cp copak kampak        # kopírujeme soubory či složky
 $ hg mv copak kampak        # přemístíme soubory či složky
 $ hg ci -m "párátko"
 $ hg log                    # prohlédneme si historii

Návrat ke starší revizi

Tím, že jsme v našem adresáři vytvořili systémový adresář (repozitář) .hg, učinili jsme z našeho pracovního adresáře 'vnímavý útvar', jehož skladba a obsah souborů se mění v závislosti na nastavené aktuální revizi.

Implicitně je touto revizí revize poslední, nazývaná 'tip'. K libovolné jiné revizi se dostaneme příkazem 'hg update REV', přičemž 'REV' je pořadové číslo revize. Poslední revizi zas můžeme aktualizovat (zkráceně) příkazem 'hg up tip'

Která revize je právě aktuální, se dozvíme příkazem 'hg identify -n', kde si přepínačem 'n' říkáme o pořadové číslo revize.

Příkaz identify bez přepínače nám vrátí zkrácený tvar ID. Na rozdíl od pořadového čísla revize, které pro tentýž changeset může být v každém repozitáři jiné, se toto číslo nemění. Pořadové číslování revizí začíná nulou.

Je-li aktuální poslední revize, hg identify -n vrátí -1.

Oprava starších chyb

Opravou chyby ve starší revizi vytvoříme v repozitáři další čelo (head), které musíme sloučit s čelem stávajícím:

 $ hg update 3              # tam máme čertovo kopýtko
 $ (opravíme chybu)
 $ hg commit

Oprava chyby je 'zaknihována', ještě sloučíme čela:

 $ hg merge

Pokud by se při sloučení vyskytl problém, použijeme příkaz hg resolve - tak, jak jsme případně programem vybízeni.

Nejprve dáme vypsat seznam konfliktních souborů:

 $ hg resolve --list

Potom je jeden po druhém řešíme. Příkaz resolve se opět pokusí o sloučení:

 $ hg resolve konfliktní_soubor
 (případně upravíme konflikt ručně)

Upravený soubor označíme jako řešený

 $ hg resolve --mark conflicting_file

Jakmile vyřešíme všechny konflikty, provedeme 'commit'! Ten ostatně provedeme i když se žádné konflikty nevyskytly.

 $ hg commit

V této chvíli máme opravu sloučenou s ostatní naší prací, ve které můžeme pokračovat. Zaznamenaná historie nám jasně ukazuje, kde chyba vznikla a kdy byla opravena.

<!> Když opravíme chybu souboru ve starší revizi a v nějaké pozdější revizi byl tento soubor kopírován nebo přemístěn, bude sloučením tato oprava rozšířena do cílových souborů. To je hlavní důvod, proč bychom kopírování a přemísťování souborů uvnitř pracovního adresáře měli provádět pomocí příkazů Mercurialu hg cp a hg mv.

Oddělený vývoj

Popis případu

Někdy pracujeme současně na několika variantách jednoho programu. Chceme-li se vyhnout náhodnému pomíchání nehotových verzí kódu, můžeme vytvořit klon lokálního repozitáře a pracovat na variantách v jejich vlastních pracovních adresářích.

Po dokončení stáhneme (pull) variantu do hlavního adresáře a sloučíme (merge) ji s lokálními změnami.

Průběh

Práce s klony

Nejprve vytvoříme klon a v něm nějaké změny:

 $ hg clone baboon makak
 $ cd makak
 $ (provedeme změny a komity)

Nyní si ověříme, co obdržíme, když provedeme pull z adresáře makak (podobně jako používáme příkaz diff před komitem). Příslušný příkaz pro to je incoming (příchozí):

 $ cd ../baboon
 $ hg incoming ../makak

<!> Kdybychom chtěli vidět i diffy, použijeme přepínač hg incoming --patch stejně jako použijeme tento přepínač (hg log --patch) při zjišťování změn v repozitáři.

Pokud se nám změny zamlouvají, stáhneme je do hlavního adresáře projektu:

 $ hg pull ../makak

Změny jsme si z adresáře makak stáhli, ale v adresáři baboon je zatím nevidíme. Jsou uloženy v repozitáři .hg (viz Za kulisami).

Pokud jsme v adresáři baboon žádné změny neprovedli, stačí nám po stažení změn z adresáře makak provést pouze hg update tip, to jest aktualizovat pracovní adresář k novému tipu. Je však více než pravděpodobné, že jsme si v baboon změny provedli; v tom případě je nutné sloučit stažené změny se změnami lokálními:

 $ hg merge

Pokud jsou konflikty, provedeme hg resolve. Po sloučení musíme provést commit, aby se naše úpravy zapsaly do repozitáře:

 $ hg ci -m "připojený makak"

<!> Lze provést libovolný počet klonů a nosit je po kapsách na tyčinkách USB.

<!> Příkaz commit musíme zadat i po nekonfliktním sloučení, protože tím tuto změnu zapisujeme do historie.

Odvolání chyb

Někdy se nám podaří provést špatný komit. Pokud to zjistíme dřív, než provedeme další komit nebo pull, můžeme tuto zmýlenou snadno napravit příkazem rollback (odvolat):

 hg rollback

Podle přísloví dobrého pomálu nelze provést rollback dvakrát bezprostředně za sebou. Příkaz rollback lze použít také pro odvolání příkazu pull, pokud jsme poté neprovedli komit.

Sdílení změn

Popis případu

Nyní postoupíme o krok dále: Již nejsme sami a chceme své změny sdílet s ostatními.

V Mercurialu můžeme tuto spolupráci realizovat prostřednictvím lokálního serveru, posíláním změn e-mailem nebo s využitím veřejně přístupného webového serveru.

Průběh

Použití lokálního serveru

Aktivací vestavěného lokálního serveru na portu 800 umožníme ostatním na síti přístup do našeho počítače:

 $ hg serve

Zkusme nyní ve vlastním webovém serveru zadat adresu http://localhost:8000/. Otevře se nám stránka s pěkným přístupem k tomu repozitáři, u kterého byl server aktivován.

Všichni ostatní se k našemu serveru dostanou, pokud znají naši IP adresu (např 192.168.178.100)

 $ firefox http://192.168.178.100:8000

Mohou si z našeho repozitáře stáhnout poslední změny:

 $ hg pull http://192.168.178.100:8000

Z bezpečnostních důvodů je možné přes tento server provádět pouze 'pull', nikoliv 'push'.

Posílání změn e-mailem

Může se stát, že nemáte přístup k cizímu repozitáři; ten je buď odstíněn bezpečnostním firewallem nebo se nachází v jiném časovém pásmu. Důvodů pro tento způsob přenosu změn může být celá řada.

Změny pošleme jako specielní oprávkové soubory s příponou .diff.

Nejprve se podíváme, co vlastně chceme poslat:

 $ cd project
 $ hg log

Řekněme, že chceme poslat revize 3 a 4. Oprávkové soubory .diff vytvoříme pomocí příkazu 'hg export':

 $ hg export 3 &gt; change3.diff
 $ hg export 4 &gt; change4.diff

Soubory pošleme e-mailem. Příjemce si změny může importovat do svého repozitáře. Když bude opatrný, vytvoří si za účelem příjmu cizích změn klonovaný repozitář, do něhož změny načte:

 $ hg clone project integration
 $ cd integration
 $ hg import change3.diff
 $ hg import change4.diff

Po patřičné kontrole si importované změny stáhne do svého hlavního repozitáře:

 $ cd ../project
 $ hg pull ../integration

<!> Velmi efektní způsob přenosu změn v souboru je pomocí tak zvaného 'svazku (bundle)' viz:

 $ hg help bundle          # poněkud složitější

Použití společného repozitáře

Společný repozitář si vytvoříme na kolektivně přístupném privátním nebo veřejném serveru. Veřejných serverů je celá řada. Vyjmenujeme-li alespoň dva, zmíníme BitBucket a Launchpad. Posledně jmenovaný je podporován konkurenčním VCS, zvaným 'Bazaar'.

Základním pravidlem dobrého chování je to, že u takového repozitáře nevytváříme dvě čela.

Znamená to, že chceme-li poslat své změny do centrálního repozitáře, provedeme nejprve akci 'pull' a ve svém repozitáři vyřešíme případné konflikty a provedeme sloučení. Takto synchronizovanou změnu potom příkazem 'push' můžeme vyslat do centrálního repozitáře.

U centrálních repozitářů lze nastavit různou přístupovou politiku.

Popíšeme si podrobněji postup na serveru BitBucket, kde se zapíšeme jako uživatel.

Po přihlášení si vytvoříme nový repozitář tak, že přejedeme kurzorem přes nápis Repositories a vybereme Create new. Zadáme nazev repozitáře a popis jeho účelu. Chceme-li uzavřít přístup široké veřejnosti, označíme jej jako private.

Poté v repozitáři poklepneme na záložku Admin, kde můžeme v části Permissions:Readers a Permissions:Writers zapsat uživatelská jména svých kolegů, čímž jim umožníme provádět push do našeho repozitáře.

Řekněme, že naše uživatelské jméno je "ozon" a název repozitáře je "foo". Potom adresa našeho repozitáře bude https://bitbucket.org/ozon/foo.

Při volání našeho repozitáře (například)

$ hg incoming https://bitbucket.org/ozon/foo

jsme žádání o zadání uživatelského jména a hesla pro BitBucket.

S tímto repozitářem zacházíme stejně jako s lokálním repozítářem. Můžeme si z něho pořídit také lokální kopii (hello):

 $ hg clone https://bitbucket.org/ArneBab/hello/ hello

Do konfiguračního souboru naklonovaného repozitáře se automaticky načte adresa on-line repozitáře, takže ji při jeho volání nemusíme zadávat.

<!> Variantně lze dohodnout, že každý člen kolektivu má na BitBucket otevřený svůj repozitář, do kterého posílá své změny. Určený administrátor potom tyto změny podle svého uvážení stahuje do centrálního repozitáře, z něhož si ostatní aktuální změny stahují.

<!> You can also use this workflow with a shared server instead of BitBucket, either via SSH or via a shared directory. An example for an SSH URL with Mercurial is be ssh://user@example.com/path/to/repo. When using a shared directory you just push as if the repository in the shared directory were on your local drive. </div>

Shrnutí

Jak bylo již řečeno na začátku, tento text nevysvětluje podrobnosti, což je někdy právě to, čeho je nám třeba. Můžeme-li trochu anglicky, je dobré zkusit nápovědu k jednotlivým příkazům

$ hg help <příkaz>

Popsané postupy si ještě stručně připomeneme.

založit projekt

 $ hg init project
 $ cd project
 $ (přidat nějaké soubory)
 $ hg add
 $ hg commit
 (napsat komentář komitu)

větvený průběh

 $ (proveď nějaké změny)
 $ hg commit
 (napiš komentář komitu)
 $ hg update 0
 $ (proveď nějaké změny)
 $ hg commit
 (napiš komentář komitu)
 $ hg merge
 $ (případně s použitím hg resolve)
 $ hg commit
 (napiš komentář komitu)

rozdělení do klonů

 $ cd ..
 $ hg clone project feature1
 $ cd feature1
 $ (proveď nějaké změny)
 $ hg commit
 (napiš komentář komitu)
 $ cd ../project
 $ hg pull ../feature1

využití integrovaného serveru

 $ hg serve 
 $ cd ..
 $ hg clone http://127.0.0.1:8000 project-clone

export změn do souboru

 $ cd project-clone
 $ (proveď nějaké změny)
 $ hg commit
 (napiš komentář komitu)
 $ hg export tip &gt; ../changes.diff

import změn ze souboru

 $ cd ../project
 $ hg import ../changes.diff

stáhnout změny z repozitáře s aktivním serverem (hg serve)

 $ cd ../feature1
 $ hg pull http://127.0.0.1:8000

použití společného repo na BitBucket

 $ (setup bitbucket repo)
 $ hg push https://bitbucket.org/USER/REPO
 (zadat jméno a heslo)
 $ hg pull https://bitbucket.org/USER/REPO

Pokročilé průběhy

Anulování špatných revizí

Popis případu

Při stahování kódu z jiných repozitářů se může stát, že přehlédneme chybný changeset. Poté, co si jej jiní od nás stáhli, máme malou šanci, že se jej někdy úplně zbavíme.

Pro řešení tohoto problému nabízí Mercurial příkaz backout. Tento příkaz vytváří nový changeset, který je dítětem anulovaného changesetu a který ruší špatný changeset. Záznam špatného changesetu v historii nezrušíme, ale můžeme jej odebrat z nových revizí.

<!> Základní příkazy historii nepřepisují. Máme-li takovou potřebu, musíme aktivovat některou extenzi, která je součástí instalace Mercurialu. K tomuto tématu se dostaneme později.

Průběh

Řekněme, že špatnou změnou byla revize 3. Špatný kód se pokusíme odstranit příkazem backout. Tím vytvoříme novou změnu, která vytěsní tu starou. Protože provádíme změnu starší revize, vytvoříme další čelo, které musíme sloučit se stávajícím.

 $ hg backout 3
 $ hg merge
 (případně vyřešíme konflikty)
 $ hg commit
 (komentář komitu, např: "merged backout")

A je to. Odvolali jsme špatnou změnu. Je stále zaznamenáno, že existovala (podle zásady "nepřepisovat historii, pokud to není nezbytné"), ale již neovlivňuje budoucí kód.

Kolektivní vývoj variant

Nyní, když si umíme předávat změny a v případě potřeby je anulovat, můžeme postoupit dále: pomocí Mercurialu koordinovat vývoj kódu.

The first part is an easy way to develop features together, without requiring every developer to keep track of several feature clones.

Popis případu

Chceme-li rozdělit náš projekt do několika variant, potřebujeme vědět, kdo na čem pracuje a kde se jeho práce ukládá.

Mercurial to umožňuje svými "pojmenovanými větvemi". Ty jsou součástí hlavního repozitáře, takže jsou přístupné každému účastníkovi. Zároveň se změny komitované v jisté větvi nemísí se změnami v hlavní (default) větvi, takže jsou variace ukládány odděleně, dokud nejsou s hlavní větví sloučeny.

Průběh

Když někdo v naší skupině chce začít pracovat na variantě tak, aby nerušil ostatní, může vytvořit pojmenovanou větev a své změny ukládat zde. Když se někdo chce připojit, nic mu nebrání; připojuje své změny na konec větve. Po ukončení vývoje varianty lze pojmenovanou větev sloučit s hlavní větví.

Práce v pojmenované větvi

Vytvoření pojmenované větve:

 $ hg branch ferari     
 (proveď nějaké změny)
 $ hg commit            # větev se nadál jmenuje ferari
 (napiš komentář komitu)

Můžeme používat příkazy commit, pull, push, merge, ... jako kdybychom pracovali v samostatném repozitáři.

 $ hg update default    # nás přenese k poslední revizi před 'ferari'
  ...
 $ hg update ferari     # nás vrátí k poslední revizi úseku 'ferari'

Sloučení pojmenované větve

Po ukončení alternativního vývoje pojmenovanou větev ukončíme sloučením.

 $ hg update default
 $ hg merge ferari
 $ hg commit
 (napiš komentář komitu)

<!> Ukončená pojmenovaná větev je natrvalo zapsaná do historie. Pokud ji tam mít nechcete, lze to řešit způsobem, popsaným v [http://www.selenic.com/mercurial/wiki/Workflows workflows].

Označování revizí

Popis případu

Pro označení revizí uživatelem se v Mercurialu používají tagy. Připojení tagu k revizi lze provést i dodatečně. Zadání tagu vytváří samostatný changeset generovaný automatickým komitem se standardním koomentářem.

<!> Tag nesmí obsahovat znak ":", protože tento znak se používá pro vymezení rozsahu revizí - viz "hg help revisions".

<!> K bezpečnému označení revizí lze použít gpg extenzi.

Průběh

Řekněme, že cheme revizi 3 dát jméno otto

Přidáme tag:

 $ hg tag -r 3 v0.1

Prohlédneme si všechny tagy:

 $ hg tags

Když se podíváme na záznam (log), uvidíme v revizi 3 další řádek s názvem tagu. Chceme-li aktualizovat pracovní adresář k označené revizi, použijeme její tag:

 $ hg update otto

Odstranění historie

Popis případu

Někdy máme v repozitáři takové změny, které vůbec nepotřebujeme a

There are many advanced options for removing these, and most of them use great extensions ([http://www.selenic.com/mercurial/wiki/MqExtension Mercurial Queues] is the most often used one), but in this basic guide, we'll solve the problem with just the commands we already learned. But we'll use an option to clone which we didn't yet use.

This workflow becomes inconvenient when you need to remove changes, which are buried below many new changes. If you spot the bad changes early enough, you can get rid of them without too much effort, though.

Workflow

Let's assume you want to get rid of revision 2 and the highest revision is 3.

The first step is to use the "--rev" option to clone<nowiki>: Create a clone which only contains the changes up to the specified revision. Since you want to keep revision 1, you only clone up to that</nowiki>

  • $ hg clone -r 1 project stripped

Now you can export the change 3 from the original repository (project) and import it into the stripped one

  • $ cd project

    $ hg export 3 > ../changes.diff $ cd ../stripped $ hg import ../changes.diff

If a part of the changes couldn't be applied, you'll see that part in *.rej files. If you have *.rej files, you'll have to include or discard changes by hand

  • $ cat *.rej (apply changes by hand) $ hg commit (write commit message)

That's it. hg export also includes the commit message, date, committer and similar metadata, so you are already done.

<div class="note">

Note:

  • removing history will change the revision IDs of revisions after the removed one, and if you pull from someone else who still has the revision you removed, you will pull the removed parts again. That's why rewriting history should most times only be done for changes which you didn't yet publicise. </div>

Summary

So now you can work with Mercurial in private, and also share your changes in a multitude of ways.

Additionally you can remove bad changes, either by creating a change in the repository which reverses the original change, or by really rewriting history, so it looks like the change never occurred.

And you can separate the work on features in a single repository by using named branches and add tags to revisions which are visible markers for others and can be used to update to the tagged revisions.

With this we can conclude our practical guide.

More Complex Workflows

If you now want to check some more complex workflows, please have a look at the general [http://selenic.com/mercurial/wiki/Workflows workflows wikipage].

To deepen your understanding, you should also check the [http://mercurial.selenic.com/wiki/UnderstandingMercurial basic concept overview].

Have fun with Mercurial!

*PS: This guide is licensed under the [http://gnu.org/licenses/gpl-2.0.html GPLv2]*

*PPS: Written by Arne Babenhauserheide, edited by David Soria Parra, Nicolas Dumazet and Steve Losh. Conversion from HTML http://labs.seapine.com/htmltowiki.cgi*

CzechWorkflows (last edited 2013-12-28 09:13:03 by Tovim)