Histórico do Git e Gerenciamento de Logs

Introdução

Bem-vindo, viajante do tempo do Git! Hoje, embarcaremos em uma jornada emocionante pelo histórico dos seus projetos Git. Um dos recursos mais poderosos do Git é sua capacidade de rastrear e exibir o histórico do seu projeto. Esse histórico não é apenas um registro do que aconteceu, mas uma ferramenta poderosa para entender, depurar e melhorar seu trabalho.

Neste laboratório, exploraremos o comando git log, que é a sua janela para os registros históricos do Git. Começaremos com o uso básico e depois mergulharemos em técnicas mais avançadas, como formatação da saída do log, filtragem de logs por data, busca por alterações específicas e até mesmo a geração de estatísticas a partir do histórico do seu projeto.

Ao final deste laboratório, você será capaz de navegar pelo histórico do seu projeto como um profissional, extraindo insights e informações valiosas que o tornarão um desenvolvedor mais eficaz. Esteja você rastreando um bug, revisando alterações ou apenas tentando entender como seu projeto evoluiu, as habilidades que você aprenderá aqui serão inestimáveis.

Vamos entrar em nossa máquina do tempo Git e explorar o passado!

Configurando Seu Espaço de Trabalho

Antes de mergulharmos nos recursos de histórico do Git, vamos configurar um espaço de trabalho com algum histórico de commits para explorar. Criaremos um novo diretório, inicializaremos um repositório Git e adicionaremos alguns commits.

Abra seu terminal e digite estes comandos:

cd ~/project
mkdir git-history-lab
cd git-history-lab
git init

Agora, vamos criar alguns arquivos e fazer uma série de commits, copiando e colando os seguintes comandos:

echo "## Git History Lab" > README.md
git add README.md
git commit -m "Initial commit"

echo "function hello() {" > script.js
echo "  console.log('Hello, Git!');" >> script.js
echo "}" >> script.js
git add script.js
git commit -m "Add hello function"

echo "function goodbye() {" >> script.js
echo "  console.log('Goodbye, Git!');" >> script.js
echo "}" >> script.js
git add script.js
git commit -m "Add goodbye function"

echo "This is a test file" > test.txt
git add test.txt
git commit -m "Add test file"

echo "hello();" >> script.js
echo "goodbye();" >> script.js
git add script.js
git commit -m "Call hello and goodbye functions"

Vamos detalhar o que acabamos de fazer:

1. Criamos um arquivo README e fizemos nosso commit inicial.
2. Criamos um arquivo JavaScript com uma função "hello" e o commitamos.
3. Adicionamos uma função "goodbye" ao mesmo arquivo e a commitamos.
4. Adicionamos um arquivo de teste e o commitamos.
5. Finalmente, modificamos nosso script para chamar ambas as funções e commitamos as alterações.

Agora temos um repositório com algum histórico para explorar!

Uso Básico do Log

Agora que temos algum histórico de commits, vamos explorar o uso básico do git log.

Para ver o histórico de commits do seu projeto, basta executar:

git log

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

commit 1234567890abcdef1234567890abcdef12345678 (HEAD -> main)
Author: Your Name <your.email@example.com>
Date:   Mon Jun 5 10:00:00 2023 +0000

    Call hello and goodbye functions

commit 2345678901abcdef2345678901abcdef23456789
Author: Your Name <your.email@example.com>
Date:   Mon Jun 5 09:45:00 2023 +0000

    Add test file

...

Cada entrada no log mostra:

• O hash completo do commit (um identificador único para o commit)
• O autor do commit
• A data e hora do commit
• A mensagem do commit

Por padrão, o git log mostra todos os commits, começando pelo mais recente. Ele os exibe em ordem cronológica inversa (os mais novos primeiro).

Se a saída for longa, o Git a mostrará em um paginador (geralmente o less). Você pode navegar usando as teclas de seta e pressionar q para sair.

Para ver uma versão mais concisa do log, você pode usar:

git log --oneline

Isso mostra cada commit em uma única linha, apenas com o hash curto do commit e a mensagem.

Lembre-se, o git log é a sua janela para o histórico do projeto. É um ótimo ponto de partida para entender quais mudanças foram feitas, quando e por quem.

Formatando a Saída do Log

O Git oferece opções poderosas para formatar a saída do log para mostrar exatamente a informação que você precisa. Vamos explorar algumas dessas opções.

Para mostrar os arquivos que foram modificados em cada commit, use a opção --stat:

git log --stat

Isso mostrará quais arquivos foram alterados em cada commit e quantas linhas foram adicionadas ou removidas.

Para uma visão mais detalhada das alterações, use a opção -p:

git log -p

Isso mostra o patch real (as linhas que foram adicionadas e removidas) para cada commit. É muito útil para revisar alterações em detalhes.

Você também pode criar formatos personalizados usando a opção --pretty. Por exemplo:

git log --pretty=format:"%h - %an, %ar : %s"

Isso mostrará:

• %h: hash abreviado do commit
• %an: nome do autor
• %ar: data do autor, relativa
• %s: assunto (mensagem do commit)

Você pode personalizar essa string de formato para incluir qualquer informação que precisar. Aqui estão alguns marcadores úteis:

• %H: hash completo do commit
• %ad: data do autor
• %cn: nome de quem realizou o commit (committer)
• %ce: e-mail de quem realizou o commit
• %cd: data de quem realizou o commit

