Introduzione

Git offre una gestione avanzata dei branch (rami di sviluppo paralleli), consentendo di creare e gestire strutture del repository anche molto complesse in modo rapido.

Per seguire questa guida è necessario:

• aver creato il progetto gitproject come indicato nella pagina principale;

• aver elaborato il progetto come mostrato nella pagina relativa ai commit.

Di solito i passi da effettuare sono i seguenti:

1. Si decide la issue da aggiungere/rimuovere/modificare.

2. Dal branch principale si crea un nuovo branch, con un nome identificativo della modifica (può essere il codice associato a Bugzilla, il nome gp-1 ne è un esempio).

3. Si lavora alla issue su branch secondario.
4. Quando si completa, si effettua il merge sul branch principale in modo che il progetto includa le modifiche e siano rese pubblicamente disponibili.

Questo modo di lavorare permette di fare tutte le sperimentazioni del caso sul proprio branch, senza la preoccupazione di andare a intaccare il progetto sul ramo principale che ne rimarrà immune fino a quando la issue non è completamente testata e funzionante.

Se nel frattempo arriva un'altra issue più urgente (un bug da risolvere o quant'altro), viene semplicemente creato un altro branch da quello principale, come fatto in precedenza, e si lavora su quello. I branch sono indipendenti fra di loro e questo assicura grande flessibilità nella gestione del progetto.

Gestione dei branch

Spostarsi all'interno della cartella del progetto, digitando nel terminale il seguente comando:

cd gitproject

Visualizzazione branch attivi

Per visualizzare i branch attivi:

1. Digitare nel terminale il comando:

    git branch

   verrà restituito:

     * master

   • L'asterisco identifica il branch attivo, quello su cui si sta lavorando in questo momento.

Creazione del branch secondario

Verrà ora creato un ramo di sviluppo del progetto chiamato gp-1 separato dal ramo principale master.

1. Per creare un nuovo branch col nome gp-1 digitare nel terminale il seguente comando:

    git branch gp-1

2. Verificare nuovamente la lista dei branch:

    git branch

   che restituirà:

       gp-1
     * master

   L'asterisco identifica il branch attivo, quello su cui stiamo lavorando in questo momento.

Effettuare switch fra i branch

1. Per lavorare sul branch gp-1 occorre il comando checkout, che ci permette di effettuare lo switch fra i branch:

    git checkout gp-1

   che stamperà un messaggio di conferma del passaggio:

    Si è passati al branch 'gp-1'

2. Verificare quale sia il branch attivo. L'output sarà:

     * gp-1
       master

   conferma che il branch attivo è ora gp-1.

3. Ispezionare la cronologia per verificare la posizione dei rami git lg. L'output:

    * 5b235ad (HEAD -> gp-1, master) - Mario Rossi : Aggiunta data in stampa. (19 minuti fa)
    * b7c1ae2 - Mario Rossi : Aggiunti sorgenti e Makefile (25 minuti fa)
    * ba12845 - Mario Rossi : README aggiunto (51 minuti fa)

   mostra entrambi i branch. Dato che ancora sono identici puntano allo stesso commit.

Modifiche al branch secondario

1. Apportare una modifica al file src/main.cpp presente nella directory del progetto tramite il seguente comando:

    sed -i '3 a \\tstd::cout << "Issue gp-1 implementata" << std::endl;' src/main.cpp

2. Visualizzare il contenuto modificato del file per verifica, digitando il comando:

    cat src/main.cpp

   che risulterà:

    #include <iostream>
    int main() {
            std::cout << "sab 17 feb 2024, 01:26:54, CET: Benvenuti su Git!" << std::endl;
            std::cout << "Issue gp-1 implementata" << std::endl;
            return 0;
    }

3. Controllare lo stato del repository per osservare la notifica della modifica:

    git status

   che risulta:

    Sul branch gp-1
    Modifiche non nell'area di staging per il commit:
      (usa "git add <file>..." per aggiornare gli elementi di cui sarà eseguito il commit)
      (usa "git restore <file>..." per scartare le modifiche nella directory di lavoro)
            modificato:             src/main.cpp
   
    nessuna modifica aggiunta al commit (usa "git add" e/o "git commit -a")

   Possiamo vedere che Git si è accorto della modifica, ma anche che si sta modificando il nuovo branch (il messaggio mostra il nome del branch su cui si sta lavorando).

4. Eseguire il commit per registrare il cambiamento nel branch corrente:

    git commit -a -m "Modificato codice per issue gp-1."

   L'output sarà:

    [gp-1 05b43f8] Modificato codice per issue gp-1.
     1 file changed, 1 insertion(+)

5. Verificare lo stato dei commit tramite la cronologia grafica:

    git lg

   L'output mostrerà che il branch master è rimasto fermo al commit precedente, mentre gp-1 risulterà avanzato con il nuovo commit. Risulterà:

    * 05b43f8 (HEAD -> gp-1) - Mario Rossi : Modificato codice per issue gp-1. (53 secondi fa)
    * 5b235ad (master) - Mario Rossi : Aggiunta data in stampa. (24 minuti fa)
    * b7c1ae2 - Mario Rossi : Aggiunti sorgenti e Makefile (30 minuti fa)
    * ba12845 - Mario Rossi : README aggiunto (56 minuti fa)

Verifica del programma nei branch

Ovviamente se proviamo a eseguire il programma otteniamo l'output modificato con la nostra aggiunta:

