Como Verificar se um Commit Git Faz Parte de uma Tag

Introdução

Neste laboratório, você aprenderá como determinar se um commit Git específico está incluído em alguma das tags do seu projeto. Esta é uma habilidade valiosa para entender quais lançamentos ou versões contêm alterações específicas.

Através de exercícios práticos, você utilizará o comando git tag --contains para identificar as tags associadas a um determinado commit e explorará a funcionalidade do git describe para verificar tags. Você também testará esses métodos com commits sem tag para solidificar sua compreensão.

Executar git tag --contains Commit

Nesta etapa, aprenderemos como usar o comando git tag --contains para encontrar quais tags contêm um commit específico. Isso é útil quando você deseja saber quais lançamentos ou versões do seu projeto incluem uma alteração específica.

Primeiro, vamos garantir que estamos no diretório do nosso projeto. Abra seu terminal e navegue até o diretório my-time-machine:

cd ~/project/my-time-machine

Agora, vamos criar alguns commits e tags para trabalhar. Adicionaremos um novo arquivo e faremos um commit:

echo "Another message for the future" > message2.txt
git add message2.txt
git commit -m "Add a second message"

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

[master <commit-hash>] Add a second message
 1 file changed, 1 insertion(+)
 create mode 100644 message2.txt

Agora, vamos adicionar uma tag a este commit. Vamos chamá-la de v1.0:

git tag v1.0

Este comando não produz nenhuma saída, mas criou uma tag apontando para o commit mais recente.

Vamos fazer outro commit sem uma tag:

echo "A third message" > message3.txt
git add message3.txt
git commit -m "Add a third message"

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

[master <commit-hash>] Add a third message
 1 file changed, 1 insertion(+)
 create mode 100644 message3.txt

Agora temos dois commits e uma tag. Vamos usar git log --oneline para ver nosso histórico de commits:

git log --oneline

Você deve ver algo como isto (os hashes dos commits serão diferentes):

<commit-hash> (HEAD -> master) Add a third message
<commit-hash> (tag: v1.0) Add a second message
<commit-hash> Send a message to the future

Observe que a tag v1.0 está associada ao commit "Add a second message".

Agora, vamos encontrar quais tags contêm o commit "Add a second message". Precisamos do hash do commit para isso. Na saída de git log --oneline, copie o hash do commit ao lado de (tag: v1.0).

Substitua <commit-hash> pelo hash real que você copiou e execute o seguinte comando:

git tag --contains <commit-hash>

Você deve ver v1.0 na saída, porque esta tag aponta diretamente para esse commit.

Agora, vamos tentar encontrar quais tags contêm o primeiro commit ("Send a message to the future"). Copie o hash do commit para esse commit de git log --oneline.

Substitua <first-commit-hash> pelo hash real e execute:

git tag --contains <first-commit-hash>

Você ainda deve ver v1.0 na saída. Isso ocorre porque v1.0 está em um commit que é um descendente do primeiro commit. A flag --contains verifica se o commit especificado é um ancestral do commit para o qual a tag aponta.

Este comando é muito útil quando você precisa determinar quais versões do seu software incluem uma correção de bug ou recurso específico.

Usar git describe para Verificar Tags

Nesta etapa, exploraremos o comando git describe. Este comando é usado para encontrar a tag mais recente que é alcançável a partir de um commit. É particularmente útil para gerar nomes legíveis por humanos para commits, especialmente aqueles que não são diretamente tagged.

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

Primeiro, vamos executar git describe sem nenhum argumento:

git describe

Como nosso commit mais recente não está tagged, git describe procurará a tag mais próxima e, em seguida, nos dirá quantos commits foram feitos desde essa tag e fornecerá uma versão abreviada do hash do commit mais recente. Você deve ver uma saída semelhante a esta:

v1.0-1-g<commit-hash>

Vamos detalhar esta saída:

• v1.0: Esta é a tag mais recente que é um ancestral do commit atual.
• 1: Isso indica que há 1 commit entre a tag v1.0 e o commit atual.
• g<commit-hash>: O g significa "git" e <commit-hash> é um identificador curto e único para o commit atual.

