A livello di implementazione, Mercurial usa un unico meccanismo per gestire i nomi dei file. Tutti i comandi si comportano in maniera uniforme rispetto ai nomi dei file e lavorano nel modo seguente.

Se indicate esplicitamente nomi di file esistenti sulla riga di comando, Mercurial lavora esattamente con quei file, come vi aspettereste.

$ hg add COPIARE LEGGIMI esempi/semplice.py

Quando fornite un nome di directory, Mercurial interpreterà questa azione come la volontà di «operare su tutti i file in questa directory e nelle sue sottodirectory». Mercurial considera i file e le sottodirectory in una directory secondo l’ordine alfabetico. Quando incontra una sottodirectory, attraverserà quella sottodirectory prima di continuare con la directory corrente.

$ hg status sorgenti
? sorgenti/principale.py
? sorgenti/controllore/_controllore.c
? sorgenti/controllore/controllore.py
? sorgenti/xyzzy.txt

I comandi Mercurial che lavorano con i nomi di file assumono un utile comportamento predefinito quando li invocate senza passare alcun nome di file o pattern. Il comportamento che dovreste aspettarvi dipende dalla funzione del comando. Ecco alcune regole pratiche che potete usare per predire quello che un comando probabilmente farà se non gli date alcun nome con cui lavorare.

Se questi comportamenti predefiniti non vi soddisfano, è facile aggirarli. Se normalmente un comando opera sull’intera directory di lavoro, potete passargli il nome «.» per invocarlo solo sulla directory corrente e sulle sue sottodirectory.

$ cd sorgenti
$ hg add -n
aggiungo ../MANIFEST.in
aggiungo ../esempi/efficiente.py
aggiungo ../setup.py
aggiungo principale.py
aggiungo controllore/_controllore.c
aggiungo controllore/controllore.py
aggiungo xyzzy.txt
$ hg add -n .
aggiungo principale.py
aggiungo controllore/_controllore.c
aggiungo controllore/controllore.py
aggiungo xyzzy.txt

Sulla stessa falsariga, alcuni comandi normalmente stampano nomi di file relativi alla radice del repository anche quando li invocate da una sottodirectory. Questi comandi stamperanno nomi di file relativi alla vostra sottodirectory se passate loro nomi espliciti. Qui di seguito eseguiremo hg status da una sottodirectory e lo faremo agire sull’intera directory di lavoro pur stampando nomi di file relativi alla nostra sottodirectory, passandogli il risultato del comando hg root.

$ hg status
A COPIARE
A LEGGIMI
A esempi/semplice.py
? MANIFEST.in
? esempi/efficiente.py
? setup.py
? sorgenti/principale.py
? sorgenti/controllore/_controllore.c
? sorgenti/controllore/controllore.py
? sorgenti/xyzzy.txt
$ hg status `hg root`
A ../COPIARE
A ../LEGGIMI
A ../esempi/semplice.py
? ../MANIFEST.in
? ../esempi/performante.py
? ../setup.py
? principale.py
? controllore/_controllore.c
? controllore/controllore.py
? xyzzy.txt

L’esempio di hg add nella sezione precedente illustra qualcos’altro che è utile sapere sui comandi Mercurial. Se un comando opera su un file che non avete nominato esplicitamente sulla riga di comando, di solito stamperà il nome del file in modo che non veniate sorpresi da quello che sta succedendo.

In questo caso, Mercurial segue il principio della minima sorpresa. Se avete fornito il nome esatto di un file sulla riga di comando, non ha senso ripetervelo. Se Mercurial sta agendo implicitamente su un file, per esempio perché non avete fornito alcun nome, o su una directory, o su un pattern (si veda più avanti), ritiene sia più sicuro farvi sapere su quali file sta lavorando.

Potete ridurre al silenzio i comandi che si comportano in questo modo usando l’opzione -q. Potete anche dire loro di stampare il nome di tutti i file, anche quelli che avete nominato esplicitamente, usando l’opzione -v.

Oltre a lavorare con i nomi di file e directory, Mercurial vi consente di usare i pattern per identificare i file. La gestione dei pattern da parte di Mercurial è espressiva.

Su sistemi di tipo Unix (Linux, Mac OS X, etc.), di solito è la shell che si occupa di trovare le corrispondenze tra i pattern e i nomi dei file. Su questi sistemi, dovete esplicitamente dire a Mercurial che un nome è un pattern. Su Windows, la shell non si occupa di espandere i pattern, quindi Mercurial identificherà automaticamente i nomi che sono pattern e li espanderà per voi.

Per fornire un pattern al posto di un nome ordinario sulla riga di comando, il meccanismo è semplice:

sintassi:corpodelpattern

Quindi, un pattern viene identificato da una breve stringa di testo che indica il tipo del pattern, seguita dai due punti, seguiti dall’effettivo pattern.

Mercurial supporta due tipi di sintassi per i pattern. Quello usato più spesso è chiamato glob: è lo stesso tipo di pattern usato dalla shell Unix e dovrebbe essere familiare anche agli utenti del prompt dei comandi di Windows.

