Como usar o Git merge

O Git usa ramificações para isolar fluxos de desenvolvimento, para evitar que a ramificação de versão estável fique poluída. Trazer o trabalho de uma ramificação para o fluxo principal significa mesclar ramificações. Veja como você faz isso.

O que é uma mesclagem no Git?

O Git foi projetado para tornar a ramificação simples e rápida. Em contraste com outros sistemas de controle de versão, ramificar no Git é uma questão trivial. Especialmente em projetos com vários desenvolvedores, a ramificação é uma das principais ferramentas organizacionais do Git.

Ramos sandbox novos esforços de desenvolvimento para que o código possa ser modificado ou adicionado sem afetar o código em outros branches, especialmente o branch principal ou mestre. Isso geralmente contém a versão estável de sua base de código.

Isolar essas alterações de sua versão de código estável faz todo o sentido. Mas, mais cedo ou mais tarde, o novo código será testado, revisado e carimbado para ser lançado no branch master. Nesse ponto, você precisa mesclar sua ramificação na ramificação principal.

RELACIONADO Como funcionam as ramificações do Git?

Na verdade, as ramificações podem ter sub-ramificações, portanto, você pode mesclar sua ramificação em outra ramificação em vez da ramificação principal. Apenas lembre-se de que as mesclagens sempre pegam uma ramificação e a mesclam em uma ramificação de destino , qualquer que seja a ramificação. Se você deseja mesclar sua ramificação principal em outra ramificação, também pode fazer isso.

Como a maioria das ações no Git, você executa mesclagens em seu repositório local e as envia para seu repositório remoto.

Preparando para mesclar uma ramificação no Git

Temos um pequeno projeto de desenvolvimento com um repositório Git local e um repositório Git remoto. Criamos um branch chamado “bugfix14” a partir do branch “master” e trabalhamos em uma solução para um bug.

Esse trabalho está concluído e testamos nosso código. Tudo funciona como esperado. Queremos aplicar essas alterações no branch master para que nossa correção faça parte do próximo lançamento do software.

Há uma pequena preparação a ser feita antes de realizarmos a fusão. Precisamos ter certeza de que a ramificação de destino - neste caso, a ramificação "mestre" - e a ramificação que vamos mesclar estão atualizadas.

Para fazer isso, usaremos o comando git status .

 git status 

• No branch bugfix14 : Este é o nosso branch atual.
• Sua ramificação está atualizada com 'origin/bugfix' : A ramificação em nosso repositório local tem o mesmo histórico de confirmação que a ramificação no repositório remoto. Isso significa que eles são idênticos.
• nada para confirmar Não há alterações na área de preparação que não tenham sido confirmadas.
• árvore de trabalho limpa : Não há alterações não preparadas no diretório de trabalho.

Tudo isso indica que a ramificação está atualizada e podemos prosseguir. Se algum deles indicasse a existência de alterações, precisaríamos testá-las, confirmá-las e enviá-las para o controle remoto. Se outra pessoa trabalhou nesses arquivos, talvez seja necessário obter as alterações do repositório remoto.

Verificar a ramificação na qual vamos mesclar simplifica o processo de mesclagem. Também nos permite verificar se está atualizado. Vamos dar uma olhada no branch master.

 mestre de checkout git

 git status 

Recebemos as mesmas confirmações de que a ramificação “mestre” está atualizada.

RELACIONADO: Como escolher o modelo de fluxo de trabalho e ramificação do Git certo para sua equipe

Executando uma fusão

Antes de fazermos o merge, nossos commits ficam assim.

O branch “bugfix14” foi derivado do branch “master”. Houve um commit no branch “master” depois que o branch “bugfix14” foi criado. Houve alguns commits no ramo “bugfix14”.

Garantimos que nossas duas ramificações estejam atualizadas e verificamos a ramificação “mestre”. Podemos emitir o comando para mesclar a ramificação “bugfix14” na ramificação “mestre”.

 git merge bugfix14 

A fusão ocorre. A ramificação “bugfix14” ainda existe, mas agora as alterações feitas nessa ramificação foram mescladas na ramificação “mestre”.

Nesse caso, o comando merge executa uma mesclagem de três vias . Existem apenas duas ramificações, mas há três commits envolvidos. Eles são o head de qualquer ramificação e um terceiro commit que representa a própria ação de mesclagem.

Para atualizar nosso repositório remoto, podemos usar o comando git push .

 git push 

Algumas pessoas preferem excluir ramificações laterais depois de fundi-las. Outros cuidam de preservá-los como registro da verdadeira história de desenvolvimento do projeto.

Se você deseja excluir a ramificação, pode fazê-lo usando o comando git branch com a opção -d (excluir).

 git branch -d bugfix14 

