Como usar o Git merge


0
Master Hands/Shutterstock.com
Para mesclar uma ramificação de desenvolvimento na ramificação atual, use “git merge dev-branch-name”. Se você receber avisos de conflito sobre uma mesclagem, use “git merge –abort” para sair dela ou edite os arquivos afetados e, em seguida, confirme-os.

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.

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. Lembre-se de que as mesclagens sempre pegam uma ramificação e a mesclam em uma alvo ramo, qualquer que seja esse ramo. 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 vamos usar o git status comando.

git status

Usando git status para ver o estado de um branch

  • No branch bugfix14: Este é o nosso ramo 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 cometer 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.

git checkout master
git status

Verificando o branch master e usando git status para ver seu estado

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 histórico de confirmação antes da mesclagem de uma ramificação

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

mesclando uma ramificação com o comando git merge

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”.

O histórico de confirmação após a mesclagem de uma ramificação

Neste caso, o comando merge executa um fusão 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 git push comando.

git push

Enviando alterações para um repositório remoto

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 git branch comando com o -d (excluir) opção.

git branch -d bugfix14

Excluindo uma ramificação no repositório local

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

git push origin --delete bugfix14

Excluindo uma ramificação no repositório remoto

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”.

O histórico de commits antes de um fast-forward merge

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 habitual git merge comando:

git merge bugfix15

Isso nos dá esse resultado.

Uma maneira de exibir o resultado de uma mesclagem de avanço rápido

Que é o mesmo que isso:

Outra maneira de visualizar o resultado de uma mesclagem de avanço rápido

Que é exatamente igual a isso:

Ainda outra maneira de visualizar o resultado de uma mesclagem de avanço rápido

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

você não pode força uma mesclagem de avanço rápido – pode não ser possível, afinal – mas você pode declarar que será uma mesclagem 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 fusão 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

Usando a opção --ff-only para evitar que uma mesclagem de três vias seja usada se uma mesclagem de avanço rápido não for possível

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

git merge --ff-only bugfix16

O Git não está executando nenhuma mesclagem porque uma mesclagem de avanço rápido não é possível e a opção --ff-only foi usada

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

Obtenha relatórios de conflitos e interrompa uma mesclagem

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 o --abort opção:

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.

Como o git identifica conflitos dentro de um arquivo

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

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

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 deseja 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.

O texto editado, resolvendo o conflito de mesclagem

Agora podemos continuar com a fusão. Mas note que usamos o commit comando para fazê-lo, não o merge comando.

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 "Merged bugfix17"

Usando o comando commit para concluir uma mesclagem após resolver conflitos

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?


Like it? Share with your friends!

0

What's Your Reaction?

hate hate
0
hate
confused confused
0
confused
fail fail
0
fail
fun fun
0
fun
geeky geeky
0
geeky
love love
0
love
lol lol
0
lol
omg omg
0
omg
win win
0
win

0 Comments

Your email address will not be published. Required fields are marked *