Como reescrever e juntar múltiplos commits locais usando git rebase interativo com squash

A importância de manter um histórico limpo no Git

Durante o desenvolvimento de software, é comum criarmos dezenas de pequenos commits locais. Na prática, isso significa salvar o progresso a cada pequena alteração, corrigindo erros de digitação ou testando ideias rápidas. No entanto, enviar essa bagunça para o repositório principal polui a linha do tempo do projeto. Um histórico organizado ajuda qualquer engenheiro a entender rapidamente o propósito de cada modificação meses mais tarde.

Quando trabalhamos em equipe, a clareza do código passa também pela forma como narramos a evolução do sistema. Commits com mensagens genéricas ou repetitivas dificultam a localização de bugs em auditorias futuras. É exatamente nesse cenário que o recurso de rebase interativo se torna uma ferramenta indispensável no dia a dia de qualquer desenvolvedor, permitindo que a faxina seja feita de forma cirúrgica.

O que é o rebase interativo e como ele funciona na prática

O comando git rebase é uma ferramenta que pega uma série de alterações e as reaplica sobre uma nova base de código. Na modalidade interativa, representada pela bandeira -i, o Git abre um editor de texto exibindo uma lista dos seus últimos commits locais. Na prática, isso significa que você ganha controle total sobre a ordem, o conteúdo e a estrutura dessas alterações antes que elas fiquem definitivas.

Imagine que você escreveu cinco commits seguidos para corrigir um único botão na interface. O primeiro criou o arquivo, o segundo ajustou a cor, o terceiro corrigiu um erro de digitação, o quarto alterou o espaçamento e o quinto finalizou. Para quem revisa o código, os quatro primeiros passos são ruído puro. O rebase interativo serve justamente para juntar tudo isso em um único commit coeso e limpo, contando uma história compreensível.

Passo a passo para aplicar o squash e juntar commits

Para iniciar o processo de limpeza no seu terminal, o primeiro passo é identificar quantos commits você deseja revisar. Na prática, você executa o comando informando a quantidade de passos que deseja voltar na sua linha do tempo local.

git rebase -i HEAD~5

O comando acima abre um arquivo no seu editor padrão listando os últimos cinco commits, do mais antigo para o mais recente. Cada linha começa com a palavra pick, que significa manter o commit sem alterações. Para fundir os commits inferiores no primeiro commit da lista, você deve alterar a palavra pick para squash, ou simplesmente s, nas linhas correspondentes aos commits que deseja absorver.

Após salvar e fechar o arquivo de configuração, o Git abrirá uma nova janela solicitando que você edite a mensagem final do commit unificado. Na prática, você apaga as mensagens antigas e escreve um texto claro e descritivo que resuma todo o trabalho realizado naquele bloco de alterações, garantindo contexto útil para o restante da equipe.

Cuidados essenciais ao reescrever o histórico de código

Reescrever o histórico altera a identidade matemática dos commits, modificando hashes e referências temporais. Na prática, isso significa que se você já enviou esses commits para um servidor remoto compartilhado, o rebase vai criar um conflito severo com a versão que os colegas possuem. A regra de ouro na engenharia de software é nunca realizar rebase em commits que já foram publicados e compartilhados.

Caso você já tenha enviado o código para o repositório remoto e precise corrigir o histórico, será necessário forçar a atualização com a bandeira --force. Essa prática deve ser evitada em branches principais como main ou master, sendo aceitável apenas em branches de uso individual onde nenhum outro desenvolvedor esteja colaborando no momento.

Lidando com conflitos durante o processo de unificação

Quando fundimos alterações antigas, é comum que o Git encontre divergências difíceis de conciliar automaticamente. Na prática, isso resulta em um conflito de código que interrompe o processo de rebase temporariamente até que você tome uma decisão manual. O terminal indicará quais arquivos foram afetados e onde estão os pontos de discordância.

Para resolver a situação, abra os arquivos apontados, edite o código para manter a versão correta, adicione as alterações corrigidas usando a ferramenta de stage e continue o processo. O comando que você utiliza para retomar o fluxo após solucionar os problemas é simples e direto no terminal.

git rebase --continue

Caso a situação fique complexa demais e você queira desistir de toda a alteração, o Git oferece uma rede de segurança imediata. A qualquer momento antes de concluir o processo, você pode abortar a operação e retornar exatamente ao estado inicial em que estava antes de digitar o comando de rebase.

git rebase --abort

Considerações finais sobre organização e boas práticas

Dominar o rebase interativo com squash eleva o nível técnico de qualquer desenvolvedor, transformando um fluxo de trabalho caótico em um histórico limpo e profissional. A habilidade de contar a história correta através do código facilita revisões, acelera a identificação de falhas e melhora a colaboração em equipe. Adotar esse hábito no dia a dia garante entregas mais seguras e manutenibilidade a longo prazo para qualquer projeto de software.

A organização do repositório não é apenas uma questão estética, mas um pilar fundamental para a saúde da engenharia de software. Ao dominar ferramentas de manipulação de histórico com responsabilidade, você protege o seu código contra ruídos desnecessários e constrói bases sólidas para a evolução contínua dos sistemas que você ajuda a construir.