Como Verificar se um Commit Git Foi Amendado

Introdução

Neste laboratório, você aprenderá como determinar se um commit Git foi amendado. Exploraremos o comando git reflog para visualizar o histórico de atualizações de referência, o que pode revelar operações de amend.

Você também aprenderá como usar git log para comparar commits e entender as diferenças entre commits amendados e não amendados, adquirindo habilidades práticas na análise do histórico do seu repositório.

Verificar o git reflog para Entradas de Amend

Nesta etapa, exploraremos o comando git reflog e como ele nos ajuda a ver o histórico do nosso repositório, incluindo ações como a amenda de commits.

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 usar o comando git reflog para ver o histórico do nosso repositório. O reflog (log de referência) registra atualizações nas pontas das branches e outras referências no repositório. Isso é diferente do git log, que mostra o histórico de commits.

Digite o seguinte comando:

git reflog

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

a1b2c3d (HEAD -> master) HEAD@{0}: commit: Send a message to the future
a1b2c3d (HEAD -> master) HEAD@{1}: initial commit (amend): Send a message to the future
e4f5g6h HEAD@{2}: commit (initial): Send a message to the future

Vamos analisar essa saída:

• Cada linha representa uma ação que atualizou uma referência (como HEAD).
• HEAD@{0} é a ação mais recente, HEAD@{1} é a ação anterior a essa, e assim por diante.
• A primeira parte de cada linha (a1b2c3d, e4f5g6h) é o hash do commit. Observe como o hash do commit muda após uma operação de "amend".
• O texto após o hash do commit descreve a ação, como commit, initial commit (amend), ou commit (initial).

O git reflog é uma ferramenta poderosa para recuperar commits perdidos ou entender a sequência de operações que levaram ao estado atual do seu repositório. Ele mostra onde seu HEAD esteve, mesmo que esses commits não façam mais parte do histórico de uma branch (por exemplo, após um amend ou rebase).

Na saída de exemplo, você pode ver uma entrada como initial commit (amend). Isso indica que o commit inicial foi amendado. Amendar um commit substitui o último commit por um novo commit que inclui as alterações que você preparou (staged). Enquanto git log mostrará apenas o commit final, amendado, git reflog mostra tanto o commit inicial original quanto o amendado.

Entender o git reflog é crucial para navegar no histórico do seu projeto, especialmente quando você usa comandos que reescrevem o histórico, como git commit --amend.

Usar git log para Comparar Commits

Nesta etapa, usaremos o comando git log para visualizar o histórico de commits e entender como ele difere do git reflog, especialmente após usar git commit --amend.

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

Agora, vamos visualizar o histórico de commits usando git log:

git log --oneline

A opção --oneline fornece uma visão concisa do histórico de commits, mostrando cada commit em uma única linha.

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

a1b2c3d (HEAD -> master) Send a message to the future

Compare esta saída com a saída do git reflog na etapa anterior. Observe que git log mostra apenas um commit, que é o commit final, amendado. Ele não mostra o commit inicial original que foi substituído pela operação de amend.

Esta é uma diferença fundamental entre git log e git reflog. git log mostra o histórico de commits alcançáveis a partir da ponta da branch atual, enquanto git reflog mostra o histórico de onde HEAD e outras referências apontaram.

Pense no git log como o histórico oficial publicado do seu projeto, enquanto o git reflog é seu diário pessoal de tudo o que você fez no repositório.

Você também pode usar git log para comparar diferentes commits. Embora tenhamos apenas um commit em nosso histórico agora, em um projeto real com múltiplos commits, você pode usar comandos como git log commit1..commit2 para ver os commits entre dois pontos específicos no histórico, ou git diff commit1 commit2 para ver as mudanças exatas introduzidas entre dois commits.

Por enquanto, apenas entender que git log mostra o histórico de commits e git reflog mostra o histórico de atualizações de referência é importante.

Testar Commits Não Amendados

Nesta etapa, criaremos um novo commit sem usar a flag --amend e observaremos como ele aparece tanto no git log quanto no git reflog. Isso ajudará a solidificar sua compreensão de como esses comandos rastreiam o histórico de forma diferente.

Primeiro, vamos adicionar mais conteúdo ao nosso arquivo message.txt. Vamos anexar uma nova linha:

echo "Hello again, Future Me!" >> message.txt

O operador >> anexa o texto ao arquivo existente, em vez de sobrescrevê-lo.

Agora, vamos verificar o status para ver as alterações:

git status

Você deve ver uma saída indicando que message.txt foi modificado:

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   message.txt

no changes added to commit (use "git add" and/or "git commit -a")

Em seguida, precisamos preparar as alterações:

git add message.txt

E agora, vamos criar um novo commit sem amendar o anterior:

git commit -m "Add another message"

Você deve ver uma saída confirmando o novo commit:

[master 1a2b3c4] Add another message
 1 file changed, 1 insertion(+)

Agora, vamos verificar o git log novamente:

git log --oneline

Desta vez, você deve ver dois commits:

1a2b3c4 (HEAD -> master) Add another message
a1b2c3d Send a message to the future

Ambos os commits são visíveis no git log porque o segundo commit foi adicionado em cima do primeiro, estendendo o histórico da branch.

Finalmente, vamos verificar o git reflog:

git reflog

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

1a2b3c4 (HEAD -> master) HEAD@{0}: commit: Add another message
1a2b3c4 (HEAD -> master) HEAD@{1}: commit (amend): Send a message to the future
e4f5g6h HEAD@{2}: commit (initial): Send a message to the future

Observe que o git reflog mostra todas as ações: o commit inicial, o commit inicial amendado e o novo commit que acabamos de criar. Cada ação que moveu o HEAD é registrada.

Esta etapa demonstra que, quando você cria um novo commit sem --amend, tanto o git log quanto o git reflog mostrarão o novo commit, mas o git reflog ainda reterá o histórico do commit amendado, o que o git log não faz.

Resumo

Neste laboratório, aprendemos como verificar se um commit Git foi amendado. Exploramos o comando git reflog, que fornece um histórico de atualizações para referências como HEAD, permitindo-nos ver ações como a amendação de commits. Ao examinar a saída do reflog, podemos identificar entradas que indicam uma operação de amendação e observar como o hash do commit muda após tal ação.

Também aprendemos que o git reflog é uma ferramenta valiosa para entender a sequência de operações em um repositório, mesmo para commits que não são mais diretamente acessíveis através do git log. Isso ajuda na recuperação de trabalho perdido ou no diagnóstico de problemas no histórico do repositório.