Como Verificar se um Git Remote Possui Novos Commits

Introdução

Neste laboratório, você aprenderá como verificar se um repositório remoto Git possui novos commits que ainda não estão presentes em seu repositório local. Esta é uma habilidade crucial para o desenvolvimento colaborativo, permitindo que você se mantenha atualizado com as alterações feitas por outros.

Começaremos simulando um repositório remoto e adicionando-o ao nosso projeto local. Em seguida, usaremos o comando git fetch para recuperar informações sobre os branches e commits do remoto sem mesclá-los. Finalmente, exploraremos como comparar seu branch local com sua contraparte upstream para identificar quaisquer novos commits no remoto.

Obter (Fetch) do Remote com git fetch

Nesta etapa, aprenderemos como buscar (fetch) as alterações de um repositório remoto. Imagine que você está trabalhando em um projeto com outras pessoas e elas fizeram algumas atualizações. Você precisa obter essas atualizações para sua máquina local. O comando git fetch é como você faz isso. Ele baixa as últimas alterações de um repositório remoto, mas não as mescla em seu branch atual.

Primeiro, vamos simular ter um repositório remoto. Criaremos um repositório bare e, em seguida, o adicionaremos como um remoto ao nosso repositório my-time-machine existente.

cd ~/project
mkdir remote-repo.git
cd remote-repo.git
git init --bare

Isso cria um repositório Git bare, que é tipicamente usado como um repositório central de onde os desenvolvedores fazem push e pull.

Agora, vamos voltar para o nosso repositório my-time-machine e adicionar este repositório bare como um remoto.

cd ~/project/my-time-machine
git remote add origin ~/project/remote-repo.git

Nomeamos nosso remoto origin, que é uma convenção comum. Agora, vamos verificar se o remoto foi adicionado corretamente.

git remote -v

Você deve ver uma saída semelhante a esta, mostrando as URLs de fetch e push para o remoto origin:

origin /home/labex/project/remote-repo.git (fetch)
origin /home/labex/project/remote-repo.git (push)

Agora, vamos simular uma alteração no repositório remoto. Como é um repositório bare, não podemos fazer commits diretamente nele. Em vez disso, simularemos uma alteração criando um novo arquivo no diretório do repositório bare.

cd ~/project/remote-repo.git
echo "This is a remote change" > remote_file.txt

Agora, volte para o seu repositório my-time-machine.

cd ~/project/my-time-machine

Neste ponto, seu repositório local não sabe sobre o remote_file.txt que foi adicionado ao remoto simulado. É aqui que o git fetch entra em ação.

Execute o comando git fetch:

git fetch origin

Você pode não ver muita saída, ou pode ver algo indicando que novos objetos foram recebidos.

O que git fetch origin fez foi conectar-se ao remoto origin e baixar quaisquer novos commits e objetos que não estão em seu repositório local. No entanto, ele não mesclou essas alterações em seu branch atual (master). As alterações agora estão disponíveis em seu repositório local, mas são armazenadas em um branch especial que rastreia o remoto, tipicamente chamado origin/master.

Esta é uma diferença fundamental entre git fetch e git pull. git pull é essencialmente git fetch seguido por um merge. Ao usar git fetch primeiro, você pode ver quais alterações estão disponíveis no remoto antes de decidir integrá-las ao seu trabalho. Isso lhe dá mais controle e ajuda a evitar conflitos inesperados.

Na próxima etapa, veremos como comparar seu branch local com o branch remoto buscado para entender quais alterações foram baixadas.

Executar git log HEAD..@{u}

Na etapa anterior, usamos git fetch para baixar as alterações do repositório remoto. Agora, vamos ver como podemos visualizar os commits que estão no remoto, mas ainda não estão em nosso branch local. É aqui que o comando git log HEAD..@{u} é muito útil.

Certifique-se de que você ainda está no diretório ~/project/my-time-machine.

cd ~/project/my-time-machine

Agora, execute o seguinte comando:

git log HEAD..@{u}

Você pode ver uma saída semelhante a esta:

commit abcdef1234567890abcdef1234567890abcdef (origin/master)
Author: Simulated User <simulated.user@example.com>
Date:   Mon Aug 7 10:05:00 2023 +0000

    Simulated remote commit

Vamos detalhar este comando:

