1.1 --- a/it/00book.xml	Sun Jun 28 17:35:24 2009 +0200
     1.2 +++ b/it/00book.xml	Mon Jun 29 17:39:32 2009 +0200
     1.3 @@ -9,8 +9,8 @@
     1.4  <!ENTITY ch00     SYSTEM "ch00-preface.xml">
     1.5  <!ENTITY ch01     SYSTEM "ch01-intro.xml">
     1.6  <!ENTITY ch02     SYSTEM "ch02-tour-basic.xml">
     1.7 +<!ENTITY ch03     SYSTEM "ch03-tour-merge.xml">
     1.8  <!--
     1.9 -<!ENTITY ch03     SYSTEM "ch03-tour-merge.xml">
    1.10  <!ENTITY ch04     SYSTEM "ch04-concepts.xml">
    1.11  <!ENTITY ch05     SYSTEM "ch05-daily.xml">
    1.12  <!ENTITY ch06     SYSTEM "ch06-collab.xml">
    1.13 @@ -87,8 +87,8 @@
    1.14    &ch01;
    1.15    <!-- BEGIN ch02 -->
    1.16    &ch02;
    1.17 -  <!-- BEGIN ch03
    1.18 -  &ch03; -->
    1.19 +  <!-- BEGIN ch03 -->
    1.20 +  &ch03;
    1.21    <!-- BEGIN ch04
    1.22    &ch04; -->
    1.23    <!-- BEGIN ch05

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/it/ch03-tour-merge.xml	Mon Jun 29 17:39:32 2009 +0200
     2.3 @@ -0,0 +1,234 @@
     2.4 +<chapter id="chap:tour-merge">
     2.5 +  <?dbhtml filename="una-panoramica-di-mercurial-unire-il-lavoro.html"?>
     2.6 +  <title>Una panoramica di Mercurial: unire il lavoro</title>
     2.7 +
     2.8 +  <para id="x_338">Abbiamo ora coperto il clonare un repository, effettuare cambiamenti in un repository, e estrarre o trasmettere cambiamenti da un repository a un altro. Il nostro prossimo passo sarà <emphasis>unire</emphasis> i cambiamenti da repository separati.</para>
     2.9 +
    2.10 +  <sect1>
    2.11 +    <title>Unire flussi di lavoro</title>
    2.12 +
    2.13 +    <para id="x_339">Le unioni sono una parte fondamentale del lavoro con uno strumento per il controllo di revisione distribuito. Ecco alcuni casi in cui il bisogno di unire il lavoro si solleva.</para>
    2.14 +    <itemizedlist>
    2.15 +      <listitem>
    2.16 +	<para id="x_33a">Alice e Bruno hanno ognuno una copia personale di un repository per un progetto su cui stanno collaborando. Mentre Alice corregge un bug nel suo repository, Bruno aggiunge una nuova caratteristica nel proprio. Entrambi vogliono che il repository condiviso contenga sia la correzione del bug sia la nuova caratteristica.</para>
    2.17 +      </listitem>
    2.18 +      <listitem>
    2.19 +	<para id="x_33b">Cinzia lavora frequentemente su numerose attività differenti alla volta per un singolo progretto, ognuna isolata al sicuro nel proprio repository. Lavorando in questo modo, Cinzia ha spesso bisogno di unire un fremmento del proprio lavoro con un altro.</para>
    2.20 +      </listitem>
    2.21 +    </itemizedlist>
    2.22 +
    2.23 +    <para id="x_33c">Dato che abbiamo bisogno di effettuare spesso delle unioni, Mercurial facilita il processo. Camminiamo attraverso una unione. Cominceremo clonando ancora un altro repository (vedete quanto spesso spuntano fuori?) e effettuando un cambiamento in esso.</para>
    2.24 +
    2.25 +    &interaction.tour.merge.clone;
    2.26 +
    2.27 +    <para id="x_33d">Ora dovremmo avere due copie di <filename>hello.c</filename> con contenuti differenti. Le cronologie dei due repository ora divergono l'una dall'altra, come illustrato nella <xref linkend="fig:tour-merge:sep-repos"/>. Ecco la copia del nostro file da un repository.</para>
    2.28 +
    2.29 +    &interaction.tour.merge.cat1;
    2.30 +
    2.31 +    <para id="x_722">Ed ecco la nostra versione leggermente differente dall'altro.</para>
    2.32 +
    2.33 +    &interaction.tour.merge.cat2;
    2.34 +
    2.35 +    <figure id="fig:tour-merge:sep-repos">
    2.36 +      <title>Le recenti cronologie divergenti dei repository <filename class="directory">my-hello</filename> e <filename class="directory">my-new-hello</filename></title>
    2.37 +      <mediaobject>
    2.38 +	<imageobject><imagedata fileref="figs/tour-merge-sep-repos.png"/></imageobject>
    2.39 +	<textobject><phrase>XXX add text</phrase></textobject>
    2.40 +      </mediaobject>
    2.41 +    </figure>
    2.42 +
    2.43 +    <para id="x_33f">Sappiamo già che estrarre i cambiamenti dal nostro repository <filename class="directory">my-hello</filename> non avrà alcun effetto sulla directory di lavoro.</para>
    2.44 +
    2.45 +    &interaction.tour.merge.pull;
    2.46 +
    2.47 +    <para id="x_340">Tuttavia, il comando <command role="hg-cmd">hg pull</command> dice qualcosa a proposito di <quote>teste</quote>.</para>
    2.48 +
    2.49 +    <sect2>
    2.50 +      <title>I changeset di testa</title>
    2.51 +
    2.52 +      <para id="x_341">Ricordate che Mercurial registra qual è il genitore di ogni cambiamento. Se un cambiamento ha un genitore, chiamiamo quel cambiamento un figlio o discendente del genitore. Una testa è un cambiamento che non ha figli. La revisione di punta è quindi una testa, perché la revisione più recente in un repository non ha alcun figlio. Ci sono occasioni in cui un repository può contenere più di una testa.</para>
    2.53 +
    2.54 +      <figure id="fig:tour-merge:pull">
    2.55 +	<title>I contenuti del repository dopo aver propagato i cambiamenti da <filename class="directory">my-hello</filename> a <filename class="directory">my-new-hello</filename></title>
    2.56 +	<mediaobject>
    2.57 +	  <imageobject>
    2.58 +	    <imagedata fileref="figs/tour-merge-pull.png"/>
    2.59 +	  </imageobject>
    2.60 +	  <textobject><phrase>XXX add text</phrase></textobject>
    2.61 +	</mediaobject>
    2.62 +      </figure>
    2.63 +
    2.64 +      <para id="x_343">Dalla figura <xref linkend="fig:tour-merge:pull"/>, potete vedere l'effetto della propagazione dei cambiamenti dal repository  <filename class="directory">my-hello</filename> al repository <filename class="directory">my-new-hello</filename>. La cronologia che era già presente in <filename class="directory">my-new-hello</filename> non viene toccata, ma una nuova revisione è stata aggiunta. Riferendoci alla <xref linkend="fig:tour-merge:sep-repos"/>, possiamo vedere che l'<emphasis>identificatore di changeset</emphasis> rimane lo stesso nel nuovo repository, ma che il <emphasis>numero di revisione</emphasis> è cambiato. (Questo, incidentalmente, è un buon esempio del perché non è sicuro usare i numeri di revisione per discutere i changeset.) Possiamo vedere le teste di un repository utilizzando il comando <command role="hg-cmd">hg heads</command>.</para>
    2.65 +
    2.66 +      &interaction.tour.merge.heads;
    2.67 +    </sect2>
    2.68 +
    2.69 +    <sect2>
    2.70 +      <title>Effettuare l'unione</title>
    2.71 +
    2.72 +      <para id="x_344">Cosa succede se proviamo a usare il normale comando <command role="hg-cmd">hg update</command> per aggiornare alla nuova punta?</para>
    2.73 +
    2.74 +      &interaction.tour.merge.update;
    2.75 +
    2.76 +      <para id="x_345">Mercurial ci sta dicendo che il comando <command role="hg-cmd">hg update</command> non farà una unione; non aggiornerà la directory di lavoro quando pensa che potremmo voler fare una unione, a meno che non lo forziamo a farlo. (Incidentalmente, forzare l'aggiornamento con <command>hg update -C</command> would revert any uncommitted changes in the working directory.)</para>
    2.77 +
    2.78 +      <para id="x_723">Per cominciare una unione tra le due teste, usiamo il comando <command role="hg-cmd">hg merge</command>.</para>
    2.79 +
    2.80 +      &interaction.tour.merge.merge;
    2.81 +
    2.82 +      <para id="x_347">We resolve il contenuto del file <filename>hello.c</filename>. Questo aggiorna la directory di lavoro in modo che contenga i cambiamenti da <emphasis>entrambe</emphasis> le teste, cosa che si riflette sia nel risultato del comando <command role="hg-cmd">hg parents</command> sia nei contenuti del file <filename>hello.c</filename>.</para>
    2.83 +
    2.84 +      &interaction.tour.merge.parents;
    2.85 +    </sect2>
    2.86 +
    2.87 +    <sect2>
    2.88 +      <title>Inserire i risultati dell'unione</title>
    2.89 +
    2.90 +      <para id="x_348">Ogni volta che eseguiamo un'unione, il comando <command role="hg-cmd">hg parents</command> mostrerà due genitori fino a quando non invocheremo <command role="hg-cmd">hg commit</command> per inserire nel repository i risultati dell'unione.</para>
    2.91 +
    2.92 +	&interaction.tour.merge.commit;
    2.93 +
    2.94 +      <para id="x_349">Ora abbiamo una nuova revisione di punta; notate che ha <emphasis>entrambe</emphasis> le nostre vecchie teste come suoi genitori. Queste sono le stesse revisioni che erano state precedentemente mostrate da <command role="hg-cmd">hg parents</command>.</para>
    2.95 +
    2.96 +      &interaction.tour.merge.tip;
    2.97 +
    2.98 +      <para id="x_34a">Nella <xref linkend="fig:tour-merge:merge"/>, potete vedere una rappresentazione di quanto accade alla directory di lavoro durante l'unione, e di come questo abbia effetto sul repository quando avviene l'inserimento. Durante l'unione, la directory di lavoro ha due changeset genitori e questi diventano i genitori del nuovo changeset.</para>
    2.99 +
   2.100 +      <figure id="fig:tour-merge:merge">
   2.101 +	<title>Lo stato della directory di lavoro e del repository durante l'unione e dopo l'inserimento</title>
   2.102 +	<mediaobject>
   2.103 +	  <imageobject>
   2.104 +	    <imagedata fileref="figs/tour-merge-merge.png"/>
   2.105 +	  </imageobject>
   2.106 +	  <textobject><phrase>XXX add text</phrase></textobject>
   2.107 +	</mediaobject>
   2.108 +      </figure>
   2.109 +
   2.110 +      <para id="x_69c">Talvolta si dice che un'unione è composta da due <emphasis>parti</emphasis>: la parte sinistra è il primo genitore nell'uscita di <command role="hg-cmd">hg parents</command>, e la parte destra è il secondo. Se per esempio la directory di lavoro si trovava alla revisione 5 prima che cominciassimo l'unione, quella revisione diventerà la parte sinistra dell'unione.</para>
   2.111 +    </sect2>
   2.112 +  </sect1>
   2.113 +
   2.114 +  <sect1>
   2.115 +    <title>Unire cambiamenti conflittuali</title>
   2.116 +
   2.117 +    <para id="x_34b">La maggior parte delle unioni sono faccende semplici, ma talvolta vi troverete a unire cambiamenti dove ognuna delle due parti modifica le stesse porzioni degli stessi file. A meno che entrambe le modifiche siano identiche, questo risulterà in un <emphasis>conflitto</emphasis>, dove voi dovete decidere come riconciliare i diversi cambiamenti in un risultato coerente.</para>
   2.118 +
   2.119 +    <figure id="fig:tour-merge:conflict">
   2.120 +      <title>Cambiamenti in conflitto a un documento</title>
   2.121 +      <mediaobject>
   2.122 +	<imageobject><imagedata fileref="figs/tour-merge-conflict.png"/></imageobject>
   2.123 +	<textobject><phrase>XXX add text</phrase></textobject>
   2.124 +      </mediaobject>
   2.125 +    </figure>
   2.126 +
   2.127 +    <para id="x_34d">La <xref linkend="fig:tour-merge:conflict"/> illustra un esempio di due cambiamenti in conflitto a un documento. Abbiamo cominciato con una singola versione del file; poi abbiamo fatto alcuni cambiamenti; mentre qualcun altro ha fatto cambiamenti differenti allo stesso testo. Il nostro compito nella risoluzione del conflitto tra i cambiamenti è quello di decidere che cosa dovrebbe contenere il file.</para>
   2.128 +
   2.129 +    <para id="x_34e">Mercurial non è dotato di uno strumento predefinito per gestire i conflitti. Invece, esegue un programma esterno, di solito uno che mostra un qualche tipo di interfaccia grafica per la risoluzione dei conflitti. Di default, Mercurial prova a trovare uno tra i vari strumenti di unione differenti che è probabile siano installati sul vostro sistema. Prima prova a cercare alcuni strumenti di unione completamente automatici; se non riesce a trovarli (perché il processo di risoluzione richiede una guida umana) o non sono presenti, prova vari altri strumenti grafici per le unioni.</para>
   2.130 +
   2.131 +    <para id="x_34f">&Egrave; anche possibile far eseguire a Mercurial uno specifico programma, impostando la variable di ambiente <envar>HGMERGE</envar> al nome del vostro programma preferito.</para>
   2.132 +
   2.133 +    <sect2>
   2.134 +      <title>Usare uno strumento grafico per le unioni</title>
   2.135 +
   2.136 +      <para id="x_350">Il mio strumento grafico per le unioni preferito è <command>kdiff3</command>, che userà per descrivere le caratteristiche che sono comuni agli strumenti grafici per l'unione di file. Potete vedere uno screenshot di <command>kdiff3</command> in azione nella <xref linkend="fig:tour-merge:kdiff3"/>. Il tipo di unione che sta eseguendo si chiama <emphasis>unione a tre vie</emphasis>, perché ci sono tre differenti versioni di un file che ci interessano. Lo strumento dunque divide la porzione superiore della finestra in tre pannelli:</para>
   2.137 +      <itemizedlist>
   2.138 +	<listitem><para id="x_351">A sinistra si trova la versione <emphasis>base</emphasis> del file, i.e. la versione più recente da cui le due versioni che stiamo cercando di unire discendono.</para>
   2.139 +	</listitem>
   2.140 +	<listitem><para id="x_352">Nel mezzo si trova la <quote>nostra</quote> versione del file, con i contenuti che abbiamo modificato.</para>
   2.141 +	</listitem>
   2.142 +	<listitem><para id="x_353">A destra troviamo la <quote>loro</quote> versione del file, quella che proviene dal changeset che stiamo cercando di incorporare.</para>
   2.143 +	</listitem></itemizedlist>
   2.144 +      <para id="x_354">Nel pannello sotto a questi si trova il <emphasis>risultato</emphasis> corrente dell'unione. Il nostro compito è quello di sostituire tutto il testo in rosso, che indica conflitti irrisolti, con una qualche unione ragionevole della <quote>nostra</quote> e della <quote>loro</quote> versione del file.</para>
   2.145 +
   2.146 +      <para id="x_355">Tutti e quattro questi pannelli sono <emphasis>collegati tra loro</emphasis>; se scrolliamo in verticale o in orizzontale in ognuo di essi, gli altri vengono aggiornati per mostrare le sezioni corrispondenti dei rispettivi file.</para>
   2.147 +
   2.148 +      <figure id="fig:tour-merge:kdiff3">
   2.149 +	<title>Usare <command>kdiff3</command> per unire versioni di un file</title>
   2.150 +	<mediaobject>
   2.151 +	  <imageobject>
   2.152 +	    <imagedata width="100%" fileref="figs/kdiff3.png"/></imageobject>
   2.153 +	  <textobject>
   2.154 +	    <phrase>XXX add text</phrase>
   2.155 +	  </textobject>
   2.156 +	</mediaobject>
   2.157 +      </figure>
   2.158 +
   2.159 +      <para id="x_357">Per ogni porzione conflittuale del file, possiamo scegliere di risolvere il conflitto usando una qualche combinazione di testo dalla versione base, dalla nostra, o dalla loro. Possiamo anche modificare manualmente il file unito in ogni momento, nel caso abbiamo bisogno di effettuare cambiamenti ulteriori.</para>
   2.160 +
   2.161 +      <para id="x_358">Esistono <emphasis>molti</emphasis> strumenti per l'unione di file, davvero troppi per elencarli qui. Essi variano a seconda della piattaforma per la quale sono disponibili, e nelle loro particolari forze e debolezze. La maggior parte è tuned per unire file contenenti testo semplice, mentre alcuni sono indirizzati a particolari formati di file (generalmente XML).</para>
   2.162 +    </sect2>
   2.163 +
   2.164 +    <sect2>
   2.165 +      <title>Un esempio lavorato</title>
   2.166 +
   2.167 +      <para id="x_359">In questo esempio, riprodurremo le cronologia delle modifiche ai file della <xref linkend="fig:tour-merge:conflict"/> precedente. Per cominciare, creiamo un repository con una versione base del nostro documento.</para>
   2.168 +
   2.169 +      &interaction.tour-merge-conflict.wife;
   2.170 +
   2.171 +      <para id="x_35a">Cloniamo il repository e apportiamo un cambiamento al file.</para>
   2.172 +
   2.173 +      &interaction.tour-merge-conflict.cousin;
   2.174 +
   2.175 +      <para id="x_35b">E ora aggiungiamo un altro clone, per simulare qualcun altro che effettui un cambiamento al file. (Questo suggerisce l'idea che non è affatto inusuale unire con sé stessi quando isolate le vostre attività in repository separati, e in effetti trovate e risolvete conflitti mentre fate così.)</para>
   2.176 +
   2.177 +      &interaction.tour-merge-conflict.son;
   2.178 +
   2.179 +      <para id="x_35c">Avendo creato due versioni differenti del file, impostiamo un ambiente adeguato a eseguire la nostra unione.</para>
   2.180 +
   2.181 +      &interaction.tour-merge-conflict.pull;
   2.182 +
   2.183 +      <para id="x_35d">In questo esempio, imposterò la variabile d'ambiente <envar>HGMERGE</envar> per dire a Mercurial di usare il comando non interattivo <command>merge</command>. Questo comando è incluso in molti sistemi Unix-like. (Se state seguento questo esempio sul vostro computer, non preoccupatevi di impostare <envar>HGMERGE</envar>. Verrete depositati in uno strumento grafico per l'unione dei file, che è di molto preferibile.)</para>
   2.184 +
   2.185 +      &interaction.tour-merge-conflict.merge;
   2.186 +
   2.187 +      <para id="x_35f">Dato che <command>merge</command> non riesce a risolvere il conflitto tra i cambiamenti, lascia <emphasis>marcatori di unione</emphasis> dentro al file che ha i conflitti, indicando quali righe sono in conflitto e se vengono dalla nostra versione del file o dalla loro.</para>
   2.188 +
   2.189 +      <para id="x_360">Mercurial può dire dal modo in cui <command>merge</command> esce che non è stato in grado di unire con successo, quindi ci dice quali comandi abbiamo bisogno di eseguire se vogliamo rifare l'operazione di unione. Questo potrebbe essere utile se, per esempio, stessimo eseguendo uno strumento di unione grafico e uscissimo perché siamo confusi o realizziamo di aver fatto un errore.</para>
   2.190 +
   2.191 +      <para id="x_361">Se l'unione automatica o manuale fallisce, non c'è nulla che ci impedisce di <quote>correggere</quote> i file interessati per conto nostro, per inserire poi nel repository i risultati della nostra unione:</para>
   2.192 +      
   2.193 +      &interaction.tour-merge-conflict.commit;
   2.194 +
   2.195 +      <note>
   2.196 +	<title>Dov'è il comando <command>hg resolve</command>?</title>
   2.197 +
   2.198 +	<para id="x_724">Il comando <command>hg resolve</command> è stato introdotto nella verisone 1.1 di Mercurial, che è stata rilasciata nel dicembre 2008. Se state usando una versione più vecchia (eseguite <command>hg version</command> per controllare) questo comando non sarà presente. Se la vostra versione di Mercurial è più vecchia della 1.1, vi consiglio vivamente di installare una versione più nuova prima di affrontare unioni complicate.</para>
   2.199 +      </note>
   2.200 +    </sect2>
   2.201 +  </sect1>
   2.202 +
   2.203 +  <sect1 id="sec:tour-merge:fetch">
   2.204 +    <title>Semplificare la sequenza di estrazione-unione-inserimento</title>
   2.205 +
   2.206 +    <para id="x_362">Il processo di unione dei cambiamenti come delineato in precedenza è molto semplice, ma richiede di eseguire tre comandi in sequenza.</para>
   2.207 +    <programlisting>hg pull -u
   2.208 +hg merge
   2.209 +hg commit -m 'Incorporati i cambiamenti remoti'</programlisting>
   2.210 +    <para id="x_363">Nel caso dell'inserimento conclusivo, avete anche bisogno di inserire un messaggio di commit, che sarà quasi sempre un frammento di testo <quote>boilerplate</quote> non interessante.</para>
   2.211 +
   2.212 +    <para id="x_364">Sarebbe carino ridurre il numero di passi necessari, se questo fosse possibile. In effetti, Mercurial viene distribuito con una estensione chiamata <literal role="hg-ext">fetch</literal> che fa proprio questo.</para>
   2.213 +
   2.214 +    <para id="x_365">Mercurial fornisce un meccanismo flessibile di estensione che permette alle persone di estendere le sue funzionalità mantenendo il cuore di Mercurial piccolo e facile da trattare. Alcune estensioni aggiungono nuovi comandi che potete usare dalla linea di comando, mentre altri lavorano <quote>dietro le quinte</quote>, per esempio aggiungendo funzionalità alla modalità server predefinita di Mercurial.</para>
   2.215 +
   2.216 +    <para id="x_366">L'estensione <literal role="hg-ext">fetch</literal> aggiunge un nuovo comando chiamato, ovviamente, <command role="hg-cmd">hg fetch</command>. Questa estensione agisce come una combinazione di <command role="hg-cmd">hg pull -u</command>, <command role="hg-cmd">hg merge</command> e <command role="hg-cmd">hg commit</command>. Comincia propagando i cambiamenti da un altro repository verso il repository corrente. Se trova che i cambiamenti aggiungono una nuova testa al repository, lo aggiorna alla nuova testa, comincia una unione, poi (se l'unione ha successo) inserisce il risultato dell'unione nel repository con un messaggio di commit generato automaticamente. Se non sono state aggiunte nuove teste, il comando aggiorna la directory di lavoro alla nuova revisione di punta.</para>
   2.217 +
   2.218 +    <para id="x_367">Abilitare l'estensione <literal role="hg-ext">fetch</literal> è facile. Aprite il file <filename role="special">.hgrc</filename> nella vostra directory personale e andate alla sezione <literal role="rc-extensions">extensions</literal> oppure create una sezione <literal role="rc-extensions">extensions</literal> se non esiste già. Poi aggiungete una riga che contenga semplicemente <quote><literal>fetch=</literal></quote>.</para>
   2.219 +
   2.220 +    <programlisting>[extensions]
   2.221 +fetch =</programlisting>
   2.222 +
   2.223 +    <para id="x_368">(Normalmente, il lato destro del simbolo <quote><literal>=</literal></quote> indicherebbe dove trovare l'estensione, ma dato che l'estensione <literal role="hg-ext">fetch</literal> è nella distribuzione standard, Mercurial sa già dove andarla a cercare.)</para>
   2.224 +  </sect1>
   2.225 +
   2.226 +  <sect1>
   2.227 +    <title>Rinominare, copiare e unire</title>
   2.228 +
   2.229 +    <para id="x_729">Durante la vita di un progetto, vorremo spesso cambiare la disposizione dei suoi file e delle sue directory. Questo può essere tanto semplice quanto rinominare un singolo file, o tanto complesso quanto ristrutturare l'intera gerarchia dei file nell'ambito del progetto.</para>
   2.230 +
   2.231 +    <para id="x_72a">Mercurial supporta questi tipi di cambiamenti complessi in maniera fluida, a patto che gli diciamo quello stiamo facendo. Se vogliamo rinominare un file, dovremmo usare il comando <command>hg rename</command><footnote>
   2.232 +	<para id="x_72b">Se siete utenti Unix, sarete contenti di sapere che il comando <command>hg rename</command> si può abbreviare in <command>hg mv</command>.</para>
   2.233 +    </footnote> per cambiarne il nome, in modo che Mercurial possa fare la cosa giusta più tardi quando effettueremo un'unione.</para>
   2.234 +
   2.235 +    <para id="x_72c">Tratteremo l'uso di questi comandi in maniera più estesa nel FIXME<!--<xref linkend="chap:daily.copy"/>-->.</para>
   2.236 +  </sect1>
   2.237 +</chapter>