#language it
== Tutorial - fare la prima modifica ==

''(Questa pagina è la parte 4 di 9 delle serie [[ItalianTutorial]]. La parte precedente è [[TutorialCronologia]], la prossima parte è [[TutorialCondividereModifiche]])''

Procedendo da quanto visto in TutorialCronologia, siamo nel nostro repository `my-hello`, già copiato in TutorialClone.

E' buona pratica nello sviluppo con Mercurial isolare ogni modifica in un [[Repository|repository]] separato (cfr. [[WorkingPractices]]). Questo permette di evitare di mescolare il codice non correlato e rende più semplice verificare le varie parti del lavoro una per una. Iniziamo seguendo il modello.

Il nostro semplicissimo obbiettivo è far stampare una riga in più al nostro programma "hello world". Per prima cosa, creiamo un nuovo repository chiamato {{{my-hello-new-output}}} [[Clone|clonando]] `my-hello`:

{{{
$ cd ..
$ hg clone my-hello my-hello-new-output
updating working directory
2 files updated, 0 files merged, 0 files removed, 0 files unresolved
}}}

Notare come abbiamo dato un nome descrittivo al nuovo repository, un nome che permetta di individuare facilmente lo scopo delle modifiche. Fin quando effettuare la "clonazione" di un repository in Mercurial sarà cosa rapida, noi accumuleremo velocemente molti repository poco diversi. Se non diamo a questi repository nomi sensati, altrettanto rapidamente perderemo la capacità di riconoscerli.

Adesso è giunto il momento di eseguire una modifica nel nuovo repository. Andiamo nella [[WorkingDirectory|directory di lavoro]], che è semplicemente il nome dato alla directory dove si trovano tutti i file e modifichiamo il codice sorgente mediante il nostro editor di testi preferito:

{{{
$ cd my-hello-new-output
$ vi hello.c
}}}

Il contenuto di `hello.c` inizialmente assomiglia a questo:

{{{#!cplusplus numbers=off
/*
 * hello.c
 *
 * Placed in the public domain by Bryan O'Sullivan
 *
 * This program is not covered by patents in the United States or other
 * countries.
 */

#include <stdio.h>

int main(int argc, char **argv)
{
        printf("hello, world!\n");
        return 0;
}
}}}

Editiamo il {{{main}}} affinché stampi una linea di output in più:

{{{#!cplusplus numbers=off
(...)

int main(int argc, char **argv)
{
        printf("hello, world!\n");
        printf("sure am glad I'm using Mercurial!\n");
        return 0;
}
}}}

Una volta che l'abbiamo fatto salviamo le modifiche, usciamo dal nostro editor di testo ed è fatta. E' tutto. Ora possiamo creare un [[ChangeSet|changeset]].

Nel caso venissimo interrotti durante l'operazione di modifica e ci fossimo dimenticati quali modifiche stessimo facendo una volta creato il changeset? A tal proposito, possiamo usare il comando `status`.

{{{
$ hg status
M hello.c
}}}

L'output è conciso, ma il prefisso `M` ci dice semplicemente che `hello.c` è stato modificato ed è pronto per andare in un changeset.

Invece del prolisso `hg status` possiamo usare alternativamente solo `hg st`, dato che Mercurial ci consente di abbreviare i comandi fintanto che la sequenza di caratteri inserita non è ambigua.

{{{
$ hg st
M hello.c
}}}

Potremmo anche analizzare le modifiche che abbiamo fatto al file finora, usando il comando `diff`:

{{{
$ hg diff
diff -r 82e55d328c8c hello.c
--- a/hello.c   Fri Aug 26 01:21:28 2005 -0700
+++ b/hello.c   Fri Sep 30 10:27:47 2005 +0800
@@ -12,5 +12,6 @@
 int main(int argc, char **argv)
 {
        printf("hello, world!\n");
+       printf("sure am glad I'm using Mercurial!\n");
        return 0;
 }
}}}

