01 - Git Rebase Interattivo: Pulizia della Storia dei Commit

Cos'è il Git Interactive Rebase

Il git interactive rebase (rebase interattivo) è uno degli strumenti più potenti di Git per riscrivere la storia dei commit. Permette di riorganizzare, modificare, combinare o eliminare commit prima di condividere il tuo lavoro, creando una storia pulita e professionale che facilità code review e debugging.

Avviare l'Interactive Rebase

Per avviare un interactive rebase, specifica quanti commit indietro vuoi modificare con git rebase -i HEAD~N dove N è il numero di commit.

# Riscrivere gli ultimi 3 commit
git rebase -i HEAD~3

# Rebase tutti i commit dal branch main
git rebase -i main

# Rebase da uno specifico commit (escluso)
git rebase -i abc1234

# Vedere quali commit saranno inclusi prima di rebase
git log --oneline HEAD~5..HEAD

L'Editor Interattivo

Quando avvii il rebase interattivo, Git apre il tuo editor di testo configurato mostrando la lista dei commit e le opzioni disponibili:

pick abc1234 Add user authentication
pick def5678 Fix typo in auth module
pick ghi9012 Add password validation
pick jkl3456 Update tests for auth

# Rebase 0123456..jkl3456 onto 0123456 (4 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup [-C | -c] <commit> = like "squash" but keep only the previous
#                    commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]

Operazioni Comuni del Rebase Interattivo

1. Squash: Combinare Commit

Squashing combina multipli commit in uno solo, perfetto per consolidare commit WIP (work in progress) o piccole fix in un commit logico e completo.

# Storia originale
pick abc1234 Add login form
pick def5678 Fix button styling
pick ghi9012 Add validation
pick jkl3456 Fix validation bug

# Modifica in:
pick abc1234 Add login form
squash def5678 Fix button styling
squash ghi9012 Add validation
squash jkl3456 Fix validation bug

# Risultato: 1 commit che combina tutti e 4

Dopo aver salvato, Git ti chiederà di creare un nuovo messaggio di commit:

# This is a combination of 4 commits.
# This is the 1st commit message:

Add login form

# This is the commit message #2:

Fix button styling

# This is the commit message #3:

Add validation

# This is the commit message #4:

Fix validation bug

# Puoi modificare in un messaggio unico più chiaro:
feat: implement user login with form validation

- Created login form component
- Added email and password validation
- Styled form buttons
- Fixed validation edge cases

abc1234 Add login form
def5678 Fix button styling
ghi9012 Add validation
jkl3456 Fix validation bug

xyz7890 feat: implement user
        login with validation

2. Fixup: Squash Senza Messaggio

fixup è come squash, ma scarta il messaggio del commit, mantenendo solo il messaggio del commit precedente. Più veloce quando i messaggi intermedi non servono.

pick abc1234 Add user profile page
fixup def5678 Fix typo
fixup ghi9012 Fix linting errors
fixup jkl3456 Remove console.log

# Risultato: 1 commit con messaggio "Add user profile page"
# I messaggi degli altri 3 sono scartati automaticamente

# Durante lo sviluppo
git commit -m "Add feature X"
# ... lavori ...
git commit --fixup abc1234  # abc1234 è l'hash del commit da fixare

# Poi quando fai rebase
git rebase -i --autosquash HEAD~5
# Git automaticamente organizza i fixup commits!

3. Reword: Modificare Messaggi

Cambia pick in reword per modificare solo il messaggio di commit, senza toccare il contenuto.

pick abc1234 Add user auth
reword def5678 Fixed bug
pick ghi9012 Update tests

# Quando salvi, Git apre l'editor per def5678
# e puoi cambiare "Fixed bug" in qualcosa di più descrittivo:
fix: resolve authentication timeout issue

Fixed a race condition that caused authentication
to timeout under heavy load.

4. Edit: Modificare Contenuto Commit

Usa edit per fermare il rebase e permetterti di modificare il commit (aggiungere/rimuovere file, modificare codice).

pick abc1234 Add payment module
edit def5678 Add validation
pick ghi9012 Add tests

# Quando arrivi a def5678, il rebase si ferma

# Ora puoi modificare file
vim src/validation.ts

# Aggiungi le modifiche al commit
git add src/validation.ts
git commit --amend --no-edit

# Oppure crea nuovi commit
git commit -m "Additional changes"

# Continua il rebase
git rebase --continue

5. Drop: Eliminare Commit

Cambia pick in drop (o elimina la riga) per rimuovere completamente un commit dalla storia.