Para excluir a ramificação no repositório remoto, use este comando:

 git push origin --delete bugfix14 

Você terá um histórico de confirmação linear, mas não será o verdadeiro histórico.

RELACIONADO: Como excluir ramificações do Git em repositórios locais e remotos

Executando um Fast-Forward Merge no Git

Se você não fez nenhum commit no branch “master”, seu histórico ficará assim. Ele também terá esta aparência se você rebaseou sua ramificação de desenvolvimento para que ela seja anexada ao final da ramificação “mestre”.

Como não há commits no branch “master”, para mesclar o branch “bugfix15”, tudo o que o Git precisa fazer é apontar o ponteiro principal “master” para o último commit do branch “bugfix15”.

Podemos usar o comando git merge usual:

 git merge bugfix15

Isso nos dá esse resultado.

Que é o mesmo que isso:

Que é exatamente igual a isso:

O Git executará uma mesclagem rápida sempre que puder . Se os commits para a ramificação “mestre” significarem que uma mesclagem de avanço rápido não é possível, o Git usará uma mesclagem de três vias .

Você não pode forçar uma fusão de avanço rápido - pode não ser possível, afinal - mas pode declarar que será uma fusão de avanço rápido ou nada. Há uma opção que instrui o Git a usar uma mesclagem de avanço rápido, se puder, mas não a fazer uma mesclagem de três vias, se não puder. A opção é --ff-only (somente mesclagem de avanço rápido).

Isso mescla a ramificação “bugfix15” na ramificação “mestre”, mas somente se uma mesclagem rápida for possível.

 git merge --ff-only bugfix15 

Git irá reclamar e sair se não for possível.

 git merge --ff-only bugfix16 

Neste caso, houve commits para o branch “master”, então uma fusão rápida não é possível.

Como resolver conflitos de mesclagem no Git

Se as mesmas partes do mesmo arquivo tiverem sido alteradas em ambas as ramificações, as ramificações não poderão ser mescladas. A interação humana é necessária para resolver as edições conflitantes.

Aqui, fizemos alterações em um arquivo chamado “rot.c” em uma ramificação chamada “bugfix17” que queremos mesclar com a ramificação “master”. Mas “rot.c” também foi alterado no branch “master”.

 git merge bugfix17 

Quando tentamos mesclá-lo, recebemos um aviso de que há conflitos. O Git lista os arquivos conflitantes e nos informa que a mesclagem falhou. Poderíamos desistir completamente usando a opção --abort :

 git merge --abort

Mas resolver fusões não é tão assustador quanto parece. Git fez algum trabalho para nos ajudar. Se editarmos um dos arquivos conflitantes - em nosso caso, temos apenas um - encontraremos as seções de código conflitantes destacadas para nós.

Cada conflito é delimitado por sete caracteres de menor que “ <<<<<<< ” e sete caracteres de maior que “ >>>>>>> “, com sete sinais de igual “ ======= ” entre eles .

• O código acima dos sinais de igual é da ramificação na qual você está mesclando.
• O código abaixo do sinal de igual é o código da ramificação que você está tentando mesclar .

Você pode pesquisar facilmente um dos conjuntos de sete caracteres e passar de um conflito para outro em seu arquivo. Para cada conflito, você precisa escolher qual conjunto de edições vai manter. Você deve editar o código que está rejeitando e as linhas de sete caracteres que o Git adicionou.

Vamos manter o código da ramificação “bugfix17”. Após a edição, nosso arquivo fica assim.

Agora podemos continuar com a fusão. Mas observe que usamos o comando commit para fazer isso, não o comando merge .

Confirmamos a alteração preparando o arquivo e confirmando-o como de costume. Verificaremos o status antes de fazer o commit final.

 git add rot.c

 git status

 git commit -m "Mesclado bugfix17" 

A fusão está completa. Agora podemos enviar isso para o nosso repositório remoto.

RELACIONADO: Como corrigir, editar ou desfazer confirmações do Git (alterando o histórico do Git)

Tudo se Funde Eventualmente

Todas as ramificações precisam ser mescladas, eventualmente, para que as alterações nelas não se tornem órfãs e esquecidas.

Mesclar filiais é fácil, mas lidar com conflitos pode ser complicado em equipes maiores e ocupadas. A resolução de conflitos pode exigir informações de cada desenvolvedor apenas para explicar o que seu código faz e por que eles fizeram suas alterações. Você precisa entender isso antes de tomar uma decisão informada sobre quais edições manter.

Infelizmente, o Git não pode ajudar com isso.

RELACIONADO: Você deve usar um cliente GUI Git?