O que é Git Rebase: Tutorial e Explicação Simplificada

Dominando o Git Rebase: Limpeza de Histórico e Sincronização de Branchs

Você já se deparou com o desafio de limpar seu histórico de commits no Git, seja para corrigir conflitos ou sincronizar suas alterações com os updates mais recentes da branch principal? Se sim, saiba que você não está sozinho. Dominar a operação `git rebase` pode poupar muitas dores de cabeça, seja você colaborador em um projeto de equipe ou gerenciando sua própria base de código.

Imagine ter a capacidade de reaplicar seus commits de forma fluida sobre outra base, resolver conflitos de merge como um profissional e manter seu projeto em perfeita harmonia. É exatamente isso que exploraremos neste artigo.

Abaixo, apresentamos a agenda do que será abordado:

• Introdução ao que é o Git Rebase.
• Como utilizar o Git Rebase.
• Como lidar com conflitos durante um rebase.
• Explorando o rebase interativo.
• Rebasing de commits de merge.
• Atividade prática (hands-on).

Antes de prosseguirmos, revisitemos alguns conceitos importantes do Git para garantir que você se sinta confortável com a prática de `git rebase`.

O Básico do Git

O Git é um sistema de controle de versão que permite que múltiplos desenvolvedores trabalhem simultaneamente no mesmo projeto sem interferir no trabalho uns dos outros. Ele rastreia as modificações nos arquivos do seu projeto e ajuda a gerenciar as versões ao longo do tempo, facilitando a colaboração ao manter o controle de quem alterou o quê e quando.

Repositório

Um repositório é uma coleção de arquivos rastreados pelo Git, incluindo todo o histórico do seu projeto.

Branch (Branching)

Uma branch é uma versão paralela do seu projeto. Por padrão, seu projeto começa com uma branch chamada `master` ou `main`.

Uma branch de recurso (`feature branch`) é criada a partir da branch principal (`main` ou `master`) para desenvolver uma nova funcionalidade ou correção de bug de forma independente do restante do projeto. Isso isola as alterações relacionadas àquele recurso específico, evitando afetar o projeto principal até que o recurso esteja completo e pronto para ser integrado.

Git Rebase vs. Git Merge

É fundamental entender a diferença entre `git rebase` e `git merge`, pois eles são as duas principais formas de integrar alterações de uma branch em outra.

Git Merge

O comando `git merge` combina duas branchs. Ao integrar uma feature branch na branch principal, ele cria um **novo commit de merge** que conecta as duas branchs.

Em um cenário de integração, se você usa `git merge`, o histórico visual mostrará ramificações e pontos de união devido a esses commits de merge adicionais.

Git Rebase

O `git rebase` também combina alterações de uma branch para outra, mas o faz **reaplicando os commits** da sua branch atual no topo da branch de destino.

A funcionalidade principal do `git rebase` é fazer com que o histórico pareça ter sido desenvolvido no topo da outra branch desde o início. Isso resulta em um **histórico linear, limpo e mais direto**, sem a “sujeira” dos commits de merge.

Se você rebasa a feature branch no master, os commits da feature são aplicados um a um no commit mais recente do master, mantendo o histórico limpo e linear.

Entendendo o Funcionamento do Rebase

O Git Rebase funciona reaplicando os commits de uma branch no topo de outra.

Em um cenário de equipe com várias features sendo desenvolvidas (Feature 1 e Feature 2), ambas baseadas no Master:

1. Se ambas as features usarem `git merge` para voltar ao Master, múltiplos commits de merge (M e N) criarão um histórico confuso e com complexidade desnecessária.
2. Se as features usarem `git rebase`, elas são atualizadas com as últimas alterações do Master *antes* da integração final. Isso garante que, ao mesclar, não haja commits de merge desnecessários, mantendo o histórico linear e fácil de seguir.

Lidando com Conflitos Durante o Rebase

Conflitos ocorrem quando o Git não consegue decidir automaticamente como combinar as alterações, geralmente porque dois desenvolvedores modificaram a mesma parte de um arquivo.

Quando um conflito surge durante o rebase, o Git **pausa a operação**, permitindo que você resolva o conflito manualmente.

Os passos para resolver um conflito são:

1. O Git marca as seções conflitantes no arquivo (com marcadores como `<<<<<<< HEAD` e `>>>>>>> [commit]`).
2. Você deve editar o arquivo manualmente, escolhendo qual alteração manter, combinando as duas ou escrevendo uma nova solução.
3. Após resolver, você deve **registrar (stage)** o arquivo resolvido usando `git add `.
4. Em seguida, você instrui o Git a continuar a operação com `git rebase –continue`.

Se, durante o rebase, você mudar de ideia sobre a operação inteira, pode cancelá-la completamente usando `git rebase –abort`. Isso retorna o branch ao estado exato em que estava antes do rebase começar, descartando quaisquer alterações parcialmente aplicadas.

Comandos Git Essenciais (Recap)

Para trabalhar com rebase, é bom lembrar alguns comandos básicos:

• git branch : Cria uma nova branch.
• git checkout : Alterna para a branch especificada.
• git pull: Busca e mescla as alterações mais recentes do repositório remoto.
• git commit -m "mensagem": Salva as alterações no repositório local.
• git fetch: Busca atualizações do repositório remoto, mas não as mescla.
• git merge : Combina alterações de uma branch na branch atual.
• git rebase : Reaplica os commits da branch atual no topo de outra, mantendo o histórico linear.
• git status: Mostra o status dos arquivos (staged, unstaged, untracked).
• git log: Exibe o histórico de commits.

Opções e Sintaxe do Git Rebase

A sintaxe geral do comando é: `git rebase [-i] [–onto ] [–rebase-merges] [–exec ]`.

Algumas das opções mais relevantes incluem:

• -i (interactive): Permite que você edite interativamente a lista de commits, reordenando, esmagando (squash) ou removendo-os.
• --onto : Especifica um novo ponto de partida para o rebase, permitindo que você mova commits de uma parte da árvore para outra.
• --continue: Continua o rebase após resolver um conflito.
• --skip: Pula o commit atual que causou problemas.
• --abort: Cancela toda a operação de rebase e retorna ao estado anterior.
• --keep-base: Mantém o commit base original da sua branch em vez de movê-lo para o topo do upstream.
• --strategy=: Permite escolher a estratégia de merge (ex: recursive) para lidar com conflitos durante o rebase.

Gerenciamento de Conflitos Detalhado

Quando um conflito ocorre durante um rebase (seja ele interativo ou não), o Git para e exige intervenção manual.

1. **Resolução Manual:** Abra o arquivo conflitante e decida o resultado final, removendo os marcadores de conflito.
2. **Stage:** Use git add para indicar que o conflito foi resolvido naquele arquivo.
3. **Continuação:** Use git rebase --continue para prosseguir com o rebase.

Como o rebase reescreve o histórico de commits, se você estiver trabalhando em um repositório remoto, precisará fazer um git push --force para atualizar o histórico remoto com o seu novo histórico reescrito.

Perguntas Frequentes

• O que acontece se eu usar git rebase em um commit que já foi publicado no repositório remoto?
  Reescrever o histórico (o que o rebase faz) pode causar problemas para outros colaboradores. O Git geralmente bloqueia o push nessas situações, exigindo um git push --force, o que deve ser feito com cautela e apenas se você tiver certeza de que mais ninguém está trabalhando ativamente naquela linha de commits.
• Qual a principal diferença entre git rebase e git merge?
  git merge preserva o histórico exato de quando as ramificações se uniram, criando um commit de merge. git rebase move os commits da sua branch para o topo da branch de destino, resultando em um histórico mais linear e limpo, mas reescrevendo os hashes dos commits reaplicados.
• É possível remover commits específicos do meio do histórico usando git rebase?
  Sim, isso é feito utilizando o git rebase -i (rebase interativo). Nele, você pode mudar a instrução de um commit de pick para drop ou squash, alterando efetivamente o histórico.
• Como eu volto ao estado original se o rebase der errado?
  Durante um rebase pausado (por conflito ou erro), use git rebase --abort. Isso cancela toda a operação de rebase e restaura seu branch ao estado em que estava antes de você iniciar o comando.

O Git Rebase é uma ferramenta poderosa para manter um histórico de projeto organizado e linear, essencial para a saúde de projetos colaborativos. Entender seus mecanismos e as opções de resolução de conflitos garante que você mantenha um controle de versão limpo e profissional.