Git Rebase: Domine a Reescrita do Histórico do Git com Confiança

💡 TL;DR (Resumo)

• Git rebase permite reescrever o histórico de commits para criar um fluxo linear e limpo.
• Use rebase interativo (rebase -i) para combinar, editar ou reordenar commits.
• Evite rebase em branches públicas para prevenir problemas de sincronização.
• A ferramenta é poderosa mas requer cuidado para evitar perda de trabalho.

Git Rebase: O Guia Definitivo para Reorganizar seu Histórico de Commits

O Git é indiscutivelmente a ferramenta de controle de versão mais popular entre desenvolvedores, mas muitos ainda sentem-se intimidados por um de seus comandos mais poderosos: o git rebase. Neste guia abrangente, desmistificaremos completamente esta ferramenta, explorando seus usos, vantagens, armadilhas e melhores práticas.

O que é Git Rebase e por que você deveria se importar?

O git rebase é um comando do Git que permite reorganizar, modificar e limpar o histórico de commits. Diferente do git merge, que une branches mantendo a história completa (incluindo commits de merge explícitos), o rebase "reescreve" a história aplicando commits em uma nova base.

O problema que o rebase resolve

Imagine que você começou a trabalhar em uma funcionalidade em uma branch derivada da main. Enquanto você desenvolve, outros membros da equipe continuam integrando suas alterações na main. Seu histórico começa a divergir, criando uma estrutura complexa que pode dificultar a revisão de código e o entendimento do fluxo de desenvolvimento.

O rebase resolve este problema permitindo que você mova seus commits para o topo da branch mais recente, criando um histórico linear e limpo.

Como o Git Rebase funciona: A magia por trás do comando

Tecnicamente, o rebase funciona identificando o ancestral comum entre sua branch atual e a branch base, salvando temporariamente os commits da sua branch, resetando a branch para a base especificada, e então reaplicando cada commit um por um.

O processo passo a passo:

1. Identificação do ancestral comum: Git encontra onde as duas branches divergiram.
2. Armazenamento de diferenças: Seus commits são convertidos em patches temporários.
3. Reset para a nova base: Sua branch é movida para o commit especificado.
4. Reaplicação de commits: Seus changesets são aplicados sequencialmente na nova base.

Rebase Básico: Movendo uma branch para uma nova base

A forma mais simples de usar rebase é atualizar uma branch de funcionalidade com as alterações mais recentes da branch principal:

Este comando pegará todos os commits exclusivos da minha-feature e os reaplicará em cima do origin/main mais recente.

Rebase Interativo: O poder real do rebase

O verdadeiro poder do rebase é revelado com a flag -i (interativa), que abre um editor onde você pode especificar como cada commit deve ser modificado durante o processo de rebase.

Iniciando rebase interativo:

Opções do rebase interativo:

Ao executar git rebase -i, você encontrará estas opções:

• pick: Mantém o commit inalterado.
• reword: Mantém as alterações mas edita a mensagem do commit.
• edit: Pausa o rebase para permitir modificar o commit.
• squash: Combina o commit com o anterior e permite unir mensagens.
• fixup: Combina o commit com o anterior, descartando sua mensagem.
• drop: Remove completamente o commit.

Cenários Práticos de Uso do Rebase

1. Combinando múltiplos commits (Squashing)

   Um dos usos mais comuns do rebase é combinar vários commits pequenos em commits maiores e mais significativos:

   bash

   # Inicie o rebase interativo para os últimos 3 commits git rebase -i HEAD~3 # No editor, mude "pick" para "squash" ou "fixup" nos commits que quer combinar

2. Limpando o histórico antes de um pull request

   Antes de enviar um pull request, é uma boa prática limpar o histórico para facilitar a revisão:

   bash

   # Certifique-se de que sua branch está atualizada git fetch origin git rebase origin/main # Execute rebase interativo para limpar commits git rebase -i origin/main

3. Corrigindo problemas em commits antigos

   Com edit no rebase interativo, você pode parar em qualquer commit para fazer modificações:

   bash

   # Durante o rebase, quando parar em um commit marcado como "edit": git commit --amend # Faça suas correções git rebase --continue # Continue o processo