• git log: Este é o comando para visualizar o histórico de commits.
• HEAD: Isso se refere ao commit que seu branch atual está apontando.
• @{u}: Esta é uma abreviação para o branch upstream. Em nosso caso, como buscamos do origin e nosso branch master local está rastreando origin/master, @{u} se refere a origin/master.
• HEAD..@{u}: Esta é uma notação de intervalo no Git. Significa "mostre-me os commits que são alcançáveis a partir de @{u}, mas não alcançáveis a partir de HEAD". Em termos mais simples, ele mostra os commits que estão no branch de rastreamento remoto (origin/master), mas não estão em seu branch local atual (master).

Este comando é incrivelmente útil para ver quais alterações você obterá se fizer merge ou rebase de seu branch local com o branch de rastreamento remoto. Ele permite que você revise as alterações recebidas antes de integrá-las, o que é uma parte crucial de um fluxo de trabalho seguro e controlado.

Você pode estar se perguntando: "Como o Git soube sobre o commit remoto simulado?" Quando executamos git fetch origin na etapa anterior, o Git baixou as informações sobre os commits no repositório origin, incluindo o commit que introduziu remote_file.txt. Essa informação é armazenada no branch de rastreamento origin/master em seu repositório local. O comando git log HEAD..@{u} então compara seu branch master local (HEAD) com este branch de rastreamento origin/master (@{u}) para mostrar a diferença.

Pressione q para sair da visualização do log se estiver em modo tela cheia.

Compreender a diferença entre seu branch local e o branch de rastreamento remoto é fundamental para trabalhar de forma eficaz com repositórios remotos. Este comando fornece uma maneira clara de visualizar essas diferenças.

Testar Remotes Sincronizados

Nas etapas anteriores, buscamos (fetched) as alterações de um repositório remoto simulado e aprendemos como visualizar os commits que estão no remoto, mas não em nosso branch local, usando git log HEAD..@{u}. Agora, vamos ver o que acontece quando nosso branch local está atualizado com o branch de rastreamento remoto.

Primeiro, vamos simular a mesclagem (merging) das alterações remotas em nosso branch local. Enquanto git fetch apenas baixa as alterações, git pull baixa e, em seguida, mescla. Para o propósito deste teste, simularemos o estado após um pull, atualizando manualmente nosso branch local para corresponder ao branch de rastreamento remoto.

Certifique-se de que você está no diretório ~/project/my-time-machine.

cd ~/project/my-time-machine

Agora, vamos simular a mesclagem redefinindo nosso branch master local para o mesmo commit que origin/master. Observação: Em um cenário real, você normalmente usaria git merge origin/master ou git pull origin master para integrar as alterações. Estamos usando git reset --hard aqui puramente para fins de demonstração, para rapidamente colocar nosso branch local em sincronia com o branch de rastreamento remoto para o teste.

git reset --hard origin/master

Você deve ver uma saída indicando que seu branch foi atualizado e a árvore de trabalho está limpa.

HEAD is now at abcdef1 Simulated remote commit

Agora que nosso branch master local está sincronizado com origin/master, vamos executar o comando git log HEAD..@{u} novamente.

git log HEAD..@{u}

Desta vez, você não deve ver nenhuma saída.

Por que nenhuma saída? Porque HEAD (nosso branch master local) e @{u} (o branch de rastreamento origin/master) agora estão apontando para o mesmo commit. O intervalo HEAD..@{u} está vazio porque não há commits alcançáveis a partir de @{u} que também não sejam alcançáveis a partir de HEAD.

Este é o comportamento esperado quando seu branch local está totalmente sincronizado com seu branch de rastreamento remoto upstream. O comando git log HEAD..@{u} é uma maneira rápida de verificar se há alguma alteração recebida do remoto que você ainda não integrou. Se o comando não mostrar nenhuma saída, significa que seu branch local está atualizado com o branch de rastreamento remoto.

Compreender como verificar as alterações recebidas e como interpretar a saída de git log HEAD..@{u} é essencial para colaborar com outras pessoas e manter seu repositório local em sincronia com o remoto.

Resumo

Neste laboratório, aprendemos como verificar se um Git remote tem novos commits. Começamos entendendo o propósito de git fetch, que baixa as alterações de um repositório remoto sem mesclá-las (merging). Simulamos um repositório remoto criando um repositório Git bare e adicionando-o como um remote chamado origin ao nosso repositório local my-time-machine. Verificamos a configuração do remote usando git remote -v.

Em seguida, simulamos uma alteração no repositório remoto criando um arquivo diretamente no diretório do repositório bare. Em seguida, usamos o comando git fetch origin para recuperar essas alterações em nosso repositório local, preparando-nos para verificar novos commits.