Este formato é muito útil para identificar builds ou versões específicas do seu projeto, mesmo que não correspondam exatamente a uma tag.

Agora, vamos tentar executar git describe no commit que tem a tag v1.0. Precisamos do hash do commit para o commit "Add a second message". Você pode obter isso de git log --oneline.

Substitua <commit-hash-of-v1.0> pelo hash real e execute:

git describe <commit-hash-of-v1.0>

Desta vez, a saída deve ser simplesmente:

v1.0

Isso ocorre porque o commit especificado está diretamente tagged com v1.0. Quando o próprio commit está tagged, git describe apenas exibe o nome da tag.

O comando git describe é uma ferramenta poderosa para entender a relação entre seus commits e suas tags, fornecendo uma maneira concisa de nomear commits com base em sua proximidade com a tag mais próxima.

Testar Commits sem Tags

Nesta etapa, exploraremos ainda mais como git describe se comporta com commits que não são diretamente tagged. Isso reforçará sua compreensão de como ele encontra a tag mais próxima.

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

Atualmente, temos um commit após a tag v1.0. Vamos fazer outro commit:

echo "Yet another message" > message4.txt
git add message4.txt
git commit -m "Add a fourth message"

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

[master <commit-hash>] Add a fourth message
 1 file changed, 1 insertion(+)
 create mode 100644 message4.txt

Agora, vamos executar git describe novamente:

git describe

Desta vez, a saída deve ser semelhante a:

v1.0-2-g<commit-hash>

Observe que o número entre v1.0 e o hash do commit agora é 2. Isso ocorre porque agora há dois commits na branch master desde que a tag v1.0 foi criada. git describe conta corretamente o número de commits do commit tagged até o commit atual.

Este comportamento é muito útil em pipelines de integração e implantação contínuas, onde você pode querer gerar automaticamente nomes de versão para builds com base na tag mais recente e no número de commits desde essa tag.

Vamos tentar mais uma coisa. Criaremos uma nova branch e faremos um commit nessa branch.

git checkout -b feature/new-feature
echo "Feature file" > feature.txt
git add feature.txt
git commit -m "Add feature file"

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

Switched to a new branch 'feature/new-feature'
[feature/new-feature <commit-hash>] Add feature file
 1 file changed, 1 insertion(+)
 create mode 100644 feature.txt

Agora, execute git describe nesta nova branch:

git describe

A saída ainda deve ser baseada na tag v1.0, mas a contagem de commits e o hash serão diferentes:

v1.0-3-g<commit-hash>

Mesmo que estejamos em uma branch diferente, git describe ainda encontra a tag mais próxima alcançável, que é v1.0 neste caso. A contagem de commits 3 reflete o número de commits da tag v1.0 para o commit atual na branch feature/new-feature (os dois commits em master mais o um na branch de recurso).

Isso demonstra como git describe funciona em várias branches, sempre encontrando a tag mais próxima no histórico de commits.

Resumo

Neste laboratório, aprendemos como verificar se um commit do Git faz parte de uma tag usando dois métodos principais. Primeiro, exploramos o comando git tag --contains <commit-hash>, que lista diretamente todas as tags que incluem o commit especificado. Isso é particularmente útil para identificar quais releases ou versões incorporam uma alteração específica. Praticamos isso criando commits e tags, depois usando git log --oneline para obter hashes de commit e, subsequentemente, consultando com git tag --contains.

Em segundo lugar, abordamos brevemente o uso de git describe como outra forma de relacionar commits a tags, embora as etapas detalhadas para isso não tenham sido totalmente fornecidas no trecho. O laboratório também incluiu uma etapa para testar commits não tagged, reforçando a compreensão de como esses comandos se comportam quando um commit não está associado a nenhuma tag. No geral, o laboratório forneceu experiência prática no uso de comandos Git para navegar e entender a relação entre commits e tags dentro do histórico de um projeto.