Mercurial: la guida definitiva

Compiled from 4fb00c894429 (2009-10-22)

Bryan O'Sullivan

Giulio Piancastelli


Indice

Prefazione
1. Raccontare la tecnologia
2. Grazie per il vostro sostegno a Mercurial
3. Ringraziamenti
4. Convenzioni usate in questo libro
5. Usare gli esempi di codice
6. Safari® Books Online
7. Come contattarci
1. Come siamo arrivati qui?
1.1. Perché il controllo di revisione? Perché Mercurial?
1.1.1. Perché usare il controllo di revisione?
1.1.2. I molti nomi del controllo di revisione
1.2. A proposito degli esempi in questo libro
1.3. Le tendenze nel campo
1.4. Alcuni vantaggi del controllo di revisione distribuito
1.4.1. Vantaggi per i progetti open source
1.4.2. Vantaggi per i progetti commerciali
1.5. Perché scegliere Mercurial?
1.6. Un confronto tra Mercurial e altri strumenti
1.6.1. Subversion
1.6.2. Git
1.6.3. CVS
1.6.4. Strumenti commerciali
1.6.5. Scegliere uno strumento di controllo di revisione
1.7. Passare da un altro strumento a Mercurial
1.8. Una breve storia del controllo di revisione
2. Una panoramica di Mercurial: i concetti di base
2.1. Installare Mercurial sul vostro sistema
2.1.1. Windows
2.1.2. Mac OS X
2.1.3. Linux
2.1.4. Solaris
2.2. Per cominciare
2.2.1. Aiuto predefinito
2.3. Lavorare con un repository
2.3.1. Fare una copia locale di un repository
2.3.2. Che cosa contiene un repository?
2.4. Un viaggio attraverso la cronologia
2.4.1. Parlare di changeset o revisioni con altre persone
2.4.2. Vedere revisioni specifiche
2.4.3. Informazioni più dettagliate
2.5. Tutto quello che dovete sapere sulle opzioni dei comandi
2.6. Come effettuare e rivedere i cambiamenti
2.7. Registrare i cambiamenti in un nuovo changeset
2.7.1. Impostare un nome utente
2.7.2. Scrivere un messaggio di commit
2.7.3. Scrivere un buon messaggio di commit
2.7.4. Abortire un commit
2.7.5. Ammirare la nostra nuova opera
2.8. Condividere i cambiamenti
2.8.1. Estrarre i cambiamenti da altri repository
2.8.2. Aggiornare la directory di lavoro
2.8.3. Pubblicare i cambiamenti in un altro repository
2.8.4. Ubicazioni predefinite
2.8.5. Condividere i cambiamenti attraverso la rete
2.9. Cominciare un nuovo progetto
3. Una panoramica di Mercurial: le unioni
3.1. Unire flussi di lavoro
3.1.1. Le teste di un repository
3.1.2. Effettuare l’unione
3.1.3. Inserire i risultati dell’unione nel repository
3.2. Risolvere i conflitti tra cambiamenti
3.2.1. Usare uno strumento grafico di unione
3.2.2. Un esempio risolto
3.3. Semplificare la sequenza di estrazione-unione-inserimento
3.4. Rinominare, copiare e unire
4. Dietro le quinte
4.1. La registrazione della cronologia di Mercurial
4.1.1. Memorizzare la cronologia di un singolo file
4.1.2. Gestire i file monitorati
4.1.3. Registrare le informazioni di changeset
4.1.4. Relazioni tra le revisioni
4.2. Memorizzazione sicura ed efficiente
4.2.1. Memorizzazione efficiente
4.2.2. Operazioni sicure
4.2.3. Reperimento veloce
4.2.4. Identificazione e integrità forte
4.3. Cronologia delle revisioni, ramificazioni e unioni
4.4. La directory di lavoro
4.4.1. Cosa succede quando eseguite un commit
4.4.2. Creare una nuova testa
4.4.3. Unire i cambiamenti
4.4.4. Le unioni e i cambiamenti di nome
4.5. Altre caratteristiche di progettazione interessanti
4.5.1. Compressione intelligente
4.5.2. Ordinamento e atomicità delle operazioni di lettura e scrittura
4.5.3. Accesso concorrente
4.5.4. Evitare le operazioni di seek
4.5.5. Altre informazioni contenute nel dirstate
5. L’uso quotidiano di Mercurial
5.1. Aggiungere file a un repository Mercurial
5.1.1. Designazione esplicita o implicita dei file
5.1.2. Mercurial registra i file, non le directory
5.2. Come rimuovere un file dal repository
5.2.1. La rimozione di un file non ha effetti sulla sua cronologia.
5.2.2. File mancanti
5.2.3. Digressione: perché dire esplicitamente a Mercurial di rimuovere un file?
5.2.4. Utile scorciatoia—aggiungere e rimuovere i file in un unico passo
5.3. Copiare i file
5.3.1. I risultati di una copia durante un’unione
5.3.2. Perché i cambiamenti dovrebbero seguire le copie?
5.3.3. Come evitare che i cambiamenti seguano una copia
5.3.4. Il comportamento del comando hg copy
5.4. Rinominare i file
5.4.1. Rinominare i file e unire i cambiamenti
5.4.2. Cambiamenti di nome divergenti e unioni
5.4.3. Cambiamenti di nome convergenti e unioni
5.4.4. Altri casi particolari legati ai nomi
5.5. Rimediare agli errori
5.6. Affrontare unioni complesse
5.6.1. Gli stati di risoluzione di un file
5.6.2. Risolvere un’unione di file
5.7. Formati di diff più utili
5.8. Quali file gestire e quali file evitare
5.9. Realizzare backup e mirror
6. Collaborare con altre persone
6.1. L’interfaccia web di Mercurial
6.2. Modelli di collaborazione
6.2.1. Fattori da considerare
6.2.2. Anarchia informale
6.2.3. Un singolo repository centrale
6.2.4. Un repository centrale su un servizio di hosting
6.2.5. Lavorare con più rami
6.2.6. Rami di funzione
6.2.7. Il treno delle release
6.2.8. Il modello del kernel di Linux
6.2.9. Collaborazione in sola lettura o in scrittura condivisa
6.2.10. Dove la collaborazione incontra la gestione dei rami
6.3. Il lato tecnico della condivisione
6.4. Condivisione informale con hg serve
6.4.1. Alcune cose da tenere a mente
6.5. Usare il protocollo di Shell Sicura (ssh)
6.5.1. Come leggere e scrivere URL ssh
6.5.2. Trovare un client ssh per il vostro sistema
6.5.3. Generare una coppia di chiavi
6.5.4. Usare un agente di autenticazione
6.5.5. Configurare adeguatamente il server
6.5.6. Usare la compressione con ssh
6.6. Condividere i dati attraverso HTTP usando CGI
6.6.1. Lista di controllo per la configurazione di un server web
6.6.2. Configurazione CGI di base
6.6.3. Condividere più repository con un solo script CGI
6.6.4. Scaricare gli archivi dei sorgenti
6.6.5. Le opzioni di configurazione web
6.7. Configurazione di sistema
6.7.1. Rendere Mercurial meno prevenuto
7. Nomi di file e corrispondenze di pattern
7.1. Denominazione semplice dei file
7.2. Eseguire comandi senza nomi di file
7.3. Mercurial vi dice cosa sta succedendo
7.4. Usare i pattern per identificare i file
7.4.1. I pattern glob sullo stile della shell
7.4.2. Corrispondenze di espressioni regolari con i pattern re
7.5. Filtrare i file
7.6. Ignorare permanentemente file e directory indesiderate
7.7. Sensibilità alle maiuscole
7.7.1. Memorizzazione del repository sicura e portabile
7.7.2. Riconoscere i conflitti tra maiuscole e minuscole
7.7.3. Correggere un conflitto tra maiuscole e minuscole
8. Gestire le release e lo sviluppo con i rami
8.1. Dare un nome persistente a una revisione
8.1.1. Gestire i conflitti di etichette durante un’unione
8.1.2. Etichette e cloni
8.1.3. Quando le etichette permanenti sono eccessive
8.2. Il flusso dei cambiamenti—la visione d’insieme e la visione di dettaglio
8.3. Gestire i rami nella visione d’insieme
8.4. Non ripetetevi: le unioni tra rami
8.5. Denominare i rami in un repository
8.6. Gestire molti rami con nome in un repository
8.7. I nomi di ramo e le unioni
8.8. La denominazione dei rami è generalmente utile
9. Trovare e correggere gli errori
9.1. Cancellare la cronologia locale
9.1.1. L’inserimento accidentale
9.1.2. Abortire una transazione
9.1.3. L’estrazione sbagliata
9.1.4. Abortire una transazione è inutile se avete già trasmesso le modifiche
9.1.5. Potete abortire una sola transazione
9.2. Rimediare alle modifiche sbagliate
9.2.1. Errori nella gestione dei file
9.3. Gestire i cambiamenti inseriti
9.3.1. Ritirare un changeset
9.3.2. Ritirare il changeset di punta
9.3.3. Ritirare un changeset diverso dalla punta
9.3.4. Controllare meglio il processo di ritiro
9.3.5. Perché hg backout funziona in questo modo
9.4. Modifiche che non avrebbero mai dovuto essere fatte
9.4.1. Ritirare un’unione
9.4.2. Proteggervi dai cambiamenti che vi sono «sfuggiti»
9.4.3. Cosa fare con i cambiamenti sensibili che sfuggono
9.5. Trovare la causa di un bug
9.5.1. Usare il comando hg bisect
9.5.2. Riordinare dopo la vostra ricerca
9.6. Suggerimenti per trovare efficacemente i bug
9.6.1. Fornite informazioni consistenti
9.6.2. Automatizzate il più possibile
9.6.3. Controllate i vostri risultati
9.6.4. Fate attenzione alle interferenze tra i bug
9.6.5. Circoscrivete la vostra ricerca in maniera approssimativa
10. Usare gli hook per gestire gli eventi nei repository
10.1. Un’introduzione agli hook di Mercurial
10.2. Hook e sicurezza
10.2.1. Gli hook vengono eseguiti con i vostri privilegi
10.2.2. Gli hook non si propagano
10.2.3. Gli hook possono essere sostituiti
10.2.4. Assicurarsi che gli hook critici vengano eseguiti
10.3. Una breve guida all’uso degli hook
10.3.1. Effettuare molteplici azioni per evento
10.3.2. Controllare se un’attività può procedere
10.4. Implementare i vostri hook
10.4.1. Scegliere la modalità di esecuzione del vostro hook
10.4.2. I parametri di hook
10.4.3. I valori di ritorno degli hook e il controllo delle attività
10.4.4. Scrivere un hook esterno
10.4.5. Dire a Mercurial di usare un hook interno
10.4.6. Implementare un hook interno
10.5. Alcuni hook di esempio
10.5.1. Scrivere messaggi di commit significativi
10.5.2. Controllare lo spazio bianco in coda
10.6. Hook inclusi
10.6.1. acl—controllo di accesso per parti di un repository
10.6.2. bugzilla—integrazione con Bugzilla
10.6.3. notify—inviare notifiche via email
10.7. Informazioni per gli implementatori di hook
10.7.1. Esecuzione degli hook interni
10.7.2. Esecuzione degli hook esterni
10.7.3. Scoprire da dove vengono i changeset
10.8. Guida di riferimento agli hook
10.8.1. changegroup—dopo l’aggiunta di changeset remoti
10.8.2. commit—dopo la creazione di un nuovo changeset
10.8.3. incoming—dopo l’aggiunta di un changeset remoto
10.8.4. outgoing—dopo la propagazione dei changeset
10.8.5. prechangegroup—prima di cominciare ad aggiungere changeset remoti
10.8.6. precommit—prima di cominciare l’inserimento di un changeset
10.8.7. preoutgoing—prima di cominciare la propagazione dei changeset
10.8.8. pretag—prima di etichettare un changeset
10.8.9. pretxnchangegroup—prima di completare l’aggiunta di changeset remoti
10.8.10. pretxncommit—prima di completare l’inserimento di un nuovo changeset
10.8.11. preupdate—prima di eseguire un aggiornamento o un’unione della directory di lavoro
10.8.12. tag—dopo aver etichettato un changeset
10.8.13. update—dopo aver eseguito un aggiornamento o un’unione della directory di lavoro
11. Personalizzare i messaggi di Mercurial
11.1. Usare gli stili di formattazione già pronti
11.1.1. Impostare uno stile predefinito
11.2. Comandi che supportano stili e template
11.3. Nozioni di base sui template
11.4. Parole chiave comuni nei template
11.5. Sequenze di escape
11.6. Filtrare le parole chiave per modificarne i risultati
11.6.1. Combinare i filtri
11.7. Dai template agli stili
11.7.1. Il più semplice dei file di stile
11.7.2. La sintassi dei file di stile
11.8. Esempi di file di stile
11.8.1. Identificare errori in un file di stile
11.8.2. Identificare univocamente un repository
11.8.3. Elencare file su più righe
11.8.4. Imitare i messaggi di Subversion
12. Gestire il cambiamento con Mercurial Queues
12.1. Il problema della gestione delle patch
12.2. La preistoria di Mercurial Queues
12.2.1. Una «coperta a scacchi»
12.2.2. Da patchwork quilt a Mercurial Queues
12.3. L’enorme vantaggio di MQ
12.4. Capire le patch
12.5. Cominciare a usare Mercurial Queues
12.5.1. Creare una nuova patch
12.5.2. Aggiornare una patch
12.5.3. Impilare e registrare le patch
12.5.4. Manipolare la pila delle patch
12.5.5. Inserire ed estrarre molte patch
12.5.6. I controlli di sicurezza e come scavalcarli
12.5.7. Lavorare su diverse patch alla volta
12.6. Ulteriori informazioni sulle patch
12.6.1. Il numero di cancellazioni
12.6.2. Strategie per applicare una patch
12.6.3. Alcune stranezze nella rappresentazione delle patch
12.6.4. Fate attenzione all’incertezza
12.6.5. Gestire il rifiuto
12.7. Ulteriori informazioni sulla gestione delle patch
12.7.1. Cancellare le patch indesiderate
12.7.2. Convertire in e da revisioni permanenti
12.8. Ottenere le prestazioni migliori da MQ
12.9. Aggiornare le vostre patch quando il codice sottostante cambia
12.10. Identificare le patch
12.11. Informazioni utili
12.12. Gestire le patch in un repository
12.12.1. Il supporto di MQ per i repository di patch
12.12.2. Alcune cose a cui fare attenzione
12.13. Strumenti di terze parti che lavorano con le patch
12.14. Strategie valide per lavorare con le patch
12.15. Il ricettario di MQ
12.15.1. Gestire patch «elementari»
12.15.2. Combinare intere patch
12.15.3. Unire parte di una patch a un’altra
12.16. Differenze tra quilt e MQ
13. Usi avanzati di Mercurial Queues
13.1. Il problema di gestire molti obiettivi
13.1.1. Approcci seducenti che non funzionano bene
13.2. Applicare patch in maniera condizionata con le guardie
13.3. Controllare le guardie su una patch
13.4. Selezionare le guardie da usare
13.5. Le regole di MQ per applicare le patch
13.6. Ridimensionare l’ambiente di lavoro
13.7. Suddividere il file series
13.8. Mantenere le serie di patch
13.8.1. L’arte di scrivere patch di backport
13.9. Suggerimenti utili per sviluppare con MQ
13.9.1. Organizzare le patch in directory
13.9.2. Visualizzare la cronologia di una patch
14. Aggiungere funzionalità con le estensioni
14.1. Migliorare le prestazioni con l’estensione inotify
14.2. Supporto flessibile per i diff con l’estensione extdiff
14.2.1. Definire alias per i comandi
14.3. Inviare cambiamenti via email con l’estensione patchbomb
14.3.1. Modificare il comportamento di patchbomb
A. Migrare verso Mercurial
A.1. Importare la cronologia da un altro sistema
A.1.1. Convertire molti rami
A.1.2. Correlare i nomi utente
A.1.3. Riordinare l’albero
A.1.4. Migliorare le prestazioni della conversione da Subversion
A.2. Migrare da Subversion
A.2.1. Differenze filosofiche
A.2.2. Guida rapida
A.3. Suggerimenti utili per i principianti
B. Guida di riferimento a Mercurial Queues
B.1. Guida di riferimento ai comandi MQ
B.1.1. qapplied—stampa le patch applicate
B.1.2. qcommit—registra i cambiamenti nel repository della coda
B.1.3. qdelete—elimina una patch dal file series
B.1.4. qdiff—stampa un diff dell’ultima patch applicata
B.1.5. qfinish—sposta le patch applicate nella cronologia del repository
B.1.6. qfold—unisce («include») diverse patch in una
B.1.7. qheader—mostra l’intestazione/descrizione di una patch
B.1.8. qimport—importa una patch di terze parti nella coda
B.1.9. qinit—prepara un repository per lavorare con MQ
B.1.10. qnew—crea una nuova patch
B.1.11. qnext—stampa il nome della patch successiva
B.1.12. qpop—estrae le patch dalla pila
B.1.13. qprev—stampa il nome della patch precedente
B.1.14. qpush—inserisce le patch in cima alla pila
B.1.15. qrefresh—aggiorna l’ultima patch applicata
B.1.16. qrename—rinomina una patch
B.1.17. qseries—stampa l’intera serie di patch
B.1.18. qtop—stampa il nome della patch corrente
B.1.19. qunapplied—stampa le patch non ancora applicate
B.1.20. hg strip—rimuove una revisione e i suoi discendenti
B.2. Guida di riferimento ai file di MQ
B.2.1. Il file series
B.2.2. Il file status
C. Installare Mercurial dai sorgenti
C.1. Sistemi di tipo Unix
C.2. Windows
D. Open Publication License
D.1. Requirements on both unmodified and modified versions
D.2. Copyright
D.3. Scope of license
D.4. Requirements on modified works
D.5. Good-practice recommendations
D.6. License options
Riferimenti