pick abc1234 Add feature X
drop def5678 Add debug logging
pick ghi9012 Add feature Y

# Oppure semplicemente elimina la riga:
pick abc1234 Add feature X
pick ghi9012 Add feature Y

# Il commit def5678 sparisce dalla storia

6. Reorder: Riordinare Commit

Sposta semplicemente le righe nell'editor per cambiare l'ordine dei commit.

# Ordine originale
pick abc1234 Add tests
pick def5678 Add feature
pick ghi9012 Add documentation

# Riordina per logica migliore
pick def5678 Add feature
pick abc1234 Add tests
pick ghi9012 Add documentation

# I commit vengono riapplicati nel nuovo ordine

Dividere un Commit

A volte hai bisogno di dividere un commit grande in commit più piccoli e focalizzati. Usa edit e git reset.

# Avvia rebase e marca il commit da dividere con 'edit'
git rebase -i HEAD~3

# Quando il rebase si ferma al commit da dividere:
# 1. Resetta il commit (mantiene i cambiamenti come unstaged)
git reset HEAD^

# 2. Ora hai tutti i cambiamenti come uncommitted
git status

# 3. Crea commit più piccoli e focalizzati
git add src/user.model.ts
git commit -m "Add user model"

git add src/user.service.ts
git commit -m "Add user service"

git add src/user.component.ts
git commit -m "Add user component"

# 4. Continua il rebase
git rebase --continue

# Risultato: 1 commit diviso in 3 commit logici

Gestione Errori e Recovery

Annullare un Rebase in Corso

# Se qualcosa va storto durante il rebase
git rebase --abort

# Torna allo stato precedente al rebase

Risolvere Conflitti Durante Rebase

# Se incontri conflitti durante rebase
# Git si ferma e mostra i file in conflitto

# 1. Risolvi i conflitti nei file
vim conflicted-file.ts

# 2. Aggiungi i file risolti
git add conflicted-file.ts

# 3. Continua il rebase
git rebase --continue

# Se il conflitto è su un commit che vuoi skippare
git rebase --skip

Recuperare da un Rebase Andato Male

# Git salva tutto nel reflog - puoi sempre recuperare

# Vedi la storia completa delle operazioni
git reflog

# Output esempio:
# abc1234 HEAD@{{ '{' }}0{{ '}' }}: rebase finished
# def5678 HEAD@{{ '{' }}1{{ '}' }}: rebase: checkout main
# ghi9012 HEAD@{{ '{' }}2{{ '}' }}: commit: Add feature

# Torna allo stato prima del rebase
git reset --hard HEAD@{{ '{' }}2{{ '}' }}

# Oppure crea un branch di backup
git branch backup-before-rebase HEAD@{{ '{' }}2{{ '}' }}

Workflow Professionale con Interactive Rebase

# Commit spesso con messaggi WIP
git commit -m "WIP: add login form"
git commit -m "WIP: fix styling"
git commit -m "WIP: add validation"
git commit -m "WIP: fix bug"

# Combina i WIP in commit logici
git rebase -i HEAD~10

# Squash tutti i WIP in:
# - feat: implement login with validation
# - test: add login form tests
# - docs: update authentication docs

# Assicurati di avere base branch aggiornato
git fetch origin
git rebase -i origin/main

# Riordina se necessario
# Migliora messaggi di commit
# Rimuovi commit di debug/test

Comandi Avanzati e Trucchi

Autosquash con --autosquash

# Durante sviluppo, marca i fixup
git commit --fixup abc1234
git commit --fixup def5678

# Al rebase, Git organizza automaticamente
git rebase -i --autosquash HEAD~10

# I commit fixup vengono automaticamente
# posizionati dopo il commit che fixano

Exec: Esegui Comandi Durante Rebase

pick abc1234 Add feature A
exec npm test
pick def5678 Add feature B
exec npm test
pick ghi9012 Add feature C
exec npm test

# Git esegue i test dopo ogni commit
# Se i test falliscono, il rebase si ferma

Root Rebase: Rebase dal Primo Commit

# Rebase dall'inizio della storia
git rebase -i --root

# Utile per pulizia completa del repository

Quando NON Usare Interactive Rebase

Conclusione

Il git interactive rebase è uno strumento potentissimo per mantenere una storia Git pulita e professionale. Usalo per consolidare commit di lavoro in commit logici e ben descritti prima di condividere il tuo codice. Ricorda sempre: rebase solo commit locali, mai commit pubblici!