Quando Mercurial effettua la corrispondenza automatica di un pattern su Windows, usa la sintassi glob. Quindi, potete omettere il prefisso «glob:» su Windows, ma se volete potete anche usarlo tranquillamente.

La sintassi re è più potente perché vi permette di specificare i pattern usando le espressioni regolari, indicate a volte con il termine regexp.

Notate che, negli esempi che seguono, farò molta attenzione a racchiudere tutti i miei pattern tra caratteri di apice, in modo che non vengano espansi dalla shell prima che Mercurial li veda.

$ hg add 'glob:*.py'
aggiungo principale.py

$ cd ..
$ hg status 'glob:**.py'
A esempi/semplice.py
A sorgenti/principale.py
? esempi/efficiente.py
? setup.py
? sorgenti/controllore/controllore.py

$ hg status 'glob:**.?'
? sorgenti/controllore/_controllore.c

$ hg status 'glob:**[nr-t]'
? MANIFEST.in
? sorgenti/xyzzy.txt

$ hg status 'glob:*.{in,py}'
? MANIFEST.in
? setup.py

$ hg status 'glob:*.py'
? setup.py
$ hg status 'glob:**.py'
A esempi/semplice.py
A sorgenti/principale.py
? esempi/efficiente.py
? setup.py
? sorgenti/controllore/controllore.py

Mercurial non vi fornisce solo una varietà di modi per specificare i file, ma vi permette di vagliare ulteriormente quei file usando i filtri. I comandi che lavorano con i nomi dei file accettano due opzioni di filtraggio.

Potete passare più opzioni -I e -X sulla riga di comando e alternarle come preferite. Mercurial interpreta i pattern che riceve usando la sintassi glob per default (ma potete usare le espressioni regolari se ne avete bisogno).

Potete interpretare un filtro -I come una richiesta di «elaborare solo i file che corrispondono a questo filtro».

$ hg status -I '*.in'
? MANIFEST.in

L’interpretazione migliore del filtro -X è quella di una richiesta di «elaborare solo i file che non corrispondono a questo pattern».

$ hg status -X '**.py' sorgenti
? sorgenti/controllore/_controllore.c
? sorgenti/xyzzy.txt

Quando create un nuovo repository, è possibile che nel tempo cresca fino a contenere file che non dovrebbero essere gestiti da Mercurial, ma che non vorreste vedere elencati ogni volta che invocate hg status. Per esempio, i «prodotti di assemblaggio» sono file che vengono creati come parte dell’assemblaggio di un progetto ma che non dovrebbero essere gestiti da un sistema di controllo di revisione. I prodotti di assemblaggio più comuni sono i file di elaborazione generati da strumenti software come i compilatori. Un altro esempio sono i file di bloccaggio, i file di lavoro temporanei e i file di backup che gli editor di testo disseminano per le directory e che non ha alcun senso gestire.

Per fare in modo che Mercurial ignori permanentemente quei file, create un file chiamato .hgignore alla radice del vostro repository. Dovreste registrare questo file tramite hg add in modo che Mercurial ne tenga traccia insieme al resto dei contenuti del vostro repository, dato che anche i vostri collaboratori potrebbero trovarlo utile.

Mercurial si aspetta che il file .hgignore contenga una lista di espressioni regolari, una per riga. Le righe vuote vengono saltate. La maggior parte delle persone preferisce descrivere i file che vuole ignorare utilizzando la sintassi «glob» che abbiamo descritto in precedenza, quindi un tipico file .hgignore comincerà con questa direttiva:

syntax: glob

Questa riga dice a Mercurial di interpretare le righe che seguono come pattern di tipo glob, non espressioni regolari.

Ecco un esempio di un tipico file .hgignore.

syntax: glob
# Questa riga è un commento e verrà saltata.
# Anche le righe vuote vengono saltate.

# File di backup lasciati dall'editor Emacs.
*~

# File di bloccaggio usati dall'editor Emacs.
# Notate che il carattere "#" è preceduto da un backslash.
# Questo evita che venga interpretato come l'inizio di un commento.
.\#*

# File temporanei usati dall'editor vim.
.*.swp

# Un file nascosto creato dal Finder di Mac OS X.
.DS_Store

Se state lavorando in un ambiente di sviluppo misto che contiene sia sistemi Linux (o di tipo Unix) che Mac e Windows, dovreste tenere a mente che questi sistemi trattano le lettere maiuscole («N» rispetto a «n») nei nomi dei file in modi incompatibili tra loro. È improbabile che questo abbia effetti su di voi ed è facile occuparsene quando succede, ma potrebbe sorprendervi se non lo sapete.

I sistemi operativi e i file system differiscono nel modo in cui gestiscono le maiuscole dei caratteri nei nomi di file e directory. Esistono tre modi comuni di gestire le maiuscole nei nomi.

Su sistemi di tipo Unix è possibile avere uno qualsiasi o tutti e tre i modi di gestire le maiuscole in azione allo stesso tempo. Per esempio, se usate Linux per operare su una chiave USB formattata con un file system FAT32, il sistema operativo gestirà i nomi su quel file system in modo da conservare le maiuscole senza essere sensibile a esse.