1.1 --- a/it/00book.xml	Fri Jul 10 18:38:26 2009 +0200
     1.2 +++ b/it/00book.xml	Sat Jul 11 14:46:53 2009 +0200
     1.3 @@ -22,7 +22,9 @@
     1.4  <!ENTITY ch12     SYSTEM "ch12-mq.xml">
     1.5  <!ENTITY ch13     SYSTEM "ch13-mq-collab.xml">
     1.6  <!ENTITY ch14     SYSTEM "ch14-hgext.xml">
     1.7 +-->
     1.8  <!ENTITY appA     SYSTEM "appA-svn.xml">
     1.9 +<!--
    1.10  <!ENTITY appB     SYSTEM "appB-mq-ref.xml">
    1.11  -->
    1.12  <!ENTITY appC     SYSTEM "appC-srcinstall.xml">
    1.13 @@ -113,8 +115,8 @@
    1.14    &ch13; -->
    1.15    <!-- BEGIN ch14
    1.16    &ch14; -->
    1.17 -  <!-- BEGIN appA
    1.18 -  &appA; -->
    1.19 +  <!-- BEGIN appA -->
    1.20 +  &appA;
    1.21    <!-- BEGIN appB
    1.22    &appB; -->
    1.23    <!-- BEGIN appC -->

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/it/appA-svn.xml	Sat Jul 11 14:46:53 2009 +0200
     2.3 @@ -0,0 +1,336 @@
     2.4 +<appendix id="svn">
     2.5 +  <?dbhtml filename="Migrare-verso-Mercurial.html"?>
     2.6 +<title>Migrare verso Mercurial</title>
     2.7 +
     2.8 +  <para id="x_6e1">Un modo comune di tastare il terreno con un nuovo strumento di controllo di revisione è sperimentarlo spostando un progetto esistente, piuttosto che cominciare un nuovo progetto da zero.</para>
     2.9 +
    2.10 +  <para id="x_6e2">In questa appendice, parliamo di come importare la cronologia di un progetto in Mercurial e di quello a cui dovete essere preparati se siete abituati a un sistema di controllo di revisione differente.</para>
    2.11 +
    2.12 +  <sect1>
    2.13 +    <title>Importare la cronologia da un altro sistema</title>
    2.14 +
    2.15 +    <para id="x_6e3">Mercurial include un'estensione chiamata <literal>convert</literal> che può importare la cronologia di un progetto dalla maggior parte dei sistemi di controllo di revisione più popolari. Al momento in cui il libro è stato scritto, l'estensione può importare la cronologia dai seguenti sistemi:</para>
    2.16 +    <itemizedlist>
    2.17 +      <listitem>
    2.18 +	<para id="x_6e4">Subversion</para>
    2.19 +      </listitem>
    2.20 +      <listitem>
    2.21 +	<para id="x_6e5">CVS</para>
    2.22 +      </listitem>
    2.23 +      <listitem>
    2.24 +	<para id="x_6e6">git</para>
    2.25 +      </listitem>
    2.26 +      <listitem>
    2.27 +	<para id="x_6e7">Darcs</para>
    2.28 +      </listitem>
    2.29 +      <listitem>
    2.30 +	<para id="x_6e8">Bazaar</para>
    2.31 +      </listitem>
    2.32 +      <listitem>
    2.33 +	<para id="x_6e9">Monotone</para>
    2.34 +      </listitem>
    2.35 +      <listitem>
    2.36 +	<para id="x_6ea">GNU Arch</para>
    2.37 +      </listitem>
    2.38 +      <listitem>
    2.39 +	<para id="x_6eb">Mercurial</para>
    2.40 +      </listitem>
    2.41 +    </itemizedlist>
    2.42 +
    2.43 +    <para id="x_6ec">(Per verificare se lo stesso Mercurial è supportato come sorgente da cui importare la cronologia, si veda la <xref linkend="svn.filemap"/>.)</para>
    2.44 +
    2.45 +    <para id="x_6ed">Potete abilitare l'estensione nel solito modo, modificando il vostro file <filename>~/.hgrc</filename>.</para>
    2.46 +
    2.47 +    <programlisting>[extensions]
    2.48 +convert =</programlisting>
    2.49 +
    2.50 +    <para id="x_6ee">Questo renderà disponibile il comando <command>hg convert</command> Il comando è facile da usare. Per esempio, l'invocazione seguente importerà la cronologia di Subversion per il framework di collaudo di unità Nose in Mercurial.</para>
    2.51 +
    2.52 +    <screen><prompt>$</prompt> <userinput>hg convert http://python-nose.googlecode.com/svn/trunk</userinput></screen>
    2.53 +
    2.54 +    <para id="x_6ef">L'estensione <literal>convert</literal> opera in maniera incrementale. In altre parole, dopo che avete eseguito <command>hg convert</command> una prima volta, eseguendolo nuovamente importerete qualsiasi nuova revisione inserita dopo che avete dato il via alla prima esecuzione. La conversione incrementale funzionerà solo se eseguite <command>hg convert</command> nello stesso repository Mercurial che avete usato in origine, perché l'estensione <literal>convert</literal> salva alcuni metadati privati in un file esterno al controllo di revisione chiamato <filename>.hg/shamap</filename> all'interno del repository.</para>
    2.55 +
    2.56 +    <para id="x_707">Quando volete cominciare a fare modifiche usando Mercurial, la cosa migliore è clonare l'alberto in cui state facendo le vostre conversioni e lasciare l'albero originale per conversioni incrementali future. Questo è il modo più sicuro di permettervi di estrarre e unire i futuri inserimenti dal sistema di controllo di revisione sorgente nel vostro progetto Mercurial appena attivato.</para>
    2.57 +
    2.58 +    <sect2>
    2.59 +      <title>Convertire rami molteplici</title>
    2.60 +
    2.61 +      <para id="x_708">Il comando <command>hg convert</command> eseguito in precedenza converte solo la cronologia del <literal>trunk</literal> del repository Subversion. Se invece usiamo l'URL <literal>http://python-nose.googlecode.com/svn</literal>, Mercurial scoprirà automaticamente le directory <literal>trunk</literal>, <literal>tags</literal> e <literal>branches</literal> che compongono il layout usato di solito dai progetti Subversion e le importerà in Mercurial come rami separati.</para>
    2.62 +
    2.63 +      <para id="x_709">Di default, a ogni ramo Subversion importato in Mercurial viene assegnato un nome di ramo. Dopo che la conversione si è conclusa, potete ottenere una lista dei nomi dei rami attivi nel repository Mercurial usando <command>hg branches -a</command>. Se preferite importare i rami Subversion senza nomi, passate l'opzione <option>--config convert.hg.usebranchnames=false</option> al comando <command>hg convert</command>.</para>
    2.64 +
    2.65 +      <para id="x_70a">Una volta che avete convertito il vostro albero, se volete seguire la classica procedura Mercurial di lavorare in un albero che contiene un singolo ramo, potete clonare quel singolo ramo usando <command>hg clone -r mybranchname</command>.</para>
    2.66 +    </sect2>
    2.67 +
    2.68 +    <sect2>
    2.69 +      <title>Correlare i nomi utente</title>
    2.70 +
    2.71 +      <para id="x_6f0">Alcuni strumenti di controllo di revisione salvano solo nomi utenti brevi con ogni inserimento e questi possono essere difficili da interpretare. La norma con Mercurial è quella di salvare il nome e l'indirizzo email di chi effettua il commit, che è molto più utile per parlare con loro dopo il fatto.</para>
    2.72 +
    2.73 +      <para id="x_6f1">Se state convertendo un albero da un sistema di controllo di revisione che usa nomi brevi, potete correlare quei nomi a equivalenti più lunghi passando l'opzione <option>--authors</option> a <command>hg convert</command>. Questa opzione accetta un nome di file che dovrebbe contenere voci della forma seguente.</para>
    2.74 +
    2.75 +      <programlisting>arist = Aristotle &lt;aristotle@phil.example.gr&gt;
    2.76 +soc = Socrates &lt;socrates@phil.example.gr&gt;</programlisting>
    2.77 +
    2.78 +      <para id="x_6f2">Ogni volta che <literal>convert</literal> incontra un commit associato al nome utente <literal>arist</literal> nel repository sorgente, userà il nome <literal>Aristotle &lt;aristotle@phil.example.gr&gt;</literal> nella revisione convertita in Mercurial. Se nessuna corrispondenza viene trovata per un dato nome, quel nome è usato alla lettera.</para>
    2.79 +    </sect2>
    2.80 +
    2.81 +    <sect2 id="svn.filemap">
    2.82 +      <title>Rassettare l'albero</title>
    2.83 +
    2.84 +      <para id="x_6f3">Non tutti i progetti hanno una cronologia pristina. Potrebbe esserci una directory che non avrebbe mai dovuto essere inserita, un file che è troppo grande, o un'intera gerarchia che ha bisogno di essere riorganizzata.</para>
    2.85 +
    2.86 +      <para id="x_6f4">L'estensione <literal>convert</literal> supporta l'idea di una <quote>mappa di file</quote> che può riorganizzare i file e le directory in un progetto nel momento in cui ne importa la cronologia. Questo è utile non solo quando si importa la cronologia da altri sistemi di controllo di revisione, ma anche per potare o riorganizzare un albero di Mercurial.</para>
    2.87 +
    2.88 +      <para id="x_6f5">Per specificare una mappa di file, usate l'opzione <option>--filemap</option> e fornitele un nome di file. Una mappa di file contiene righe nei seguenti formati.</para>
    2.89 +
    2.90 +      <programlisting># Questo è un commento
    2.91 +# Le righe vuote vengono ignorate
    2.92 +
    2.93 +include path/to/file
    2.94 +
    2.95 +exclude path/to/file
    2.96 +
    2.97 +rename from/some/path to/some/other/place
    2.98 +</programlisting>
    2.99 +
   2.100 +      <para id="x_6f6">La direttiva <literal>include</literal> provoca l'inclusione di un file, o di tutti i file contenuti in una directory, nel repository destinazione. Questa direttiva provoca anche l'esclusione di tutti gli altri file o directory che non sono stati esplicitamente inclusi. La direttiva <literal>exclude</literal> provoca l'omissione di file e directory indicati e di tutti quegli altri che non sono stati esplicitamente menzionati per essere inclusi.</para>
   2.101 +
   2.102 +      <para id="x_6f7">Per spostare un file o una directory da una posizione a un'altra, usate la direttiva <literal>rename</literal>. Se dovete spostare un file o una directory da una sottodirectory alla radice del repository, usate <literal>.</literal> come secondo argomento della direttiva <literal>rename</literal>.</para>
   2.103 +    </sect2>
   2.104 +
   2.105 +    <sect2>
   2.106 +      <title>Migliorare le prestazioni della conversione da Subversion</title>
   2.107 +
   2.108 +      <para id="x_70b">Avrete spesso bisogno di fare diversi tentativi prima di trovare la combinazione perfetta tra mappa di utenti, mappa di file e altri parametri di conversione. Convertire un repository Subversion attraverso un protocollo di accesso come <literal>ssh</literal> o <literal>http</literal> può procedere migliaia di volte più lentamente di quanto Mercurial sia in grado di operare effettivamente, a causa della latenza di rete. Questo può rendere molto dolorosa la regolazione di quella ricetta per la conversione perfetta.</para>
   2.109 +
   2.110 +      <para id="x_70c">Il comando <ulink url="http://svn.collab.net/repos/svn/trunk/notes/svnsync.txt"><command>svnsync</command></ulink> può velocizzare grandemente la conversione di un repository Subversion. Serve per creare un mirror di sola lettura di un repository Subversion. L'idea è quella di creare un mirror locale del vostro albero Subversion, poi di convertire il mirror in un repository Mercurial.</para>
   2.111 +
   2.112 +      <para id="x_70d">Immaginiamo di voler convertire il repository Subversion che contiene il popolare progetto Memcached in un albero Mercurial. Per prima cosa, creiamo un repository Subversion locale.</para>
   2.113 +
   2.114 +      <screen><prompt>$</prompt> <userinput>svnadmin create memcached-mirror</userinput></screen>
   2.115 +
   2.116 +      <para id="x_70e">Successivamente, impostiamo un ~hook~ Subversion di cui <command>svnsync</command> ha bisogno.</para>
   2.117 +
   2.118 +      <screen><prompt>$</prompt> <userinput>echo '#!/bin/sh' > memcached-mirror/hooks/pre-revprop-change</userinput>
   2.119 +<prompt>$</prompt> <userinput>chmod +x memcached-mirror/hooks/pre-revprop-change</userinput></screen>
   2.120 +
   2.121 +      <para id="x_70f">Poi inizializziamo <command>svnsync</command> in questo repository.</para>
   2.122 +
   2.123 +      <screen><prompt>$</prompt> <userinput>svnsync --init file://`pwd`/memcached-mirror \
   2.124 +  http://code.sixapart.com/svn/memcached</userinput></screen>
   2.125 +
   2.126 +      <para id="x_710">Il passo successivo consiste nel cominciare il processo di creazione del mirror con il comando <command>svnsync</command>.</para>
   2.127 +
   2.128 +      <screen><prompt>$</prompt> <userinput>svnsync sync file://`pwd`/memcached-mirror</userinput></screen>
   2.129 +
   2.130 +      <para id="x_711">Infine, importiamo la cronologia del nostro mirror locale del repository Subversion in un repository Mercurial.</para>
   2.131 +
   2.132 +      <screen><prompt>$</prompt> <userinput>hg convert memcached-mirror</userinput></screen>
   2.133 +      
   2.134 +      <para id="x_712">Possiamo usare questo processo in maniera incrementale se il repository Subversion è ancora attivo. Eseguiamo <command>svnsync</command> per propagare i nuovi cambiamenti verso il nostro mirror e poi eseguiamo <command>hg convert</command> per importarli nel nostro albero Mercurial.</para>
   2.135 +
   2.136 +      <para id="x_713">Ci sono due vantaggi nel fare una importazione in due stadi con <command>svnsync</command>. Il primo è che usa una sincronizzazione di rete con Subversion più efficiente rispetto al comando <command>hg convert</command>, quindi trasferisce meno dati attraverso la rete. Il secondo è che l'importazione da un albero Subversion locale è così veloce che potete aggiustare ripetutamente le vostre impostazioni di conversione senza aspettare che un processo di conversione basato sulla rete e dolorosamente lento si concluda ogni volta.</para>
   2.137 +    </sect2>
   2.138 +  </sect1>
   2.139 +
   2.140 +  <sect1>
   2.141 +    <title>Migrare da Subversion</title>
   2.142 +
   2.143 +    <para id="x_6f8">Attualmente Subversion è il sistema di controllo di revisione open source più popolare. Sebbene ci siano molte differenze tra Mercurial e Subversion, effettuare una transizione da Subversion a Mercurial non è particolarmente difficile. I due hanno insiemi di comandi simili e interfacce generalmente uniformi.</para>
   2.144 +
   2.145 +    <sect2>
   2.146 +      <title>Differenze filosofiche</title>
   2.147 +
   2.148 +      <para id="x_6f9">Naturalmente, la differenza fondamentale tra Subversion e Mercurial è che Subversion è centralizzato mentre Mercurial è distribuito. Dato che Mercurial memorizza tutta la cronologia di un progetto sul vostro disco locale, ha bisogno di accedere alla rete solo quando volete esplicitamente comunicare con un altro repository. Al contrario, Subversion memorizza localmente un'esigua quantità di informazioni, perciò il client deve contattare il proprio server per molte operazioni comuni.</para>
   2.149 +
   2.150 +      <para id="x_6fa">Subversion riesce più o meno a cavarsela senza una nozione di ramo ben definita: quale porzione di uno spazio di nomi sul server si qualifica come ramo è un problema di convenzioni, e il software non fornisce alcuna imposizione. Mercurial tratta un repository come l'unità della gestione dei rami.</para>
   2.151 +
   2.152 +      <sect3>
   2.153 +	<title>L'ambito dei comandi</title>
   2.154 +
   2.155 +	<para id="x_6fb">Dato che Subversion non sa quali parti del suo spazio di nomi siano realmente rami, tratta la maggior parte dei comandi come se richiedesse di operare al livello di qualsiasi directory stiate correntemente visitando e ai livelli sottostanti. Per esempio, se eseguite <command>svn log</command>, otterrete la cronologia di qualunque parte dell'albero stiate osservando, non dell'intero albero.</para>
   2.156 +
   2.157 +	<para id="x_6fc">I comandi Mercurial si comportano in maniera differente, perché di default operano sull'intero repository. Eseguite <command>hg log</command> e vi mostrerà la cronologia dell'intero albero, a prescindere da quale parte della directory di lavoro stiate visitando in quel momento. Se volete solo la cronologia di un file o una directory particolare, vi basta fornire un nome al comando, e.g. <command>hg log src</command>.</para>
   2.158 +
   2.159 +	<para id="x_6fd">Per la mia esperienza, questa differenza nel comportamento predefinito dei comandi è probabilmente la cosa che potrà confondervi di più se dovete spostarvi frequentemente avanti e indietro tra i due strumenti.</para>
   2.160 +      </sect3>
   2.161 +
   2.162 +      <sect3>
   2.163 +	<title>Operazioni multi-utente e sicurezza</title>
   2.164 +
   2.165 +	<para id="x_6fe">Con Subversion, è normale (anche se leggermente disapprovato) collaborare tra più persone in un singolo ramo. Se Alice e Bruno stanno lavorando insieme e Alice inserisce alcune modifiche al loro ramo condiviso, Bruno deve aggiornare la vista del ramo del suo client prima di poter effettuare un commit. Dato che in quel momento non ha alcuna registrazione permanente dei cambiamenti che ha fatto, potrebbe rovinare o perdere le proprie modifiche durante e dopo questo aggiornamento.</para>
   2.166 +
   2.167 +	<para id="x_6ff">Mercurial, invece, incoraggia un modello di inserimento-e-unione. Bruno inserisce le proprie modifiche nel suo repository locale prima di estrarre i cambiamenti dal, o trasmetterli al, server che condivide con Alice. Se Alice trasmette i suoi cambiamenti prima che Bruno provi a trasmettere i propri, Bruno non sarà in grado di trasmettere i propri cambiamenti prima di aver estratto quelli di Alice, averli incorporati e aver effettuato il commit dei risultati dell'unione. Se commette un errore durante l'unione, ha ancora l'opzione di ritornare al commit che aveva registrato i suoi cambiamenti.</para>
   2.168 +
   2.169 +	<para id="x_700">Vale la pena sottolineare che questi sono i modi più comuni di lavorare con questi strumenti. Subversion supporta un modello più sicuro di lavorare-nel-vostro-ramo-personale, che però in pratica si rivela abbastanza scomodo da non essere largamente usato. Mercurial può supportare il modello meno sicuro di consentire l'estrazione e l'unione di cambiamenti su modifiche non ancora registrate, ma questo è considerato estremamente inusuale.</para>
   2.170 +      </sect3>
   2.171 +
   2.172 +      <sect3>
   2.173 +	<title>Cambiamenti locali o pubblici</title>
   2.174 +
   2.175 +	<para id="x_701">Il comando <command>svn commit</command> pubblica immediatamente i cambiamenti su un server dove possono essere visti da chiunque abbia accesso in lettura.</para>
   2.176 +
   2.177 +	<para id="x_702">Con Mercurial, i commit sono sempre locali e devono essere pubblicati successivamente tramite il comando <command>hg push</command>.</para>
   2.178 +
   2.179 +	<para id="x_703">Ogni approccio ha i propri vantaggi e svantaggi. Il modello di Subversion significa che i cambiamenti sono pubblicati, e quindi revisionabili e utilizzabili, immediatamente. D'altra parte, questo significa che un utente deve avere accesso in scrittura a un repository per utilizzare lo strumento in maniera normale, ma la maggior parte dei progetti open source non concede alla leggera i permessi di scrittura.</para>
   2.180 +
   2.181 +	<para id="x_704">L'approccio di Mercurial consente a chiunque possa clonare un repository di inserirvi modifiche senza il bisogno del permesso di qualcun altro, e chiunque può pubblicare i propri cambiamenti e continuare a partecipare nel modo che preferisce. La distinzione tra le operazioni di inserimento e trasmissione dei cambiamenti apre la possibilità che qualcuno effettui il commit di alcune modifiche sul proprio computer e si allontani per qualche giorno dimenticandosi di trasmetterli, che in rari casi potrebbe lasciare i collaboratori temporaneamente bloccati.</para>
   2.182 +      </sect3>
   2.183 +    </sect2>
   2.184 +
   2.185 +    <sect2>
   2.186 +      <title>~Quick reference~</title>
   2.187 +
   2.188 +      <table>
   2.189 +	<title>Equivalenze tra i comandi Subversion e Mercurial</title>
   2.190 +	<tgroup cols="3">
   2.191 +	  <thead>
   2.192 +	    <row>
   2.193 +	      <entry>Subversion</entry>
   2.194 +	      <entry>Mercurial</entry>
   2.195 +	      <entry>Notes</entry>
   2.196 +	    </row>
   2.197 +	  </thead>
   2.198 +	  <tbody>
   2.199 +	    <row>
   2.200 +	      <entry><command>svn add</command></entry>
   2.201 +	      <entry><command>hg add</command></entry>
   2.202 +	      <entry></entry>
   2.203 +	    </row>
   2.204 +	    <row>
   2.205 +	      <entry><command>svn blame</command></entry>
   2.206 +	      <entry><command>hg annotate</command></entry>
   2.207 +	      <entry></entry>
   2.208 +	    </row>
   2.209 +	    <row>
   2.210 +	      <entry><command>svn cat</command></entry>
   2.211 +	      <entry><command>hg cat</command></entry>
   2.212 +	      <entry></entry>
   2.213 +	    </row>
   2.214 +	    <row>
   2.215 +	      <entry><command>svn checkout</command></entry>
   2.216 +	      <entry><command>hg clone</command></entry>
   2.217 +	      <entry></entry>
   2.218 +	    </row>
   2.219 +	    <row>
   2.220 +	      <entry><command>svn cleanup</command></entry>
   2.221 +	      <entry>n/a</entry>
   2.222 +	      <entry>Nessuna pulizia necessaria</entry>
   2.223 +	    </row>
   2.224 +	    <row>
   2.225 +	      <entry><command>svn commit</command></entry>
   2.226 +	      <entry><command>hg commit</command>; <command>hg
   2.227 +		  push</command></entry>
   2.228 +	      <entry><command>hg push</command> pubblica le modifiche dopo il commit</entry>
   2.229 +	    </row>
   2.230 +	    <row>
   2.231 +	      <entry><command>svn copy</command></entry>
   2.232 +	      <entry><command>hg clone</command></entry>
   2.233 +	      <entry>Per creare un nuovo ramo</entry>
   2.234 +	    </row>
   2.235 +	    <row>
   2.236 +	      <entry><command>svn copy</command></entry>
   2.237 +	      <entry><command>hg copy</command></entry>
   2.238 +	      <entry>Per copiare file o directory</entry>
   2.239 +	    </row>
   2.240 +	    <row>
   2.241 +	      <entry><command>svn delete</command> (<command>svn
   2.242 +		  remove</command>)</entry>
   2.243 +	      <entry><command>hg remove</command></entry>
   2.244 +	      <entry></entry>
   2.245 +	    </row>
   2.246 +	    <row>
   2.247 +	      <entry><command>svn diff</command></entry>
   2.248 +	      <entry><command>hg diff</command></entry>
   2.249 +	      <entry></entry>
   2.250 +	    </row>
   2.251 +	    <row>
   2.252 +	      <entry><command>svn export</command></entry>
   2.253 +	      <entry><command>hg archive</command></entry>
   2.254 +	      <entry></entry>
   2.255 +	    </row>
   2.256 +	    <row>
   2.257 +	      <entry><command>svn help</command></entry>
   2.258 +	      <entry><command>hg help</command></entry>
   2.259 +	      <entry></entry>
   2.260 +	    </row>
   2.261 +	    <row>
   2.262 +	      <entry><command>svn import</command></entry>
   2.263 +	      <entry><command>hg addremove</command>; <command>hg
   2.264 +		  commit</command></entry>
   2.265 +	      <entry></entry>
   2.266 +	    </row>
   2.267 +	    <row>
   2.268 +	      <entry><command>svn info</command></entry>
   2.269 +	      <entry><command>hg parents</command></entry>
   2.270 +	      <entry>Mostra quale revisione è stata estratta</entry>
   2.271 +	    </row>
   2.272 +	    <row>
   2.273 +	      <entry><command>svn info</command></entry>
   2.274 +	      <entry><command>hg showconfig
   2.275 +		  paths.parent</command></entry>
   2.276 +	      <entry>Mostra quale URL è stato estratto</entry>
   2.277 +	    </row>
   2.278 +	    <row>
   2.279 +	      <entry><command>svn list</command></entry>
   2.280 +	      <entry><command>hg manifest</command></entry>
   2.281 +	      <entry></entry>
   2.282 +	    </row>
   2.283 +	    <row>
   2.284 +	      <entry><command>svn log</command></entry>
   2.285 +	      <entry><command>hg log</command></entry>
   2.286 +	      <entry></entry>
   2.287 +	    </row>
   2.288 +	    <row>
   2.289 +	      <entry><command>svn merge</command></entry>
   2.290 +	      <entry><command>hg merge</command></entry>
   2.291 +	      <entry></entry>
   2.292 +	    </row>
   2.293 +	    <row>
   2.294 +	      <entry><command>svn mkdir</command></entry>
   2.295 +	      <entry>n/a</entry>
   2.296 +	      <entry>Mercurial non tiene traccia delle directory</entry>
   2.297 +	    </row>
   2.298 +	    <row>
   2.299 +	      <entry><command>svn move</command> (<command>svn
   2.300 +		  rename</command>)</entry>
   2.301 +	      <entry><command>hg rename</command></entry>
   2.302 +	      <entry></entry>
   2.303 +	    </row>
   2.304 +	    <row>
   2.305 +	      <entry><command>svn resolved</command></entry>
   2.306 +	      <entry><command>hg resolve -m</command></entry>
   2.307 +	      <entry></entry>
   2.308 +	    </row>
   2.309 +	    <row>
   2.310 +	      <entry><command>svn revert</command></entry>
   2.311 +	      <entry><command>hg revert</command></entry>
   2.312 +	      <entry></entry>
   2.313 +	    </row>
   2.314 +	    <row>
   2.315 +	      <entry><command>svn status</command></entry>
   2.316 +	      <entry><command>hg status</command></entry>
   2.317 +	      <entry></entry>
   2.318 +	    </row>
   2.319 +	    <row>
   2.320 +	      <entry><command>svn update</command></entry>
   2.321 +	      <entry><command>hg pull -u</command></entry>
   2.322 +	      <entry></entry>
   2.323 +	    </row>
   2.324 +	  </tbody>
   2.325 +	</tgroup>
   2.326 +      </table>
   2.327 +    </sect2>
   2.328 +  </sect1>
   2.329 +
   2.330 +  <sect1>
   2.331 +    <title>Suggerimenti utili per i principianti</title>
   2.332 +
   2.333 +    <para id="x_705">In alcuni sistemi di controllo di revisione, stampare le differenze per una singola revisione inserita può essere doloroso. Per esempio, con Subversion, per vedere cosa è cambiato nella revisione 104654 dovete digitare <command>svn diff -r104653:104654</command>. Mercurial elimina la necessità di digitare due volte l'identificatore di revisione in questo caso comune. Per ottenere solo le differenze, digitate <command>hg export 104654</command>. Per un ottenere messaggio nel registro della cronologia seguito dalle differenze, digitate <command>hg log -r104654 -p</command>.</para>
   2.334 +
   2.335 +    <para id="x_706">Quando eseguite <command>hg status</command> senza argomenti, vi viene mostrato lo stato dell'intero albero, con i percorsi relativi alla radice del repository. Questo rende complicato copiare un nome di file dal risultato di <command>hg status</command> alla riga di comando. Se eseguite <command>hg command</command> passandogli il nome di un file o di una directory, il comando stamperà i percorsi relativi alla vostra posizione corrente. Quindi, per ottenere da <command>hg status</command> lo stato di tutto l'albero, con i percorsi relativi alla vostra directory corrente invece che alla radice del repository, passate il risultato di <command>hg root</command> al comando <command>hg status</command>. Su un sistema di tipo Unix, potete farlo facilmente nel modo che segue:</para>
   2.336 +
   2.337 +    <screen><prompt>$</prompt> <userinput>hg status `hg root`</userinput></screen>
   2.338 +  </sect1>
   2.339 +</appendix>