4. Separando mudanças grandes em commits menores

   Às vezes você precisa fazer o oposto do squash - separar um commit grande em vários menores:

   bash

   # Marque um commit como "edit" no rebase interativo # Quando o rebase pausar, reset para o commit mas mantenha as mudanças: git reset HEAD~ # Faça commit das mudanças em partes menores git add -p # Adicione mudanças interativamente git commit -m "Parte 1 das mudanças" git commit -m "Parte 2 das mudanças" # Continue o rebase git rebase --continue

Rebase vs Merge: Quando usar cada um

Esta é uma das grandes discussões no mundo Git. Aqui está um guia prático:

Use rebase quando:

• Trabalhando em branches locais não compartilhadas.
• Preparando commits para um pull request.
• Querendo criar um histórico linear e limpo.
• Precisa modificar commits antigos.

Use merge quando:

• Trabalhando em branches públicas compartilhadas com outros.
• Preservando a história completa de como o trabalho foi desenvolvido.
• Integrando funcionalidades completas no branch principal.

Armadilhas comuns e como evitá-las

1. Nunca faça rebase em commits públicos

   A regra de ouro do rebase: nunca faça rebase em commits que já foram enviados para um repositório público e podem ter sido baixados por outras pessoas. Isso causa inconsistências de histórico que são extremamente difíceis de resolver.

2. Conflitos durante o rebase

   Ao contrário do merge que resolve conflitos uma vez, o rebase pode exigir a resolução dos mesmos conflitos múltiplas vezes (para cada commit reaplicado). Esteja preparado para resolver conflitos sequencialmente.

3. Recuperando-se de um rebase problemático

   Se você cometeu um erro durante o rebase, não entre em pânico. O Git mantém uma referência temporária (ORIG_HEAD) apontando para onde sua branch estava antes do rebase:

   bash

   # Abortar um rebase em andamento git rebase --abort # Reverter um rebase completo git reset --hard ORIG_HEAD

Fluxo de trabalho com rebase: Melhores práticas

1. Mantenha branches de funcionalidades atualizadas regularmente

   Em vez de esperar até o final para integrar mudanças da branch principal, atualize frequentemente:

   bash

   # Diariamente, sincronize com a branch principal git checkout main git pull git checkout minha-feature git rebase main

2. Use --rebase no pull para histórico limpo

   Configure seu Git para usar rebase por padrão ao fazer pull:

   bash

   git config --global pull.rebase true

   Isso evita commits de merge desnecessários quando você faz git pull.

3. Revise o histórico antes de push

   Antes de enviar suas alterações, revise o histórico:

   bash

   git log --oneline --graph

   Certifique-se de que o histórico está como você espera antes de compartilhar com outros.

Comandos avançados de rebase

Rebase com autostash

Para rebase quando há mudanças não commitadas:

O Git automaticamente guarda suas mudanças, executa o rebase, e então aplica novamente as mudanças.

Rebase seletivo (--onto)

O comando rebase --onto é poderoso para cenários complexos:

# Suponha que você tem:
# A---B---C feature
#   \
#    D---E main
#         \
#          F---G outra-feature

# Para mover F e G para depois de C:
git rebase --onto feature E outra-feature

Integração com ferramentas modernas

Muitas IDEs modernas e clientes Git oferecem suporte visual para rebase, tornando o processo mais intuitivo. No entanto, entender os comandos por trás das interfaces gráficas é crucial para resolver problemas quando surgem.

Conclusão

O git rebase é uma ferramenta extremamente poderosa que, quando usada apropriadamente, pode transformar um histórico de Git confuso em uma narrativa clara e linear do desenvolvimento do projeto. Domine o rebase interativo, entenda quando usá-lo versus merge, e sempre respeite a regra de não fazer rebase em commits públicos.

Com prática, o rebase se tornará uma parte natural do seu fluxo de trabalho, permitindo que você mantenha um histórico limpo que facilita a leitura, o debugging e a compreensão da evolução do seu código.

Nota do Editor

Este post é um resumo do nosso Simulador Interativo de Git Rebase, uma ferramenta completa para desmistificar, visualizar e dominar uma das funcionalidades mais poderosas e incompreendidas do Git.