Lista delle figure

2.1. Rappresentazione grafica della cronologia per il repository hello
3.1. Le cronologie divergenti dei repository mio-hello e mio-nuovo-hello
3.2. I contenuti del repository dopo aver propagato i cambiamenti da mio-hello a mio-nuovo-hello
3.3. Lo stato della directory di lavoro e del repository durante l’unione e dopo l’inserimento
3.4. Modifiche in conflitto a un documento
3.5. Usare kdiff3 per unire diverse versioni di un file
4.1. Relazioni tra i file nella directory di lavoro e i filelog nel repository
4.2. Relazioni tra i metadati
4.3. Fotografia di un revlog, con delta incrementali
4.4. La struttura concettuale di un revlog
4.5. La directory di lavoro può avere due genitori
4.6. La directory di lavoro acquisisce nuovi genitori dopo un commit
4.7. La directory di lavoro, aggiornata a un vecchio changeset
4.8. La situazione dopo un commit effettuato su un aggiornamento a un vecchio changeset
4.9. Unire due teste
6.1. Rami di funzione
9.1. Ritirare un cambiamento tramite il comando hg backout
9.2. Ritiro automatico di un changeset diverso dalla punta tramite il comando hg backout
9.3. Ritirare un cambiamento tramite il comando hg backout
9.4. Incorporare manualmente un cambiamento ritirato
9.5. Un’unione sbagliata
9.6. Ritirare l’unione favorendo un genitore
9.7. Ritirare l’unione favorendo l’altro genitore
9.8. Unire i risultati dei ritiri
9.9. Unire i risultati dei ritiri
12.1. Patch applicate e non applicate nella pila delle patch di MQ

Lista delle tabelle

A.1. Equivalenze tra i comandi Subversion e Mercurial