Como usar a mesclagem do Git

O Git usa ramificações para isolar fluxos de desenvolvimento, para evitar que a ramificação de lançamento estável seja 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.

Ramifica novos esforços de desenvolvimento em sandbox para que o código possa ser modificado ou adicionado sem afetar o código em outras ramificações, especialmente a ramificação principal ou mestre. Geralmente contém a versão estável da sua base de código.

Isolar essas alterações da 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 implementado no branch master. Nesse ponto, você precisa mesclar seu branch no branch master.

Na verdade, as ramificações podem ter sub-ramificações, então você pode mesclar sua ramificação em alguma outra ramificação em vez da ramificação mestre. Apenas lembre-se de que as mesclagens sempre pegam uma ramificação e a mesclam em uma ramificação de destino, qualquer que seja essa ramificação. Se quiser mesclar seu branch master em outro branch, você também pode fazer isso.

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

Preparando-se 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” do branch “master” e trabalhamos em uma solução para um bug.

Esse trabalho foi concluído e testamos nosso código. Tudo funciona conforme o esperado. Queremos implementar essas alterações no branch master para que nossa correção faça parte da próxima versão do software.

Há um pouco de preparação a ser feita antes de realizarmos a mesclagem. Precisamos ter certeza de que o branch de destino — neste caso o branch “mestre” — e o branch que iremos mesclar nele estão ambos atualizados.

Para fazer isso usaremos o

 git status 

comando.

status do git

• No branch bugfix14 : Este é o nosso branch atual.
• Seu branch está atualizado com ‘origin/bugfix’ : O branch em nosso repositório local tem o mesmo histórico de commits que o branch 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.
• limpeza da árvore de trabalho : não há alterações não preparadas no diretório de trabalho.

Tudo isso indica que a filial está atualizada e podemos prosseguir. Se algum deles indicasse que existiam alterações, precisaríamos prepará-las, confirmá-las e enviá-las para o controle remoto. Se alguém tiver trabalhado nesses arquivos, talvez seja necessário extrair as alterações do repositório remoto.

Verificar o branch em que iremos fazer a fusão simplifica o processo de fusão. Também nos permite verificar se está atualizado. Vamos dar uma olhada no branch master.

mestre de checkout git

status do git

Recebemos as mesmas confirmações de que o branch “master” está atualizado.

Executando uma mesclagem

Antes de mesclarmos, nossos commits ficam assim.

O branch “bugfix14” foi ramificado do branch “master”. Houve um commit no branch “master” após a criação do branch “bugfix14”. Houve alguns commits no branch “bugfix14”.

Certificamo-nos de que nossos dois ramos estão atualizados e verificamos o ramo “master”. Podemos emitir o comando para mesclar o branch “bugfix14” no branch “master”.

git merge correção de bug14

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

Neste caso, o comando merge executa uma mesclagem de três vias. Existem apenas dois ramos, mas há três commits envolvidos. Eles são o chefe de qualquer branch 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.

dê um empurrão

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

Se quiser deletar o branch, você pode fazer isso usando o git branchcomando com a -dopção (delete).

git branch -d bugfix14

Para excluir o branch no repositório remoto use este comando:

git push origem --delete bugfix14

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

Executando uma mesclagem rápida no Git

Se você não fez nenhum commit no branch “master”, seu histórico ficará assim. Também ficará assim se você tiver rebaseado seu branch de desenvolvimento para que ele fique anexado ao final do branch “master”.

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 git mergecomando usual:

git merge correção de bug15

Isso nos dá esse resultado.

Que é igual a isto:

Que é igual a isto:

O Git realizará uma mesclagem rápida sempre que puder. Se os commits no branch “master” 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 mesclagem de avanço rápido — talvez não seja possível, afinal — mas você pode declarar que será uma mesclagem de avanço rápido ou nada. Existe 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 o branch “bugfix15” no branch “master”, mas somente se uma mesclagem de avanço rápido for possível.

git merge --ff-only bugfix15

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

git merge --ff-only bugfix16

Neste caso, houve commits no branch “master”, portanto uma mesclagem de avanço rápido 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 um branch chamado “bugfix17” que queremos mesclar com o branch “master”. Mas “rot.c” também foi alterado no branch “master”.

git merge correção de bug17

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 recuar completamente usando a --abortopção:

git mesclar --abortar

Mas resolver fusões não é tão assustador quanto parece. Git fez algum trabalho para nos ajudar. Se editarmos um dos arquivos conflitantes – no 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 é do branch no qual você está mesclando.
• O código abaixo do sinal de igual é o código do branch que você está tentando mesclar.

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

Manteremos o código do branch “bugfix17”. Após a edição, nosso arquivo fica assim.

Agora podemos continuar com a fusão. Mas observe que usamos o commitcomando para fazer isso, não o mergecomando.

Confirmamos a alteração preparando o arquivo e enviando-o normalmente. Verificaremos o status antes de fazer o commit final.

git adicionar rot.c

status do git

git commit -m "Mesclado bugfix17"

A mesclagem está concluída. Agora podemos enviar isso para nosso repositório remoto.

Tudo se funde eventualmente

Todas as ramificações precisam ser mescladas, eventualmente, para que as alterações nelas não fiquem ó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 a contribuição de cada desenvolvedor apenas para explicar o que seu código faz e por que fizeram as 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.