Comandos GIT: Merge, a arte de unir esforços no desenvolvimento de software

Imagine que, como em um filme de aventura, você e alguns amigos devem coletar peças de um quebra cabeça e construí-lo em uma cidade. As peças estarão espalhadas pelo caminho até ela. A princípio vocês chegariam lá apenas por uma estrada, e logo ao iniciar a viagem, já coletam diversas peças pelo caminho. No entanto, em um dado momento vocês encontram uma bifurcação, dando início a outra estrada que também dá acesso à cidade. Para garantir que todas as peças sejam coletadas, você se disponibiliza a ir por esse segundo caminho e lá no final, se reencontrar com seus amigos para juntar as peças. E assim ocorreu.

Agora pense que o quebra cabeça é o software que você trabalha, as peças são as alterações feitas nesse software e as estradas são onde essas alterações são feitas. Esse cenário é só mais um dia comum na vida de um desenvolvedor...

O que é merge?

Esse conceito de juntar alterações é antigo e para gerenciar isso, surgiram os sistemas de controle de versão. GIT é um deles, o mais usado hoje em dia, e ele chama essa operação de junção de merge, que traduzido significa mesclar. Nele, as estradas têm o nome de branch e são nelas que ocorrem o desenvolvimento.

Quando durante o curso do desenvolvimento, é necessário que um desenvolvedor crie uma nova branch e trabalhe nela, em algum momento as alterações dele se unirão às alterações de seus colegas feitas em outras branches. É aí que entra o merge. 

Como fazer um merge?

Suponha que você está desenvolvendo na BranchA e os seus colegas estão na BranchB. Quando chegar a hora de juntar as as alterações, é necessário executar o comando:

git merge BranchB

Isso fará com que as alterações da BranchB, feitas pelos seus colegas, sejam trazidas para a BranchA onde você está trabalhando. 

Tipos de merge

Em nosso exemplo, supondo que não houvessem ainda alterações na BranchA, apenas na BranchB, esse merge seria feito apenas com a atualização dos arquivos da BranchB na BranchA de forma simples e rápida, apenas por uma movimentação de ponteiro de versão. Esse merge é chamado de Fast Forward, ou "avanço rápido".

Já se houvessem alterações em ambas as branches, o trabalho do GIT seria maior e ele teria que aplicar um merge Three Way, que consiste em gerenciar 3 revisões dos arquivos envolvidos, as atuais da BranchA, as da BranchB e as futuras da BranchA.

Muitas vezes ele consegue fazer isso de forma automática, mesmo quando o mesmo arquivo foi alterado nas duas branches. Porém, como nada na vida é fácil, dependendo das alterações ele encontrará conflitos, que são alterações em pontos do arquivo que concorrem entre si e que precisam de intervenção manual pra finalizar o processo. 

Resolução de conflitos

Vamos ver um caso de conflito no exemplo em C# a seguir. Em uma classe chamada MinhaClasse, você cria o método Imprimir na BranchA conforme abaixo:

public class MinhaClasse
{
  public string Nome { get; set; }

  public void Imprimir()
  {
      Console.WriteLine("Saudações da BranchA, " + Nome);
  }
}

Já um colega desenvolvedor na BranchB cria o mesmo método nessa classe com outro conteúdo:

public class MinhaClasse
{
  public string Nome { get; set; }

  public void Imprimir()
  {
      Console.WriteLine("Cumprimentos da BranchB para, " + Nome);
  }
}

Quando ocorrer a execução do merge que citamos acima, ocorrerá um conflito e o GIT não saberá qual versão do método deve ser assumida como a final. Assim, ele delega a você essa definição, apontando com marcações no código os pontos que concorrem entre si:

public class MinhaClasse
{
  public string Nome { get; set; }

  public void Imprimir()
  {
<<<<<<< HEAD
      Console.WriteLine("Saudações da BranchA, " + Nome);
=======
      Console.WriteLine("Cumprimentos da BranchB para, " + Nome);
>>>>>>> BranchB
  }
}

Onde ele marca com HEAD é a sua alteração na BranchA enquanto que o outro trecho ele marca como sendo a alteração na BranchB. Você, através da edição do arquivo diretamente ou por uma ferramenta, deverá realizar a resolução desses conflitos manualmente, definindo o quê deve ir para o arquivo final, e depois confirmar a atualização por um comando de commit.

Recomendo que sempre seja utilizada uma ferramenta adequada para esse processo. Normalmente os ambientes de desenvolvimento (IDEs) tem plugins que integram com o GIT permitindo que nela você consiga efetuar o merge de forma simples e segura ali mesmo, onde você escreve seu código. Porém, existem ferramentas mais específicas, com recursos mais completos, como o KDiff3 e o Beyond Compare, dentre outros.

Conclusão

O merge no GIT nada mais é do que unir esforços de desenvolvimento de software em torno de um resultado único, por isso ele se torna um dos comandos mais utilizados e importantes no processo de desenvolvimento, especialmente se a equipe trabalha de forma diversa, com um processo que gerencia diversas branches.