Se estiver a usar o Git para gestão de código-fonte, poderá precisar de mesclar diferentes ramos de desenvolvimento de um projeto num único ramo. Este artigo irá orientá-lo sobre como combinar dois ramos de desenvolvimento com o comando de mesclagem do Git.
Mostraremos como criar um projeto Git, criar diferentes ramos e mesclar um ramo noutro. Além disso, aprenderá o que é uma mesclagem rápida e uma mesclagem de 3 vias, e como mesclar um ramo num repositório remoto.
O que é a mesclagem no Git?
O Git é uma ferramenta DevOps popular que os desenvolvedores podem usar para rastrear e gerir alterações no código escrito por diferentes equipas. Com o comando git merge, pode pegar no seu ramo de desenvolvimento atual (que tenha bifurcado do ramo principal) e mesclar as suas alterações de código de volta para o ramo principal.
A mesclagem no Git é um comando que usará mais frequentemente quando estiver a trabalhar numa equipa. Pode haver momentos em que você e outro desenvolvedor colaboram numa funcionalidade em dois ramos separados. No entanto, quando chegar a hora, terá de combinar o seu trabalho num ramo, testar essas alterações e, em seguida, mesclar o seu desenvolvimento colaborativo no ramo principal de desenvolvimento.
À medida que o ramo de desenvolvimento principal está sendo atualizado, o ramo de funcionalidade separado em que você e outros desenvolvedores estão trabalhando não será atualizado com as alterações de sua equipe. Portanto, como prática recomendada, quando chegar a hora de abrir uma solicitação de recebimento, você sempre deve começar atualizando sua versão local do ramo principal com as alterações mais recentes. Em seguida, você pode mesclar o ramo principal atualizado em seu ramo de desenvolvimento antes de confirmar e abrir uma solicitação de recebimento para mesclá-lo no ramo de desenvolvimento principal.
Como combinar dois ramos do Git com o Git merge
Como desenvolvedor, ser proficiente no Git pode realmente ajudá-lo a ser mais produtivo. Para começar, é fundamental entender como executar comandos Git a partir da linha de comando. Antes de começarmos, vamos ver o que você terá que configurar primeiro antes de poder começar a mesclar diferentes ramos do Git.
Pré-requisitos
Para começar, você precisará dos seguintes itens:
- A Windows, Mac, or Linux machine to run Git.
- O aplicativo Git, que está disponível para download aqui.
- A GitHub or Gitlab account.
- Um software de edição de código, como o Visual Studio Code.
Vamos rapidamente percorrer os diferentes passos necessários para instalar o Git em um PC com Windows (também temos um guia separado sobre como instalar o Git no Ubuntu):
- Siga o link para baixar o Git para sua máquina e instale os arquivos.
- Depois de instalado, abra seu terminal e digite git –version:
git –version
Se receber um número de versão retornado, ótimo! No entanto, se receber uma mensagem de “comando não encontrado”, então pode ser necessário adicionar o Git à sua variável $PATH. Isso é geralmente um problema do Windows.
Vamos rapidamente resolver isso para você não ter que sair em busca disso.
- Vá até a barra de Inicialização e clique com o botão direito em Este PC.
- Selecione Propriedades.
- Clique em Configurações avançadas do sistema.
- Em Propriedades do Sistema, clique em Variáveis de Ambiente. Aqui, você pode adicionar valores à variável $PATH.
- Selecione $PATH e clique em Editar.
- Clique em Novo e adicione um caminho para o git/cmd.
- Clique em Novo e adicione o caminho para o arquivo git.exe.
Salve as alterações, volte ao terminal e execute novamente o comando git -version.
git -version
Agora você deve ver o número da versão retornado. Depois de fazer o pré-trabalho e configurar sua conta no GitHub ou Gitlab, você agora deve estar pronto para começar.
Criando um projeto Git
Nesta seção, vou guiá-lo pelas diferentes etapas necessárias para criar um novo repositório.
Na sua nova conta do Github, clique em Novo no lado esquerdo da tela.
Em seguida, você precisará dar um nome ao seu repositório e preencher alguns outros detalhes. Dê uma breve descrição se desejar, torne-o público e uma prática recomendada é sempre adicionar um arquivo ReadMe. Depois de terminar, clique em Criar repositório.
Agora, para começar a trabalhar em seu editor de código, você desejará clonar seu novo repositório clicando no botão Clonar. Selecione HTTPS, copie o endereço e abra o seu terminal.
No seu terminal, use o comando cd para escolher onde deseja criar um novo diretório para o seu projeto.
cd user/desktop/repo/
Quando estiver no ramo correto, use o comando mkdir para criar um novo diretório:
mkdir <name of your directory>
Agora, use o comando cd novamente para mudar para esse diretório recém-criado:
cd <name of your newly created directory>
Uma vez no seu novo diretório, use o comando git init para criar um novo repositório:
git init
Em seguida, use o comando git clone com o endereço HTTPS correto e pressione Enter. Por padrão, isso criará um ramo principal no seu repositório local.
git clone <paste https address here>
Agora, abra seu repositório recém-clonado com o Visual Studio Code. Agora você pode começar a escrever código.
Após criar seu repositório, você já estará no ramo principal. Como prática recomendada, você nunca deve, em hipótese alguma, enviar código diretamente para o ramo principal, que precisa ser protegido.
Para o propósito deste tutorial, não iremos abordar ramos Git protegidos. Mas no mundo real, você nunca será capaz de enviar código para o ramo principal sem uma solicitação de extração.
Criando outro ramo Git
Atualmente estamos no ramo principal, você codificou algo para criar algum conteúdo, e agora quer criar um novo ramo.
No seu terminal, use o comando git checkout para criar um novo ramo e trocar automaticamente para ele:
git checkout -b <name of new branch>
O comando deve automaticamente criar esse novo ramo a partir do seu ramo principal, portanto o código deste último não deve mudar.
Agora, aqui vem a parte divertida onde poderemos usar o comando git merge. No seu novo ramo criado, você primeiro precisará adicionar mais código para que o seu ramo atual esteja à frente do ramo principal com algumas alterações novas.
Agora que deseja mesclar este novo ramo ao principal, você pode encontrar um conflito de mesclagem, que é uma inserção de código que entra em conflito com um código que já existe. Não é nada divertido lidar com isso.
Então o que você faz? Vamos ver como mesclar um ramo em outro.
Mesclando seus dois ramos Git no seu repositório local
Enquanto estiver no seu novo ramo, vá para o terminal e use o comando git branch para verificar o nome do ramo em que está:
git branch
Agora você está no seu novo ramo, use o comando git checkout novamente para mudar para o ramo principal:
git checkout Main
Em seguida, use o comando git pull para importar quaisquer alterações que sua equipe possa ter feito e atualizar seu ramo principal localmente:
git pull
Agora, use git checkout novamente para mudar para o novo ramo que deseja mesclar com o ramo principal:
git checkout <your specified branch>
Agora é a hora de usar o comando git merge. Isso pegará a versão atual do seu ramo principal e mesclará com o seu ramo de desenvolvimento:
git merge Main
O resultado da mesclagem terá a última versão do código mais a funcionalidade que você desenvolveu.
Outras maneiras de mesclar ramos Git
Depois de mostrar como mesclar um novo ramo com nosso ramo principal, vamos explorar outras maneiras de mesclar ramos Git que você pode precisar usar.
O que é uma mesclagem de avanço rápido?
A fast-forward merge is another way to merge multiple commits on one branch with one command rather than merging them all manually. Another advantage of using a fast-forward merge is that it will combine the histories of multiple commits while squashing the commit history.
Vamos supor que temos um ramo de funcionalidade à frente do ramo principal por vários commits. Queremos mesclar todos esses commits sem ter que mesclá-los manualmente um por um. Neste caso, vamos usar uma mesclagem avançada.
No nosso exemplo, vamos começar escrevendo algum código e adicionando um novo commit ao nosso ramco com os comandos git add e git commit:
git add <filename>
git commit –m “added a thing”
Agora, vamos adicionar outro commit ao nosso novo ramo usando os mesmos comandos mais uma vez:
git add <filename>
git commit –m “added another thing”
Em seguida, queremos enviar esses dois commits para o nosso repositório remoto sem ter que fazer dois envios. Para fazer isso, precisamos usar o –ff no comando git merge
git merge --ff
Isto irá mesclar ambos os commits ao mesmo tempo em um só e fazer com que o seu código alcance o ramo principal.
O que é uma mesclagem de 3 vias?
Imagine um caso em que a sua equipe de desenvolvimento criou algumas novas funcionalidades em dois ramos separados. Agora você está pronto para atualizar os ramos e mesclá-los no ramo principal para que este último esteja pronto para enviar código para um repositório remoto.
Para garantir que as novas funcionalidades estejam funcionando corretamente juntas, é uma boa ideia mesclar os ramos de funcionalidade um no outro e depois fazer alguns testes. Uma mesclagem de 3 vias nos permitirá combinar dois ramos separados com seu ancestral comum.
Vamos seguir os passos necessários para fazer uma mesclagem de 3 vias com o ramo de destino. No exemplo abaixo, começaremos criando um novo ramo, adicionando dois commits a ele, e depois combinaremos com nosso ramo principal usando uma mesclagem de 3 vias.
Primeiro, vamos começar criando um ramo ‘nova-funcionalidade’ e alternando automaticamente para ele com o comando git checkout. Especificar -b com este comando faz com que um novo ramo seja criado:
git checkout -b new-feature main
Em seguida, adicionamos alguns arquivos e um novo commit ao nosso ramo com os seguintes comandos:
git add <file>
git commit -m "Start a feature"
Em seguida, adicionamos mais um commit ao nosso novo ramo com os seguintes comandos:
git add <file>
git commit -m "Finish a feature"
Depois de adicionarmos novo código ao nosso novo ramo, é necessário imaginar uma situação em que nosso ramo principal continue a progredir. Primeiro, vamos alternar de volta para ele com o comando git checkout:
git checkout main
Em seguida, adicionaremos um novo commit ao nosso ramo principal:
git add <file>
git commit -m "make some changes to Main"
Agora, queremos mesclar o ramo ‘nova-funcionalidade’ que criamos anteriormente com nosso ramo principal atualizado. Como o trabalho continuará em nosso ramo principal, vamos finalizar excluindo o ramo ‘nova-funcionalidade’ com o comando git branch.
git merge new-feature
git branch -d new-feature
Agora, mesclamos nossos dois ramos com um ancestral comum em nosso ramo principal. Este último está pronto para ser mesclado em seu repositório remoto e incrementar ainda mais nosso projeto de software, e veremos como fazer isso a seguir.
Como mesclar um ramo do Git em um repositório remoto
Por vezes, pode ser necessário mesclar um ramo em um repositório remoto. Vamos seguir os passos sobre como realizar essa tarefa.
Vamos imaginar uma situação em que você escreveu um novo código para uma nova funcionalidade que o proprietário do produto queria criar. Após testar o seu código e revisá-lo com o proprietário do produto, você está pronto para mesclar seu trabalho árduo no repositório remoto da equipe.
Como mencionado anteriormente, você nunca deve enviar o seu código diretamente para o ramo principal. Você sempre deve respeitar o fluxo de trabalho do Git que detalhamos no início deste guia.
Após revisar o processo do Git, vamos mesclar o seu código. Seguindo de onde paramos, temos agora um ramo atualizado: as últimas atualizações do ramo principal foram puxadas para o seu repositório local.
Você está agora à porta do repositório remoto. Como chegar lá? Simples, vamos usar mais alguns comandos do git.
Como prática recomendada, você deve sempre verificar o estado do seu ramo com o comando git status. Esse comando irá mostrar quais arquivos foram adicionados, removidos, rastreados ou não rastreados.
git status
Você também deve verificar se adicionou arquivos que não estão sendo rastreados. Nesse caso, você precisa adicioná-los para que sejam rastreados e adicionados ao commit.
Você pode usar o comando git add para adicionar todos os arquivos que você criou em seu desenvolvimento. Agora, talvez precise escrever alguns nomes de arquivos se quiser adicionar arquivos específicos. Se desejar adicionar todos os arquivos, use “.” para adicionar todos os arquivos.
Em seguida, vamos usar o comando git commit para confirmar todos os arquivos que adicionamos na etapa anterior. Será necessário usar a bandeira -m para escrever uma mensagem, caso contrário, você será direcionado para o modo de editor de texto para escrever uma mensagem, o que não é um processo simplificado.
Para sua mensagem, você pode escrever uma breve nota sobre o que fez. Por exemplo: “criei um novo recurso legal e adicionei um novo ícone ao menu, além de correções de bugs”.
git commit -m “<your commit message goes here>”
Por fim, você pode usar o comando git push para enviar seu branch para o repositório remoto.
git push --set-upstream origin <<your branch name>>
Agora, após enviar seu branch, será necessário ir ao GitHub ou onde seus repositórios remotos estão hospedados, encontrar seu envio recente e clicar em Criar pull request.
Ao clicar neste botão, você será direcionado para uma página para adicionar revisores e membros de sua equipe que aprovarão ou negarão sua solicitação de merge. No segundo caso, eles poderão adicionar comentários sobre o que precisa ser corrigido antes de permitir que você junte seu branch ao branch main remoto.
Uma vez que a revisão esteja completa e o seu pedido de merge tenha sido aprovado, o botão Merge estará disponível. Clique neste botão para iniciar o merge. Se o merge for bem-sucedido, você receberá uma mensagem confirmando que o seu novo código foi adicionado.
Parabéns! Você aprendeu o básico sobre como usar o comando git merge!
Conclusão
O git merge é um comando poderoso que permitirá a você e à sua equipe usar diferentes branches para trabalhar em novas funcionalidades e posteriormente juntá-las ao repositório principal.
Você aprendeu os passos necessários para criar branches, fazer merge entre eles, adicionar arquivos e commits e, mais importante, fazer push dessas branches para um repositório remoto. Além disso, você entende agora como fazer um merge fast-forward para combinar várias branches relacionadas usando um único comando, o que pode realmente tornar o trabalho de desenvolvimento mais eficiente.
O Git é uma ferramenta poderosa que pode fazer muito. Quanto mais você aprender sobre os diferentes comandos que pode utilizar, melhor você se tornará como desenvolvedor. Agora que aprendeu tudo o que precisa saber sobre fazer merge entre branches, é hora de partir para aprender outros comandos. Boa sorte na sua jornada para dominar o Git!