1. Eseguire il programma nel branch gp-1 digitando i comandi:

    make clean && make && bin/main

   L'output includerà la stringa "Issue gp-1 implementata":

    sab 17 feb 2024, 01:26:54, CET: Benvenuti su Git!
    Issue gp-1 implementata

2. Tornare nel branch master:

   git checkout master

3. Eseguire nuovamente il programma:

   make clean && make && bin/main

   l'ultimo comando restituirà:

    sab 17 feb 2024, 01:26:54, CET: Benvenuti su Git!

   In questo caso, l'output sarà quello dello stato precedente, confermando che il ramo principale non è stato intaccato.

4. Ispezionare la cronologia per verificare la posizione dei rami git lg, da cui risulta

     * 05b43f8 (gp-1) - Mario Rossi : Modificato codice per issue gp-1. (5 minuti fa)
     * 5b235ad (HEAD -> master) - Mario Rossi : Aggiunta data in stampa. (27 minuti fa)
     * b7c1ae2 - Mario Rossi : Aggiunti sorgenti e Makefile (34 minuti fa)
     * ba12845 - Mario Rossi : README aggiunto (60 minuti fa)

   Da notare HEAD che adesso punta al commit master.

HEAD è quindi un puntatore al commit in cui attualmente ci si trova. È possibile spostarsi in qualsiasi commit, non solo sugli ultimi dei rispettivi branch, digitando:

git checkout SHA1

dove SHA1 è il codice SHA1 del commit (i valori d8b610a, 1412239, ecc.. mostrati nel log).

Modifica al branch principale

Mentre il branch gp-1 è isolato, è possibile procedere con lo sviluppo parallelo sul master.

1. Creare una directory di documentazione e un file Changelog, digitando nel terminale i seguenti comandi:

    mkdir doc
    echo '== Changelog =='$'\n'$'\n''First release' > doc/Changelog

2. Visualizzare il contenuto:

    cat doc/Changelog

   che risulterà:

    == Changelog ==
   
    First release

3. Aggiungere i file ed seguire il commit:

    git add doc/
    git commit -a -m "Aggiunta cartella documentazione."

   che restituirà:

    [master 158633d] Aggiunta cartella documentazione.
     1 file changed, 3 insertions(+)
     create mode 100644 doc/Changelog

4. Ispezionare la cronologia per verificare la posizione dei rami git lg. Risulterà:

    * 158633d (HEAD -> master) - Mario Rossi : Aggiunta cartella documentazione. (32 secondi fa)
    | * 05b43f8 (gp-1) - Mario Rossi : Modificato codice per issue gp-1. (8 minuti fa)
    |/  
    * 5b235ad - Mario Rossi : Aggiunta data in stampa. (31 minuti fa)
    * b7c1ae2 - Mario Rossi : Aggiunti sorgenti e Makefile (37 minuti fa)
    * ba12845 - Mario Rossi : README aggiunto (63 minuti fa)

   È possibile notare come adesso i due branch stiano prendendo strade parallele. Sono partiti da un punto in comune, ma ognuno sta avendo modifiche indipendenti.

Merge

Adesso siamo nella situazione in cui:

• il branch master ha aggiunto la documentazione;

• il branch gp-1 ha implementato una feature.

Verrà effettuato un merge ossia introdurre le modifiche fatte in un branch in un altro branch.
In particolare, vogliamo che nel branch master vengano introdotte le modifiche aggiunte nel branch gp-1. Vogliamo quindi effettuare il merge di gp-1 su master:

1. Assicurarsi di essere nel branch di destinazione (master) tramite git branch.:

    git branch

   cioé che risulti:

      gp-1
    * master

2. Effettuare il merge:

    git merge gp-1

   il cui output sarà:

    Merge made by the 'ort' strategy.
     src/main.cpp | 1 +
     1 file changed, 1 insertion(+)

   • Il comando per effettuare i merge in Git sarà del tipo git merge MERGE

3. Per verificare che le modifiche apportate su gp-1 siano state incluse nel master, visualizzare il contenuto del file ~/gitproject/src/main.cpp, digitare:

    cat src/main.cpp

   che restituisce:

    #include <iostream>
    int main() {
           std::cout << "sab 17 feb 2024, 01:26:54, CET: Benvenuti su Git!" << std::endl;
           std::cout << "Issue gp-1 implementata" << std::endl;
           return 0;
    }

4. Controllare lo storico con git lg: verrà visualizzato un nuovo commit di merge che riunisce i rami. Verificando il contenuto di src/main.cpp, la modifica di gp-1 risulterà ora integrata. Risulterà:

     *   b92d7ff (HEAD -> master) - Mario Rossi : Merge branch 'gp-1' (3 minuti fa)
     |\  
     | * 05b43f8 (gp-1) - Mario Rossi : Modificato codice per issue gp-1. (14 minuti fa)
     * | 158633d - Mario Rossi : Aggiunta cartella documentazione. (7 minuti fa)
     |/  
     * 5b235ad - Mario Rossi : Aggiunta data in stampa. (37 minuti fa)
     * b7c1ae2 - Mario Rossi : Aggiunti sorgenti e Makefile (44 minuti fa)
     * ba12845 - Mario Rossi : README aggiunto (70 minuti fa)

   Si può vedere che nel branch master è stato creato un nuovo commit, che è il commit di merge. Il suo commento dice che è stato effettuato il merge del branch gp-1. Questo significa che le modifiche che abbiamo apportato su questo branch sono state riportate sul branch corrente (master).

Ulteriori risorse

• Guida a Git

CategoryProgrammazione