Git è uno dei software di controllo della versione distribuito su Linux più utilizzati dagli sviluppatori per facilitare il coordinamento sullo stesso progetto.
Se non hai familiarità con Git, ti consigliamo di leggere questa guida introduttiva all'installazione e all'inizio di Git. Finora sono state mostrate solo le funzioni di base. Questi includono la preparazione dell'area di lavoro e la creazione dei vari repository, tramite file "stage" e "commit" delle modifiche, nonché l'eventuale rimozione o ridenominazione dei file.
Il passaggio successivo è per capire come muoversi tra le diverse versioni del progetto. Come suggerisce la natura del software, infatti, la possibilità di creare nuovi ed infiniti repository, partendo da un'opera preesistente, crea inevitabilmente una catena di percorsi differenti, tutti derivanti dallo stesso progetto.
Lo scopo di questa guida è spiegare, quindi, come gestire correttamente il versionamento di un progetto, spostandosi tra i vari rami (branching), unendo diversi rami e ripristinando le versioni precedenti. Questa guida è valida per le principali distribuzioni Linux ed è stata testata su Ubuntu 18.04.
Utilizzo dei rami Git
La ramificazione è una delle funzionalità più potenti di Git. I rami vengono utilizzati per implementare funzioni diverse e indipendenti tra loro a partire dalla stessa radice. Il ramo principale di un progetto viene generato quando viene creato un "repository" ed è etichettato come "master".
La prima cosa da fare per imparare a muoversi tra i vari rami di un repository è usare il comando "git checkout", seguito dal ramo su cui lavorare:
$ git checkout <branch> Ad esempio, per muoverti e lavorare sul ramo principale, usa il comando seguito da "master", come mostrato di seguito:
$ git checkout master Una volta indicato il ramo per la creazione del tuo repository, i file verranno portati nell'ultima fase del ramo scelto nella cartella di lavoro. Quindi, eventuali modifiche future apportate creeranno una nuova versione del progetto per quel particolare ramo.
Creazione di un nuovo ramo con Git
Per creare un nuovo ramo con Git basta usare il comando "git branch" seguito dal nome da dare al ramo creato:
$ git branch <nome_ramo> Il passaggio al ramo appena creato non è automatico. Quindi, per lavorare sul ramo appena creato, ricorrere al comando "git checkout":
$ git checkout <nome_ramo> A questo punto, ogni commit farà riferimento al ramo appena creato.
Nella Figura 1 vengono eseguite le seguenti operazioni:
- Sposta al ramo "master";
- Creazione di un nuovo ramo (Test0);
- Sposta nel ramo appena creato;
- Aggiunta di un file (BranchTest);
- Commettere modifiche;
- Torna al ramo "master".
Fig. 1 - Esempio di creazione di branch e commit su Ubuntu 18.04
Trovare ed eliminare rami Git
Il comando "git branch" senza seguire nulla rilascerà semplicemente un elenco di tutti i rami esistenti.
$ git branch Per eliminare un ramo usa il comando "git branch", in questo caso seguito dall'argomento "-d" e dal nome del ramo da rimuovere :
$ git branch -d <nome_ramo> La figura 2 mostra un esempio di elenco di rami e di cancellazione del ramo appena creato (Test0).
Fig. 2 - Esempio di Elenco Rami ed Eliminazione su Ubuntu 18.04
Come mostrato in figura, quando si tenta di eliminare un ramo su cui sono state apportate modifiche, Git restituirà un errore. Poiché il ramo non è stato unito (unione di rami), per evitare di perdere tutto il lavoro svolto per errore, ne eviterà l'eliminazione.
Sarà comunque possibile eliminare il ramo utilizzando l'argomento "-D":
$ git branch -D <nome_ramo> Unire rami Git
Lo scopo delle branch è quello di creare flussi di lavoro paralleli e indipendenti al fine di sperimentare nuove funzionalità senza intaccare il progetto principale (es. versioni "release", "beta" o "fix").
Per questo motivo il le filiali sono progettate per avere una vita breve, che culmina nella fusione con un'altra filiale.
I rami possono essere uniti usando il comando "git merge" seguito dal nome del ramo da unire.
$ git merge <ramo_da_unire>
Ovviamente, la fusione deve avvenire tra due rami. Il comando "git merge" unisce il ramo indicato nella sintassi con quello su cui ti trovi attualmente. Quindi, per eseguire il "merge", assicurati, tramite "git checkout", di trovarti sul ramo con cui vuoi unirti.
Quindi, il comando "git merge" indicato non lascerà traccia dell'unione in la cronologia del "repository".
Molto spesso può essere necessario tenere traccia dell'unione in modo che sia sufficiente utilizzare semplicemente l'argomento "--no-ff". In questo modo, Git eseguirà automaticamente un nuovo commit per identificare la "unione" in futuro:
$ git merge --no-ff <ramo_da_unire> La fusione di due rami non comporta l'eliminazione del ramo che è stato accorpato a quello indicato. Invece continuerà ad esistere. Per rimuoverlo definitivamente, procedi con l'eliminazione utilizzando il comando "git branch -d".
Nella Figura 3 è mostrato un esempio di unione tra rami. In particolare, le operazioni eseguite sono:
- Sposta al ramo "master";
- Elenco delle filiali;
- Unire il ramo "Br01";
- Cancellazione della filiale "Br01".
Fig. 3 - Esempio di rami uniti su Ubuntu 18.04
Per ottenere un elenco che mostri solo i rami non uniti a quello corrente, usa il comando "git branch" seguito dall'argomento "--no-merged".
$ git branch --no-merged Risoluzione dei conflitti
Quando due branch vengono uniti, Git determina automaticamente quale dei due commit principali è il migliore e si unisce ad esso.
Git potrebbe non essere in grado di decidere automaticamente quale versione dei file conservare durante questa operazione e quindi notificherà a un conflitto.
Se si verifica questa situazione, risolvere il conflitto manualmente e confermare le modifiche apportate. In alternativa, l'unione delle filiali non avverrà.
L'esempio seguente mostra meglio questa occorrenza. Poiché considera due rami diversi in cui vengono salvate due versioni diverse dello stesso file, una volta uniti, Git visualizzerà il seguente avviso:
CONFLICT (content): Merge conflict in <filename>
Automatic merge failed; fix conflicts and then commit the result.
Per risolvere il problema, vai nella cartella in cui si trova il file in conflitto, modificalo ed effettua un successivo "aggiungi" con "commit". In caso di file di testo, Git segnalerà le sezioni incriminate nel file inserendo la sezione presente solo nel primo ramo e tra "=" tra "<<<<<<<" e "=======" ======"e">>>>>>> "quello presente solo nel secondo.
Modificando manualmente il file ed eseguendo il comando "git add" seguito dal " git commit", i due rami si uniranno finalmente, come mostrato in figura 4.
Nell'esempio mostrato in figura 4 sono stati controllati anche i rami non uniti per essere sicuri che il "merge" fosse eseguito correttamente.
Fig. 4 - Esempio di Risoluzione di Conflitti e Merge su Ubuntu 18.04
Infatti, dopo il commit, il ramo "Br03" non compare più nell'elenco delle filiali disconnesse, a dimostrazione del fatto che la fusione con il ramo "Br04" è andata a buon fine.
Git Tag Git
I "Tag" non sono altro che etichette da allegare ai vari "commit" per riportare informazioni utili sulla versione e sul progetto su cui si sta lavorando.
Per visualizzare i tag in un "repository", usa il comando "git tag":
$ git tag Esistono due diversi tipi di tag in Git:"annotati" e "leggeri". I primi servono per indicare le informazioni complete sulla versione, come il "checksum", il nome dello sviluppatore, la data/ora ed eventuali commenti. I secondi sono semplici puntatori a un commit.
Il comando "git tag" seguito dal testo di identificazione della versione creerà un tag "leggero". La sintassi è mostrata di seguito:
$ git tag <Nome_Versione> L'utilizzo dell'argomento "-a", invece, porta alla versione di un tag "annotato":
$ git tag -a <Nome_Versione> -m <Commento> Infine, per visualizzare un tag, usa il comando "git show" come mostrato di seguito:
$ git show <Nome_Versione> I comandi appena esaminati consentono di aggiungere "tag" solo all'ultimo commit. Per aggiungere un tag ad un commit precedente, indicare dopo il comando "git tag" anche l'identificatore (Checksume) del commit a cui fare riferimento. La sintassi completa è mostrata di seguito:
$ git tag -a <Nome_Versione> <Checksum_Commit> Per tenere traccia del "checksum" dei vari commit effettuati, usa il comando "git log".
$ git log --pretty=oneline Una volta lanciato il comando, verrà visualizzato sul terminale un elenco in ordine cronologico dei vari "checksum" dei commit seguito dal commento inserito durante la fase di "commit" delle modifiche.