Experimente diferentes formatos para encontrar o que funciona melhor para você!

Filtrando o Log por Data

Muitas vezes, você desejará examinar commits dentro de um intervalo de tempo específico. O Git fornece várias opções para filtrar o log por data.

Para ver os commits da última semana:

git log --since=1.week

Você também pode usar datas específicas:

git log --after="2023-06-01" --before="2023-06-30"

Isso mostrará os commits entre 1º de junho e 30 de junho de 2023.

O Git entende uma variedade de formatos de data, incluindo os relativos como "yesterday" (ontem), "1 month 2 weeks 3 days ago" (1 mês, 2 semanas e 3 dias atrás), etc.

Você também pode usar a opção --until em vez de --before, e --after é sinônimo de --since.

Lembre-se de que esses filtros mostram commits cuja data de commit cai dentro do intervalo especificado. A data do commit é quando o commit foi criado, o que pode ser diferente de quando as alterações reais foram feitas.

Se você estiver investigando quando uma alteração específica foi introduzida, talvez queira usar a opção --grep para pesquisar mensagens de commit específicas, o que abordaremos na próxima etapa.

Pesquisando no Log por Alterações Específicas

O Git oferece recursos de pesquisa poderosos para ajudá-lo a encontrar commits específicos. Vamos explorar alguns desses recursos.

Para pesquisar commits com uma palavra específica na mensagem do commit:

git log --grep="function"

Isso mostrará todos os commits onde a palavra "function" aparece na mensagem.

Você também pode pesquisar por alterações em um arquivo específico:

git log -- script.js

Isso mostra todos os commits que afetaram o arquivo script.js.

Para pesquisar por alterações que adicionaram ou removeram uma linha de código específica:

git log -S "console.log"

Isso é chamado de busca "pickaxe". Ele mostra os commits onde o número de ocorrências de "console.log" mudou.

Você pode combinar essas opções com outras. Por exemplo, para ver alterações detalhadas no arquivo script.js na última semana:

git log -p --since=1.week -- script.js

Lembre-se de que a pesquisa do Git diferencia maiúsculas de minúsculas por padrão. Use a opção -i para uma pesquisa insensível a maiúsculas:

git log --grep="function" -i

Essas capacidades de pesquisa são incrivelmente úteis quando você está tentando rastrear quando uma alteração específica foi introduzida ou um bug foi corrigido.

Gerando Estatísticas a partir do Log

O Git pode fornecer insights valiosos sobre o histórico do seu projeto por meio de estatísticas. Vamos explorar algumas maneiras de gerar essas estatísticas.

Para ver um resumo do número de commits por autor:

git shortlog -s -n

Isso mostra uma lista de autores, ordenados pelo número de commits, com a contagem de commits ao lado de cada nome.

Para ver quantas linhas cada autor adicionou e removeu:

git log --author="Jane Doe" --pretty=tformat: --numstat | awk '{ add += $1; subs += $2; loc += $1 - $2 } END { printf "Added lines: %s, Removed lines: %s, Total lines: %s\n", add, subs, loc }'

Substitua "Jane Doe" pelo nome do autor que você deseja verificar.

Para ver quais arquivos mudaram mais:

git log --pretty=format: --name-only | sort | uniq -c | sort -rg | head -10

Isso mostra os 10 arquivos modificados com mais frequência.

Para ver o número total de commits:

git rev-list --count HEAD

Essas estatísticas podem ser muito úteis para entender os padrões gerais de desenvolvimento em seu projeto. Elas podem ajudar a identificar quais partes do projeto são desenvolvidas de forma mais ativa, quem são os colaboradores mais ativos e como o projeto cresceu ao longo do tempo.

Lembre-se de que, embora essas estatísticas possam ser informativas, elas não contam a história toda. O número de commits ou linhas alteradas não se correlaciona necessariamente com o impacto ou a qualidade das contribuições.

Resumo

Parabéns, historiador do Git! Você acaba de desbloquear o poder dos recursos de histórico e gerenciamento de log do Git. Vamos recapitular os principais conceitos que abordamos:

1. Uso Básico do Log: Você aprendeu como visualizar o histórico de commits do seu projeto usando git log.
2. Formatando a Saída do Log: Você descobriu como personalizar a saída do log para mostrar exatamente as informações necessárias.
3. Filtrando o Log por Data: Você viu como focar em commits dentro de intervalos de tempo específicos.
4. Pesquisando no Log por Alterações Específicas: Você aprendeu técnicas poderosas para descobrir quando alterações específicas foram introduzidas.
5. Gerando Estatísticas a partir do Log: Você explorou maneiras de extrair insights sobre os padrões de desenvolvimento do seu projeto.

Essas habilidades serão inestimáveis à medida que você trabalha em projetos maiores. Esteja você rastreando um bug, revisando a evolução de um recurso ou tentando entender as tendências gerais de desenvolvimento em seu projeto, o comando git log e suas várias opções serão seus companheiros fiéis.

Lembre-se, o histórico do Git não é apenas um registro do que aconteceu — é uma ferramenta poderosa para entender e melhorar seu projeto. Use-o com sabedoria e ele o tornará um desenvolvedor mais eficaz.

Continue explorando e experimentando esses comandos. Quanto mais confortável você se tornar navegando no histórico do seu projeto, mais insights conseguirá extrair dele. Boa viagem no tempo em seus repositórios Git!