<!> Nel caso volessimo annullare le nostre modifiche e ricominciare, possiamo usare il comando `revert` per ripristinare `hello.c` al suo stato iniziale (si potrebbe usare anche l'opzione `-a` per ripristinare tutti i file). Fare attenzione però che sia proprio quello che desideriamo fare.

{{{
$ hg revert hello.c
}}}

Il comando {{{revert}}} rinomina inoltre il file modificato `hello.c` con `hello.c.orig`.

Il comando `status` ora elenca `hello.c.orig` come non monitorato (prefisso "?").

{{{
$ hg status
? hello.c.orig
}}}

Se ci ripensiamo nuovamente e vogliamo tornare al file modificato è sufficiente rimuovere lo stato originario di hello.c e rinominare hello.c.orig, quello modificato, con hello.c.

{{{
$ rm hello.c
$ mv hello.c.orig hello.c
$ hg status
M hello.c
}}} 

L'azione di creare un changeset è chiamata [[Commit|committing]]. Eseguiamo tale operazione, utilizzando il comando `commit`. Il comando `commit` possiede una alternativa più corta: `ci` (check in) che possiamo usare in questo modo:

{{{
$ hg ci
}}}

Questa operazione ci porta in un editor, che ci mostra poche criptiche linee di testo.

''N.B.:'' L'editor predefinito è `vi`. Questo si può cambiare usando le variabile d'ambiente {{{EDITOR}}} o HGEDITOR.

{{{
 
HG: Enter commit message.  Lines beginning with 'HG:' are removed.
HG: --
HG: user: mpm@selenic.com
HG: branch 'default'
HG: changed hello.c
}}}

La prima linea è vuota e le linee che seguono identificano l'utente, il nome del branch ed i file che andranno dentro questo changeset.

Il nome predefinito del branch è "default" (cfr. NamedBranches). Il valore predefinito per "user" deriva dalla voce "username" della sezione "ui" (cfr. [[http://www.selenic.com/mercurial/hgrc.5.html#ui|hgrc(5)]]) presente nel file di configurazione {{{~/.hgrc}}}. Alternativamente, può anche essere specificato sulla linea di comando con l'opzione -u (cfr. `hg help ci` or [[http://www.selenic.com/mercurial/hg.1.html#commit|hg.1.html#commit]]).

Per effettuare il commit del changeset, dobbiamo descrivere la ragione per la quale lo facciamo (cfr. [[ChangeSetComments]]). Inseriamo qualcosa tipo:

{{{
Express great joy at existence of Mercurial
HG: Enter commit message.  Lines beginning with 'HG:' are removed.
HG: --
HG: user: mpm@selenic.com
HG: branch 'default'
HG: changed hello.c
}}}

Poi salviamo il testo, usciamo dall'editor e, se tutto è andato a buon fine, il comando commit uscirà e non stamperà alcun output. 

<!> Se si esce dall'editor senza salvare il testo, l'operazione di commit sarà annullata in maniera da poter ripensare ai cambiamenti effettuati.

Vediamo cosa ci dirà il comando {{{status}}}:

{{{
$ hg st
}}}

Niente! I nostri cambiamenti sono stati applicati a un changeset, pertanto non ci sono file modificati che necessitano dell'operazione di commit. Il nostro [[Tip|tip]] adesso coincide con il contenuto della nostra directory di lavoro.

Il comando [[Parent|parents]] ci mostra che la directory di lavoro del nostro repository è ora sincronizzata (cfr. [[Update]]) al changeset recentemente creato (qui abbiamo solo una revisione, la quale è sempre il caso dopo un commit. Vedremo due parents nel TutorialEffettuareMerge):

{{{
$ hg par
changeset:   2:86794f718fb1
tag:         tip
user:        mpm@selenic.com
date:        Mon May 05 01:20:46 2008 +0200
summary:     Express great joy at existence of Mercurial
}}}

Eccolo! Abbiamo creato un nuovo changeset.

Possiamo esaminare la cronologia dei cambiamenti per il nostro nuovo lavoro:

{{{
$ hg log
changeset:   2:a58809af174d
tag:         tip
user:        mpm@selenic.com
date:        Fri Aug 26 01:26:28 2005 -0700
summary:     Express great joy at existence of Mercurial

(...)
}}}

C'è: abbiamo creato il changeset.

''N.B.:'' L'utente, la data e il [[ChangeSetID|changeset ID]] ovviamente cambieranno.

Come abbiamo spiegato in [[TutorialCopia]], il nuovo changeset esiste per adesso solo in questo repository. Questa è una parte critica sul modo in cui opera Mercurial.

Per condividere le modifiche, dobbiamo continuare passando a TutorialCondividereModifiche

----
CategoryItalian